qb 0.4.3 → 0.4.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 023cb0a8d6ea38e59c77d21236f4c95944843093
-  data.tar.gz: 7d307bb9c37772b4dd06a0d9f1f3af694c5425d4
+  metadata.gz: 1adb8b34388a2f7459a5acff24162cb7c3959401
+  data.tar.gz: 16174eacdd3a1b2bdd19084d674d2834284c7dfc
 SHA512:
-  metadata.gz: 25520e571a52e90950dfff2263d4e57154900adb42f63fea546fa1967b175f45bdebd276145a5741f2001ebfbf1791b4065e28cda4b63588a70eeabc81a1cf53
-  data.tar.gz: 3de536eadddf790d77ea0d3e97af2a1d6c03c39d179e45bc96b259f3302ccf3d6eda933731d89f7f370558d02b7166744127712013af220ca40b305c428274e9
+  metadata.gz: a214e3865fd351527b73637e87e1a53358c88362c24966fa64ced70868241ae4db773bb35d62289dc726c7fe66e8dfa607be3620a6340fd4c04d5a6aa8e48c8b
+  data.tar.gz: 99358c88001aa83cfdebdc9bc6b4af4fcc03468715c637f152cba56edb6e52b2fd73303a6198ffb02cd5883fd921b0904a30ac562ee5660de4a5aeacb0ecd6ad

data/.vscode/.gitignore

@@ -0,0 +1,2 @@
+# It seems like the `tags` file should not be checked in..?
+/tags

data/.vscode/settings.json

@@ -0,0 +1,3 @@
+{
+  "javascript.validate.enable": false,
+}

data/VERSION

@@ -1 +1 @@
-0.4.3
+0.4.4

data/exe/qb

@@ -62,6 +62,8 @@ def main *args
     [:setup, args.rest]
   when 'list', 'ls'
     [:list, *args.rest]
+  when '.dev'
+    [:dev, *args.rest]
   when 'root'
     puts QB::ROOT.to_s
     exit true

data/lib/python/qb/ansible/display_handler.py

@@ -0,0 +1,136 @@
+from __future__ import absolute_import, division, print_function
+__metaclass__ = type
+
+import logging
+import qb.logging
+
+# Find a Display if possible
+try:
+    from __main__ import display
+except ImportError:
+    try:
+        from ansible.utils.display import Display
+    except ImportError:
+        display = None
+    else:
+        display = Display()
+
+
+class DisplayHandler(logging.Handler):
+    '''
+    A handler class that writes messages to Ansible's
+    `ansible.utils.display.Display`, which then writes them to the user output.
+
+    Includes static methods that let it act as a sort of a singleton, with
+    a single instance created on-demand.
+    '''
+
+
+    # Singleton instance
+    _instance = None
+
+
+    @staticmethod
+    def getDisplay():
+        '''
+        Get the display instance, if we were able to import or create one.
+
+        :rtype:     None
+        :return:    No display could be found or created.
+        
+        :rtype:     ansible.util.display.Display
+        :return:    The display we're using.
+        '''
+        return display
+    # .getDisplay
+    
+
+    @staticmethod
+    def getInstance():
+        '''
+        :rtype:     DisplayHandler
+        :return:    The singleton instance.
+        '''
+        if DisplayHandler._instance is None:
+            DisplayHandler._instance = DisplayHandler()
+        return DisplayHandler._instance
+    # .getInstance
+
+
+    @staticmethod
+    def enable():
+        '''
+        Enable logging to Ansible's display by sending {.getInstance()} to
+        {qb.logging.addHandler()}.
+
+        :raises:
+        '''
+        instance = DisplayHandler.getInstance()
+
+        if instance.display is None:
+            raise RuntimeError("No display available")
+
+        return qb.logging.addHandler(instance)
+    # .enable
+
+
+    def disable():
+        '''
+        Disable logging to Ansible's display be sending {.getInstance()} to
+        {qb.logging.removeHandler()}.
+        '''
+        return qb.logging.removeHandler(DisplayHandler.getInstance())
+    # .disable
+
+
+    def is_enabled():
+        return qb.logging.hasHandler(DisplayHandler.getInstance())
+    # .is_enabled
+
+
+    def __init__(self, display=None):
+        logging.Handler.__init__(self)
+
+        if display is None:
+            display = DisplayHandler.getDisplay()
+        
+        self.display = display
+    # #__init__
+
+
+    def emit(self, record):
+        '''
+        Overridden to send log records to Ansible's display.
+        '''
+
+        if self.display is None:
+            # Nothing we can do, drop it
+            return
+
+        try:
+            self.format(record)
+
+            if record.levelname == 'DEBUG':
+                self.display.debug(record.message)
+
+            elif record.levelname == 'INFO':
+                # `verbose` I guess?
+                self.display.verbose(record.message)
+
+            elif record.levelname == 'WARNING':
+                self.display.warning(record.message)
+
+            elif record.levelname == 'ERROR':
+                self.display.error(record.message)
+
+            elif record.levelname == 'CRITICAL':
+                self.display.error("(CRITICAL) {}".format(record.message))
+
+            else:
+                pass
+        except (KeyboardInterrupt, SystemExit):
+            raise
+        except:
+            raise
+            # self.handleError(record)
+    # #emit

