def _find_needed_params(model_file_name, path, response): from murphy.model import Model from murphy.run_planner import get_params_needed model = Model(model_file_name) path = get_params_needed(path, model.new_worker()) response.put(path)
def _build_view(model_file_name, view_name, view_type, output_dir): ''' Builds the given view ''' import sys, os from murphy.model import Model from murphy import utils, graphviz #FIXME: this is needed in order to import the module, but may be better to #do it in the model object before importing? base_path = os.path.dirname(os.path.dirname(model_file_name)) base_path = os.path.abspath(os.path.dirname(base_path)) sys.path.append(base_path) model = Model(model_file_name) worker = model.new_worker() start_node = model.get_starting_node(view_name) dot = worker.graphs.generate_from_spider(start_node, {}) temp_file = '%s/temp.dot' % output_dir target_file = '%s/flow.xml' % output_dir #FIXME: do silent_remove with proper exception handling... if os.path.isfile(temp_file): os.remove(temp_file) if os.path.isfile(target_file): os.remove(target_file) utils.save_file(dot, temp_file) graphviz.generate_svg(temp_file) os.rename('%s.svg' % temp_file, target_file) #os.remove(temp_file) #svg_content = utils.load_text_file(target_file) import zipfile zip = zipfile.ZipFile('%s.zip' % target_file, 'w') zip.write(target_file, 'flow.xml') zip.close() _build_dot_with_screenshots(dot, worker, output_dir, model.images_dir) svg_content = utils.load_text_file('%s/simple-flow-images.xml' % output_dir) svg_content = svg_content.replace('xlink:href="%s/' % output_dir, 'xlink:href="') utils.save_file(svg_content, '%s/local-simple-flow-images.xml' % output_dir) downloadable_name = os.path.basename(model_file_name) if downloadable_name.find(".") != -1: downloadable_name = downloadable_name.split(".")[0] downloadable_name = '%s-%s-simple.zip' % (downloadable_name, view_name) zip = zipfile.ZipFile('%s/%s' % (output_dir, downloadable_name), 'w') zip.write('%s/local-simple-flow-images.xml' % output_dir, 'flow.xml') for file_name in os.listdir(output_dir): if file_name.endswith(".png") or file_name.endswith(".gif"): zip.write('%s/%s' % (output_dir, file_name), file_name) zip.close()
def run_remote_test(test_function, model_file): remoting_obj = None try: model = Model(model_file) remoting_obj = model.rules.get_remoting_vnc_object() worker = model.new_worker(remoting_obj.automation) test_function(worker) print "PASS" except Exception, e: print "FAILED TEST, error: %s" % str(e)
def run_local_test(test_function, model_file): try: logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(name)s - %(levelname)s - %(message)s') model = Model(model_file) worker = model.new_worker() test_function(worker) print "PASS" except Exception, e: print "FAILED TEST, error: %s" % str(e)
def _run_plan(model_file_name, plan, out_file_name): import os, sys, time, json try: os.makedirs(os.path.dirname(out_file_name)) except: pass print "should log to " + out_file_name import logging from murphy.model import Model fileHandler = logging.FileHandler(out_file_name + '.bsy', mode='a', encoding=None, delay=False) root_logger = logging.getLogger() root_logger.addHandler(fileHandler) formatter = logging.Formatter( '%(asctime)s - %(name)s - %(levelname)s - %(message)s') fileHandler.setFormatter(formatter) logging.getLogger().removeHandler(logging.getLogger().handlers[0]) LOGGER = logging.getLogger('root.' + __name__) LOGGER.info("Run request runs on pid " + str(os.getpid())) remoting = None try: steps = [] run_params = {} for step in plan: steps.append((step['node'], step['arc'])) params = step['params'] for param in params: values = run_params.get(param['name'], []) values.append(param['value']) run_params[param['name']] = values model = Model(model_file_name) remoting = model.rules.get_remoting_vnc_object() worker = model.new_worker(remoting.automation) worker.parameters.update(run_params) LOGGER.info("Requesting run:\n%s" % json.dumps(steps, sort_keys=True, indent=4)) LOGGER.info("Using values:\n%s" % json.dumps(worker.parameters, sort_keys=True, indent=4)) LOGGER.info("Running at ip %s" % remoting.ip_address) LOGGER.info("Remoting at vnc://%s:%s" % (remoting.vnc_host, remoting.vnc_port)) worker.Walk_ext(steps) except Exception, ex: # traceback.print_exc(file=sys.stdout) LOGGER.exception(ex)
def _get_edge_logs(model_file_name, node_name, edge_name, response): try: from murphy.model import Model model = Model(model_file_name) worker = model.new_worker() ret = worker.get_verb_logs(node_name, edge_name) if ret != "": with open(model.working_dir + "/" + ret, "r") as the_log: ret = the_log.read() response.put(ret) except Exception, ex: traceback.print_exc(file=sys.stdout) print "Problem: %s" % str(ex) response.put("Error while getting edge logs: %s" % str(ex))
def _get_views(model_file_name): ''' Returns the view names of the given model ''' if os.path.exists(model_file_name): model = Model(model_file_name, load_modules=False) view_names = [] for view in model.model['views']: view_names.append({ 'name': view['name'], 'starts_at': view['starts at'] }) return view_names else: print "No views found since model %s does not exists" % model_file_name return []
def _solve_route(steps, model_file_name, tags, response): ''' Multiprocessing friendly implementation ''' from murphy.model import Model from murphy.run_planner import solve_plan from murphy.errors import NoRouteFound model = Model(model_file_name) plan = [] for step in steps: a_step = {'node': step, 'heuristics': ['shortest']} plan.append(a_step) path = [] try: path = solve_plan(plan, model.new_worker(), model, tags) except NoRouteFound: pass #return an empty path when there's no path response.put(path)
def _get_graph_logs(model_file_name, response): try: from murphy.model import Model model = Model(model_file_name) worker = model.new_worker() views = worker.get_views() ret = {} for node in views.keys(): for edge in views[node]['verbs'].keys(): edge_def = views[node]['verbs'][edge] log = worker.get_verb_logs(node, edge) if log != "": with open(model.working_dir + "/" + log, "r") as the_log: log = the_log.read() ret["%s.%s" % (node, edge)] = json.loads(log) response.put(json.dumps(ret)) except Exception, ex: traceback.print_exc(file=sys.stdout) print "Problem: %s" % str(ex) response.put("Error while getting graph logs: %s" % str(ex))
def __init__(self, model_file_name, reference_model_file_name): self.model = Model(model_file_name) self.reference_model = Model(reference_model_file_name)
def get_view(model_name, view_name): ''' Responses are: flow.xml flow-images.xml simple-flow-images.xml empty.xml local-simple-flow-images is not returned but built for zip ''' try: view_type = request.query.type if view_type == '': view_type = 'flow' should_build = True view_directory = "projects/%s/%s" % (model_name, view_name) view_file_name = "%s/%s.xml" % (view_directory, view_type) if not os.path.isdir(view_directory): os.makedirs(view_directory) model_file = _get_model_file_name(model_name) if os.path.isfile(view_file_name): since = os.stat(view_file_name).st_mtime if utils.files_modified_since(os.path.dirname(model_file), since): os.remove(view_file_name) else: should_build = False if should_build: return_empty = False if os.path.exists(model_file) == False: return_empty = True else: model = Model(model_file, load_modules=False) view_exists = False for view in model.model['views']: if view['name'] == view_name: view_exists = True break if not view_exists: return_empty = True if return_empty: resp = static_file('empty.xml', root='static') resp.headers['Cache-Control'] = 'no-cache' return resp build_view(model_file, view_name, view_type, view_directory) utils.inline_images("%s/flow-images.xml" % view_directory) utils.inline_images("%s/simple-flow-images.xml" % view_directory) if view_type == 'download': resp = static_file('%s/download.zip' % view_directory, root='') else: # FIXME: lacks wrap the answer with status if view_type in ('flow-images', 'simple-flow-images'): view_file_name = "%s/%s.xml" % (view_directory, 'inlined_' + view_type) resp = static_file(view_file_name, root='') resp.headers['Cache-Control'] = 'no-cache' return resp except Exception, ex: # pylint: disable=W0703 traceback.print_exc(file=sys.stdout) return { "status": "fail", "text": "Error when creating the model graph: %s" % str(ex) }