dwho 0.3.60__py2.py3-none-any.whl

dwho/__init__.py

@@ -0,0 +1,4 @@
+# -*- coding: utf-8 -*-
+# Copyright (C) 2015-2019 Adrien Delle Cave
+# SPDX-License-Identifier: GPL-3.0-or-later
+__all__ = []

dwho/adapters/__init__.py

@@ -0,0 +1,4 @@
+# -*- coding: utf-8 -*-
+# Copyright (C) 2015-2019 Adrien Delle Cave
+# SPDX-License-Identifier: GPL-3.0-or-later
+__all__ = []

dwho/adapters/redis.py

@@ -0,0 +1,289 @@
+# -*- coding: utf-8 -*-
+# Copyright (C) 2015-2019 Adrien Delle Cave
+# SPDX-License-Identifier: GPL-3.0-or-later
+"""dwho.adapters.redis"""
+
+from __future__ import absolute_import
+
+from six import iteritems, iterkeys
+from six.moves.urllib.parse import urlparse, parse_qs
+
+from redis import Redis
+
+
+class DWhoAdapterRedis(object): # pylint: disable=useless-object-inheritance
+    def __init__(self, config, prefix = None, load = True):
+        self.config  = config
+        self.servers = {}
+
+        if load:
+            self.load(prefix)
+
+    def load(self, prefix = None):
+        for name in iterkeys(self.config['general']['redis']):
+            if not prefix or name.startswith(prefix):
+                self.connect(name)
+
+    def connect(self, name):
+        if name not in self.servers:
+            self.servers[name] = {'conn': None, 'options': {}}
+
+        if self.servers[name]['conn']:
+            return self.servers[name]
+
+        has_from_url = hasattr(Redis, 'from_url')
+        for key, value in iteritems(self.config['general']['redis'][name]):
+            if key != 'url':
+                self.servers[name]['options'][key] = value
+                continue
+            elif has_from_url:
+                self.servers[name]['conn'] = Redis().from_url(value)
+                continue
+
+            p     = urlparse(value)
+            rconf = {'host': p.hostname,
+                     'port': int(p.port or 6379),
+                     'db':   0}
+
+            if p.query:
+                q = parse_qs(p.query)
+                if 'db' in q:
+                    rconf['db'] = int(q['db'][0])
+
+            self.servers[name]['conn'] = Redis(**rconf)
+
+        return self.servers[name]
+
+    def ping(self, servers = None, prefix = None):
+        r = {}
+
+        if not servers:
+            servers = self.servers
+
+        for name, server in iteritems(servers):
+            if not prefix or name.startswith(prefix):
+                r[name] = server['conn'].ping()
+
+        return r
+
+    def set_key(self, key, val, expire = None, servers = None, prefix = None):
+        r = {}
+
+        if not servers:
+            servers = self.servers
+
+        if expire is not None:
+            for name, server in iteritems(servers):
+                if not prefix or name.startswith(prefix):
+                    r[name] = server['conn'].setex(name = key, time = expire, value = val)
+        else:
+            for name, server in iteritems(servers):
+                if not prefix or name.startswith(prefix):
+                    r[name] = server['conn'].set(key, val)
+
+        return r
+
+    def get_key(self, key, servers = None, prefix = None):
+        if not servers:
+            servers = self.servers
+
+        for name, server in iteritems(servers):
+            if (not prefix or name.startswith(prefix)) \
+               and server['conn'].exists(key):
+                return server['conn'].get(key)
+
+        return None
+
+    def del_key(self, key, servers = None, prefix = None):
+        r = {}
+
+        if not servers:
+            servers = self.servers
+
+        if not isinstance(key, (list, tuple)):
+            key = [key]
+
+        for name, server in iteritems(servers):
+            if not prefix or name.startswith(prefix):
+                r[name] = server['conn'].delete(*key)
+
+        return r
+
+    def exists(self, key, servers = None, prefix = None):
+        r = {}
+
+        if not servers:
+            servers = self.servers
+
+        if not isinstance(key, (list, tuple)):
+            key = [key]
+
+        for name, server in iteritems(servers):
+            if not prefix or name.startswith(prefix):
+                r[name] = server['conn'].exists(*key)
+
+        return r
+
+    def expire(self, key, xtime, servers = None, prefix = None):
+        r = {}
+
+        if not servers:
+            servers = self.servers
+
+        for name, server in iteritems(servers):
+            if (not prefix or name.startswith(prefix)) \
+               and server['conn'].exists(key):
+                r[name] = server['conn'].expire(key, xtime)
+
+        return r
+
+    def hset_key(self, key, field, val, expire = None, servers = None, prefix = None):
+        r = {}
+
+        if not servers:
+            servers = self.servers
+
+        if expire is not None:
+            for name, server in iteritems(servers):
+                if not prefix or name.startswith(prefix):
+                    r[name] = server['conn'].hset(key, field, val)
+                    server['conn'].expire(key, expire)
+        else:
+            for name, server in iteritems(servers):
+                if not prefix or name.startswith(prefix):
+                    r[name] = server['conn'].hset(key, field, val)
+
+        return r
+
+    def hget_key(self, key, field, servers = None, prefix = None):
+        if not servers:
+            servers = self.servers
+
+        for name, server in iteritems(servers):
+            if (not prefix or name.startswith(prefix)) \
+               and server['conn'].exists(key):
+                return server['conn'].hget(key, field)
+
+        return None
+
+    def hdel_key(self, key, field, servers = None, prefix = None):
+        r = {}
+
+        if not servers:
+            servers = self.servers
+
+        if not isinstance(field, (list, tuple)):
+            field = [field]
+
+        for name, server in iteritems(servers):
+            if not prefix or name.startswith(prefix):
+                r[name] = server['conn'].hdel(key, *field)
+
+        return r
+
+    def has_key(self, key, servers = None, prefix = None):
+        if not servers:
+            servers = self.servers
+
+        for name, server in iteritems(servers):
+            if not prefix or name.startswith(prefix):
+                return server['conn'].exists(key)
+
+        return None
+
+    def keys(self, pattern = '*', servers = None, prefix = None):
+        r = {}
+
+        if not servers:
+            servers = self.servers
+
+        for name, server in iteritems(servers):
+            if not prefix or name.startswith(prefix):
+                r[name] = server['conn'].keys(pattern)
+
+        return r
+
+    def sadd(self, key, member, servers = None, prefix = None):
+        r = {}
+
+        if not servers:
+            servers = self.servers
+
+        if not isinstance(member, (list, tuple)):
+            member = [member]
+
+        for name, server in iteritems(servers):
+            if not prefix or name.startswith(prefix):
+                r[name] = server['conn'].sadd(key, *member)
+
+        return r
+
+    def srem(self, key, member, servers = None, prefix = None):
+        r = {}
+
+        if not servers:
+            servers = self.servers
+
+        if not isinstance(member, (list, tuple)):
+            member = [member]
+
+        for name, server in iteritems(servers):
+            if not prefix or name.startswith(prefix):
+                r[name] = server['conn'].srem(key, *member)
+
+        return r
+
+    # pylint: disable=too-many-arguments
+    def sort(self, key, start = None, num = None, by = None, get = None,
+             desc = False, alpha = False, store = None,
+             servers = None, prefix = None):
+
+        r = {}
+
+        if not servers:
+            servers = self.servers
+
+        for name, server in iteritems(servers):
+            if not prefix or name.startswith(prefix):
+                r[name] = server['conn'].sort(name   = key,
+                                              start  = start,
+                                              num    = num,
+                                              by     = by,
+                                              get    = get,
+                                              desc   = desc,
+                                              alpha  = alpha,
+                                              store  = store)
+
+        return r
+
+    def disconnect(self, name = None, prefix = None, servers = None):
+        if not servers:
+            servers = self.servers
+
+        if name:
+            if not servers.get(name) or not servers[name]['conn']:
+                return self
+
+            try:
+                servers[name]['conn'].connection_pool.disconnect()
+            except Exception:
+                pass
+
+            servers[name]['conn'] = None
+
+            return self
+
+        for cname in iterkeys(self.config['general']['redis']):
+            if prefix and not cname.startswith(prefix):
+                continue
+            elif not servers.get(cname) or not servers[cname]['conn']:
+                continue
+
+            try:
+                servers[cname]['conn'].connection_pool.disconnect()
+            except Exception:
+                pass
+
+            servers[cname]['conn']   = None
+
+        return self