data/lib/python/qb/ipc/rpc/client.py

@@ -0,0 +1,170 @@
+##############################################################################
+# 
+##############################################################################
+
+# Imports
+# ============================================================================
+
+# Make Python 3-ish 
+from __future__ import (absolute_import, division, print_function)
+__metaclass__ = type
+
+# Stdlib
+# ----------------------------------------------------------------------------
+
+# Need {os.environ}, {os.path.join}
+import os
+
+# Need {urllib.quote_plus} to URL-encode socket paths for the 
+# {requests_unixsocket} package.
+import urllib
+
+# Deps
+# ----------------------------------------------------------------------------
+
+# Facilities making requests to UNIX domain sockets with the {requests}
+# package.
+import requests_unixsocket
+
+
+# Constants
+# ============================================================================
+
+# The name of the ENV var that holds the socket path, which is created in a
+# temp dir that only exists while the main QB process is running and is only
+# accessible to the user that ran it.
+# 
+RPC_SOCKET_ENV_VAR_NAME = 'QB_RPC_SOCKET'
+
+
+# Module Variables
+# ============================================================================
+
+# A "module-level global" (yeah, weird they're called "globals") that holds 
+# the default {Client}, which is created on demand.
+# 
+# Need to preface it's use with
+# 
+#       global _client
+# 
+_client = None
+
+
+# Module Functions
+# ============================================================================
+#
+# Static helpers and functions that operate on the default {Client}, which is
+# created on demand using the ENV var set by the QB master process that hosts
+# the server (during normal execution... things are set up flexibly because I'm
+# sure we'd want to do things differently during testing).
+#
+# NOTE  Due to the way Python's files<->imports system works, this seems like
+#       the least annoying way to create a decent API without sticking stuff in
+#       the `__init__.py` file, which I *hate* because it's really hard to
+#       remember which ones have shit in them.
+#
+
+def client_from_env():
+    return Client(socket_path=os.environ[RPC_SOCKET_ENV_VAR_NAME])
+
+
+def requests_path_for(socket_path):
+    '''
+    URL-quotes the socket file path and protocol prefixes it with `http+unix://`
+
+    The {requests} module - as extended by {requests_unixsocket} - requires that
+    the actual file path to the socket by URL-quoted, probably because it uses
+    some split-by-/ logic to parse it, which would normally consider the socket
+    path part of the HTTP path.
+
+    :rtype:     str
+    :return:    Path ready for use with {requests_unixsocket.Session}.
+    '''
+    return "http+unix://{}".format(urllib.quote_plus(socket_path))
+
+
+def init_from_env(force=False):
+    global _client
+
+    if _client is None or force is True:
+        _client = client_from_env()
+        return True
+    else:
+        return False
+
+
+def get_client():
+    global _client
+    init_from_env()
+    return _client
+
+
+def set_client(client):
+    global _client
+    _client = client
+
+
+def get(path):
+    return get_client().get(path)
+
+
+def post(path, **payload):
+    return get_client().post(path, **payload)
+
+
+def send(receiver, method, *args, **kwds):
+    return get_client().send(receiver, method, *args, **kwds)
+
+
+class Client:
+    '''
+    RPC client for making calls to the QB master Ruby process (HTTP over 
+    a UNIX domain socket).
+    '''
+
+    def __init__(self, socket_path):
+        self.socket_path = socket_path
+        self.session = requests_unixsocket.Session()
+        self.requests_path = requests_path_for(self.socket_path)
+
+
+    def full_path_for(self, path):
+        if path[0] == '/':
+            path = path[1:]
+        return os.path.join(self.requests_path, path)
+
+
+    def handle_response(self, response):
+        return response.json()['data']
+
+
+    def get(self, path):
+        return self.handle_response(
+            self.session.get(
+                self.full_path_for(path)
+            )
+        )
+    
+
+    def post(self, path, **payload):
+        return self.handle_response(
+            self.session.post(
+                self.full_path_for(path),
+                json = payload,
+            )
+        )
+    
+    
+    def send(self, receiver, method, *args, **kwds):
+        return self.handle_response(
+            self.session.post(
+                self.full_path_for('/send'),
+                json = dict(
+                    receiver = receiver,
+                    method = method,
+                    args = args,
+                    kwds = kwds,
+                )
+            )
+        )
+

