def __init__(self): super(RawReportProcessor, self).__init__() from faraday.client.start_client import setupPlugins setupPlugins() self.pending_actions = Queue() try: plugin_manager = PluginManager( os.path.join(CONF.getConfigPath(), "plugins")) except AttributeError: get_logger().warning( "Upload reports in WEB-UI not configurated, run Faraday client and try again..." ) self._stop = True return mappers_manager = MapperManager() self.model_controller = ModelController(mappers_manager, self.pending_actions) self.model_controller.start() self.end_event = Event() plugin_controller = PluginController('PluginController', plugin_manager, mappers_manager, self.pending_actions, self.end_event) self.processor = ReportProcessor(plugin_controller, None) self._stop = False
def __init__(self, args): self._original_excepthook = sys.excepthook self.args = args if args.creds_file: try: with open(args.creds_file, 'r') as fp: creds = json.loads(fp.read()) username = creds.get('username') password = creds.get('password') session_cookie = login_user(CONF.getServerURI(), username, password) if session_cookie: logger.info('Login successful') CONF.setDBUser(username) CONF.setDBSessionCookies(session_cookie) else: logger.error('Login failed') except (IOError, ValueError): logger.error("Credentials file couldn't be loaded") self._mappers_manager = MapperManager() pending_actions = Queue() self._model_controller = ModelController(self._mappers_manager, pending_actions) self._plugin_manager = PluginManager( os.path.join(CONF.getConfigPath(), "plugins"), pending_actions=pending_actions, ) self._workspace_manager = WorkspaceManager( self._mappers_manager) # Create a PluginController and send this to UI selected. self._plugin_controller = PluginController( 'PluginController', self._plugin_manager, self._mappers_manager, pending_actions ) if self.args.cli: self.app = CliApp(self._workspace_manager, self._plugin_controller) if self.args.keep_old: CONF.setMergeStrategy("old") else: CONF.setMergeStrategy("new") else: self.app = UiFactory.create(self._model_controller, self._plugin_manager, self._workspace_manager, self._plugin_controller, self.args.gui) self.timer = TimerClass() self.timer.start()
def test_end_pluging_multiple_times(): mappers_manager = MapperManager() pending_actions = Queue() controller = ModelController(mappers_manager, pending_actions) controller._pluginEnd('test', None) controller._pluginEnd('test', None) assert controller.active_plugins_count == 0 assert controller.processing is False
def test_controller_stop_when_is_not_processing(): mappers_manager = MapperManager() pending_actions = Queue() controller = ModelController(mappers_manager, pending_actions) assert controller.processing is False assert controller._must_stop is False controller.start() assert controller.is_alive() controller.stop() controller.join() assert controller._must_stop is True assert controller.is_alive() is False
def test_find(get, url_endpoint, test_data, session): if 'api_result' in test_data: get.return_value = test_data['api_result'] mappers_manager = MapperManager() pending_actions = Queue() controller = ModelController(mappers_manager, pending_actions) workspace = WorkspaceFactory.create() mappers_manager.createMappers(workspace.name) obj = test_data['factory'].create(workspace=workspace) session.add(obj) session.commit() result = controller.find(test_data['class_signature'], obj.id) assert get.called print(get.mock_calls[0][1][0]) assert get.mock_calls[0][1][0].endswith('/_api/v2/ws/{0}/{1}/{2}/'.format( workspace.name, url_endpoint, obj.id))
def process_workspaces(mappers_manager, plugin_manager, query, disable_polling): report_managers = [] controllers = [] for workspace in query.all(): pending_actions = Queue() plugin_controller = PluginController( 'PluginController', plugin_manager, mappers_manager, pending_actions ) mappers_manager.createMappers(workspace.name) controller = ModelController(mappers_manager, pending_actions) workspace_manager = WorkspaceManager(mappers_manager) setUpAPIs(controller, workspace_manager, hostname=None, port=None) controller.start() controllers.append(controller) report_manager = ReportManager( 0.1, workspace.name, plugin_controller, polling=not disable_polling ) report_managers.append(report_manager) report_manager.start() for report_manager in report_managers: report_manager.stop() for controller in controllers: controller.stop()
def test_only_start_plugin(): mappers_manager = MapperManager() pending_actions = Queue() controller = ModelController(mappers_manager, pending_actions) controller._pluginStart('test', None) assert controller.active_plugins_count == 1 assert controller.processing controller._pluginStart('test', None) assert controller.active_plugins_count == 2
class RawReportProcessor(Thread): def __init__(self): super(RawReportProcessor, self).__init__() from faraday.client.start_client import setupPlugins setupPlugins() self.pending_actions = Queue() try: plugin_manager = PluginManager( os.path.join(CONF.getConfigPath(), "plugins")) except AttributeError: get_logger().warning( "Upload reports in WEB-UI not configurated, run Faraday client and try again..." ) self._stop = True return mappers_manager = MapperManager() self.model_controller = ModelController(mappers_manager, self.pending_actions) self.model_controller.start() self.end_event = Event() plugin_controller = PluginController('PluginController', plugin_manager, mappers_manager, self.pending_actions, self.end_event) self.processor = ReportProcessor(plugin_controller, None) self._stop = False def stop(self): self.model_controller.stop() self._stop = True def run(self): logger.info('Tool report processor started') while not self._stop: try: workspace, file_path, cookie = UPLOAD_REPORTS_QUEUE.get( False, timeout=0.1) get_logger().info( 'Processing raw report {0}'.format(file_path)) # Cookie of user, used to create objects in server with the right owner. server.FARADAY_UPLOAD_REPORTS_WEB_COOKIE = cookie server.FARADAY_UPLOAD_REPORTS_OVERWRITE_SERVER_URL = "http://{0}:{1}".format( FaradayServerConfig.faraday_server.bind_address, FaradayServerConfig.faraday_server.port) self.processor.ws_name = workspace command_id = self.processor.processReport(file_path) UPLOAD_REPORTS_CMD_QUEUE.put(command_id) if not command_id: continue self.end_event.wait() get_logger().info( 'Report processing of report {0} finished'.format( file_path)) self.end_event.clear() except Empty: time.sleep(0.1) except KeyboardInterrupt as ex: get_logger().info( 'Keyboard interrupt, stopping report processing thread') self.stop() except Exception as ex: get_logger().exception(ex) continue
def test_controller_cant_be_stopped_when_is_processing(): """ If someone tells the controller to stop and it is processing then it will stop when the processing finishes """ mappers_manager = MapperManager() pending_actions = Queue() controller = ModelController(mappers_manager, pending_actions) assert controller.processing is False assert controller._must_stop is False controller.start() controller.processing = True controller.active_plugins_count = 1 assert controller.is_alive() controller.stop() assert controller._must_stop is True assert controller.processing controller.join(timeout=2) assert controller.is_alive() controller.processing = False controller.join() assert controller.is_alive() is False
def test_controller_plugin_start_action_updates_internal_state(): mappers_manager = MapperManager() pending_actions = Queue() controller = ModelController(mappers_manager, pending_actions) controller.start() controller.add_action((Modelactions.PLUGINSTART, "test", None)) time.sleep(1) assert controller.active_plugins_count == 1 assert controller.processing controller.add_action((Modelactions.PLUGINEND, "test", None)) time.sleep(1) assert controller.active_plugins_count == 0 assert controller.processing is False controller.stop() controller.join() assert controller.is_alive() is False
def dispatch(args, unknown, user_help, username, password): session_cookie = login_user(args.url, username, password) if not session_cookie: raise UserWarning('Invalid credentials!') CONF.setDBUser(username) CONF.setDBSessionCookies(session_cookie) if '--' in unknown: unknown.remove('--') # We need the ModelController to register all available models mappers_manager = MapperManager() pending_actions = Queue() model_controller = ModelController(mappers_manager, pending_actions) if not args.command: print(user_help) if not args.interactive: sys.exit(1) if args.command not in list(plugins.keys()): sys.stderr.write(Fore.RED + ("ERROR: Plugin %s not found.\n" % args.command) + Fore.RESET) if args.interactive: return None else: sys.exit(1) from faraday import client # pylint:disable=import-outside-toplevel faraday_directory = os.path.dirname( os.path.realpath(os.path.join(client.__file__))) plugin_path = os.path.join(faraday_directory, "bin/", args.command + '.py') # Get filename and import this module_fplugin = imp.load_source('module_fplugin', plugin_path) module_fplugin.models.server.FARADAY_UP = False module_fplugin.models.server.SERVER_URL = args.url module_fplugin.models.server.AUTH_USER = username module_fplugin.models.server.AUTH_PASS = password call_main = getattr(module_fplugin, 'main', None) if call_main is None: sys.stderr.write(Fore.RED + "ERROR: Main function not found.\n" + Fore.RESET) if args.interactive: return None else: sys.exit(1) # Inspect the main function imported from the plugin and decide the best calling option main_argspec = inspect.getargspec(call_main) if main_argspec != CURRENT_MAIN_ARGSPEC: # Function argspec does not match current API. # Warn the user and call with original parameteres. sys.stderr.write( Fore.YELLOW + "WARNING: Plugin does not follow current call signature. Please update it! [%s.py]\n" % args.command + Fore.RESET) obj_id = None if {'args', 'parser'} <= set(main_argspec.args): # Function accepts args and parser arguments new_parser = argparse.ArgumentParser( description=plugins[args.command]['description'], prog="fplugin %s" % args.command, formatter_class=RawDescriptionAndDefaultsHelpFormatter) ret, obj_id = call_main(workspace=args.workspace, args=unknown, parser=new_parser) if obj_id is not None: print(obj_id) else: # Use old API to call plugin sys.stderr.write( Fore.YELLOW + "WARNING: Call with arguments and parser not supported.\n" + Fore.RESET) ret = call_main(workspace=args.workspace) if ret is None: ret = 0 if args.interactive: # print ('code = %d' % ret) return obj_id else: sys.exit(ret)
class MainApplication(object): def __init__(self, args): self._original_excepthook = sys.excepthook self.args = args if args.creds_file: try: with open(args.creds_file, 'r') as fp: creds = json.loads(fp.read()) username = creds.get('username') password = creds.get('password') session_cookie = login_user(CONF.getServerURI(), username, password) if session_cookie: logger.info('Login successful') CONF.setDBUser(username) CONF.setDBSessionCookies(session_cookie) else: logger.error('Login failed') except (IOError, ValueError): logger.error("Credentials file couldn't be loaded") self._mappers_manager = MapperManager() pending_actions = Queue() self._model_controller = ModelController(self._mappers_manager, pending_actions) self._plugin_manager = PluginManager( os.path.join(CONF.getConfigPath(), "plugins"), pending_actions=pending_actions, ) self._workspace_manager = WorkspaceManager( self._mappers_manager) # Create a PluginController and send this to UI selected. self._plugin_controller = PluginController( 'PluginController', self._plugin_manager, self._mappers_manager, pending_actions ) if self.args.cli: self.app = CliApp(self._workspace_manager, self._plugin_controller) if self.args.keep_old: CONF.setMergeStrategy("old") else: CONF.setMergeStrategy("new") else: self.app = UiFactory.create(self._model_controller, self._plugin_manager, self._workspace_manager, self._plugin_controller, self.args.gui) self.timer = TimerClass() self.timer.start() def on_connection_lost(self): """All it does is send a notification to the notification center""" faraday.client.model.guiapi.notification_center.DBConnectionProblem() def enableExceptHook(self): sys.excepthook = exception_handler installThreadExcepthook() def start(self): try: signal.signal(signal.SIGINT, self.ctrlC) faraday.client.model.api.devlog("Starting application...") faraday.client.model.api.devlog("Setting up remote API's...") if not self.args.workspace: workspace = CONF.getLastWorkspace() self.args.workspace = workspace faraday.client.model.api.setUpAPIs( self._model_controller, self._workspace_manager, CONF.getApiConInfoHost(), CONF.getApiConInfoPort()) faraday.client.model.guiapi.setUpGUIAPIs(self._model_controller) faraday.client.model.api.devlog("Starting model controller daemon...") self._model_controller.start() faraday.client.model.api.startAPIServer() restapi.startAPIs( self._plugin_controller, self._model_controller, CONF.getApiConInfoHost(), CONF.getApiRestfulConInfoPort() ) faraday.client.model.api.devlog("Faraday ready...") exit_code = self.app.run(self.args) except Exception as exception: print("There was an error while starting Faraday:") print("*" * 3) print(exception) # instead of traceback.print_exc() print("*" * 3) exit_code = -1 finally: return self.__exit(exit_code) def __exit(self, exit_code=0): """ Exits the application with the provided code. It also waits until all app threads end. """ faraday.client.model.api.log("Closing Faraday...") faraday.client.model.api.devlog("stopping model controller thread...") faraday.client.model.api.stopAPIServer() restapi.stopServer() self._model_controller.stop() if self._model_controller.isAlive(): # runs only if thread has started, i.e. self._model_controller.start() is run first self._model_controller.join() self.timer.stop() faraday.client.model.api.devlog("Waiting for controller threads to end...") return exit_code def quit(self): """ Redefined quit handler to nicely end up things """ self.app.quit() def ctrlC(self, signal, frame): logger.info("Exiting...") self.app.quit()