dwho/classes/__init__.py

@@ -0,0 +1,4 @@
+# -*- coding: utf-8 -*-
+# Copyright (C) 2015-2019 Adrien Delle Cave
+# SPDX-License-Identifier: GPL-3.0-or-later
+__all__ = []

dwho/classes/abstract.py

@@ -0,0 +1,237 @@
+# -*- coding: utf-8 -*-
+# Copyright (C) 2015-2019 Adrien Delle Cave
+# SPDX-License-Identifier: GPL-3.0-or-later
+"""dwho.classes.abstract"""
+
+import abc
+import re
+
+try:
+    from threading import _get_ident as thread_get_ident
+except ImportError:
+    from threading import get_ident as thread_get_ident
+
+from threading import _active_limbo_lock, _active
+from six import iterkeys, iteritems, string_types
+
+from sonicprobe.libs import anysql
+
+_RE_MATCH_OBJECT_FUNCS       = ('match', 'search')
+_PARAMS_DICT_MODIFIERS_MATCH = re.compile(r'^(?:(?P<modifiers>[\+\-~=%]+)\s)?(?P<key>.+)$').match
+_PARAM_REGEX_OPTS            = ('default', 'func', 'return', 'return_args')
+
+
+class DWhoAbstractHelper(object): # pylint: disable=useless-object-inheritance,too-few-public-methods
+    __metaclass__ = abc.ABCMeta
+
+    @classmethod
+    def _parse_re_flags(cls, flags):
+        if isinstance(flags, int):
+            return flags
+
+        if isinstance(flags, list):
+            r = 0
+            for x in flags:
+                r |= cls._parse_re_flags(x)
+            return r
+
+        if isinstance(flags, string_types):
+            if flags.isdigit():
+                return int(flags)
+            return getattr(re, flags)
+
+        return 0
+
+    @classmethod
+    def _param_regex(cls, args, value):
+        args         = args.copy()
+        func         = args.get('func') or 'sub'
+        rfunc        = args.get('return')
+        rargs        = args.get('return_args')
+        is_match_obj = func in _RE_MATCH_OBJECT_FUNCS
+
+        if is_match_obj and not rfunc:
+            rfunc = 'group'
+            rargs = [1]
+
+        if is_match_obj and not rargs:
+            rargs = [1]
+
+        for x in _PARAM_REGEX_OPTS:
+            if x in args:
+                del args[x]
+
+        if 'pattern' in args:
+            flags = 0
+            if 'flags' in args:
+                flags = cls._parse_re_flags(args.pop('flags'))
+            func = getattr(re.compile(pattern = args.pop('pattern'),
+                                      flags = flags),
+                           func)
+        else:
+            func = getattr(re, func)
+
+        args['string'] = value
+        ret            = func(**args)
+
+        if ret is None:
+            return ''
+
+        if not rfunc:
+            return ret
+
+        if rargs:
+            return getattr(ret, rfunc)(*rargs)
+
+        return getattr(ret, rfunc)()
+
+    @classmethod
+    def _build_params_dict(cls, name, cfg, values = None, xvars = None, r = None):
+        if not isinstance(values, dict):
+            values = {}
+
+        if not isinstance(r, dict):
+            r = {}
+
+        if not cfg or not isinstance(cfg, list):
+            return r
+
+        fkwargs = {name: values.copy()}
+
+        if isinstance(xvars, dict):
+            fkwargs.update(xvars)
+
+        for elt in cfg:
+            ename = list(elt.keys())[0]
+            m = _PARAMS_DICT_MODIFIERS_MATCH(ename)
+            if m:
+                modifiers = m.group('modifiers') or '+'
+                key       = m.group('key')
+            else:
+                modifiers = '+'
+                key       = ename
+
+            if '+' in modifiers:
+                r[key] = elt[ename]
+            elif '-' in modifiers:
+                if key not in r:
+                    continue
+                if elt[ename] in (None, r[key]):
+                    del r[key]
+            elif '~' in modifiers:
+                args = elt[ename]
+
+                if key not in r:
+                    r[key] = args.get('default') or ''
+                else:
+                    r[key] = cls._param_regex(args, r[key])
+            elif '=' in modifiers:
+                if key in r:
+                    r[elt[ename]] = r[key]
+
+            if '{' in modifiers and '}' in modifiers:
+                r[key] = r[key].format(**fkwargs)
+
+        return r
+
+
+class DWhoAbstractDB(object): # pylint: disable=useless-object-inheritance
+    __metaclass__ = abc.ABCMeta
+
+    def __init__(self):
+        self.config = {}
+        self._db    = {}
+
+    @property
+    def db(self):
+        thread_id = thread_get_ident()
+        if thread_id not in self._db:
+            self._db[thread_id] = {}
+
+        return self._db[thread_id]
+
+    @db.setter
+    def db(self, value):
+        with _active_limbo_lock:
+            for tid, db in iteritems(self._db):
+                if tid in _active:
+                    continue
+
+                for name in iterkeys(db):
+                    self.db_disconnect(name, db)
+
+        thread_id = thread_get_ident()
+        if thread_id not in self._db:
+            self._db[thread_id] = {}
+
+        self._db[thread_id] = value
+
+    def db_connect(self, name):
+        if name not in self.db:
+            self.db[name] = {'conn': None, 'cursor': None}
+
+        if not self.db[name]['conn'] or not self.db[name]['conn'].is_connected(self.db[name]['cursor']):
+            if self.db[name]['cursor']:
+                try:
+                    self.db[name]['cursor'].close()
+                except Exception:
+                    pass
+                self.db[name]['cursor'] = None
+
+            if self.db[name]['conn']:
+                try:
+                    self.db[name]['conn'].close()
+                except Exception:
+                    pass
+
+            self.db[name]['conn'] = anysql.connect_by_uri(self.config['general']["db_uri_%s" % name])
+
+        if not self.db[name]['cursor']:
+            self.db[name]['cursor'] = self.db[name]['conn'].cursor()
+
+        return self.db[name]
+
+    @staticmethod
+    def get_column_name(column):
+        return (".%s" % column).split('.', 2)[-1]
+
+    def db_prepare_column(self, res, column = None):
+        if column:
+            prep_method = "_prepcol_%s" % self.get_column_name(column)
+            if hasattr(self, prep_method):
+                return getattr(self, prep_method)(column, res)
+
+        if not isinstance(res, object) \
+           or res is None \
+           or isinstance(res, string_types):
+            return res
+
+        return "%s" % res
+
+    def db_disconnect(self, name, db = None):
+        if not db:
+            if not self.db:
+                self.db = {name: {'conn':   None,
+                                  'cursor': None}}
+            db = self.db
+
+        if not db:
+            return self
+
+        if db[name]['cursor']:
+            try:
+                db[name]['cursor'].close()
+            except Exception:
+                pass
+
+        db[name]['cursor'] = None
+
+        if db[name]['conn']:
+            try:
+                db[name]['conn'].close()
+            except Exception:
+                pass
+
+        db[name]['conn']   = None
+
+        return self

dwho/classes/errors.py

@@ -0,0 +1,16 @@
+# -*- coding: utf-8 -*-
+# Copyright (C) 2015-2019 Adrien Delle Cave
+# SPDX-License-Identifier: GPL-3.0-or-later
+"""dwho.classes.errors"""
+
+from pyinotify import PyinotifyError
+
+
+class DWhoError(Exception):
+    pass
+
+class DWhoConfigurationError(DWhoError):
+    pass
+
+class DWhoInotifyError(PyinotifyError):
+    pass