lmaps.core package

Submodules

lmaps.core.client module

class lmaps.core.client.Client(*args)

Bases: lmaps.core.manager.Manager

Handles RPC between the shell (or anyother) and the manager

manager_socket_type = 3
request(payload)

Handles the round trip of the payload to the manager and back :param payload: :return:

zmq = <module 'zmq' from '/home/josiah/PycharmProjects/python-lmaps/env/lib/python2.7/site-packages/zmq/__init__.pyc'>

lmaps.core.config module

lmaps.core.config.extend_with_default(validator_class)

Handles applying default values to schemas :param validator_class: Draft version class to validate with :return: Wrapped validator

lmaps.core.config.find_config_file()

Use the list of paths and files above to find a config to use :return: Filepath of config file

lmaps.core.config.load_config(config_file='/home/josiah/lmaps.yaml')

Load the config as a dict from a given config file :param config_file: Path to config file :return: Dict containing the config

lmaps.core.daemon module

class lmaps.core.daemon.Daemon(config)

Bases: object

Handles running various threads needed on the host

config = {}
make_workers(count=1)

Create workers :param count: Number of workers to create

manage_workers()

Maintains the manager and worker threads

run()

Start the workers

start_workers()

Start the workers in their own threads

threads = []
workers = []

lmaps.core.data module

class lmaps.core.data.DataStore(*args, **kwargs)

Bases: object

Base class that provides the actual structures used by handlers

args = ()
exists(data)

Check if a store already contains data :param data: Data to compare :return: Boolean as to whether or not it exists

kwargs = {}
new_store()

Create a new store in which to put/get state :return: Pointer to the new store

rollback()
setup()

Prepare the instance :return:

state()

Get the summary of the current state :return: Dict of state summary

class lmaps.core.data.YamlFile(*args, **kwargs)

Bases: lmaps.core.data.DataStore

DataStore based on using merged YAML files to determine state

current_dir = 'current'
exists(data)

Check if data is already in a store based on a sample :param data: :return: Boolean as to whether or not the data is already in a store

get_current_store_dir()

Get the filepath to the “current” data stores :return: String filepath

get_rollback_store_dir()

Get the filepath to the “rollback” data stores :return: String filepath

new_store(data)

Provision a new store :param data: Dict of instamce :return: String filepath

rollback()

Rollback the latest change by moving the last store from the “current” directory to the “rollback” directory :return: Dict of the data rolled back

rollback_dir = 'rollback'
setup()

Setup this instance to work with yaml files

state()

Get the current summary of the state :return: Dict of state

store_files()

Enumerate the “current” store’s files :return: List of filepaths

store_key = 'root'
store_root = None
class lmaps.core.data.YamlKeyDict(*args, **kwargs)

Bases: lmaps.core.data.YamlKeyList

DataStore based on using YAML files to present state as a dict of dicts

state(reverse=False)

DataStore based on using YAML files to present state as a merged dict

class lmaps.core.data.YamlKeyList(*args, **kwargs)

Bases: lmaps.core.data.YamlList

DataStore based on using YAML files to present state as a dict of dicts

exists(data)

Check if data is already in a store based on a sample :param data: :return: Boolean as to whether or not the data is already in a store

state(reverse=False)

DataStore based on using YAML files to present state as a list of dicts

class lmaps.core.data.YamlList(*args, **kwargs)

Bases: lmaps.core.data.YamlFile

DataStore based on using YAML files to present state as a list of dicts

exists(data)

Check if data is already in a store based on a sample :param data: :return: Boolean as to whether or not the data is already in a store

state(reverse=False)

Get the current summary of the state :param reverse: whether or not the state needs to be reversed :return: List of instances

lmaps.core.handlers module

class lmaps.core.handlers.Handler(**kwargs)

Bases: object

Base class for handling /anything/

context = None
setup()

Handles setting up this instance

class lmaps.core.handlers.ManagerHandler(**kwargs)

Bases: lmaps.core.handlers.Handler

The handler used by the manager to get requests from clients and farm out work for workers

client_request(request)

Handle an incoming request from a client :param request: The request from the client :return: A response to the client

create_or_apply(request)

Handle a request from the client to create or apply instances :param request: The request from the client :return: A response to the client

class lmaps.core.handlers.UnitHandler(**kwargs)

Bases: lmaps.core.handlers.Handler

Base class for unit handlers

lmaps.core.manager module

class lmaps.core.manager.Manager(worker_connection_uri, *args)

Bases: lmaps.core.worker.Worker

In charge of listening to clients and passing the requests to a handler

manager_socket_type = 4
run_task(runnable, *args, **kwargs)

Takes a “runnable” method and args, marshalls them, and sends them to a worker via the worker socket. After sending, this will wait for a response from the worker as the return from the runnable. :param runnable: An unbound method/function/whatever :return: return from the runnable that executed on the worker

setup_args(args)

Make sure we can connect to workers and bind our socket for clients :param args: :return:

socket_type = 3
start()

Begin serving

zmq = <module 'zmq' from '/home/josiah/PycharmProjects/python-lmaps/env/lib/python2.7/site-packages/zmq/__init__.pyc'>

