[mod] simplifu code, remove global pkg object

moulinette/__init__.py

@@ -1,7 +1,7 @@
 # -*- coding: utf-8 -*-
 
-from moulinette import m18n, pkg
+from moulinette.core import init_interface, MoulinetteError, MoulinetteSignals, Moulinette18n
-from moulinette.core import init_interface, MoulinetteError, MoulinetteSignals
+from moulinette.globals import DATA_DIR, LIB_DIR, LOCALES_DIR, CACHE_DIR
 
 __title__ = 'moulinette'
 __version__ = '0.1'
@@ -28,12 +28,15 @@ __credits__ = """
     along with this program; if not, see http://www.gnu.org/licenses
     """
 __all__ = [
-    'init', 'api', 'cli',
+    'init', 'api', 'cli', 'm18n',
     'init_interface', 'MoulinetteError',
+    'DATA_DIR', 'LIB_DIR', 'LOCALES_DIR', 'CACHE_DIR',
 ]
 
+
 msignals = MoulinetteSignals()
 msettings = dict()
+m18n = Moulinette18n()
 
 
 # Package functions
@@ -54,29 +57,12 @@ def init(logging_config=None, **kwargs):
 
     """
     import sys
-    from moulinette.core import Package, Moulinette18n
     from moulinette.utils.log import configure_logging
 
     configure_logging(logging_config)
 
-    # Define and instantiate global objects
-
-    # here I need to add attributes/methods to modules because those globals
-    # are only initialized here and using empty modules is the only working
-    # solution I've found for that (using globals() doesn't work because of the
-    # order of importation)
-    _pkg = Package(**kwargs)
-    for i in dir(_pkg):
-        if not i.startswith("_"):
-            setattr(pkg, i, getattr(_pkg, i))
-
-    _m18n = Moulinette18n(pkg)
-    for i in dir(_m18n):
-        if not i.startswith("_"):
-            setattr(m18n, i, getattr(_m18n, i))
-
     # Add library directory to python path
-    sys.path.insert(0, pkg.libdir)
+    sys.path.insert(0, LIB_DIR)
 
 
 # Easy access to interfaces

moulinette/actionsmap.py

@@ -9,7 +9,9 @@ import cPickle as pickle
 from time import time
 from collections import OrderedDict
 
-from moulinette import m18n, msignals, pkg
+from moulinette import m18n, msignals
+from moulinette.cache import open_cachefile
+from moulinette.globals import CACHE_DIR, DATA_DIR
 from moulinette.core import (MoulinetteError, MoulinetteLock)
 from moulinette.interfaces import (
     BaseActionsMapParser, GLOBAL_SECTION, TO_RETURN_PROP
@@ -374,10 +376,10 @@ class ActionsMap(object):
         for n in namespaces:
             logger.debug("loading actions map namespace '%s'", n)
 
-            actionsmap_yml = '%s/actionsmap/%s.yml' % (pkg.datadir, n)
+            actionsmap_yml = '%s/actionsmap/%s.yml' % (DATA_DIR, n)
             actionsmap_yml_stat = os.stat(actionsmap_yml)
             actionsmap_pkl = '%s/actionsmap/%s-%d-%d.pkl' % (
-                pkg.cachedir,
+                CACHE_DIR,
                 n,
                 actionsmap_yml_stat.st_size,
                 actionsmap_yml_stat.st_mtime
@@ -499,7 +501,7 @@ class ActionsMap(object):
         """
         namespaces = []
 
-        for f in os.listdir('%s/actionsmap' % pkg.datadir):
+        for f in os.listdir('%s/actionsmap' % DATA_DIR):
             if f.endswith('.yml'):
                 namespaces.append(f[:-4])
         return namespaces
@@ -525,23 +527,23 @@ class ActionsMap(object):
             logger.debug("generating cache for actions map namespace '%s'", n)
 
             # Read actions map from yaml file
-            am_file = '%s/actionsmap/%s.yml' % (pkg.datadir, n)
+            am_file = '%s/actionsmap/%s.yml' % (DATA_DIR, n)
             with open(am_file, 'r') as f:
                 actionsmaps[n] = ordered_yaml_load(f)
 
             # at installation, cachedir might not exists
-            if os.path.exists('%s/actionsmap/' % pkg.cachedir):
+            if os.path.exists('%s/actionsmap/' % CACHE_DIR):
                 # clean old cached files
-                for i in os.listdir('%s/actionsmap/' % pkg.cachedir):
+                for i in os.listdir('%s/actionsmap/' % CACHE_DIR):
                     if i.endswith(".pkl"):
