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")
