mirror of
https://github.com/YunoHost/moulinette.git
synced 2024-09-03 20:06:31 +02:00
[mod] proposition to remove globals magic
This commit is contained in:
Laurent Peuch
parent
e6cffbc3e2
commit
863c3dd050
10 changed files with 118 additions and 105 deletions
|
|
@ -1,6 +1,6 @@
|
|||
# -*- coding: utf-8 -*-
|
||||
|
||||
from moulinette.core import init_interface, MoulinetteError
|
||||
from moulinette.core import init_interface, MoulinetteError, MoulinetteSignals
|
||||
|
||||
__title__ = 'moulinette'
|
||||
__version__ = '0.1'
|
||||
|
|
@ -31,6 +31,11 @@ __all__ = [
|
|||
'init_interface', 'MoulinetteError',
|
||||
]
|
||||
|
||||
msignals = MoulinetteSignals()
|
||||
msettings = dict()
|
||||
pkg = None
|
||||
m18n = None
|
||||
|
||||
|
||||
# Package functions
|
||||
|
||||
|
|
@ -50,21 +55,16 @@ def init(logging_config=None, **kwargs):
|
|||
|
||||
"""
|
||||
import sys
|
||||
import __builtin__
|
||||
from moulinette.core import (
|
||||
Package, Moulinette18n, MoulinetteSignals
|
||||
)
|
||||
from moulinette.core import Package, Moulinette18n
|
||||
from moulinette.utils.log import configure_logging
|
||||
|
||||
configure_logging(logging_config)
|
||||
|
||||
pkg = Package(**kwargs)
|
||||
global pkg, m18n
|
||||
|
||||
# Define and instantiate global objects
|
||||
__builtin__.__dict__['pkg'] = pkg
|
||||
__builtin__.__dict__['m18n'] = Moulinette18n(pkg)
|
||||
__builtin__.__dict__['msignals'] = MoulinetteSignals()
|
||||
__builtin__.__dict__['msettings'] = dict()
|
||||
pkg = Package(**kwargs)
|
||||
m18n = Moulinette18n(pkg)
|
||||
|
||||
# Add library directory to python path
|
||||
sys.path.insert(0, pkg.libdir)
|
||||
|
|
|
|||
|
|
@ -9,6 +9,7 @@ import cPickle as pickle
|
|||
from time import time
|
||||
from collections import OrderedDict
|
||||
|
||||
import moulinette
|
||||
from moulinette.core import (MoulinetteError, MoulinetteLock)
|
||||
from moulinette.interfaces import (
|
||||
BaseActionsMapParser, GLOBAL_SECTION, TO_RETURN_PROP
|
||||
|
|
@ -98,7 +99,7 @@ class AskParameter(_ExtraParameter):
|
|||
|
||||
try:
|
||||
# Ask for the argument value
|
||||
return msignals.prompt(m18n.n(message))
|
||||
return moulinette.msignals.prompt(moulinette.m18n.n(message))
|
||||
except NotImplementedError:
|
||||
return arg_value
|
||||
|
||||
|
|
@ -131,7 +132,7 @@ class PasswordParameter(AskParameter):
|
|||
|
||||
try:
|
||||
# Ask for the password
|
||||
return msignals.prompt(m18n.n(message), True, True)
|
||||
return moulinette.msignals.prompt(moulinette.m18n.n(message), True, True)
|
||||
except NotImplementedError:
|
||||
return arg_value
|
||||
|
||||
|
|
@ -160,12 +161,12 @@ class PatternParameter(_ExtraParameter):
|
|||
v, arg_name, pattern)
|
||||
|
||||
# Attempt to retrieve message translation
|
||||
msg = m18n.n(message)
|
||||
msg = moulinette.m18n.n(message)
|
||||
if msg == message:
|
||||
msg = m18n.g(message)
|
||||
msg = moulinette.m18n.g(message)
|
||||
|
||||
raise MoulinetteError(errno.EINVAL,
|
||||
m18n.g('invalid_argument',
|
||||
moulinette.m18n.g('invalid_argument',
|
||||
argument=arg_name, error=msg))
|
||||
return arg_value
|
||||
|
||||
|
|
@ -196,7 +197,7 @@ class RequiredParameter(_ExtraParameter):
|
|||
logger.debug("argument '%s' is required",
|
||||
arg_name)
|
||||
raise MoulinetteError(errno.EINVAL,
|
||||
m18n.g('argument_required',
|
||||
moulinette.m18n.g('argument_required',
|
||||
argument=arg_name))
|
||||
return arg_value
|
||||
|
||||
|
|
@ -261,7 +262,7 @@ class ExtraArgumentParser(object):
|
|||
except Exception as e:
|
||||
logger.error("unable to validate extra parameter '%s' "
|
||||
"for argument '%s': %s", p, arg_name, e)
|
||||
raise MoulinetteError(errno.EINVAL, m18n.g('error_see_log'))
|
||||
raise MoulinetteError(errno.EINVAL, moulinette.m18n.g('error_see_log'))
|
||||
|
||||
return parameters
|
||||
|
||||
|
|
@ -373,10 +374,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' % (moulinette.pkg.datadir, n)
|
||||
actionsmap_yml_stat = os.stat(actionsmap_yml)
|
||||
actionsmap_pkl = '%s/actionsmap/%s-%d-%d.pkl' % (
|
||||
pkg.cachedir,
|
||||
moulinette.pkg.cachedir,
|
||||
n,
|
||||
actionsmap_yml_stat.st_size,
|
||||
actionsmap_yml_stat.st_mtime
|
||||
|
|
@ -399,7 +400,7 @@ class ActionsMap(object):
|
|||
actionsmaps[n] = ordered_yaml_load(f)
|
||||
|
||||
# Load translations
|
||||
m18n.load_namespace(n)
|
||||
moulinette.m18n.load_namespace(n)
|
||||
|
||||
# Generate parsers
|
||||
self.extraparser = ExtraArgumentParser(parser_class.interface)
|
||||
|
|
@ -466,7 +467,7 @@ class ActionsMap(object):
|
|||
except (AttributeError, ImportError):
|
||||
logger.exception("unable to load function %s.%s.%s",
|
||||
namespace, category, func_name)
|
||||
raise MoulinetteError(errno.EIO, m18n.g('error_see_log'))
|
||||
raise MoulinetteError(errno.EIO, moulinette.m18n.g('error_see_log'))
|
||||
else:
|
||||
log_id = start_action_logging()
|
||||
if logger.isEnabledFor(logging.DEBUG):
|
||||
|
|
@ -478,7 +479,7 @@ class ActionsMap(object):
|
|||
log_id, namespace, category, action)
|
||||
|
||||
# Load translation and process the action
|
||||
m18n.load_namespace(namespace)
|
||||
moulinette.m18n.load_namespace(namespace)
|
||||
start = time()
|
||||
try:
|
||||
return func(**arguments)
|
||||
|
|
@ -498,7 +499,7 @@ class ActionsMap(object):
|
|||
"""
|
||||
namespaces = []
|
||||
|
||||
for f in os.listdir('%s/actionsmap' % pkg.datadir):
|
||||
for f in os.listdir('%s/actionsmap' % moulinette.pkg.datadir):
|
||||
if f.endswith('.yml'):
|
||||
namespaces.append(f[:-4])
|
||||
return namespaces
|
||||
|
|
@ -524,23 +525,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' % (moulinette.pkg.datadir, 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/' % moulinette.pkg.cachedir):
|
||||
# clean old cached files
|
||||
for i in os.listdir('%s/actionsmap/' % pkg.cachedir):
|
||||
for i in os.listdir('%s/actionsmap/' % moulinette.pkg.cachedir):
|
||||
if i.endswith(".pkl"):
|
||||
os.remove('%s/actionsmap/%s' % (pkg.cachedir, i))
|
||||
os.remove('%s/actionsmap/%s' % (moulinette.pkg.cachedir, 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 moulinette.pkg.open_cachefile(pkl, 'w', subdir='actionsmap') as f:
|
||||
pickle.dump(actionsmaps[n], f)
|
||||
|
||||
return actionsmaps
|
||||
|
|
|
|||
|
|
@ -4,6 +4,7 @@ import errno
|
|||
import gnupg
|
||||
import logging
|
||||
|
||||
import moulinette
|
||||
from moulinette.core import MoulinetteError
|
||||
|
||||
logger = logging.getLogger('moulinette.authenticator')
|
||||
|
|
@ -95,7 +96,7 @@ class BaseAuthenticator(object):
|
|||
except TypeError:
|
||||
logger.error("unable to extract token parts from '%s'", token)
|
||||
if password is None:
|
||||
raise MoulinetteError(errno.EINVAL, m18n.g('error_see_log'))
|
||||
raise MoulinetteError(errno.EINVAL, moulinette.m18n.g('error_see_log'))
|
||||
|
||||
logger.info("session will not be stored")
|
||||
store_session = False
|
||||
|
|
@ -112,7 +113,7 @@ class BaseAuthenticator(object):
|
|||
except:
|
||||
logger.exception("authentication (name: '%s', vendor: '%s') fails",
|
||||
self.name, self.vendor)
|
||||
raise MoulinetteError(errno.EACCES, m18n.g('unable_authenticate'))
|
||||
raise MoulinetteError(errno.EACCES, moulinette.m18n.g('unable_authenticate'))
|
||||
|
||||
# Store session
|
||||
if store_session:
|
||||
|
|
@ -129,7 +130,7 @@ 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 moulinette.pkg.open_cachefile('%s.asc' % session_id, mode,
|
||||
subdir='session/%s' % self.name)
|
||||
|
||||
def _store_session(self, session_id, session_hash, password):
|
||||
|
|
@ -148,7 +149,7 @@ class BaseAuthenticator(object):
|
|||
except IOError:
|
||||
logger.debug("unable to retrieve session", exc_info=1)
|
||||
raise MoulinetteError(errno.ENOENT,
|
||||
m18n.g('unable_retrieve_session'))
|
||||
moulinette.m18n.g('unable_retrieve_session'))
|
||||
else:
|
||||
gpg = gnupg.GPG()
|
||||
gpg.encoding = 'utf-8'
|
||||
|
|
@ -158,5 +159,5 @@ class BaseAuthenticator(object):
|
|||
logger.error("unable to decrypt password for the session: %s",
|
||||
decrypted.status)
|
||||
raise MoulinetteError(errno.EINVAL,
|
||||
m18n.g('unable_retrieve_session'))
|
||||
moulinette.m18n.g('unable_retrieve_session'))
|
||||
return decrypted.data
|
||||
|
|
|
|||
|
|
@ -7,6 +7,7 @@ import logging
|
|||
import ldap
|
||||
import ldap.modlist as modlist
|
||||
|
||||
import moulinette
|
||||
from moulinette.core import MoulinetteError
|
||||
from moulinette.authenticators import BaseAuthenticator
|
||||
|
||||
|
|
@ -75,10 +76,10 @@ class Authenticator(BaseAuthenticator):
|
|||
else:
|
||||
con.simple_bind_s()
|
||||
except ldap.INVALID_CREDENTIALS:
|
||||
raise MoulinetteError(errno.EACCES, m18n.g('invalid_password'))
|
||||
raise MoulinetteError(errno.EACCES, moulinette.m18n.g('invalid_password'))
|
||||
except ldap.SERVER_DOWN:
|
||||
logger.exception('unable to reach the server to authenticate')
|
||||
raise MoulinetteError(169, m18n.g('ldap_server_down'))
|
||||
raise MoulinetteError(169, moulinette.m18n.g('ldap_server_down'))
|
||||
else:
|
||||
self.con = con
|
||||
|
||||
|
|
@ -139,7 +140,7 @@ class Authenticator(BaseAuthenticator):
|
|||
except:
|
||||
logger.exception("error during LDAP add operation with: rdn='%s', "
|
||||
"attr_dict=%s", rdn, attr_dict)
|
||||
raise MoulinetteError(169, m18n.g('ldap_operation_error'))
|
||||
raise MoulinetteError(169, moulinette.m18n.g('ldap_operation_error'))
|
||||
else:
|
||||
return True
|
||||
|
||||
|
|
@ -159,7 +160,7 @@ class Authenticator(BaseAuthenticator):
|
|||
self.con.delete_s(dn)
|
||||
except:
|
||||
logger.exception("error during LDAP delete operation with: rdn='%s'", rdn)
|
||||
raise MoulinetteError(169, m18n.g('ldap_operation_error'))
|
||||
raise MoulinetteError(169, moulinette.m18n.g('ldap_operation_error'))
|
||||
else:
|
||||
return True
|
||||
|
||||
|
|
@ -189,7 +190,7 @@ class Authenticator(BaseAuthenticator):
|
|||
except:
|
||||
logger.exception("error during LDAP update operation with: rdn='%s', "
|
||||
"attr_dict=%s, new_rdn=%s", rdn, attr_dict, new_rdn)
|
||||
raise MoulinetteError(169, m18n.g('ldap_operation_error'))
|
||||
raise MoulinetteError(169, moulinette.m18n.g('ldap_operation_error'))
|
||||
else:
|
||||
return True
|
||||
|
||||
|
|
@ -211,6 +212,6 @@ class Authenticator(BaseAuthenticator):
|
|||
logger.info("attribute '%s' with value '%s' is not unique",
|
||||
attr, value)
|
||||
raise MoulinetteError(errno.EEXIST,
|
||||
m18n.g('ldap_attribute_already_exists',
|
||||
attribute=attr, value=value))
|
||||
moulinette.m18n.g('ldap_attribute_already_exists',
|
||||
attribute=attr, value=value))
|
||||
return True
|
||||
|
|
|
|||
|
|
@ -8,6 +8,8 @@ import logging
|
|||
|
||||
from importlib import import_module
|
||||
|
||||
import moulinette
|
||||
|
||||
logger = logging.getLogger('moulinette.core')
|
||||
|
||||
|
||||
|
|
@ -450,7 +452,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
|
||||
|
|
@ -458,7 +460,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):
|
||||
|
|
@ -467,7 +469,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)
|
||||
|
||||
|
|
@ -488,7 +490,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)
|
||||
|
||||
|
|
@ -504,7 +506,7 @@ def clean_session(session_id, profiles=[]):
|
|||
- profiles -- A list of profiles to clean
|
||||
|
||||
"""
|
||||
sessiondir = pkg.get_cachedir('session')
|
||||
sessiondir = moulinette.pkg.get_cachedir('session')
|
||||
if not profiles:
|
||||
profiles = os.listdir(sessiondir)
|
||||
|
||||
|
|
@ -578,7 +580,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)
|
||||
|
||||
|
|
@ -605,8 +607,8 @@ class MoulinetteLock(object):
|
|||
except IOError:
|
||||
raise MoulinetteError(
|
||||
errno.EPERM, '%s. %s.'.format(
|
||||
m18n.g('permission_denied'),
|
||||
m18n.g('root_required')))
|
||||
moulinette.m18n.g('permission_denied'),
|
||||
moulinette.m18n.g('root_required')))
|
||||
|
||||
def __enter__(self):
|
||||
if not self._locked:
|
||||
|
|
|
|||
|
|
@ -7,6 +7,8 @@ import logging
|
|||
import argparse
|
||||
from collections import deque
|
||||
|
||||
import moulinette
|
||||
from moulinette import msignals, msettings
|
||||
from moulinette.core import (init_authenticator, MoulinetteError)
|
||||
|
||||
logger = logging.getLogger('moulinette.interface')
|
||||
|
|
@ -138,7 +140,7 @@ class BaseActionsMapParser(object):
|
|||
# Validate tid and namespace
|
||||
if not isinstance(tid, tuple) and \
|
||||
(namespace is None or not hasattr(namespace, TO_RETURN_PROP)):
|
||||
raise MoulinetteError(errno.EINVAL, m18n.g('invalid_usage'))
|
||||
raise MoulinetteError(errno.EINVAL, moulinette.m18n.g('invalid_usage'))
|
||||
elif not tid:
|
||||
tid = GLOBAL_SECTION
|
||||
|
||||
|
|
@ -159,7 +161,7 @@ class BaseActionsMapParser(object):
|
|||
auth = msignals.authenticate(cls(), **auth_conf)
|
||||
if not auth.is_authenticated:
|
||||
raise MoulinetteError(errno.EACCES,
|
||||
m18n.g('authentication_required_long'))
|
||||
moulinette.m18n.g('authentication_required_long'))
|
||||
if self.get_conf(tid, 'argument_auth') and \
|
||||
self.get_conf(tid, 'authenticate') == 'all':
|
||||
namespace.auth = auth
|
||||
|
|
@ -263,7 +265,7 @@ class BaseActionsMapParser(object):
|
|||
else:
|
||||
logger.error("expecting 'all', 'False' or a list for "
|
||||
"configuration 'authenticate', got %r", ifaces)
|
||||
raise MoulinetteError(errno.EINVAL, m18n.g('error_see_log'))
|
||||
raise MoulinetteError(errno.EINVAL, moulinette.m18n.g('error_see_log'))
|
||||
|
||||
# -- 'authenticator'
|
||||
try:
|
||||
|
|
@ -278,7 +280,7 @@ class BaseActionsMapParser(object):
|
|||
except KeyError:
|
||||
logger.error("requesting profile '%s' which is undefined in "
|
||||
"global configuration of 'authenticator'", auth)
|
||||
raise MoulinetteError(errno.EINVAL, m18n.g('error_see_log'))
|
||||
raise MoulinetteError(errno.EINVAL, moulinette.m18n.g('error_see_log'))
|
||||
elif is_global and isinstance(auth, dict):
|
||||
if len(auth) == 0:
|
||||
logger.warning('no profile defined in global configuration '
|
||||
|
|
@ -301,7 +303,7 @@ class BaseActionsMapParser(object):
|
|||
else:
|
||||
logger.error("expecting a dict of profile(s) or a profile name "
|
||||
"for configuration 'authenticator', got %r", auth)
|
||||
raise MoulinetteError(errno.EINVAL, m18n.g('error_see_log'))
|
||||
raise MoulinetteError(errno.EINVAL, moulinette.m18n.g('error_see_log'))
|
||||
|
||||
# -- 'argument_auth'
|
||||
try:
|
||||
|
|
@ -314,7 +316,7 @@ class BaseActionsMapParser(object):
|
|||
else:
|
||||
logger.error("expecting a boolean for configuration "
|
||||
"'argument_auth', got %r", arg_auth)
|
||||
raise MoulinetteError(errno.EINVAL, m18n.g('error_see_log'))
|
||||
raise MoulinetteError(errno.EINVAL, moulinette.m18n.g('error_see_log'))
|
||||
|
||||
# -- 'lock'
|
||||
try:
|
||||
|
|
@ -327,7 +329,7 @@ class BaseActionsMapParser(object):
|
|||
else:
|
||||
logger.error("expecting a boolean for configuration 'lock', "
|
||||
"got %r", lock)
|
||||
raise MoulinetteError(errno.EINVAL, m18n.g('error_see_log'))
|
||||
raise MoulinetteError(errno.EINVAL, moulinette.m18n.g('error_see_log'))
|
||||
|
||||
return conf
|
||||
|
||||
|
|
@ -427,7 +429,7 @@ class _CallbackAction(argparse.Action):
|
|||
except:
|
||||
logger.exception("cannot get value from callback method "
|
||||
"'{0}'".format(self.callback_method))
|
||||
raise MoulinetteError(errno.EINVAL, m18n.g('error_see_log'))
|
||||
raise MoulinetteError(errno.EINVAL, moulinette.m18n.g('error_see_log'))
|
||||
else:
|
||||
if value:
|
||||
if self.callback_return:
|
||||
|
|
@ -487,10 +489,10 @@ class _ExtendedSubParsersAction(argparse._SubParsersAction):
|
|||
else:
|
||||
# Warn the user about deprecated command
|
||||
if correct_name is None:
|
||||
logger.warning(m18n.g('deprecated_command', prog=parser.prog,
|
||||
logger.warning(moulinette.m18n.g('deprecated_command', prog=parser.prog,
|
||||
command=parser_name))
|
||||
else:
|
||||
logger.warning(m18n.g('deprecated_command_alias',
|
||||
logger.warning(moulinette.m18n.g('deprecated_command_alias',
|
||||
old=parser_name, new=correct_name,
|
||||
prog=parser.prog))
|
||||
values[0] = correct_name
|
||||
|
|
|
|||
|
|
@ -13,6 +13,8 @@ from geventwebsocket import WebSocketError
|
|||
|
||||
from bottle import run, request, response, Bottle, HTTPResponse
|
||||
|
||||
import moulinette
|
||||
from moulinette import msignals
|
||||
from moulinette.core import MoulinetteError, clean_session
|
||||
from moulinette.interfaces import (
|
||||
BaseActionsMapParser, BaseInterface, ExtendedArgumentParser,
|
||||
|
|
@ -308,7 +310,7 @@ class _ActionsMapPlugin(object):
|
|||
response.set_cookie('session.id', s_id, secure=True)
|
||||
response.set_cookie('session.hashes', s_hashes, secure=True,
|
||||
secret=s_secret)
|
||||
return m18n.g('logged_in')
|
||||
return moulinette.m18n.g('logged_in')
|
||||
|
||||
def logout(self, profile=None):
|
||||
"""Log out from an authenticator profile
|
||||
|
|
@ -324,13 +326,13 @@ class _ActionsMapPlugin(object):
|
|||
try:
|
||||
del self.secrets[s_id]
|
||||
except KeyError:
|
||||
raise HTTPUnauthorizedResponse(m18n.g('not_logged_in'))
|
||||
raise HTTPUnauthorizedResponse(moulinette.m18n.g('not_logged_in'))
|
||||
else:
|
||||
# TODO: Clean the session for profile only
|
||||
# Delete cookie and clean the session
|
||||
response.set_cookie('session.hashes', '', max_age=-1)
|
||||
clean_session(s_id)
|
||||
return m18n.g('logged_out')
|
||||
return moulinette.m18n.g('logged_out')
|
||||
|
||||
def messages(self):
|
||||
"""Listen to the messages WebSocket stream
|
||||
|
|
@ -350,7 +352,7 @@ class _ActionsMapPlugin(object):
|
|||
|
||||
wsock = request.environ.get('wsgi.websocket')
|
||||
if not wsock:
|
||||
raise HTTPErrorResponse(m18n.g('websocket_request_expected'))
|
||||
raise HTTPErrorResponse(moulinette.m18n.g('websocket_request_expected'))
|
||||
|
||||
while True:
|
||||
item = queue.get()
|
||||
|
|
@ -413,9 +415,9 @@ class _ActionsMapPlugin(object):
|
|||
secret=s_secret)[authenticator.name]
|
||||
except KeyError:
|
||||
if authenticator.name == 'default':
|
||||
msg = m18n.g('authentication_required')
|
||||
msg = moulinette.m18n.g('authentication_required')
|
||||
else:
|
||||
msg = m18n.g('authentication_profile_required',
|
||||
msg = moulinette.m18n.g('authentication_profile_required',
|
||||
profile=authenticator.name)
|
||||
raise HTTPUnauthorizedResponse(msg)
|
||||
else:
|
||||
|
|
@ -603,7 +605,7 @@ class ActionsMapParser(BaseActionsMapParser):
|
|||
tid, parser = self._parsers[route]
|
||||
except KeyError:
|
||||
logger.error("no argument parser found for route '%s'", route)
|
||||
raise MoulinetteError(errno.EINVAL, m18n.g('error_see_log'))
|
||||
raise MoulinetteError(errno.EINVAL, moulinette.m18n.g('error_see_log'))
|
||||
ret = argparse.Namespace()
|
||||
|
||||
if not self.get_conf(tid, 'lock'):
|
||||
|
|
@ -619,7 +621,7 @@ class ActionsMapParser(BaseActionsMapParser):
|
|||
# TODO: Catch errors
|
||||
auth = msignals.authenticate(klass(), **auth_conf)
|
||||
if not auth.is_authenticated:
|
||||
raise MoulinetteError(errno.EACCES, m18n.g('authentication_required_long'))
|
||||
raise MoulinetteError(errno.EACCES, moulinette.m18n.g('authentication_required_long'))
|
||||
if self.get_conf(tid, 'argument_auth') and \
|
||||
self.get_conf(tid, 'authenticate') == 'all':
|
||||
ret.auth = auth
|
||||
|
|
@ -693,8 +695,8 @@ class Interface(BaseInterface):
|
|||
try:
|
||||
locale = request.params.pop('locale')
|
||||
except KeyError:
|
||||
locale = m18n.default_locale
|
||||
m18n.set_locale(locale)
|
||||
locale = moulinette.m18n.default_locale
|
||||
moulinette.m18n.set_locale(locale)
|
||||
return callback
|
||||
|
||||
# Install plugins
|
||||
|
|
@ -742,8 +744,8 @@ class Interface(BaseInterface):
|
|||
host, port)
|
||||
if e.args[0] == errno.EADDRINUSE:
|
||||
raise MoulinetteError(errno.EADDRINUSE,
|
||||
m18n.g('server_already_running'))
|
||||
raise MoulinetteError(errno.EIO, m18n.g('error_see_log'))
|
||||
moulinette.m18n.g('server_already_running'))
|
||||
raise MoulinetteError(errno.EIO, moulinette.m18n.g('error_see_log'))
|
||||
|
||||
# Routes handlers
|
||||
|
||||
|
|
@ -756,11 +758,11 @@ class Interface(BaseInterface):
|
|||
|
||||
"""
|
||||
if category is None:
|
||||
with open('%s/../doc/resources.json' % pkg.datadir) as f:
|
||||
with open('%s/../doc/resources.json' % moulinette.pkg.datadir) as f:
|
||||
return f.read()
|
||||
|
||||
try:
|
||||
with open('%s/../doc/%s.json' % (pkg.datadir, category)) as f:
|
||||
with open('%s/../doc/%s.json' % (moulinette.pkg.datadir, category)) as f:
|
||||
return f.read()
|
||||
except IOError:
|
||||
return None
|
||||
|
|
|
|||
|
|
@ -11,6 +11,8 @@ from collections import OrderedDict
|
|||
|
||||
import argcomplete
|
||||
|
||||
import moulinette
|
||||
from moulinette import msignals
|
||||
from moulinette.core import MoulinetteError
|
||||
from moulinette.interfaces import (
|
||||
BaseActionsMapParser, BaseInterface, ExtendedArgumentParser,
|
||||
|
|
@ -183,7 +185,7 @@ class TTYHandler(logging.StreamHandler):
|
|||
level = '%s ' % record.levelname
|
||||
elif record.levelname in ['SUCCESS', 'WARNING', 'ERROR']:
|
||||
# add translated level name before message
|
||||
level = '%s ' % m18n.g(record.levelname.lower())
|
||||
level = '%s ' % moulinette.m18n.g(record.levelname.lower())
|
||||
color = self.LEVELS_COLOR.get(record.levelno, 'white')
|
||||
msg = '{0}{1}{2}{3}'.format(
|
||||
colors_codes[color], level, END_CLI_COLOR, msg)
|
||||
|
|
@ -297,7 +299,7 @@ class ActionsMapParser(BaseActionsMapParser):
|
|||
raise
|
||||
except:
|
||||
logger.exception("unable to parse arguments '%s'", ' '.join(args))
|
||||
raise MoulinetteError(errno.EINVAL, m18n.g('error_see_log'))
|
||||
raise MoulinetteError(errno.EINVAL, moulinette.m18n.g('error_see_log'))
|
||||
else:
|
||||
self.prepare_action_namespace(getattr(ret, '_tid', None), ret)
|
||||
self._parser.dequeue_callbacks(ret)
|
||||
|
|
@ -317,7 +319,7 @@ class Interface(BaseInterface):
|
|||
|
||||
def __init__(self, actionsmap):
|
||||
# Set user locale
|
||||
m18n.set_locale(get_locale())
|
||||
moulinette.m18n.set_locale(get_locale())
|
||||
|
||||
# Connect signals to handlers
|
||||
msignals.set_handler('display', self._do_display)
|
||||
|
|
@ -344,7 +346,7 @@ class Interface(BaseInterface):
|
|||
|
||||
"""
|
||||
if output_as and output_as not in ['json', 'plain', 'none']:
|
||||
raise MoulinetteError(errno.EINVAL, m18n.g('invalid_usage'))
|
||||
raise MoulinetteError(errno.EINVAL, moulinette.m18n.g('invalid_usage'))
|
||||
|
||||
# auto-complete
|
||||
argcomplete.autocomplete(self.actionsmap.parser._parser)
|
||||
|
|
@ -357,7 +359,7 @@ class Interface(BaseInterface):
|
|||
try:
|
||||
ret = self.actionsmap.process(args, timeout=timeout)
|
||||
except (KeyboardInterrupt, EOFError):
|
||||
raise MoulinetteError(errno.EINTR, m18n.g('operation_interrupted'))
|
||||
raise MoulinetteError(errno.EINTR, moulinette.m18n.g('operation_interrupted'))
|
||||
|
||||
if ret is None or output_as == 'none':
|
||||
return
|
||||
|
|
@ -384,7 +386,7 @@ class Interface(BaseInterface):
|
|||
|
||||
"""
|
||||
# TODO: Allow token authentication?
|
||||
msg = m18n.n(help) if help else m18n.g('password')
|
||||
msg = moulinette.m18n.n(help) if help else moulinette.m18n.g('password')
|
||||
return authenticator(password=self._do_prompt(msg, True, False,
|
||||
color='yellow'))
|
||||
|
||||
|
|
@ -398,16 +400,16 @@ class Interface(BaseInterface):
|
|||
|
||||
"""
|
||||
if is_password:
|
||||
prompt = lambda m: getpass.getpass(colorize(m18n.g('colon', m),
|
||||
prompt = lambda m: getpass.getpass(colorize(moulinette.m18n.g('colon', m),
|
||||
color))
|
||||
else:
|
||||
prompt = lambda m: raw_input(colorize(m18n.g('colon', m), color))
|
||||
prompt = lambda m: raw_input(colorize(moulinette.m18n.g('colon', m), color))
|
||||
value = prompt(message)
|
||||
|
||||
if confirm:
|
||||
m = message[0].lower() + message[1:]
|
||||
if prompt(m18n.g('confirm', prompt=m)) != value:
|
||||
raise MoulinetteError(errno.EINVAL, m18n.g('values_mismatch'))
|
||||
if prompt(moulinette.m18n.g('confirm', prompt=m)) != value:
|
||||
raise MoulinetteError(errno.EINVAL, moulinette.m18n.g('values_mismatch'))
|
||||
|
||||
return value
|
||||
|
||||
|
|
@ -420,10 +422,10 @@ class Interface(BaseInterface):
|
|||
if isinstance(message, unicode):
|
||||
message = message.encode('utf-8')
|
||||
if style == 'success':
|
||||
print('{} {}'.format(colorize(m18n.g('success'), 'green'), message))
|
||||
print('{} {}'.format(colorize(moulinette.m18n.g('success'), 'green'), message))
|
||||
elif style == 'warning':
|
||||
print('{} {}'.format(colorize(m18n.g('warning'), 'yellow'), message))
|
||||
print('{} {}'.format(colorize(moulinette.m18n.g('warning'), 'yellow'), message))
|
||||
elif style == 'error':
|
||||
print('{} {}'.format(colorize(m18n.g('error'), 'red'), message))
|
||||
print('{} {}'.format(colorize(moulinette.m18n.g('error'), 'red'), message))
|
||||
else:
|
||||
print(message)
|
||||
|
|
|
|||
|
|
@ -5,6 +5,7 @@ import json
|
|||
import grp
|
||||
from pwd import getpwnam
|
||||
|
||||
import moulinette
|
||||
from moulinette.core import MoulinetteError
|
||||
|
||||
# Files & directories --------------------------------------------------
|
||||
|
|
@ -22,7 +23,7 @@ def read_file(file_path):
|
|||
# Check file exists
|
||||
if not os.path.isfile(file_path):
|
||||
raise MoulinetteError(errno.ENOENT,
|
||||
m18n.g('file_not_exist', path=file_path))
|
||||
moulinette.m18n.g('file_not_exist', path=file_path))
|
||||
|
||||
# Open file and read content
|
||||
try:
|
||||
|
|
@ -30,11 +31,11 @@ def read_file(file_path):
|
|||
file_content = f.read()
|
||||
except IOError as e:
|
||||
raise MoulinetteError(errno.EACCES,
|
||||
m18n.g('cannot_open_file',
|
||||
moulinette.m18n.g('cannot_open_file',
|
||||
file=file_path, error=str(e)))
|
||||
except Exception as e:
|
||||
raise MoulinetteError(errno.EIO,
|
||||
m18n.g('error_reading_file',
|
||||
moulinette.m18n.g('error_reading_file',
|
||||
file=file_path, error=str(e)))
|
||||
|
||||
return file_content
|
||||
|
|
@ -56,7 +57,7 @@ def read_json(file_path):
|
|||
loaded_json = json.loads(file_content)
|
||||
except ValueError as e:
|
||||
raise MoulinetteError(errno.EINVAL,
|
||||
m18n.g('corrupted_json',
|
||||
moulinette.m18n.g('corrupted_json',
|
||||
ressource=file_path, error=str(e)))
|
||||
|
||||
return loaded_json
|
||||
|
|
@ -88,11 +89,11 @@ def write_to_file(file_path, data, file_mode="w"):
|
|||
f.write(data)
|
||||
except IOError as e:
|
||||
raise MoulinetteError(errno.EACCES,
|
||||
m18n.g('cannot_write_file',
|
||||
moulinette.m18n.g('cannot_write_file',
|
||||
file=file_path, error=str(e)))
|
||||
except Exception as e:
|
||||
raise MoulinetteError(errno.EIO,
|
||||
m18n.g('error_writing_file',
|
||||
moulinette.m18n.g('error_writing_file',
|
||||
file=file_path, error=str(e)))
|
||||
|
||||
|
||||
|
|
@ -129,11 +130,11 @@ def write_to_json(file_path, data):
|
|||
json.dump(data, f)
|
||||
except IOError as e:
|
||||
raise MoulinetteError(errno.EACCES,
|
||||
m18n.g('cannot_write_file',
|
||||
moulinette.m18n.g('cannot_write_file',
|
||||
file=file_path, error=str(e)))
|
||||
except Exception as e:
|
||||
raise MoulinetteError(errno.EIO,
|
||||
m18n.g('_error_writing_file',
|
||||
moulinette.m18n.g('_error_writing_file',
|
||||
file=file_path, error=str(e)))
|
||||
|
||||
|
||||
|
|
@ -154,7 +155,7 @@ def mkdir(path, mode=0777, parents=False, uid=None, gid=None, force=False):
|
|||
|
||||
"""
|
||||
if os.path.exists(path) and not force:
|
||||
raise OSError(errno.EEXIST, m18n.g('folder_exists', path=path))
|
||||
raise OSError(errno.EEXIST, moulinette.m18n.g('folder_exists', path=path))
|
||||
|
||||
if parents:
|
||||
# Create parents directories as needed
|
||||
|
|
@ -194,7 +195,7 @@ def chown(path, uid=None, gid=None, recursive=False):
|
|||
uid = getpwnam(uid).pw_uid
|
||||
except KeyError:
|
||||
raise MoulinetteError(errno.EINVAL,
|
||||
m18n.g('unknown_user', user=uid))
|
||||
moulinette.m18n.g('unknown_user', user=uid))
|
||||
elif uid is None:
|
||||
uid = -1
|
||||
if isinstance(gid, basestring):
|
||||
|
|
@ -202,7 +203,7 @@ def chown(path, uid=None, gid=None, recursive=False):
|
|||
gid = grp.getgrnam(gid).gr_gid
|
||||
except KeyError:
|
||||
raise MoulinetteError(errno.EINVAL,
|
||||
m18n.g('unknown_group', group=gid))
|
||||
moulinette.m18n.g('unknown_group', group=gid))
|
||||
elif gid is None:
|
||||
gid = -1
|
||||
|
||||
|
|
@ -216,7 +217,7 @@ def chown(path, uid=None, gid=None, recursive=False):
|
|||
os.chown(os.path.join(root, f), uid, gid)
|
||||
except Exception as e:
|
||||
raise MoulinetteError(errno.EIO,
|
||||
m18n.g('error_changing_file_permissions',
|
||||
moulinette.m18n.g('error_changing_file_permissions',
|
||||
path=path, error=str(e)))
|
||||
|
||||
|
||||
|
|
@ -242,7 +243,7 @@ def chmod(path, mode, fmode=None, recursive=False):
|
|||
os.chmod(os.path.join(root, f), fmode)
|
||||
except Exception as e:
|
||||
raise MoulinetteError(errno.EIO,
|
||||
m18n.g('error_changing_file_permissions',
|
||||
moulinette.m18n.g('error_changing_file_permissions',
|
||||
path=path, error=str(e)))
|
||||
|
||||
|
||||
|
|
@ -263,5 +264,5 @@ def rm(path, recursive=False, force=False):
|
|||
except OSError as e:
|
||||
if not force:
|
||||
raise MoulinetteError(errno.EIO,
|
||||
m18n.g('error_removing',
|
||||
moulinette.m18n.g('error_removing',
|
||||
path=path, error=str(e)))
|
||||
|
|
|
|||
|
|
@ -2,6 +2,7 @@ import errno
|
|||
import requests
|
||||
import json
|
||||
|
||||
import moulinette
|
||||
from moulinette.core import MoulinetteError
|
||||
|
||||
|
||||
|
|
@ -23,24 +24,24 @@ def download_text(url, timeout=30):
|
|||
# Invalid URL
|
||||
except requests.exceptions.ConnectionError:
|
||||
raise MoulinetteError(errno.EBADE,
|
||||
m18n.g('invalid_url', url=url))
|
||||
moulinette.m18n.g('invalid_url', url=url))
|
||||
# SSL exceptions
|
||||
except requests.exceptions.SSLError:
|
||||
raise MoulinetteError(errno.EBADE,
|
||||
m18n.g('download_ssl_error', url=url))
|
||||
moulinette.m18n.g('download_ssl_error', url=url))
|
||||
# Timeout exceptions
|
||||
except requests.exceptions.Timeout:
|
||||
raise MoulinetteError(errno.ETIME,
|
||||
m18n.g('download_timeout', url=url))
|
||||
moulinette.m18n.g('download_timeout', url=url))
|
||||
# Unknown stuff
|
||||
except Exception as e:
|
||||
raise MoulinetteError(errno.ECONNRESET,
|
||||
m18n.g('download_unknown_error',
|
||||
moulinette.m18n.g('download_unknown_error',
|
||||
url=url, error=str(e)))
|
||||
# Assume error if status code is not 200 (OK)
|
||||
if r.status_code != 200:
|
||||
raise MoulinetteError(errno.EBADE,
|
||||
m18n.g('download_bad_status_code',
|
||||
moulinette.m18n.g('download_bad_status_code',
|
||||
url=url, code=str(r.status_code)))
|
||||
|
||||
return r.text
|
||||
|
|
@ -56,6 +57,6 @@ def download_json(url, timeout=30):
|
|||
loaded_json = json.loads(text)
|
||||
except ValueError:
|
||||
raise MoulinetteError(errno.EINVAL,
|
||||
m18n.g('corrupted_json', ressource=url))
|
||||
moulinette.m18n.g('corrupted_json', ressource=url))
|
||||
|
||||
return loaded_json
|
||||
|
|
|
|||
Loading…
Add table
Reference in a new issue