-                        os.remove('%s/actionsmap/%s' % (pkg.cachedir, i))
+                        os.remove('%s/actionsmap/%s' % (CACHE_DIR, i))
 
             # Cache actions map into pickle file
             am_file_stat = os.stat(am_file)
 
             pkl = '%s-%d-%d.pkl' % (n, am_file_stat.st_size, am_file_stat.st_mtime)
 
-            with pkg.open_cachefile(pkl, 'w', subdir='actionsmap') as f:
+            with open_cachefile(pkl, 'w', subdir='actionsmap') as f:
                 pickle.dump(actionsmaps[n], f)
 
         return actionsmaps

moulinette/authenticators/__init__.py

@@ -4,7 +4,8 @@ import errno
 import gnupg
 import logging
 
-from moulinette import m18n, pkg
+from moulinette import m18n
+from moulinette.cache import open_cachefile
 from moulinette.core import MoulinetteError
 
 logger = logging.getLogger('moulinette.authenticator')
@@ -130,8 +131,8 @@ class BaseAuthenticator(object):
 
     def _open_sessionfile(self, session_id, mode='r'):
         """Open a session file for this instance in given mode"""
-        return pkg.open_cachefile('%s.asc' % session_id, mode,
+        return open_cachefile('%s.asc' % session_id, mode,
-                                  subdir='session/%s' % self.name)
+                              subdir='session/%s' % self.name)
 
     def _store_session(self, session_id, session_hash, password):
         """Store a session and its associated password"""

moulinette/cache.py

@@ -0,0 +1,43 @@
+# -*- coding: utf-8 -*-
+
+import os
+
+from moulinette.globals import CACHE_DIR
+
+
+def get_cachedir(subdir='', make_dir=True):
+    """Get the path to a cache directory
+
+    Return the path to the cache directory from an optional
+    subdirectory and create it if needed.
+
+    Keyword arguments:
+        - subdir -- A cache subdirectory
+        - make_dir -- False to not make directory if it not exists
+
+    """
+    path = os.path.join(CACHE_DIR, subdir)
+
+    if make_dir and not os.path.isdir(path):
+        os.makedirs(path)
+    return path
+
+
+def open_cachefile(filename, mode='r', **kwargs):
+    """Open a cache file and return a stream
+
+    Attempt to open in 'mode' the cache file 'filename' from the
+    default cache directory and in the subdirectory 'subdir' if
+    given. Directories are created if needed and a stream is
+    returned if the file can be written.
+
+    Keyword arguments:
+        - filename -- The cache filename
+        - mode -- The mode in which the file is opened
+        - **kwargs -- Optional arguments for get_cachedir
+
+    """
+    # Set make_dir if not given
+    kwargs['make_dir'] = kwargs.get('make_dir',
+                                    True if mode[0] == 'w' else False)
+    return open('%s/%s' % (get_cachedir(**kwargs), filename), mode)

moulinette/core.py

@@ -8,117 +8,14 @@ import logging
 
 from importlib import import_module
 
-from moulinette import m18n, pkg
+import moulinette
+from moulinette.globals import LOCALES_DIR, LIB_DIR
+from moulinette.cache import get_cachedir
 
 
 logger = logging.getLogger('moulinette.core')
 
 
-# Package manipulation -------------------------------------------------
-
-class Package(object):
-    """Package representation and easy access methods
-
-    Initialize directories and variables for the package and give them
-    easy access.
-
-    Keyword arguments:
-        - _from_source -- Either the package is running from source or
-            not (only for debugging)
-
-    """
-
-    def __init__(self, _from_source=False):
-        if _from_source:
-            import sys
-
-            logger.debug('initialize Package object running from source')
-
-            # Retrieve source's base directory
-            basedir = os.path.abspath(os.path.dirname(sys.argv[0]) + '/../')
-
-            # Set local directories
-            self._datadir = '%s/data' % basedir
-            self._libdir = '%s/lib' % basedir
-            self._localedir = '%s/locales' % basedir
-            self._cachedir = '%s/cache' % basedir
-        else:
-            import package
-
-            # Set system directories
-            self._datadir = package.datadir
-            self._libdir = package.libdir
-            self._localedir = package.localedir
-            self._cachedir = package.cachedir
-
-    def __setattr__(self, name, value):
-        if name[0] == '_' and name in self.__dict__:
-            # Deny reassignation of package directories
-            logger.error("cannot reassign Package variable '%s'", name)
-            return
-        self.__dict__[name] = value
-
-    # Easy access to package directories
-
-    @property
-    def datadir(self):
-        """Return the data directory of the package"""
-        return self._datadir
-
-    @property
-    def libdir(self):
-        """Return the lib directory of the package"""
-        return self._libdir
-
-    @property
-    def localedir(self):
-        """Return the locale directory of the package"""
-        return self._localedir
-
-    @property
-    def cachedir(self):
-        """Return the cache directory of the package"""
-        return self._cachedir
-
-    # Additional methods
-
-    def get_cachedir(self, subdir='', make_dir=True):
-        """Get the path to a cache directory
-
-        Return the path to the cache directory from an optional
-        subdirectory and create it if needed.
-
-        Keyword arguments:
-            - subdir -- A cache subdirectory
-            - make_dir -- False to not make directory if it not exists
-
-        """
-        path = os.path.join(self.cachedir, subdir)
-
-        if make_dir and not os.path.isdir(path):
-            os.makedirs(path)
-        return path
-
-    def open_cachefile(self, filename, mode='r', **kwargs):
-        """Open a cache file and return a stream
-
-        Attempt to open in 'mode' the cache file 'filename' from the
-        default cache directory and in the subdirectory 'subdir' if
-        given. Directories are created if needed and a stream is
-        returned if the file can be written.
-
-        Keyword arguments:
-            - filename -- The cache filename
-            - mode -- The mode in which the file is opened
-            - **kwargs -- Optional arguments for get_cachedir
-
-        """
-        # Set make_dir if not given
-        kwargs['make_dir'] = kwargs.get('make_dir',
-                                        True if mode[0] == 'w' else False)
-        return open('%s/%s' % (self.get_cachedir(**kwargs), filename), mode)
-
-
 # Internationalization -------------------------------------------------
 
 class Translator(object):
