#!{{ python_executable }} # Put this file in the software release promise_runner_path = "{{ promise_runner_path }}" public_folder = "{{ public_folder }}" private_folder = "{{ private_folder }}" monitor_configuration_path = "{{ monitor_configuration_path }}" promise_folder = "{{ promise_folder }}" monitor_promise_folder = "{{ monitor_promise_folder }}" promise_wrapper_folder = "{{ promise_wrapper_folder }}" import sys import os import stat import subprocess import threading import json import ConfigParser import traceback def main(): # initialisation config = loadConfig([monitor_configuration_path]) # get promises in monitor_promise_folder promise_dict = {} fillPromiseDictFromFolder(promise_dict, monitor_promise_folder) # get promises in promise_folder fillPromiseDictFromFolder(promise_dict, promise_folder) # get promises configurations for filename in os.listdir(monitor_promise_folder): path = os.path.join(monitor_promise_folder, filename) if os.path.isfile(path) and filename[-4:] == ".cfg": promise_name = filename[:-4] if promise_name in promise_dict: loadConfig([path], promise_dict[promise_name]["configuration"]) promise_items = promise_dict.items() # create symlinks from service configurations for service_name, promise in promise_items: service_config = promise["configuration"] createSymlinksFromConfig((config, "monitor", "public-folder"), (service_config, "service", "public-path-list"), service_name) createSymlinksFromConfig((config, "monitor", "private-folder"), (service_config, "service", "private-path-list"), service_name) # create symlinks from monitor.conf createSymlinksFromConfig((config, "monitor", "public-folder"), (config, "monitor", "public-path-list")) createSymlinksFromConfig((config, "monitor", "private-folder"), (config, "monitor", "private-path-list")) # generate monitor.json monitor_dict = {} tmp = softConfigGet(config, "monitor", "title") if tmp: monitor_dict["title"] = tmp tmp = softConfigGet(config, "monitor", "monitor-url-list") if tmp: monitor_dict["_links"] = {"related_monitor": [{"href": url} for url in tmp.split()]} if promise_items: service_list = [] monitor_dict["_embedded"] = {"service": service_list} for service_name, promise in promise_items: service_config = promise["configuration"] service_dict = {} service_list.append(service_dict) service_dict["id"] = service_name service_dict["_links"] = {"status": {"href": "/public/%s.status.json" % service_name}} # hardcoded tmp = softConfigGet(service_config, "service", "title") if tmp: service_dict["title"] = tmp interface_path = os.path.join(private_folder, service_name, "interface/index.html") # hardcoded if os.path.isfile(interface_path): service_dict["_links"]["interface"] = {"href": "/private/%s/interface/" % service_name} # hardcoded else: service_dict["_links"]["interface"] = {"href": "/default-promise-interface.html?service_name=%s" % service_name} # XXX hardcoded with open(config.get("monitor", "monitor-hal-json"), "w") as fp: json.dump(monitor_dict, fp) # put promises to a cron file # XXX only if at least one configuration file is modified, then write in the cron service_pid_folder = config.get("monitor", "service-pid-folder") crond_folder = config.get("monitor", "crond-folder") cron_line_list = [] for service_name, promise in promise_items: service_status_path = "%s/%s.status.json" % (public_folder, service_name) # hardcoded mkdirAll(os.path.dirname(service_status_path)) command = ("%s %s %s " % ( promise_runner_path, os.path.join(service_pid_folder, "%s.pid" % service_name), service_status_path, )) + promise["path"] cron_line_list.append("%s %s" % ( softConfigGet(service_config, "service", "frequency") or "* * * * *", command.replace("%", "\\%"), )) wrapper_path = os.path.join(promise_wrapper_folder, service_name) with open(wrapper_path, "w") as fp: fp.write("#!/bin/sh\n%s" % command) # XXX hardcoded, use dash, sh or bash binary! os.chmod(wrapper_path, stat.S_IRUSR | stat.S_IWUSR | stat.S_IXUSR | stat.S_IRGRP | stat.S_IROTH ) with open(crond_folder + "/monitor-promises", "w") as fp: fp.write("\n".join(cron_line_list)) return 0 def loadConfig(pathes, config=None): if config is None: config = ConfigParser.ConfigParser() try: config.read(pathes) except ConfigParser.MissingSectionHeaderError: traceback.print_exc() return config def fillPromiseDictFromFolder(promise_dict, folder): for filename in os.listdir(folder): path = os.path.join(folder, filename) if os.path.isfile(path) and os.access(path, os.X_OK): promise_dict[filename] = {"path": path, "configuration": ConfigParser.ConfigParser()} def softConfigGet(config, *args, **kwargs): try: return config.get(*args, **kwargs) except (ConfigParser.NoOptionError, ConfigParser.NoSectionError): return None def createSymlinksFromConfig(destination_folder_config_tuple, source_list_config_tuple, service_name=""): destination_folder = softConfigGet(*destination_folder_config_tuple) if destination_folder: source_path_str = softConfigGet(*source_list_config_tuple) if source_path_str: for path in source_path_str.split(): dirname = os.path.join(destination_folder, service_name) try: mkdirAll(dirname) # could also raise OSError os.symlink(path, os.path.join(dirname, os.path.basename(path))) except OSError, e: if e.errno != os.errno.EEXIST: raise def mkdirAll(path): try: os.makedirs(path) except OSError, e: if e.errno == os.errno.EEXIST and os.path.isdir(path): pass else: raise if __name__ == "__main__": sys.exit(main())