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