def upload(self, engine, timeout=5, wait_for_finish=False, preserve_connections=True, generate_snapshot=True, **kw): """ Upload policy to specific device. Using wait for finish returns a poller thread for monitoring progress:: policy = FirewallPolicy('_NSX_Master_Default') poller = policy.upload('myfirewall', wait_for_finish=True) while not poller.done(): poller.wait(3) print(poller.task.progress) print("Task finished: %s" % poller.message()) :param str engine: name of device to upload policy to :param bool preserve_connections: flag to preserve connections (True by default) :param bool generate_snapshot: flag to generate snapshot (True by default) :raises: TaskRunFailed :return: TaskOperationPoller """ return Task.execute(self, "upload", params={"filter": engine}, json={ "preserve_connections": preserve_connections, "snapshot_creation": generate_snapshot, }, timeout=timeout, wait_for_finish=wait_for_finish, **kw)
def export_elements(self, filename='export_elements.zip', typeof='all', timeout=5, max_tries=36): """ Export elements from SMC. Valid types are: all (All Elements)|nw (Network Elements)|ips (IPS Elements)| sv (Services)|rb (Security Policies)|al (Alerts)| vpn (VPN Elements) :param type: type of element :param filename: Name of file for export :raises TaskRunFailed: failure during export with reason :rtype: DownloadTask """ valid_types = ['all', 'nw', 'ips', 'sv', 'rb', 'al', 'vpn'] if typeof not in valid_types: typeof = 'all' return Task.download(self, 'export_elements', filename, timeout=timeout, max_tries=max_tries, params={ 'recursive': True, 'type': typeof })
def upload(self, policy=None, wait_for_finish=False, sleep=3): """ Upload policy to engine. This is used when a new policy is required for an engine, or this is the first time a policy is pushed to an engine. If an engine already has a policy and the intent is to re-push, then use :py:func:`refresh` instead. The policy argument can use a wildcard * to specify in the event a full name is not known:: engine = Engine('myfw') task = engine.upload('Amazon*', wait_for_finish=True) for message in task: print message :param str policy: name of policy to upload to engine; if None, current policy :param boolean wait_for_finish: whether to wait for async responses :param int sleep: number of seconds to sleep if wait_for_finish=True :raises: :py:class:`smc.api.exceptions.TaskRunFailed` :return: generator yielding updates on progress """ element = prepared_request(TaskRunFailed, href=self._link('upload'), params={ 'filter': policy }).create() return task_handler(Task(**element.json), wait_for_finish=wait_for_finish, sleep=sleep)
def export_elements(self, filename="export_elements.zip", typeof="all", timeout=5, max_tries=36): """ Export elements from SMC. Valid types are: all (All Elements)|nw (Network Elements)|ips (IPS Elements)| sv (Services)|rb (Security Policies)|al (Alerts)| vpn (VPN Elements) :param type: type of element :param filename: Name of file for export :raises TaskRunFailed: failure during export with reason :rtype: DownloadTask """ valid_types = ["all", "nw", "ips", "sv", "rb", "al", "vpn"] if typeof not in valid_types: typeof = "all" return Task.download( self, "export_elements", filename, timeout=timeout, max_tries=max_tries, params={ "recursive": True, "type": typeof }, )
def generate(self, start_time=0, end_time=0, senders=None, wait_for_finish=False, timeout=5, **kw): # @ReservedAssignment """ Generate the report and optionally wait for results. You can optionally add filters to the report by providing the senders argument as a list of type Element:: report = ReportDesign('Firewall Weekly Summary') begin = datetime_to_ms(datetime.strptime("2018-02-03T00:00:00", "%Y-%m-%dT%H:%M:%S")) end = datetime_to_ms(datetime.strptime("2018-02-04T00:00:00", "%Y-%m-%dT%H:%M:%S")) report.generate(start_time=begin, end_time=end, senders=[Engine('vm')]) :param int period_begin: milliseconds time defining start time for report :param int period_end: milliseconds time defining end time for report :param senders: filter targets to use when generating report :type senders: list(Element) :param bool wait_for_finish: enable polling for results :param int timeout: timeout between polling :raises TaskRunFailed: refresh failed, possibly locked policy :rtype: TaskOperationPoller """ if start_time and end_time: kw.setdefault('params', {}).update( {'start_time': start_time, 'end_time': end_time}) if senders: kw.setdefault('json', {}).update({'senders': element_resolver(senders)}) return Task.execute(self, 'generate', timeout=timeout, wait_for_finish=wait_for_finish, **kw)
def download(self, timeout=5, wait_for_finish=False): """ Download Package or Engine Update :param int timeout: timeout between queries :raises TaskRunFailed: failure during task status :rtype: TaskOperationPoller """ return Task.execute(self, 'download', timeout=timeout, wait_for_finish=wait_for_finish)
def generate(self, timeout=5, wait_for_finish=False, **kw): """ Generate the report and optionally wait for results. :param int timeout: timeout between queries :param bool wait_for_finish: enable polling for results :raises TaskRunFailed: refresh failed, possibly locked policy :rtype: TaskOperationPoller """ return Task.execute(self, 'generate', timeout=timeout, wait_for_finish=wait_for_finish, **kw)
def remove_from_master_node(self, wait_for_finish=False, timeout=20, **kw): """ Remove this VSS Context from it's parent VSS Container. This is required before calling VSSContext.delete(). It preps the engine for removal. :param bool wait_for_finish: wait for the task to finish :param int timeout: how long to wait if delay :type: TaskOperationPoller """ return Task.execute(self, 'remove_from_master_node', timeout=timeout, wait_for_finish=wait_for_finish, **kw)
def activate(self, resource=None, timeout=3, wait_for_finish=False): """ Activate this package on the SMC :param list resource: node href's to activate on. Resource is only required for software upgrades :param int timeout: timeout between queries :raises TaskRunFailed: failure during activation (downloading, etc) :rtype: TaskOperationPoller """ return Task.execute(self, 'activate', json={'resource': resource}, timeout=timeout, wait_for_finish=wait_for_finish)
def import_elements(self, import_file): """ Import elements into SMC. Specify the fully qualified path to the import file. :param str import_file: system level path to file :raises: ActionCommandFailed :return: None """ import_follower = Task( self.make_request( method="create", resource="import_elements", files={"import_file": open(import_file, "rb")}, )) in_progress = import_follower.data.in_progress progress = import_follower.progress while in_progress is True: time.sleep(1) logger.info("[{}] XML Import task => {}%".format( "{:%H:%M:%S.%f}".format(datetime.now())[:-3], progress)) in_progress = import_follower.update_status().data.in_progress progress = import_follower.update_status().progress succeed = import_follower.update_status().success last_message = import_follower.update_status().last_message if not succeed: logger.info("[{}] XML Import task failed:{}".format( "{:%H:%M:%S.%f}".format(datetime.now())[:-3], last_message)) raise ActionCommandFailed(last_message) logger.info("[{}] XML Import task succeed".format( "{:%H:%M:%S.%f}".format(datetime.now())[:-3]))
def start(self): """ Start the scheduled task now. Task can then be tracked by using common Task methods. :raises ActionCommandFailed: failed starting task :return: return as a generic Task :rtype: Task """ return Task( self.make_request(ActionCommandFailed, method='create', resource='start'))
def import_elements(self, import_file): """ Import elements into SMC. Specify the fully qualified path to the import file. :param str import_file: system level path to file :raises: ActionCommandFailed :return: None """ import_follower = Task( self.make_request(method='create', resource='import_elements', files={'import_file': open(import_file, 'rb')})) in_progress = import_follower.data.in_progress progress = import_follower.progress while in_progress is True: time.sleep(1) logger.info("[{}] XML Import task => {}%".format( '{:%H:%M:%S.%f}'.format(datetime.now())[:-3], progress)) in_progress = import_follower.update_status().data.in_progress progress = import_follower.update_status().progress logger.info("[{}] XML Import task finished".format( '{:%H:%M:%S.%f}'.format(datetime.now())[:-3]))
def upload(self, engine, timeout=5, wait_for_finish=False, **kw): """ Upload policy to specific device. Using wait for finish returns a poller thread for monitoring progress:: policy = FirewallPolicy('_NSX_Master_Default') poller = policy.upload('myfirewall', wait_for_finish=True) while not poller.done(): poller.wait(3) print(poller.task.progress) print("Task finished: %s" % poller.message()) :param str engine: name of device to upload policy to :raises: TaskRunFailed :return: TaskOperationPoller """ return Task.execute(self, 'upload', params={'filter': engine}, timeout=timeout, wait_for_finish=wait_for_finish, **kw)
def refresh(self, timeout=3, wait_for_finish=False, **kw): """ Refresh existing policy on specified device. This is an asynchronous call that will return a 'follower' link that can be queried to determine the status of the task. :: poller = engine.refresh() while not poller.done(): poller.wait(5) print('Percentage complete {}%'.format(poller.task.progress)) :param int timeout: timeout between queries :raises TaskRunFailed: refresh failed, possibly locked policy :rtype: TaskOperationPoller """ return Task.execute(self, 'refresh', timeout=timeout, wait_for_finish=wait_for_finish, **kw)
def policy_waiter(self, follower): """ Wait for policy upload """ logger.info('Uploading policy for {}..'.format(self.engine.name)) start_time = time.time() while True: reply = Task(**element_by_href_as_json(follower)) if reply.progress: logger.info('[{}]: policy progress -> {}%'.format(self.engine.name, reply.progress)) if not reply.in_progress: logger.info('Upload policy task completed for {} in {} seconds' .format(self.engine.name, time.time() - start_time)) if not reply.success: yield [reply.last_message] else: yield [] yield None
def export_elements(self, filename='export_elements.zip', typeof='all'): """ Export elements from SMC. Valid types are: all (All Elements)|nw (Network Elements)|ips (IPS Elements)| sv (Services)|rb (Security Policies)|al (Alerts)| vpn (VPN Elements) :param type: type of element :param filename: Name of file for export :raises TaskRunFailed: failure during export with reason :rtype: DownloadTask """ valid_types = ['all', 'nw', 'ips', 'sv', 'rb', 'al', 'vpn'] if typeof not in valid_types: typeof = 'all' return Task.download(self, 'export_elements', filename, params={'recursive': True, 'type': typeof})
def upload(self, engine, wait_for_finish=True): """ Upload policy to specific device. This is an asynchronous call that will return a 'follower' link that can be queried to determine the status of the task. If wait_for_finish is False, the progress href is returned when calling this method. If wait_for_finish is True, this generator function will return the new messages as they arrive. :param engine: name of device to upload policy to :param wait_for_finish: whether to wait in a loop until the upload completes :return: generator with updates, or follower href if wait_for_finish=False """ element = prepared_request(TaskRunFailed, href=self._link('upload'), params={'filter': engine}).create() return task_handler(Task(**element.json), wait_for_finish=wait_for_finish)
def export(self, filename='element.zip', wait_for_finish=False): """ Export this element :param str filename: filename to store exported element :param boolean wait_for_finish: wait for update msgs (default: False) :raises: ActionCommandFailed :return: generator yielding updates on progress, or [] if element cannot be exported, like for system elements """ from smc.administration.tasks import Task, task_handler try: element = prepared_request(ActionCommandFailed, href=self._link('export'), filename=filename).create() return task_handler(Task(**element.json), wait_for_finish=wait_for_finish, filename=filename) except ResourceNotFound: return []
def export(self, filename='element.zip'): """ Export this element. Usage:: engine = Engine('myfirewall') extask = engine.export(filename='fooexport.zip') while not extask.done(): extask.wait(3) print("Finished download task: %s" % extask.message()) print("File downloaded to: %s" % extask.filename) :param str filename: filename to store exported element :raises TaskRunFailed: invalid permissions, invalid directory, or this element is a system element and cannot be exported. :return: DownloadTask .. note:: It is not possible to export system elements """ from smc.administration.tasks import Task return Task.download(self, 'export', filename)
def generate(self, start_time=0, end_time=0, senders=None, wait_for_finish=False, timeout=5, **kw): # @ReservedAssignment """ Generate the report and optionally wait for results. You can optionally add filters to the report by providing the senders argument as a list of type Element:: report = ReportDesign('Firewall Weekly Summary') begin = datetime_to_ms(datetime.strptime("2018-02-03T00:00:00", "%Y-%m-%dT%H:%M:%S")) end = datetime_to_ms(datetime.strptime("2018-02-04T00:00:00", "%Y-%m-%dT%H:%M:%S")) report.generate(start_time=begin, end_time=end, senders=[Engine('vm')]) :param int period_begin: milliseconds time defining start time for report :param int period_end: milliseconds time defining end time for report :param senders: filter targets to use when generating report :type senders: list(Element) :param bool wait_for_finish: enable polling for results :param int timeout: timeout between polling :raises TaskRunFailed: refresh failed, possibly locked policy :rtype: TaskOperationPoller """ if start_time and end_time: kw.setdefault("params", {}).update({ "start_time": start_time, "end_time": end_time }) if senders: kw.setdefault("json", {}).update({"senders": element_resolver(senders)}) return Task.execute(self, "generate", timeout=timeout, wait_for_finish=wait_for_finish, **kw)
def upload(self, policy=None, timeout=5, wait_for_finish=False, **kw): """ Upload policy to engine. This is used when a new policy is required for an engine, or this is the first time a policy is pushed to an engine. If an engine already has a policy and the intent is to re-push, then use :py:func:`refresh` instead. The policy argument can use a wildcard * to specify in the event a full name is not known:: engine = Engine('myfw') task = engine.upload('Amazon*') for message in task.wait(): print(message) :param str policy: name of policy to upload to engine; if None, current policy :param int timeout: timeout between queries :raises TaskRunFailed: upload failed with reason :rtype: TaskOperationPoller """ return Task.execute(self, 'upload', params={'filter': policy}, timeout=timeout, wait_for_finish=wait_for_finish, **kw)
def refresh(self, wait_for_finish=True, sleep=3): """ Refresh existing policy on specified device. This is an asynchronous call that will return a 'follower' link that can be queried to determine the status of the task. Last yield is result href; if wait_for_finish=False, the only yield is the follower href:: task = engine.refresh() for message in task: print message :param boolean wait_for_finish: whether to wait in a loop until the upload completes :param int sleep: number of seconds to sleep if wait_for_finish=True :raises: :py:class:`smc.api.exceptions.TaskRunFailed` :return: generator yielding updates on progress """ element = prepared_request(TaskRunFailed, href=self._link('refresh')).create() return task_handler(Task(**element.json), wait_for_finish=wait_for_finish, sleep=sleep)