def _try_resolve(current, to_resolve):
if current['resolved']:
return
definition = current['definition']
pending = definition.get('executor', {}).get('actors', ())
if definition.get('extends'):
pending = (definition['extends'].get('name'), )
for name in pending:
actor = get_actor(name)
if not actor and name in to_resolve:
if not to_resolve[name]['resolved']:
_try_resolve(to_resolve[name], to_resolve)
actor = get_actor(name)
if not actor:
raise LookupError("Failed to resolve dependencies for {}".format(
current['name']))
if definition.get('extends'):
_apply_extension_resolve(current,
get_actor(definition['extends'].get('name')))
else:
create_actor(current['name'], definition)
current['resolved'] = True
def _try_resolve(i, l):
if i['resolved']:
return
definition = i['definition']
pending = definition.get('executor', {}).get('actors', ())
if definition.get('extends'):
pending = (definition['extends'].get('name'), )
for name in pending:
actor = get_actor(name)
if not actor and name in l:
if not l[name]['resolved']:
_try_resolve(l[name], l)
actor = get_actor(name)
if not actor:
raise LookupError("Failed to resolve dependencies for {}".format(
i['name']))
if definition.get('extends'):
extends = get_actor(definition['extends'].get('name'))
_apply_extension_resolve(i, extends)
else:
create_actor(i['name'], definition)
i['resolved'] = True
def check_target():
""" Run multiple checks at target machine """
targetinfo = {}
get_actor('check_target_group')().execute(targetinfo)
get_actor('check_target')().execute(targetinfo)
pprint(targetinfo['targetinfo'])
def test_extended_actor():
""" Execute filter_kernel_packages actor to test extended actor """
data = {
"rpm_packages": {
"packages": [{
"name": "test-1",
"version": "1"
}, {
"name": "kernel-2",
"version": "1"
}, {
"name": "test-3",
"version": "1"
}, {
"name": "kernel-1",
"version": "1"
}]
}
}
print("Before execution")
print("=" * 70)
pprint(data)
print("=" * 70)
print("Execution result:",
get_actor('filter_kernel_packages')().execute(data))
print("=" * 70)
print("After execution")
pprint(data)
def _try_resolve(i, l):
if not i['resolved']:
name = i['definition']['extends'].get('name')
actor = get_actor(name)
if not actor and name in l:
if not l[name]['resolved']:
_try_resolve(l[name], l)
actor = get_actor(name)
if not actor:
raise LookupError("Failed to resolve dependencies for {}".format(
i['name']))
_apply_resolve(i, actor)
i['resolved'] = True
def test_ansible_executor():
""" Execute ansible_setup actor to test ansible executor """
data = {}
print("Before execution")
print("=" * 70)
pprint(data)
print("=" * 70)
print("Execution result:",
get_actor('ansible_setup')().execute(data))
print("=" * 70)
print("After execution")
pprint(data)
def _try_resolve(current, to_resolve):
if current['resolved']:
return
definition = current['definition']
pending = definition.get('group', ())
for name in pending:
actor = get_actor(name)
if not actor and name in to_resolve:
if not to_resolve[name]['resolved']:
_try_resolve(to_resolve[name], to_resolve)
actor = get_actor(name)
if not actor:
raise LookupError("Failed to resolve dependency '{}' for {}".format(name, current['name']))
create_actor(current['name'], definition)
current['resolved'] = True
def test_output_processors():
""" Execute iplist actor to test output processors """
data = {}
print("Before execution")
print("=" * 70)
pprint(data)
print("=" * 70)
print("Execution result:",
get_actor('iplist')().execute(data))
print("=" * 70)
print("After execution")
pprint(data)
def test_passing_data_actor():
""" Execute actor providing data"""
data = {
"filter": {
"value": "test"
},
"rpm_packages": {
"packages": [{
"name": "test-1",
"version": "1"
}, {
"name": "tast-2",
"version": "1"
}, {
"name": "test-3",
"version": "1"
}, {
"name": "tast-1",
"version": "1"
}]
}
}
get_actor('filter_packages')().execute(data)
pprint(data)
def main():
loader.load(ACTOR_DIRECTORY)
loader.load_schemas(SCHEMA_DIRECTORY)
loader.validate_actor_types()
logging.basicConfig(format='[%(name)s] %(levelname)s:%(message)s',
level=logging.DEBUG,
stream=NullLogSink())
_COMMANDS = {
'migrate-machine': _migrate_machine,
'check-target': _check_target,
'port-inspect': _port_inspect,
'destroy-container': _destroy_container,
}
ap = _make_argument_parser()
argcomplete.autocomplete(ap)
parsed = ap.parse_args()
with _stdout_socket():
actor_data, actor_name = _COMMANDS[parsed.action](parsed)
logging.debug("Actor %s Inputs:\n%s", actor_name, actor_data)
actor = registry.get_actor(actor_name)
if not actor:
logging.error("Could not find %s actor to complete the process",
actor_name)
sys.exit(-1)
success = actor.execute(actor_data)
logging.debug("After execution data:\n%s", actor_data)
if success:
logging.info("SUCCESS - %s has been completed", parsed.action)
else:
logging.error("ERROR: %s failed", parsed.action)
sys.exit(-1)
def test_group_actor():
""" Execute group-actor to test group executor """
data = {}
get_actor('group-actor')().execute(data)
pprint(data)
import snactor.executors
from snactor.loader import load
from snactor.registry import get_actor
from pprint import pprint
import logging
logging.basicConfig(format='%(levelname)s:%(message)s', level=logging.DEBUG)
load('examples/actors')
data = {}
print "Before execution"
print "======================================================================="
pprint(data)
print "======================================================================="
print "Execution result:", get_actor('ansible_setup')().execute(data)
print "======================================================================="
print "After execution"
pprint(data)
def test_extends_no_actor(self):
""" Load an actor that extends a non-existent actor """
with self.assertRaises(LookupError):
load(self.actors_path, tags=['extends_no_actor'])
self.assertIsNone(get_actor('extends_no_actor'))
def test_incomplete_actor(self):
""" Load aa incomplete actor """
with self.assertRaises(LookupError):
load(self.actors_path, tags=['incomplete_group_actor'])
self.assertIsNone(get_actor('incomplete_group_actor'))
def test_load_actor_twice(self):
""" Load an actor twice"""
load(self.actors_path, tags=['load_twice_actor'])
self.assertIsNotNone(get_actor('load_twice_actor'))
with self.assertRaises(LookupError):
load(self.actors_path, tags=['load_twice_actor'])
def test_extends_executor_actor(self):
""" Load an actor with both extends and executor """
with self.assertRaises(ValueError):
load(self.actors_path, tags=['extends_executor_actor'])
self.assertIsNone(get_actor('extends_executor_actor'))
def test_no_executor_actor(self):
""" Load an actor with no executor """
with self.assertRaises(ValueError):
load(self.actors_path, tags=['no_executor_actor'])
self.assertIsNone(get_actor('no_executor_actor'))
def test_unknown_executor_actor(self):
""" Load an actor with an unknown executor """
with self.assertRaises(LookupError):
load(self.actors_path, tags=['unknown_executor_actor'])
self.assertIsNone(get_actor('unknown_executor_actor'))
def test_extends_actor(self):
""" Load an extended actor """
load(self.actors_path, tags=['extends_actor'])
self.assertIsNotNone(get_actor('extends_actor'))
def test_group_actor(self):
""" Load a group actor """
load(self.actors_path, tags=['group_actor'])
self.assertIsNotNone(get_actor('group_actor'))
def test_simple_actor(self):
""" Load a simple actor """
load(self.actors_path, tags=['simple_actor'])
self.assertIsNotNone(get_actor('simple_actor'))
def test_python_executor():
""" Execute osversion actor to test python executor """
data = {}
get_actor('osversion')().execute(data)
pprint(data)
import snactor.executors
from snactor.loader import load
from snactor.registry import get_actor
from pprint import pprint
import logging
logging.basicConfig(format='%(levelname)s:%(message)s', level=logging.DEBUG)
load('examples/actors')
data = {}
print get_actor('osversion')().execute(data)
pprint(data)
import snactor.executors
from snactor.loader import load
from snactor.registry import get_actor
from pprint import pprint
import logging
logging.basicConfig(format='%(levelname)s:%(message)s', level=logging.DEBUG)
load('examples/actors')
data = {}
print "Before execution"
print "======================================================================="
pprint(data)
print "======================================================================="
print "Execution result:", get_actor('iplist')().execute(data)
print "======================================================================="
print "After execution"
pprint(data)
logging.basicConfig(format='%(levelname)s:%(message)s', level=logging.DEBUG)
load('examples/actors')
data = {
# "filter": {"value": "test"},
"rpm_packages": {
"packages": [{
"name": "test-1",
"version": "1"
}, {
"name": "kernel-2",
"version": "1"
}, {
"name": "test-3",
"version": "1"
}, {
"name": "kernel-1",
"version": "1"
}]
}
}
print "Before execution"
print "======================================================================="
pprint(data)
print "======================================================================="
print "Execution result:", get_actor('filter_kernel_packages')().execute(data)
print "======================================================================="
print "After execution"
pprint(data)
from snactor.loader import load
from snactor.registry import get_actor
from pprint import pprint
import logging
logging.basicConfig(format='%(levelname)s:%(message)s', level=logging.DEBUG)
load('examples/actors', tags=['packages'])
data = {
"filter": {
"value": "test"
},
"rpm_packages": {
"packages": [{
"name": "test-1",
"version": "1"
}, {
"name": "tast-2",
"version": "1"
}, {
"name": "test-3",
"version": "1"
}, {
"name": "tast-1",
"version": "1"
}]
}
}
print get_actor('filter_packages')().execute(data)
pprint(data)
def test_simple_actor():
""" Execute simple-actor to test simple executor """
data = {}
get_actor('simple-actor')().execute(data)
pprint(data)
