def _prepare_plans(self):
all_plans = self.ctx.get_plans()
all_test_plans = self.ctx.get_test_plans()
requested_plans = trim_all(self._get_str(RUN_SECTION,
PLANS_KEY)).split(',')
ignore_plans = trim_all(self._get_str(RUN_SECTION,
IGNORE_KEY)).split(',')
ignore_plans = self._expand_plans(ignore_plans)
should_run_all = False
if ALL in requested_plans:
should_run_all = True
del requested_plans[requested_plans.index(ALL)]
if len(requested_plans) == 1 and not requested_plans[0]:
raise RestrekError('No plans specified')
for p in requested_plans:
if p not in all_plans:
raise RestrekError('Unknown plan %s' % p)
all_test_plans_but_requested = [
x for x in all_test_plans if x not in requested_plans
]
_plans = requested_plans
if should_run_all:
_plans.extend(all_test_plans_but_requested)
self.plans_to_run = [x for x in _plans if x not in ignore_plans]
def run(self):
urischema = 'https://' if self.secure else 'http://'
url = '{}{}{}'.format(urischema, self.host, self.url)
req = HttpRequest(http_method=self.method,
url=url,
data=self.payload,
headers=self.headers)
self.log(req)
try:
self.set_response(self.do_run(req, self.timeout))
except ConnectionError as e:
raise RestrekError(e.message)
except TypeError as e:
raise RestrekError(e.message)
def from_raw(cls, data):
cmd_attrs = data.keys()
descr = data[cmd_attrs.pop(
cmd_attrs.index('name'))] if 'name' in cmd_attrs else None
if len(cmd_attrs) > 1:
raise RestrekError('malformed plan')
if len(cmd_attrs) == 0:
raise RestrekError('plan is missing a plugin to run')
plugin_name = cmd_attrs.pop(0)
props = data[plugin_name]
return cls(plugin_name, descr, props)
def _do_load(self, env, name, data=None):
try:
tpl = env.get_template(name)
except TemplateNotFound:
raise RestrekError('%s not found' % name)
output = tpl.render(data) if data else tpl.render()
return yaml_load(output)
def split_name(name):
r"""Commands and plans are identified by their group and their actual name
So for example if a plan `myplan` is grouped in `mygroup` then its full qualified
name is `mygroup.myplan`
this method will extract both group and template name.
"""
if not name:
raise RestrekError('can\'t split empty names')
words = re.split('\.', name)
if len(words) == 1:
return None, words[0]
elif len(words) == 0 or len(words) > 2:
raise RestrekError('%s not a valid name' % name)
else:
return words
def load_step(self, obj, data=None):
source = yaml_dump(obj)
tpl = self.default_env.from_string(source)
try:
output = tpl.render(data) if data else tpl.render()
except jinja2.exceptions.UndefinedError as e:
raise RestrekError('%s' % e.message)
return yaml_load(output)
def parse(self):
r"""Parse props and set attributes to the command according to its schema"""
for k in self.schema_in:
if k not in self._props:
if DEFAULT_KEY in self.schema_in[k]:
setattr(self, k, self.schema_in[k][DEFAULT_KEY])
else:
raise RestrekError(
'attribute `{}` in command `{}` is requried'.format(
k, self.name))
else:
setattr(self, k, self._props[k])
def load_plan(self, name):
g, f = utils.split_name(name)
path = ''
for ext in C.YAML_EXTS:
test_path = join(self.plans_dir, g, f + ext)
if exists(test_path):
path = test_path
break
if not exists(path):
raise RestrekError('Plan %s does not exist (%s)' % (name, path))
return yaml_load_file(path)
def _load_properies(self):
properties_file = ''
for ext in C.YAML_EXTS:
tmp = join(self.environments_dir, self.env,
C.PROPERTIES_NAME + ext)
if os.path.isfile(tmp):
properties_file = tmp
break
if not os.path.isfile(properties_file):
raise RestrekError(
'Environment {} should have a properties file'.format(
self.env))
self.properties_source[C.ENV_KEY] = properties_file
def parse_registration_statement(target_kw,
register_statement,
context=dict()):
r"""Will parse registration statement"""
if not target_kw or not is_valid_identifier(target_kw):
raise RestrekError('%s is not a valid keyword' % target_kw)
out = dict()
try:
out[target_kw] = eval(register_statement, {}, context)
except (NameError, KeyError, IndexError) as e:
print 'Unknown element %s - %s' % (target_kw, e)
except SyntaxError as e:
print 'Invalid syntax %s' % e
except TypeError as e:
print 'Problem in statement `%s` (%r)' % (register_statement, e)
return out
def ensure_filename(filename):
if is_valid_filename(filename) is None:
raise RestrekError('%s invalid filename' % filename)