def run(fun, tags=()):
logging.basicConfig(format='%(levelname)s:%(message)s',
level=logging.DEBUG)
load(os.path.join(_BASE_DIR, 'actors'), tags=tags)
load_schemas(os.path.join(_BASE_DIR, 'schema'))
validate_actor_types()
fun()
def main():
logging.basicConfig(format='%(levelname)s:%(message)s', level=logging.INFO)
load(os.path.join(_BASE_DIR, 'actors'))
load_schemas(os.path.join(_BASE_DIR, 'schema'))
validate_actor_types()
data = {}
get_actor('modules_check').execute(data)
parse_data(data)
def load_as_group(name, location, tags=()):
"""
load_as_group creates a group actor with the given `name`, with actors loaded from `location` and is filtered
by `tags`
:param name: Name of the group actor to create
:param location: Where to load the actors from
:param tags: List of tags to filter by
:return: A group actor ordered with resolved dependencies
"""
load(location, tags)
return _create_group_from_actors(name,
get_registered_actors().values(), tags)
def test_actors_and_schemas(self):
failed = False
try:
loader.load(self.actors_path)
loader.load_schemas(self.schema_path)
loader.validate_actor_types()
except loader.ActorTypeValidationError as e:
for (type_name, direction, actor_name) in e.data:
print("Schema for type '{}' defined in actor '{}' section '{}' was not found"
.format(type_name, actor_name, direction))
failed = True
except Exception as e:
print(str(e))
failed = True
self.assertEqual(False, failed)
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_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_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_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_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_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'))
""" 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)
if __name__ == '__main__':
logging.basicConfig(format='%(levelname)s:%(message)s',
level=logging.DEBUG)
load('../actors', tags=['packages'])
test_passing_data_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_simple_actor(self):
""" Load a simple actor """
load(self.actors_path, tags=['simple_actor'])
self.assertIsNotNone(get_actor('simple_actor'))
""" Sample script to test output processors """
import logging
from pprint import pprint
from snactor.loader import load
from snactor.registry import get_actor
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)
if __name__ == '__main__':
logging.basicConfig(format='%(levelname)s:%(message)s',
level=logging.DEBUG)
load('../actors')
test_output_processors()
""" Run target checks using snactor """
import logging
from pprint import pprint
from snactor.loader import load
from snactor.registry import get_actor
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'])
if __name__ == '__main__':
logging.basicConfig(format='%(levelname)s:%(message)s', level=logging.INFO)
load('../actors', tags=['check_target'])
check_target()
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_group_actor(self):
""" Load a group actor """
load(self.actors_path, tags=['group_actor'])
self.assertIsNotNone(get_actor('group_actor'))
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', 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_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'))
