def write_playbook_to_file(playbook_name): """Writes a playbook to file. Args: playbook_name (str): The name of the playbook to write to a file. """ playbook_filename = os.path.join(core.config.paths.workflows_path, '{0}.playbook'.format(playbook_name)) backup = None try: with open(playbook_filename) as original_file: backup = original_file.read() os.remove(playbook_filename) except (IOError, OSError) as e: logger.warning('Cannot read original playbook! Saving without backup! ' 'Reason: {}'.format(helpers.format_exception_message(e))) app.logger.debug('Writing playbook {0} to file'.format(playbook_name)) try: with open(playbook_filename, 'w') as workflow_out: playbook_json = running_context.controller.get_playbook_representation(playbook_name) workflow_out.write(json.dumps(playbook_json, sort_keys=True, indent=4, separators=(',', ': '))) except Exception as e: logger.error('Could not save playbook to file. Reverting file to original. ' 'Error: {0}'.format(helpers.format_exception_message(e))) if backup is not None: with open(playbook_filename, 'w') as f: f.write(backup)
def __func(): form = forms.ImportCaseForm(request.form) filename = form.filename.data if form.filename.data else core.config.paths.default_case_export_path if os.path.isfile(filename): try: with open(filename, 'r') as cases_file: cases_file = cases_file.read() cases_file = cases_file.replace('\n', '') cases = json.loads(cases_file) case_subscription.add_cases(cases) for case in cases.keys(): running_context.db.session.add( running_context.CaseSubscription(name=case)) running_context.CaseSubscription.update(case) running_context.db.session.commit() return { "cases": case_subscription.subscriptions_as_json() }, SUCCESS except (OSError, IOError) as e: current_app.logger.error( 'Error importing cases from file {0}: {1}'.format( filename, format_exception_message(e))) return {"error": "Error reading file."}, IO_ERROR except ValueError as e: current_app.logger.error( 'Error importing cases from file {0}: Invalid JSON {1}'. format(filename, format_exception_message(e))) return {"error": "Invalid JSON file."}, INVALID_INPUT_ERROR else: current_app.logger.debug( 'Cases successfully imported from {0}'.format(filename)) return {"error": "File does not exist."}, IO_ERROR
def load_playbook(resource): """Loads a playbook from a file. Args: resource (str): Path to the workflow. """ try: playbook_file = open(resource, 'r') except (IOError, OSError) as e: logger.error( 'Could not load workflow from {0}. Reason: {1}'.format( resource, format_exception_message(e))) return None else: with playbook_file: workflow_loaded = playbook_file.read() try: playbook_json = json.loads(workflow_loaded) return Playbook.create(playbook_json) except ValueError: logger.error('Cannot parse {}'.format(resource)) except (InvalidInput, UnknownApp, UnknownAppAction, UnknownFilter, UnknownFlag) as e: logger.error('Error constructing playbook from {0}. ' 'Reason: {1}'.format( resource, format_exception_message(e))) return None
def validate_primitive_parameter(value, param, parameter_type, message_prefix, hide_input=False): try: converted_value = convert_primitive_type(value, parameter_type) except (ValueError, TypeError): message = '{0} has invalid input. ' \ 'Input {1} could not be converted to type {2}'.format(message_prefix, value, parameter_type) logger.error(message) raise InvalidInput(message) else: param = deepcopy(param) if 'required' in param: param.pop('required') try: Draft4Validator( param, format_checker=draft4_format_checker).validate(converted_value) except ValidationError as exception: if not hide_input: message = '{0} has invalid input. ' \ 'Input {1} with type {2} does not conform to ' \ 'validators: {3}'.format(message_prefix, value, parameter_type, format_exception_message(exception)) else: message = '{0} has invalid input. {1} does not conform to ' \ 'validators: {2}'.format(message_prefix, parameter_type, format_exception_message(exception)) logger.error(message) raise InvalidInput(message) return converted_value
def __func(): data = request.get_json() filename = (data['filename'] if (data is not None and 'filename' in data and data['filename']) else core.config.paths.default_case_export_path) if os.path.isfile(filename): try: with open(filename, 'r') as cases_file: cases_file = cases_file.read() cases_file = cases_file.replace('\n', '') cases = json.loads(cases_file) case_subscription.add_cases(cases) for case in cases: db.session.add(running_context.CaseSubscription(name=case)) running_context.CaseSubscription.update(case) db.session.commit() return {"cases": case_subscription.subscriptions}, SUCCESS except (OSError, IOError) as e: current_app.logger.error('Error importing cases from file ' '{0}: {1}'.format( filename, format_exception_message(e))) return {"error": "Error reading file."}, IO_ERROR except ValueError as e: current_app.logger.error( 'Error importing cases from file {0}: ' 'Invalid JSON {1}'.format(filename, format_exception_message(e))) return {"error": "Invalid JSON file."}, INVALID_INPUT_ERROR else: current_app.logger.debug( 'Cases successfully imported from {0}'.format(filename)) return {"error": "File does not exist."}, IO_ERROR
def __call__(self, data_in, accumulator): data = data_in for filter_element in self.filters: data = filter_element(data, accumulator) try: data = validate_parameter(data, self.data_in_api, 'Flag {0}'.format(self.action)) args = dereference_step_routing(self.args, accumulator, 'In Flag {0}'.format(self.name)) callbacks.FlagSuccess.send(self) logger.debug('Arguments passed to flag {0} are valid'.format( self.ancestry)) args.update({self.data_in_api['name']: data}) return get_flag(self.action)(**args) except InvalidInput as e: logger.error( 'Flag {0} has invalid input {1} which was converted to {2}. Error: {3}. ' 'Returning False'.format(self.action, data_in, data, format_exception_message(e))) callbacks.FlagError.send(self) return False except Exception as e: logger.error('Error encountered executing ' 'flag {0} with arguments {1} and value {2}: ' 'Error {3}. Returning False'.format( self.action, self.args, data, format_exception_message(e))) callbacks.FlagError.send(self) return False
def __func(): data = request.get_json() filename = data[ 'filename'] if 'filename' in data else core.config.paths.default_appdevice_export_path try: with open(filename, 'r') as devices_file: read_file = devices_file.read() read_file = read_file.replace('\n', '') apps = json.loads(read_file) except (OSError, IOError) as e: current_app.logger.error( 'Error importing devices from {0}: {1}'.format(filename, e)) return {"error": "Error reading file."}, IO_ERROR for app in apps: for device in apps[app]: if device_db.session.query(Device).filter( Device.name == device['name']).first() is not None: current_app.logger.error('Could not import device {0}. ' 'Device already exists.'.format( device['name'])) continue fields = { field['name']: field['value'] for field in device['fields'] } device_type = device['type'] try: device_api = get_app_device_api(app, device_type) device_fields_api = device_api['fields'] validate_device_fields(device_fields_api, fields, device_type, app) except UnknownDevice: current_app.logger.error( 'Cannot import device for app {0}, type {1}. ' 'Type does not exist'.format(app, device_type)) continue except InvalidArgument as e: current_app.logger.error( 'Cannot import device for app {0}, type {1}. ' 'Invalid input'.format(app, device_type, format_exception_message(e))) continue else: fields = device['fields'] add_configuration_keys_to_device_json( fields, device_fields_api) app = device_db.session.query(App).filter( App.name == app).first() if app is None: current_app.logger.error( 'SEVERE: App defined in api does not have corresponding entry in database. ' 'Cannot import device') continue device_obj = Device.from_json(device) app.add_device(device_obj) device_db.session.add(device_obj) device_db.session.commit() current_app.logger.debug('Imported devices from {0}'.format(filename)) return {}, SUCCESS
def load_app_apis(apps_path=None): from core.helpers import list_apps, format_exception_message global app_apis if apps_path is None: apps_path = core.config.paths.apps_path try: with open(join(core.config.paths.walkoff_schema_path), 'r') as schema_file: json.loads(schema_file.read()) except Exception as e: __logger.fatal( 'Could not load JSON schema for apps. Shutting down...: ' + str(e)) sys.exit(1) else: for app in list_apps(apps_path): try: url = join(apps_path, app, 'api.yaml') with open(url) as function_file: api = yaml.load(function_file.read()) from core.validator import validate_app_spec validate_app_spec(api, app) app_apis[app] = api except Exception as e: __logger.error( 'Cannot load apps api for app {0}: Error {1}'.format( app, str(format_exception_message(e))))
def __shutdown(self, instances): # Upon finishing shuts down instances for instance_name, instance in instances.items(): try: if instance() is not None: logger.debug( 'Shutting down app instance: Device: {0}'.format( instance_name)) instance.shutdown() except Exception as e: logger.error('Error caught while shutting down app instance. ' 'Device: {0}. Error {1}'.format( instance_name, format_exception_message(e))) result_str = {} for action, action_result in self._accumulator.items(): try: result_str[action] = json.dumps(action_result) except TypeError: logger.error( 'Result of workflow is neither string or a JSON-able. Cannot record' ) result_str[action] = 'error: could not convert to JSON' data = dict(self._accumulator) try: data_json = json.dumps(data) except TypeError: data_json = str(data) WalkoffEvent.CommonWorkflowSignal.send( self, event=WalkoffEvent.WorkflowShutdown, data=data_json) logger.info('Workflow {0} completed. Result: {1}'.format( self.name, self._accumulator))
def create(cls, json_in, element_class=None): """ Creates an ExecutionElement from json Args: json_in (dict): The JSON to convert to an ExecutionElement element_class (cls): The class of the ExecutionElement to convert Returns: (ExecutionElement) The constructed ExecutionElement """ from core.executionelements.playbook import Playbook cls._setup_ordering() if element_class is None: element_class = Playbook class_iterator = iteritems(cls.playbook_class_ordering) current_class, subfield_lookup = next(class_iterator) while current_class != element_class: try: current_class, subfield_lookup = next(class_iterator) except StopIteration: raise ValueError('Unknown class {}'.format(element_class.__class__.__name__)) try: return cls.construct_current_class(current_class, json_in, subfield_lookup) except (KeyError, TypeError) as e: from core.helpers import format_exception_message raise ValueError( 'Improperly formatted JSON for ExecutionElement {0} {1}'.format(current_class.__name__, format_exception_message(e)))
def write_playbook_to_file(playbook_name): playbook_filename = os.path.join(core.config.paths.workflows_path, '{0}.playbook'.format(playbook_name)) backup = None try: with open(playbook_filename) as original_file: backup = original_file.read() os.remove(playbook_filename) except (IOError, OSError): pass app.logger.debug('Writing playbook {0} to file'.format(playbook_name)) write_format = 'w' if sys.version_info[0] == 2 else 'wb' try: with open(playbook_filename, write_format) as workflow_out: xml = ElementTree.tostring( running_context.controller.playbook_to_xml(playbook_name)) xml_dom = minidom.parseString(xml).toprettyxml(indent='\t') workflow_out.write(xml_dom.encode('utf-8')) except Exception as e: logger.error( 'Could not save playbook to file. Reverting file to original. ' 'Error: {0}'.format(helpers.format_exception_message(e))) with open(playbook_filename, 'w') as f: f.write(backup)
def __func(): form = forms.ExportImportAppDevices(request.form) filename = form.filename.data if form.filename.data else core.config.paths.default_appdevice_export_path returned_json = {} apps = running_context.App.query.all() for app in apps: devices = [] for device in app.devices: device_json = device.as_json(with_apps=False) device_json.pop('app', None) device_json.pop('id', None) devices.append(device_json) returned_json[app.as_json()['name']] = devices try: with open(filename, 'w') as appdevice_file: appdevice_file.write( json.dumps(returned_json, indent=4, sort_keys=True)) except (OSError, IOError) as e: current_app.logger.error('Error importing devices from {0}: ' '{1}'.format( filename, helpers.format_exception_message(e))) return {"error": "Error writing file"}, IO_ERROR else: current_app.logger.debug( 'Exported devices to {0}'.format(filename)) return {}, SUCCESS
def __func(): form = forms.ExportImportAppDevices(request.form) filename = form.filename.data if form.filename.data else core.config.paths.default_appdevice_export_path try: with open(filename, 'r') as appdevice_file: read_file = appdevice_file.read() read_file = read_file.replace('\n', '') apps_devices = json.loads(read_file) except (OSError, IOError) as e: current_app.logger.error('Error importing devices from {0}: ' '{1}'.format( filename, helpers.format_exception_message(e))) return {"error": "Error reading file."}, IO_ERROR for app in apps_devices: for device in apps_devices[app]: extra_fields = {} for key in device: if key not in ['ip', 'name', 'port', 'username']: extra_fields[key] = device[key] extra_fields_str = json.dumps(extra_fields) running_context.Device.add_device( name=device['name'], username=device['username'], ip=device['ip'], port=device['port'], extra_fields=extra_fields_str, app_server=app, password=None) current_app.logger.debug('Imported devices from {0}'.format(filename)) return {}, SUCCESS
def load_workflow(resource, workflow_name): """Loads a workflow from a file. Args: resource (str): Path to the workflow. workflow_name (str): Name of the workflow to load. Returns: True on success, False otherwise. """ try: playbook_file = open(resource, 'r') except (IOError, OSError) as e: logger.error( 'Could not load workflow from {0}. Reason: {1}'.format( resource, format_exception_message(e))) return None else: with playbook_file: workflow_loaded = playbook_file.read() try: playbook_json = json.loads(workflow_loaded) playbook_name = playbook_json['name'] workflow_json = next( (workflow for workflow in playbook_json['workflows'] if workflow['name'] == workflow_name), None) if workflow_json is None: logger.warning( 'Workflow {0} not found in playbook {0}. ' 'Cannot load.'.format(workflow_name, playbook_name)) return None workflow = Workflow.create(workflow_json) return playbook_name, workflow except ValueError as e: logger.error('Cannot parse {0}. Reason: {1}'.format( resource, format_exception_message(e))) except (InvalidInput, UnknownApp, UnknownAppAction, UnknownFilter, UnknownFlag) as e: logger.error( 'Error constructing workflow {0}. Reason: {1}'.format( workflow_name, format_exception_message(e))) return None except KeyError as e: logger.error( 'Invalid Playbook JSON format. Details: {}'.format(e)) return None
def execute(self, data_in, accumulator): """Executes the Condition object, determining if the Condition evaluates to True or False. Args: data_in (): The input to the Transform objects associated with this Condition. accumulator (dict): The accumulated data from previous Actions. Returns: True if the Condition evaluated to True, False otherwise """ data = data_in for transform in self.transforms: data = transform.execute(data, accumulator) try: self.arguments.update({ self._data_param_name: Argument(self._data_param_name, value=data) }) args = validate_condition_parameters(self._api, self.arguments, self.action_name, accumulator=accumulator) logger.debug('Arguments passed to condition {} are valid'.format( self.uid)) ret = self._condition_executable(**args) WalkoffEvent.CommonWorkflowSignal.send( self, event=WalkoffEvent.ConditionSuccess) return ret except InvalidArgument as e: logger.error( 'Condition {0} has invalid input {1} which was converted to {2}. Error: {3}. ' 'Returning False'.format(self.action_name, data_in, data, format_exception_message(e))) WalkoffEvent.CommonWorkflowSignal.send( self, event=WalkoffEvent.ConditionError) return False except Exception as e: logger.error('Error encountered executing ' 'condition {0} with arguments {1} and value {2}: ' 'Error {3}. Returning False'.format( self.action_name, self.arguments, data, format_exception_message(e))) WalkoffEvent.CommonWorkflowSignal.send( self, event=WalkoffEvent.ConditionError) return False
def __swap_step_input(self, step, start_input): logger.debug('Swapping input to first step of workflow {0}'.format(self.name)) try: step.set_input(start_input) data_sent.send(self, callback_name="Workflow Input Validated", object_type="Workflow") except InvalidInput as e: logger.error('Cannot change input to workflow {0}. ' 'Invalid input. Error: {1}'.format(self.name, format_exception_message(e))) data_sent.send(self, callback_name="Workflow Input Invalid", object_type="Workflow")
def validate_parameter(value, param, message_prefix): primitive_type = 'primitive' if 'type' in param else 'object' converted_value = None if value is not None: if primitive_type == 'primitive': primitive_type = param['type'] if primitive_type in TYPE_MAP: converted_value = validate_primitive_parameter( value, param, primitive_type, message_prefix) elif primitive_type == 'array': try: converted_value = convert_array(param, value, message_prefix) Draft4Validator( param, format_checker=draft4_format_checker).validate( converted_value) except ValidationError as exception: message = '{0} has invalid input. Input {1} does not conform to ' \ 'validators: {2}'.format(message_prefix, value, format_exception_message(exception)) logger.error(message) raise InvalidArgument(message) else: raise InvalidArgument( 'In {0}: Unknown parameter type {1}'.format( message_prefix, primitive_type)) else: try: converted_value = convert_json(param, value, message_prefix) Draft4Validator(param['schema'], format_checker=draft4_format_checker).validate( converted_value) except ValidationError as exception: message = '{0} has invalid input. Input {1} does not conform to ' \ 'validators: {2}'.format(message_prefix, value, format_exception_message(exception)) logger.error(message) raise InvalidArgument(message) elif param.get('required'): message = "In {0}: Missing {1} parameter '{2}'".format( message_prefix, primitive_type, param['name']) logger.error(message) raise InvalidArgument(message) return converted_value
def read_json(filename): if not os.path.exists(filename) or not os.path.isfile(filename): return 'File does not exist', 'FileDoesNotExist' try: with open(filename, 'r') as file_in: return json.loads(file_in.read()) except (IOError, IOError) as e: return {'error': 'Could not read file', 'reason': format_exception_message(e)}, 'FileDoesNotExist' except ValueError: return 'Could not read file as json. Invalid JSON', 'InvalidJson'
def execute(self, instance, accumulator): """Executes a Step by calling the associated app function. Args: instance (App): The instance of an App object to be used to execute the associated function. accumulator (dict): Dict containing the results of the previous steps Returns: The result of the executed function. """ callbacks.StepInputValidated.send(self) try: args = dereference_step_routing(self.input, accumulator, 'In step {0}'.format(self.name)) args = validate_app_action_parameters(self.input_api, args, self.app, self.action) action = get_app_action(self.app, self.run) result = action(instance, **args) callbacks.FunctionExecutionSuccess.send( self, data=json.dumps({"result": result.as_json()})) except InvalidInput as e: formatted_error = format_exception_message(e) logger.error('Error calling step {0}. Error: {1}'.format( self.name, formatted_error)) callbacks.StepInputInvalid.send(self) self.output = ActionResult('error: {0}'.format(formatted_error), 'InvalidInput') raise except Exception as e: formatted_error = format_exception_message(e) logger.error('Error calling step {0}. Error: {1}'.format( self.name, formatted_error)) self.output = ActionResult('error: {0}'.format(formatted_error), 'UnhandledException') raise else: self.output = result for widget in self.widgets: get_widget_signal(widget.app, widget.widget).send( self, data=json.dumps({"result": result.as_json()})) logger.debug('Step {0} executed successfully'.format( self.ancestry)) return result
def __swap_step_input(self, step, start_input): logger.debug('Swapping input to first step of workflow {0}'.format( self.ancestry)) try: step.set_input(start_input) callbacks.WorkflowInputValidated.send(self) except InvalidInput as e: logger.error('Cannot change input to workflow {0}. ' 'Invalid input. Error: {1}'.format( self.name, format_exception_message(e))) callbacks.WorkflowInputInvalid.send(self)
def resume(self): """Resumes a Workflow that has previously been paused. """ try: logger.info('Attempting to resume workflow {0}'.format(self.name)) self._is_paused = False self._resume.set() except (StopIteration, AttributeError) as e: logger.warning('Cannot resume workflow {0}. Reason: {1}'.format( self.name, format_exception_message(e))) pass
def resume_breakpoint_step(self): """Resumes a Workflow that has hit a breakpoint at a Step. This is used for debugging purposes. """ try: logger.debug( 'Attempting to resume workflow {0} from breakpoint'.format( self.ancestry)) self.executor.send(None) except (StopIteration, AttributeError) as e: logger.warning('Cannot resume workflow {0} from breakpoint. ' 'Reason: {1}'.format(self.ancestry, format_exception_message(e))) pass
def validate_devices_api(devices_api, app_name): for device_type, device_type_api in devices_api.items(): for field_api in device_type_api['fields']: if 'default' in field_api: message_prefix = 'App {0} device type {1}'.format(app_name, device_type) default_value = field_api['default'] try: validate_device_field(field_api, default_value, message_prefix) except InvalidInput as e: logger.error( 'For {0}: Default input {1} does not conform to schema. (Error: {2})' 'Using anyways'.format(message_prefix, field_api['name'], format_exception_message(e))) raise
def validate_parameters(api, inputs, message_prefix): api_dict = {} for param in api: api_dict[param['name']] = param converted = {} seen_params = set() input_set = set(inputs.keys()) for param_name, param_api in api_dict.items(): if param_name in inputs: if not isinstance(inputs[param_name], string_types): converted[param_name] = validate_parameter( inputs[param_name], param_api, message_prefix) else: if inputs[param_name].startswith('@'): converted[param_name] = inputs[param_name] elif inputs[param_name].startswith('\@'): inputs[param_name] = inputs[param_name][1:] converted[param_name] = validate_parameter( inputs[param_name], param_api, message_prefix) else: converted[param_name] = validate_parameter( inputs[param_name], param_api, message_prefix) elif 'default' in param_api: try: default_param = validate_parameter(param_api['default'], param_api, message_prefix) except InvalidInput as e: default_param = param_api['default'] logger.warning( 'For {0}: Default input {1} (value {2}) does not conform to schema. (Error: {3})' 'Using anyways'.format(message_prefix, param_name, param_api['default'], format_exception_message(e))) converted[param_name] = default_param input_set.add(param_name) elif 'required' in param_api: message = 'For {0}: Parameter {1} is not specified and has no default'.format( message_prefix, param_name) logger.error(message) raise InvalidInput(message) else: converted[param_name] = None input_set.add(param_name) seen_params.add(param_name) if seen_params != input_set: message = 'For {0}: Too many inputs. Extra inputs: {1}'.format( message_prefix, input_set - seen_params) logger.error(message) raise InvalidInput(message) return converted
def __func(): add_device_json = request.get_json() if device_db.session.query(Device).filter( Device.name == add_device_json['name']).first() is not None: current_app.logger.error('Could not create device {0}. ' 'Device already exists.'.format( add_device_json['name'])) return {"error": "Device already exists."}, OBJECT_EXISTS_ERROR fields = { field['name']: field['value'] for field in add_device_json['fields'] } app = add_device_json['app_name'] device_type = add_device_json['type'] try: device_api = get_app_device_api(app, device_type) device_fields_api = device_api['fields'] validate_device_fields(device_fields_api, fields, device_type, app) except UnknownApp: current_app.logger.error( 'Cannot create device for app {0}, type {1}. ' 'App does not exist'.format(app, device_type)) return {'error': 'Unknown app'}, INVALID_INPUT_ERROR except UnknownDevice: current_app.logger.error( 'Cannot create device for app {0}, type {1}. ' 'Type does not exist'.format(app, device_type)) return {'error': 'Unknown device type'}, INVALID_INPUT_ERROR except InvalidArgument as e: current_app.logger.error( 'Cannot create device for app {0}, type {1}. ' 'Invalid input'.format(app, device_type, format_exception_message(e))) return {'error': 'Invalid device fields'}, INVALID_INPUT_ERROR else: fields = add_device_json['fields'] add_configuration_keys_to_device_json(fields, device_fields_api) app = device_db.session.query(App).filter(App.name == app).first() if app is None: current_app.logger.error( 'SEVERE: App defined in api does not have corresponding entry in database. ' 'Cannot add device') return {'error': 'Unknown app'}, INVALID_INPUT_ERROR device = Device.from_json(add_device_json) app.add_device(device) device_db.session.add(device) device_db.session.commit() device_json = get_device_json_with_app_name(device) # remove_configuration_keys_from_device_json(device_json) return device_json, OBJECT_CREATED
def __func(): update_device_json = request.get_json() device = device_db.session.query(Device).filter( Device.id == update_device_json['id']).first() if device is None: current_app.logger.error('Could not update device {0}. ' 'Device does not exist.'.format( update_device_json['id'])) return {"error": "Device does not exist."}, OBJECT_DNE_ERROR fields = ({ field['name']: field['value'] for field in update_device_json['fields'] } if 'fields' in update_device_json else None) app = update_device_json['app_name'] device_type = update_device_json[ 'type'] if 'type' in update_device_json else device.type try: device_api = get_app_device_api(app, device_type) device_fields_api = device_api['fields'] if fields is not None: validate_device_fields(device_fields_api, fields, device_type, app) except UnknownApp: current_app.logger.error( 'Cannot update device for app {0}, type {1}. ' 'App does not exist'.format(app, device_type)) return {'error': 'Unknown app'}, INVALID_INPUT_ERROR except UnknownDevice: current_app.logger.error( 'Cannot update device for app {0}, type {1}. ' 'Type does not exist'.format(app, device_type)) return {'error': 'Unknown device type'}, INVALID_INPUT_ERROR except InvalidArgument as e: current_app.logger.error( 'Cannot update device for app {0}, type {1}. ' 'Invalid input'.format(app, device_type, format_exception_message(e))) return {'error': 'Invalid device fields'}, INVALID_INPUT_ERROR else: if fields is not None: fields = update_device_json[ 'fields'] if 'fields' in update_device_json else None add_configuration_keys_to_device_json(fields, device_fields_api) device.update_from_json(update_device_json) device_db.session.commit() device_json = get_device_json_with_app_name(device) # remove_configuration_keys_from_device_json(device_json) return device_json, SUCCESS
def connect(self): try: self.transport = paramiko.Transport( (self.device_fields['ip'], self.device_fields['port'])) self.transport.connect( username=self.device_fields['username'], password=self.device.get_encrypted_field('password')) self.sftp_client = paramiko.SFTPClient.from_transport( self.transport) self.is_connected = True return 'Success' except SSHException as e: return 'Could not connect {}'.format( format_exception_message(e)), 'ConnectionError'
def __swap_action_arguments(self, action, start_arguments): logger.debug( 'Swapping arguments to first action of workflow {0}'.format( self.name)) try: action.set_arguments(start_arguments) WalkoffEvent.CommonWorkflowSignal.send( self, event=WalkoffEvent.WorkflowArgumentsValidated) except InvalidArgument as e: logger.error('Cannot change arguments to workflow {0}. ' 'Invalid arguments. Error: {1}'.format( self.name, format_exception_message(e))) WalkoffEvent.CommonWorkflowSignal.send( self, event=WalkoffEvent.WorkflowArgumentsInvalid)
def __func(): form = forms.ExportCaseForm(request.form) filename = form.filename.data if form.filename.data else core.config.paths.default_case_export_path try: with open(filename, 'w') as cases_file: cases_file.write( json.dumps(case_subscription.subscriptions_as_json())) current_app.logger.debug( 'Cases successfully exported to {0}'.format(filename)) return SUCCESS except (OSError, IOError) as e: current_app.logger.error( 'Error exporting cases to {0}: {1}'.format( filename, format_exception_message(e))) return {"error": "Could not write to file."}, IO_ERROR
def __func(): data = request.get_json() filename = (data['filename'] if (data is not None and 'filename' in data and data['filename']) else core.config.paths.default_case_export_path) try: with open(filename, 'w') as cases_file: cases_file.write(json.dumps(case_subscription.subscriptions)) current_app.logger.debug( 'Cases successfully exported to {0}'.format(filename)) return SUCCESS except (OSError, IOError) as e: current_app.logger.error( 'Error exporting cases to {0}: {1}'.format( filename, format_exception_message(e))) return {"error": "Could not write to file."}, IO_ERROR