Esempio n. 1
0
 def __init__(self, logger, config_filename=CONFIG_FILENAME):
     self._logger = logger
     self._node_config = ConfigParser(config_filename)
     self._reporter_queue = Queue()
     if self._node_config.node_net_mode == "net":
         beacon_server, beacon_port, beacon_interval = self._node_config.beacon_config
         report_server, report_port = self._node_config.report_config
         tcp_listener_port = self._node_config.listener_config
         self._listener_queue = Queue()
         self._beacon_client = BeaconClient(beacon_server, beacon_port,
                                            self._node_config.node_name,
                                            beacon_interval,
                                            tcp_listener_port)
         self._tcp_listener = Listener(tcp_listener_port,
                                       self._listener_queue)
         self._listener_worker = ListenerWorker(self._listener_queue,
                                                self._reporter_queue)
         self._report_worker = ReportWorker(True, self._reporter_queue,
                                            self._node_config.file_type,
                                            self._node_config.programs,
                                            report_server, report_port)
     else:  # else single mode
         self._report_worker = ReportWorker(False, self._reporter_queue,
                                            self._node_config.file_type,
                                            self._node_config.programs)
     if self._node_config.node_op_mode == 'fuzzing':
         self._fuzzer = self.__choose_fuzzer()
         if os.path.isfile("fuzz_state.pickle"):
             try:
                 with open("fuzz_state.pickle", 'r') as fd:
                     self._fuzzer.set_state(pickle.load(fd))
                 os.remove("fuzz_state.pickle")
             except KeyError as er:
                 self._logger.error(
                     "Error while restoring the PRNG state -> " +
                     er.message)
                 self._fuzzer.set_seed()
         self._operation_worker = FuzzingWorker(
             self._node_config.programs,
             self._fuzzer,
             self._reporter_queue,
         )
     elif self._node_config.node_op_mode == 'reducing':
         self._reducer = self.__choose_reducer()
         self._operation_worker = ReducingWorker(self._reducer,
                                                 self._node_config.programs,
                                                 self._reporter_queue)
     else:
         raise ValueError('Unsupported operation mode!')
Esempio n. 2
0
 def __init__(self, logger, config_filename=CONFIG_FILENAME):
     self._node_dict = {}
     self._crash_dict = {}
     self._logger = logger
     self._config = ConfigParser(config_filename)
     beacon_port, beacon_timeout, config_req_interval = self._config.beacon_config
     report_port = self._config.report_server_config
     web_port = self._config.web_server_config
     self._beacon_queue = Queue()
     self._node_queue = Queue()
     self._report_queue = Queue()
     self._web_queue = Queue()
     self._db_queue = Queue()
     self._db_worker = DatabaseWorker(self._db_queue, self._node_dict,
                                      self._crash_dict)
     self._db_worker.load()
     self._beacon_server = BeaconServer(beacon_port, self._beacon_queue)
     self._beacon_worker = BeaconWorker(self._beacon_queue,
                                        self._node_queue, self._db_queue,
                                        beacon_timeout, config_req_interval,
                                        self._node_dict)
     self._report_server = ReportServer(report_port, self._report_queue)
     self._report_worker = ReportWorker(self._report_queue, self._db_queue,
                                        self._node_dict, self._crash_dict)
     self._node_client_worker = NodeClientWorker(self._node_queue)
     self._web_server = WebServer(web_port, self._web_queue, self.web_main)