lmaps.core.shell module

lmaps.core.shell.get_parser()

Get shell args for command line usage :return: argparse namespace

lmaps.core.shell.print_response(msg, format='dict')

Prints dictionaries in a human readable way :param msg: message to make human readable :param format: How to format the msg (i.e. coercion strategy)

lmaps.core.shell.start()

Start the CLI :param args: Argparse namespace

lmaps.core.tasks module

Tasks that can be run on workers.

lmaps.core.tasks.error_message(context, msg)

Cannot remember, maybe I was starting to setup a logging facility? :param context: The runner’s instance :param msg: :return:

lmaps.core.tasks.get_worker_config(context)

Get the config from the worker’s perspective. :param context: The runner’s instance :return:

lmaps.core.tasks.get_worker_units(context)

Get installed units from the worker’s perspective. :param context: The runner’s instance :return:

lmaps.core.tasks.get_worker_units_instances(context, name)

Get instances of a unit based on the unit’s name. :param context: The runner’s instance :param name: Name of unit :return:

lmaps.core.tasks.no_work(context)

Do nothing. :param context: The runner’s instance :return: dict

lmaps.core.tasks.rollback_worker_units_instances(context, name)

Perform a rollback on the workers local datastore. :param context: The runner’s instance :param name: Name of unit :return:

lmaps.core.tasks.stop_worker_thread(context)

Inform a worker that it needs to die. :param context: The runner’s instance :return:

lmaps.core.tasks.validate_instance(context, unit_name, instance)

Determine if a dict is a valid instance request based on the schema of the unit as well as apply defaults from the schema. :param context: The runner’s instance :param unit_name: String name of unit :param instance: Dict the instance to validate :return: Dict the valid and default-mixed-in instance

lmaps.core.utils module

Handy functions and objects

class lmaps.core.utils.OpenThread(method, args=None)

Bases: lmaps.core.utils.Threader

Same as above, but lets a thread keep running after exiting the with statement.

class lmaps.core.utils.Threader(method, args=None)

Bases: object

A basic thread manager that I reuse so much I should just polish it up and throw it into PyPI. More or less lets you run a “runnable” in a thread while something meaningful is happening in the main thread and kills it when complete. I usually use it for things like API persistence on unrully/expirary endpoints that I don’t want my interact logic to have to constantly poll something. i.e.: ``` def maintain_connection_to_some_api():

while not amConnectedToSomeAPI:
client = connectBackToTheStoopidThing(with_these,credentials)
with Threader(maintain_connection_to_some_api) as API:
API.client(“don’t worry”) API.client(“be happy”)

``` after the last API.client() call in that example, maintain_connection_to_some_api() is reaped silently.

args = None
isAlive()

Check to see if the thread is alive still. :return: Bool whether or not it is

method = None
start()

Start the thread :return: Bool whether the thread is still alive

stop()

Stop the thread :return: Bool if the assertion passes of course ;)

thread = None
threading = <module 'threading' from '/usr/lib64/python2.7/threading.pyc'>
time = <module 'time' from '/home/josiah/PycharmProjects/python-lmaps/env/lib64/python2.7/lib-dynload/timemodule.so'>
lmaps.core.utils.client_message(message, level=0, extra={})

Create a properly formatted dict that can be handled by the client shell when the manager replies. :param message: String the main message :param level: Int more or the exit code you wish the client to experience :param extra: Dict extra debug info if needed :return: Dict the message to reply to the client with

lmaps.core.utils.get_data_type_by_name(name)

For a given name, get a datatype. For example this is used to get the datastore instance used by the handler based on the config in the unit. :param name: String the datastore’s classname :return: The class

lmaps.core.utils.get_unit_by_name(name, config=None)

For a given config, return a unit by its name. :param name: String name of the unit :param config: Dict the config to compare :return: Dict the unit found

lmaps.core.utils.validate_unit_instance(instance, unit)

Locally validate and mixin schema defaults for a given instance by the unit to be applied. :param instance: Dict the instance to try :param unit: Dict the unit containing the schema :return: Dict the valid, mixed instance or an error containing what and why the instance is not valid

lmaps.core.worker module

class lmaps.core.worker.Worker(worker_connection_uri, *args)

Bases: object

A generic worker

cloud = <module 'cloud' from '/home/josiah/PycharmProjects/python-lmaps/env/lib/python2.7/site-packages/cloud/__init__.pyc'>
pickle = <module 'pickle' from '/usr/lib64/python2.7/pickle.pyc'>
running = True
setup_args(args)

Not used here, but useful for more verbose workers :param args: :return:

socket_type = 4
start()

Bind the worker socket and wait for work

stop()

Stop the private main loop logically :return:

time = <module 'time' from '/home/josiah/PycharmProjects/python-lmaps/env/lib64/python2.7/lib-dynload/timemodule.so'>
worker_connection_uri = None
zmq = <module 'zmq' from '/home/josiah/PycharmProjects/python-lmaps/env/lib/python2.7/site-packages/zmq/__init__.pyc'>

Module contents