def log_to_database(_data, _category, _severity, _process_id_param, _user_id, _occurred_when, _address_param, _node_id, _uid, _pid): global _log_to_database_severity, process_id, _broker_url, _peers, _verify_SSL, _address if _process_id_param is None: _process_id_param = process_id if _severity < _log_to_database_severity: log_locally(_data, _category, _severity, _process_id_param, _user_id, _occurred_when, _address, _node_id, _uid, _pid) else: _event = make_event(_data, _category, _severity, _process_id_param, _user_id, _occurred_when, _address, _node_id, _uid, _pid) if _session_id in _peers: _session = _peers[_session_id] if "web_socket" in _session and _session["web_socket"].connected: _session["queue"].put(_event) else: try: call_api("https://" + _broker_url + "/write_to_log", _session_id, _event, _print_log=True, _verify_SSL=_verify_SSL) except Exception as e: log_locally("Failed to send to broker, error: " + str(e) + "\nEvent:" + str(_event), EC_UNCATEGORIZED, SEV_ERROR, _process_id_param, _user_id, _occurred_when,_address, _node_id, _uid, _pid) log_locally(_data, _category, _severity, process_id, _user_id, _occurred_when,_address, _node_id, _uid, _pid)
def step_impl(context): """ :type context behave.runner.Context """ call_api(_url="https://127.0.0.1:8080/admin/control/agent_control", _session_id=context.session["session_id"], _data={"address": "agent01", "command": "stop", "reason": "Testing to stop an Agent."}, _verify_SSL=False ) ok_(True)
def step_impl(context): """ :type context behave.runner.Context """ print(_log_prefix + "Telling Broker to stop using a call to stop_broker...") call_api(_url="https://127.0.0.1:8080/admin/broker_control", _session_id=context.session["session_id"], _data={"command": "stop", "reason": "Testing stopping the broker"}, _verify_SSL=False ) ok_(True)
def step_impl(context): """ :type context behave.runner.Context """ call_api(_url="https://127.0.0.1:8080/admin/control/agent_control", _session_id=context.session["session_id"], _data={ "address": "agent01", "command": "stop", "reason": "Testing to stop an Agent." }, _verify_SSL=False) ok_(True)
def step_impl(context): """ :type context behave.runner.Context """ print(_log_prefix + "Telling Broker to restart using a call to broker_control...") call_api(_url="https://127.0.0.1:8080/admin/broker_control", _session_id=context.session["session_id"], _data={"command": "restart", "reason": "Testing restarting the broker"}, _verify_SSL=False ) print(_log_prefix + "Waiting for process to exit...") context.broker_process.join(timeout=2) ok_(True)
def step_impl(context): """ :type context behave.runner.Context """ try: _response = call_api(_url="https://127.0.0.1:8080/get_broker_environment", _session_id=context.session["session_id"], _data={}, _verify_SSL=False) except Exception as e: ok_(True, str(e)) else: os.kill(_response["systemPid"], 9) ok_(False, "The broker could still be reached after being told to shut down, killed pid "+ str(_response["systemPid"] + " manually."))
def step_impl(context): """ :type context behave.runner.Context """ _processes = call_api(_url="https://127.0.0.1:8080/admin/control/get_system_processes", _session_id=context.session["session_id"], _data={}, _verify_SSL=False ) print("Processes:") for _process in _processes: print(str(_process)) if _process["name"] == "Agent instance(agent01)": ok_(True) return ok_(False)
def step_impl(context): """ :type context behave.runner.Context """ _processes = call_api( _url="https://127.0.0.1:8080/admin/control/get_system_processes", _session_id=context.session["session_id"], _data={}, _verify_SSL=False) print("Processes:") for _process in _processes: print(str(_process)) if _process["name"] == "Agent instance(agent01)": ok_(True) return ok_(False)
def step_impl(context, address): """ :type context behave.runner.Context """ print("Tester: Calling get_peers and checking for the address " + str(address)) try: _peers = call_api(_url="https://127.0.0.1:8080/admin/get_peers", _session_id=context.session["session_id"], _data={}, _verify_SSL=False ) except Exception as e: ok_(False, "An error occurred contacting server:" + str(e)) if _peers: for _peer in _peers: if "web_socket" in _peer and _peer["address"] == address and _peer["web_socket"] == "removed for serialization": ok_(True) return ok_(False, "No " + str(address) + " peer registered.") else: ok_(False, "No response from the server.")
def start_agent(_cfg_filename = None): """ Starts the agent; Loads settings, connects to database, registers process and starts the web server. """ global process_id, _control_monitor, _terminated, _address, _process_queue_manager, _broker_url, \ _username, _password, _peers, _log_to_database_severity, _verify_SSL _process_id = str(ObjectId()) of.common.logging.callback = log_locally _terminated = False # Handle multiprocessing on windows freeze_support() write_srvc_dbg("=====start_agent===============================") try: if _cfg_filename is None: _cfg_filename = resolve_config_path() _settings = JSONXPath(_cfg_filename) except Exception as e: write_to_log("Error loading settings: " + str(e), _category=EC_SERVICE, _severity=SEV_FATAL, _process_id=_process_id) return of.common.logging.severity = of.common.logging.severity_identifiers.index( _settings.get("agent/logging/severityLevel", _default="warning")) _log_to_database_severity = of.common.logging.severity_identifiers.index( _settings.get("agent/logging/brokerLevel", _default="warning")) write_srvc_dbg("===register signal handlers===") register_signals(stop_agent) # An _address is completely necessary. _address = _settings.get("agent/address", _default=None) if not _address or _address == "": raise Exception(write_to_log( "Fatal error: Agent cannot start, missing [agent] _address setting in configuration file.", _category=EC_SERVICE, _severity=SEV_FATAL)) # An _address is completely necessary. _verify_SSL = _settings.get("agent/verifySSL", _default=True) # Gather credentials _broker_url = _settings.get("agent/brokerUrl", _default="127.0.0.1:8080") _username = _settings.get("agent/username") if not _username: raise Exception(write_to_log("Username must be configured", _category=EC_SERVICE, _severity=SEV_FATAL)) _password = _settings.get("agent/password") if not _password: raise Exception(write_to_log("Password must be configured", _category=EC_SERVICE, _severity=SEV_FATAL)) _retries = int(_settings.get("agent/connectionRetries", 5)) # Register at the broker if not register_agent(_retries): raise Exception(write_to_log("Fatal: The agent failed to register with the broker, tried " + str( _retries + 1) + " time(s), quitting.", _category=EC_SERVICE, _severity=SEV_FATAL)) os._exit(1) of.common.logging.callback = log_to_database _repository_base_folder = _settings.get_path("agent/repositoryFolder", _default=os.path.join(os.path.dirname(__file__), "repositories")) write_srvc_dbg("Load schema tool") try: # Initiate a schema tools instance for validation other purposes. _schema_tools = SchemaTools(_json_schema_folders=[of_schema_folder(), os.path.abspath(os.path.join(script_dir, "..", "schemas", "namespaces")) ], _uri_handlers={"ref": None}) except Exception as e: raise Exception(write_to_log("An error occurred while loading schema tools:" + str(e), _category=EC_SERVICE, _severity=SEV_FATAL)) os._exit(1) return write_srvc_dbg("Load schema tool done") try: write_srvc_dbg("Initializing monitors") # Init the monitor for incoming messages _message_monitor = Monitor( _handler=AgentWebSocketHandler(_process_id=_process_id, _peers=_peers, _schema_tools=_schema_tools, _address=_address, _broker_address="broker")) # The manager for the process queue _process_queue_manager = multiprocessing.Manager() # Init the monitor for the worker queue _worker_monitor = Monitor( _handler=WorkerSupervisor(_process_id=_process_id, _message_monitor=_message_monitor, _repo_base_folder=_repository_base_folder, _severity=of.common.logging.severity), _queue=_process_queue_manager.Queue()) # Init the monitor for the agent queue _control_monitor = Monitor( _handler=ControlHandler(_process_id=_process_id, _message_monitor=_message_monitor, _worker_monitor=_worker_monitor, _stop_agent=stop_agent )) # The global variable for handling websockets. TODO: Could this be done without globals? (PROD-33) of.common.messaging.websocket.monitor = _message_monitor write_srvc_dbg("Initializing monitors done") except Exception as e: raise Exception(write_to_log("Fatal: An error occurred while initiating the monitors and handlers:" + str(e), _category=EC_SERVICE, _severity=SEV_FATAL)) os._exit(1) # Try to connect to websocket, quit on failure if not connect_to_websocket(): os._exit(1) write_srvc_dbg("Register agent system process") _control_monitor.handler.message_monitor.queue.put( [None, store_process_system_document(_process_id=_process_id, _name="Agent instance(" + _address + ")")]) write_srvc_dbg("Log agent system state") _control_monitor.handler.message_monitor.queue.put([None, log_process_state_message(_changed_by=zero_object_id, _state="running", _process_id=_process_id, _reason="Agent starting up at " + _address)]) # Security check to remind broker if it is unsecured if not _verify_SSL: try: call_api("https://"+ _broker_url + "/status", _data={}, _session_id= _session_id, _verify_SSL=True) except SSLError as e: write_to_log("There is a problem with the security certificate:\n" + str(e) + "\n" "This is a security risk, and and important thing to _address.", _category=EC_NOTIFICATION, _severity=SEV_WARNING) except Exception as e: write_to_log("An error occured while checking status of broker and SSL certificate:" + str(e), _category=EC_NOTIFICATION, _severity=SEV_ERROR) write_srvc_dbg("Agent up and running.") while not _terminated: time.sleep(0.1) write_srvc_dbg("Exiting main thread")