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