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