data/lib/python/qb/ipc/stdio/__init__.py

@@ -4,7 +4,24 @@ __metaclass__ = type
 import os
 import socket
 
+
 def path_env_var_name(name):
+    '''
+    Get the ENV var name whose value (if any) will be the file system path
+    to the UNIX socket file for that IO stream.
+
+    The names in current use:
+
+    >>> path_env_var_name('out')
+    'QB_STDIO_OUT'
+
+    >>> path_env_var_name('err')
+    'QB_STDIO_ERR'
+
+    >>> path_env_var_name('log')
+    'QB_STDIO_LOG'
+    '''
+
     return "QB_STDIO_{}".format(name.upper())
 
 

data/lib/python/qb/ipc/stdio/logging.py

@@ -5,9 +5,11 @@ import logging
 import threading
 import json
 
+import qb.logging
 import qb.ipc.stdio
 
 
+# FIXME     After adding central logging stuff
 def getLogger(name, level=logging.DEBUG, io_client=qb.ipc.stdio.client):
     logger = logging.getLogger(name)
     if level is not None:
@@ -16,27 +18,6 @@ def getLogger(name, level=logging.DEBUG, io_client=qb.ipc.stdio.client):
     return Adapter(logger, {})
 
 
-class Adapter(logging.LoggerAdapter):
-    def process(self, msg, kwds):
-        payload = None
-        if 'payload' in kwds:
-            payload = kwds['payload']
-            del kwds['payload']
-        
-        if payload:
-            try:
-                msg = msg.format(**payload)
-            except:
-                pass
-            
-            if 'extra' not in kwds:
-                kwds['extra'] = {}
-            
-            kwds['extra']['payload'] = payload
-            
-        return msg, kwds
-
-
 class Handler(logging.Handler):
     """
     A handler class which writes logging records to the QB master process
@@ -103,6 +84,9 @@ class Handler(logging.Handler):
     def emit(self, record):
         """
         Emit a record.
+
+        Doc coppied in (TOOD re-write):
+
         Pickles the record and writes it to the socket in binary format.
         If there is an error with the socket, silently drop the packet.
         If there was a problem with the socket, re-establishes the

data/lib/python/qb/logging.py

@@ -0,0 +1,97 @@
+from __future__ import absolute_import, division, print_function
+__metaclass__ = type
+
+import logging
+import threading
+import json
+import weakref
+
+import qb.ipc.stdio
+
+# Current handlers
+_handlers = []
+
+
+def hasHandler(handler):
+    return handler in _handlers
+# hasHandler
+
+
+def addHandler(handler):
+    '''
+    Add a handler if it's not already added.
+
+    :rtype:     Boolean
+    :return:    `True` if it was added (not already there), `False` if already
+                present.
+    '''
+    if not handler in _handlers:
+        _handlers.append(handler)
+        return True
+    else:
+        return False
+# addHandler
+
+
+def removeHandler(handler):
+    '''
+    Remove a handler.
+
+    :rtype:     Boolean
+    :return:    `True` if it was removed, `False` if wasn't  there to begin
+                with.
+    '''
+    if handler in _handlers:
+        _handlers.remove(handler)
+        return True
+    else:
+        return False
+# removeHandler
+
+
+def getLogger(name, level=logging.DEBUG):
+    logger = logging.getLogger(name)
+    if level is not None:
+        logger.setLevel(level)
+    for handler in _handlers:
+        logger.addHandler(handler)
+    return Adapter(logger, {})
+
+
+class Adapter(logging.LoggerAdapter):
+    '''
+    Adapter to allow Ruby's Semantic Logger (basis of NRSER::Log) style logging,
+    which is then easy to translate when sending logs up to the QB master
+    process via IPC.
+
+    Usage:
+
+        logger.info(
+            "Message with payload {value} interpolations",
+            payload = dict(
+                value = "interpolated into message",
+                mote = "values",
+                # ...
+            )
+        )
+
+    '''
+    
+    def process(self, msg, kwds):
+        payload = None
+        if 'payload' in kwds:
+            payload = kwds['payload']
+            del kwds['payload']
+        
+        if payload:
+            try:
+                msg = msg.format(**payload)
+            except:
+                pass
+            
+            if 'extra' not in kwds:
+                kwds['extra'] = {}
+            
+            kwds['extra']['payload'] = payload
+            
+        return msg, kwds