@@ -247,13 +144,12 @@ class Moulinette18n(object):
 
     """
 
-    def __init__(self, package, default_locale='en'):
+    def __init__(self, default_locale='en'):
         self.default_locale = default_locale
         self.locale = default_locale
-        self.pkg = package
 
         # Init global translator
-        self._global = Translator(self.pkg.localedir, default_locale)
+        self._global = Translator(LOCALES_DIR, default_locale)
 
         # Define namespace related variables
         self._namespaces = {}
@@ -276,7 +172,7 @@ class Moulinette18n(object):
         """
         if namespace not in self._namespaces:
             # Create new Translator object
-            n = Translator('%s/%s/locales' % (self.pkg.libdir, namespace),
+            n = Translator('%s/%s/locales' % (LIB_DIR, namespace),
                            self.default_locale)
             n.set_locale(self.locale)
             self._namespaces[namespace] = n
@@ -453,7 +349,7 @@ def init_interface(name, kwargs={}, actionsmap={}):
         mod = import_module('moulinette.interfaces.%s' % name)
     except ImportError:
         logger.exception("unable to load interface '%s'", name)
-        raise MoulinetteError(errno.EINVAL, m18n.g('error_see_log'))
+        raise MoulinetteError(errno.EINVAL, moulinette.m18n.g('error_see_log'))
     else:
         try:
             # Retrieve interface classes
@@ -461,7 +357,7 @@ def init_interface(name, kwargs={}, actionsmap={}):
             interface = mod.Interface
         except AttributeError:
             logger.exception("unable to retrieve classes of interface '%s'", name)
-            raise MoulinetteError(errno.EIO, m18n.g('error_see_log'))
+            raise MoulinetteError(errno.EIO, moulinette.m18n.g('error_see_log'))
 
     # Instantiate or retrieve ActionsMap
     if isinstance(actionsmap, dict):
@@ -470,7 +366,7 @@ def init_interface(name, kwargs={}, actionsmap={}):
         amap = actionsmap
     else:
         logger.error("invalid actionsmap value %r", actionsmap)
-        raise MoulinetteError(errno.EINVAL, m18n.g('error_see_log'))
+        raise MoulinetteError(errno.EINVAL, moulinette.m18n.g('error_see_log'))
 
     return interface(amap, **kwargs)
 
@@ -491,7 +387,7 @@ def init_authenticator((vendor, name), kwargs={}):
         mod = import_module('moulinette.authenticators.%s' % vendor)
     except ImportError:
         logger.exception("unable to load authenticator vendor '%s'", vendor)
-        raise MoulinetteError(errno.EINVAL, m18n.g('error_see_log'))
+        raise MoulinetteError(errno.EINVAL, moulinette.m18n.g('error_see_log'))
     else:
         return mod.Authenticator(name, **kwargs)
 
@@ -507,7 +403,7 @@ def clean_session(session_id, profiles=[]):
         - profiles -- A list of profiles to clean
 
     """
-    sessiondir = pkg.get_cachedir('session')
+    sessiondir = get_cachedir('session')
     if not profiles:
         profiles = os.listdir(sessiondir)
 
@@ -581,7 +477,7 @@ class MoulinetteLock(object):
 
             if self.timeout is not None and (time.time() - start_time) > self.timeout:
                 raise MoulinetteError(errno.EBUSY,
-                                      m18n.g('instance_already_running'))
+                                      moulinette.m18n.g('instance_already_running'))
             # Wait before checking again
             time.sleep(self.interval)
 
@@ -608,8 +504,8 @@ class MoulinetteLock(object):
         except IOError:
             raise MoulinetteError(
                 errno.EPERM, '%s. %s.'.format(
-                    m18n.g('permission_denied'),
+                    moulinette.m18n.g('permission_denied'),
-                    m18n.g('root_required')))
+                    moulinette.m18n.g('root_required')))
 
     def __enter__(self):
         if not self._locked:

moulinette/globals.py

@@ -0,0 +1,4 @@
+DATA_DIR = '/usr/share/moulinette'
+LIB_DIR = '/usr/lib/moulinette'
+LOCALES_DIR = '/usr/share/moulinette/locale'
+CACHE_DIR = '/var/cache/moulinette'

moulinette/interfaces/api.py

@@ -13,7 +13,7 @@ from geventwebsocket import WebSocketError
 
 from bottle import run, request, response, Bottle, HTTPResponse
 
-from moulinette import msignals, m18n, pkg
+from moulinette import msignals, m18n, DATA_DIR
 from moulinette.core import MoulinetteError, clean_session
 from moulinette.interfaces import (
     BaseActionsMapParser, BaseInterface, ExtendedArgumentParser,
@@ -757,11 +757,11 @@ class Interface(BaseInterface):
 
         """
         if category is None:
-            with open('%s/../doc/resources.json' % pkg.datadir) as f:
+            with open('%s/../doc/resources.json' % DATA_DIR) as f:
                 return f.read()
 
         try:
-            with open('%s/../doc/%s.json' % (pkg.datadir, category)) as f:
+            with open('%s/../doc/%s.json' % (DATA_DIR, category)) as f:
                 return f.read()
         except IOError:
             return None

moulinette/m18n.py

@@ -1,3 +0,0 @@
-"""
-Empty module used to gather m18n method to avoid to have a global magic variable
-"""

moulinette/package.py.in

@@ -1,15 +0,0 @@
-# -*- coding: utf-8 -*-
-
-# Public constants defined during build
-
-"""Package's data directory (e.g. /usr/share/moulinette)"""
-datadir = '%PKGDATADIR%'
-
-"""Package's library directory (e.g. /usr/lib/moulinette)"""
-libdir = '%PKGLIBDIR%'
-
-"""Locale directory for the package (e.g. /usr/share/moulinette/locale)"""
-localedir = '%PKGLOCALEDIR%'
-
-"""Cache directory for the package (e.g. /var/cache/moulinette)"""
-cachedir = '%PKGCACHEDIR%'

moulinette/pkg.py

@@ -1,3 +0,0 @@
-"""
-Empty module used to gather pkg method/attributes to avoid to have a global magic variable
-"""

moulinette/utils/filesystem.py

@@ -6,6 +6,7 @@ import grp
 from pwd import getpwnam
 
 from moulinette import m18n
+from moulinette.globals import CACHE_DIR
 from moulinette.core import MoulinetteError
 
 # Files & directories --------------------------------------------------

setup.py

@@ -3,35 +3,19 @@ import os
 import sys
 
 from distutils.core import setup
-from distutils.sysconfig import PREFIX
 
-# Define package directories
+from moulinette.globals import LOCALES_DIR
-datadir = os.path.join(PREFIX, 'share/moulinette')
+
-libdir = os.path.join(PREFIX, 'lib/moulinette')
-localedir = os.path.join(datadir, 'locale')
-cachedir = '/var/cache/moulinette'
 
 # Extend installation
 locale_files = []
+
 if "install" in sys.argv:
     # Evaluate locale files
     for f in os.listdir('locales'):
         if f.endswith('.json'):
             locale_files.append('locales/%s' % f)
 
-    # Generate package.py
-    package = open('moulinette/package.py.in').read()
-    package = package.replace('%PKGDATADIR%', datadir) \
-                  .replace('%PKGLIBDIR%', libdir) \
-                  .replace('%PKGLOCALEDIR%', localedir) \
-                  .replace('%PKGCACHEDIR%', cachedir)
-    with open('moulinette/package.py', 'w') as f:
-        f.write(package)
-
-    # Create needed directories
-#    mkpath(libdir, mode=0755, verbose=1)
-#    mkpath(os.path.join(datadir, 'actionsmap'), mode=0755, verbose=1)
-
 
 setup(name='Moulinette',
       version='2.0.0',
@@ -46,5 +30,5 @@ setup(name='Moulinette',
           'moulinette.interfaces',
           'moulinette.utils',
       ],
-      data_files=[(localedir, locale_files)]
+      data_files=[(LOCALES_DIR, locale_files)]
       )