mirror of
https://github.com/YunoHost/moulinette.git
synced 2024-09-03 20:06:31 +02:00
146 lines
4.6 KiB
Python
Executable file
146 lines
4.6 KiB
Python
Executable file
# -*- coding: utf-8 -*-
|
|
|
|
from moulinette.core import init_interface, MoulinetteError
|
|
|
|
__title__ = 'moulinette'
|
|
__version__ = '0.1'
|
|
__author__ = ['Kload',
|
|
'jlebleu',
|
|
'titoko',
|
|
'beudbeud',
|
|
'npze']
|
|
__license__ = 'AGPL 3.0'
|
|
__credits__ = """
|
|
Copyright (C) 2014 YUNOHOST.ORG
|
|
|
|
This program is free software; you can redistribute it and/or modify
|
|
it under the terms of the GNU Affero General Public License as published
|
|
by the Free Software Foundation, either version 3 of the License, or
|
|
(at your option) any later version.
|
|
|
|
This program is distributed in the hope that it will be useful,
|
|
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
GNU Affero General Public License for more details.
|
|
|
|
You should have received a copy of the GNU Affero General Public License
|
|
along with this program; if not, see http://www.gnu.org/licenses
|
|
"""
|
|
__all__ = [
|
|
'init', 'api', 'cli',
|
|
'init_interface', 'MoulinetteError',
|
|
]
|
|
|
|
|
|
# Package functions
|
|
|
|
def init(logging_config=None, **kwargs):
|
|
"""Package initialization
|
|
|
|
Initialize directories and global variables. It must be called
|
|
before any of package method is used - even the easy access
|
|
functions.
|
|
|
|
Keyword arguments:
|
|
- logging_config -- A dict containing logging configuration to load
|
|
- **kwargs -- See core.Package
|
|
|
|
At the end, the global variable 'pkg' will contain a Package
|
|
instance. See core.Package for available methods and variables.
|
|
|
|
"""
|
|
import sys
|
|
import __builtin__
|
|
from moulinette.core import (
|
|
Package, Moulinette18n, MoulinetteSignals
|
|
)
|
|
from moulinette.utils.log import configure_logging
|
|
|
|
configure_logging(logging_config)
|
|
|
|
pkg = Package(**kwargs)
|
|
|
|
# Define and instantiate global objects
|
|
__builtin__.__dict__['pkg'] = pkg
|
|
__builtin__.__dict__['m18n'] = Moulinette18n(pkg)
|
|
__builtin__.__dict__['msignals'] = MoulinetteSignals()
|
|
__builtin__.__dict__['msettings'] = dict()
|
|
|
|
# Add library directory to python path
|
|
sys.path.insert(0, pkg.libdir)
|
|
|
|
|
|
# Easy access to interfaces
|
|
|
|
def api(namespaces, host='localhost', port=80, routes={},
|
|
use_websocket=True, use_cache=True):
|
|
"""Web server (API) interface
|
|
|
|
Run a HTTP server with the moulinette for an API usage.
|
|
|
|
Keyword arguments:
|
|
- namespaces -- The list of namespaces to use
|
|
- host -- Server address to bind to
|
|
- port -- Server port to bind to
|
|
- routes -- A dict of additional routes to add in the form of
|
|
{(method, uri): callback}
|
|
- use_websocket -- Serve via WSGI to handle asynchronous responses
|
|
- use_cache -- False if it should parse the actions map file
|
|
instead of using the cached one
|
|
|
|
"""
|
|
try:
|
|
moulinette = init_interface('api',
|
|
kwargs={
|
|
'routes': routes,
|
|
'use_websocket': use_websocket
|
|
},
|
|
actionsmap={
|
|
'namespaces': namespaces,
|
|
'use_cache': use_cache
|
|
}
|
|
)
|
|
moulinette.run(host, port)
|
|
except MoulinetteError as e:
|
|
import logging
|
|
logging.getLogger(namespaces[0]).error(e.strerror)
|
|
return e.errno
|
|
except KeyboardInterrupt:
|
|
import logging
|
|
logging.getLogger(namespaces[0]).info(m18n.g('operation_interrupted'))
|
|
return 0
|
|
|
|
|
|
def cli(namespaces, args, use_cache=True, output_as=None,
|
|
password=None, timeout=None, parser_kwargs={}):
|
|
"""Command line interface
|
|
|
|
Execute an action with the moulinette from the CLI and print its
|
|
result in a readable format.
|
|
|
|
Keyword arguments:
|
|
- namespaces -- The list of namespaces to use
|
|
- args -- A list of argument strings
|
|
- use_cache -- False if it should parse the actions map file
|
|
instead of using the cached one
|
|
- output_as -- Output result in another format, see
|
|
moulinette.interfaces.cli.Interface for possible values
|
|
- password -- The password to use in case of authentication
|
|
- parser_kwargs -- A dict of arguments to pass to the parser
|
|
class at construction
|
|
|
|
"""
|
|
try:
|
|
moulinette = init_interface('cli',
|
|
actionsmap={
|
|
'namespaces': namespaces,
|
|
'use_cache': use_cache,
|
|
'parser_kwargs': parser_kwargs,
|
|
},
|
|
)
|
|
moulinette.run(args, output_as=output_as, password=password, timeout=timeout)
|
|
except MoulinetteError as e:
|
|
import logging
|
|
logging.getLogger(namespaces[0]).error(e.strerror)
|
|
return e.errno
|
|
return 0
|