X-Git-Url: http://git.inspyration.org/?a=blobdiff_plain;f=openerp%2Fnetsvc.py;h=506c1e4bcba5c3687fb9f21d1232d89a7515306e;hb=f05c4faf5b40910d25ceda3506d6e3bc090fac58;hp=a4190336941dbf73db436a1a80753266387bd04b;hpb=23ecb4f95650c5bcf822a06e82fb7802f0540e42;p=odoo%2Fodoo.git diff --git a/openerp/netsvc.py b/openerp/netsvc.py index a419033..506c1e4 100644 --- a/openerp/netsvc.py +++ b/openerp/netsvc.py @@ -3,30 +3,24 @@ ############################################################################## # # OpenERP, Open Source Management Solution -# Copyright (C) 2004-2009 Tiny SPRL (). All Rights Reserved -# The refactoring about the OpenSSL support come from Tryton -# Copyright (C) 2007-2009 Cédric Krier. -# Copyright (C) 2007-2009 Bertrand Chenal. -# Copyright (C) 2008 B2CK SPRL. +# Copyright (C) 2004-2011 OpenERP SA () # # This program is free software: you can redistribute it and/or modify -# it under the terms of the GNU General Public License as published by -# the Free Software Foundation, either version 3 of the License, or -# (at your option) any later version. +# 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 General Public License for more details. +# GNU Affero General Public License for more details. # -# You should have received a copy of the GNU General Public License +# You should have received a copy of the GNU Affero General Public License # along with this program. If not, see . # ############################################################################## -import cgitb import errno -import heapq import logging import logging.handlers import os @@ -36,13 +30,15 @@ import socket import sys import threading import time -import warnings import types from pprint import pformat # TODO modules that import netsvc only for things from loglevels must be changed to use loglevels. from loglevels import * import tools +import openerp + +_logger = logging.getLogger(__name__) def close_socket(sock): """ Closes a socket instance cleanly @@ -63,20 +59,22 @@ def close_socket(sock): sock.close() +#.apidoc title: Common Services: netsvc +#.apidoc module-mods: member-order: bysource + +def abort_response(dummy_1, description, dummy_2, details): + # TODO Replace except_{osv,orm} with these directly. + raise openerp.osv.osv.except_osv(description, details) + class Service(object): """ Base class for *Local* services Functionality here is trusted, no authentication. """ _services = {} - def __init__(self, name, audience=''): + def __init__(self, name): Service._services[name] = self self.__name = name - self._methods = {} - - def joinGroup(self, name): - raise Exception("No group for local services") - #GROUPS.setdefault(name, {})[self.__name] = self @classmethod def exists(cls, name): @@ -87,74 +85,37 @@ class Service(object): if cls.exists(name): cls._services.pop(name) - def exportMethod(self, method): - if callable(method): - self._methods[method.__name__] = method - - def abortResponse(self, error, description, origin, details): - if not tools.config['debug_mode']: - raise Exception("%s -- %s\n\n%s"%(origin, description, details)) - else: - raise - -class LocalService(object): - """ Proxy for local services. - - Any instance of this class will behave like the single instance - of Service(name) - """ - __logger = logging.getLogger('service') - def __init__(self, name): - self.__name = name - try: - self._service = Service._services[name] - for method_name, method_definition in self._service._methods.items(): - setattr(self, method_name, method_definition) - except KeyError, keyError: - self.__logger.error('This service does not exist: %s' % (str(keyError),) ) - raise +def LocalService(name): + # Special case for addons support, will be removed in a few days when addons + # are updated to directly use openerp.osv.osv.service. + if name == 'object_proxy': + return openerp.osv.osv.service - def __call__(self, method, *params): - return getattr(self, method)(*params) + return Service._services[name] class ExportService(object): - """ Proxy for exported services. + """ Proxy for exported services. - All methods here should take an AuthProxy as their first parameter. It - will be appended by the calling framework. - - Note that this class has no direct proxy, capable of calling - eservice.method(). Rather, the proxy should call - dispatch(method,auth,params) + Note that this class has no direct proxy, capable of calling + eservice.method(). Rather, the proxy should call + dispatch(method, params) """ - + _services = {} - _groups = {} - _logger = logging.getLogger('web-services') - def __init__(self, name, audience=''): + def __init__(self, name): ExportService._services[name] = self self.__name = name - self._logger.debug("Registered an exported service: %s" % name) - - def joinGroup(self, name): - ExportService._groups.setdefault(name, {})[self.__name] = self + _logger.debug("Registered an exported service: %s" % name) @classmethod def getService(cls,name): return cls._services[name] - def dispatch(self, method, auth, params): + # Dispatch a RPC call w.r.t. the method name. The dispatching + # w.r.t. the service (this class) is done by OpenERPDispatcher. + def dispatch(self, method, params): raise Exception("stub dispatch at %s" % self.__name) - - def new_dispatch(self,method,auth,params): - raise Exception("stub dispatch at %s" % self.__name) - - def abortResponse(self, error, description, origin, details): - if not tools.config['debug_mode']: - raise Exception("%s -- %s\n\n%s"%(origin, description, details)) - else: - raise BLACK, RED, GREEN, YELLOW, BLUE, MAGENTA, CYAN, WHITE, _NOTHING, DEFAULT = range(10) #The background is set with 40 plus the number of the color, and the foreground with 30 @@ -164,9 +125,6 @@ COLOR_SEQ = "\033[1;%dm" BOLD_SEQ = "\033[1m" COLOR_PATTERN = "%s%s%%s%s" % (COLOR_SEQ, COLOR_SEQ, RESET_SEQ) LEVEL_COLOR_MAPPING = { - logging.DEBUG_SQL: (WHITE, MAGENTA), - logging.DEBUG_RPC: (BLUE, WHITE), - logging.DEBUG_RPC_ANSWER: (BLUE, WHITE), logging.DEBUG: (BLUE, DEFAULT), logging.INFO: (GREEN, DEFAULT), logging.TEST: (WHITE, BLUE), @@ -177,6 +135,7 @@ LEVEL_COLOR_MAPPING = { class DBFormatter(logging.Formatter): def format(self, record): + record.pid = os.getpid() record.dbname = getattr(threading.currentThread(), 'dbname', '?') return logging.Formatter.format(self, record) @@ -186,13 +145,13 @@ class ColoredFormatter(DBFormatter): record.levelname = COLOR_PATTERN % (30 + fg_color, 40 + bg_color, record.levelname) return DBFormatter.format(self, record) + def init_logger(): - import os from tools.translate import resetlocale resetlocale() # create a format for log messages and dates - format = '[%(asctime)s][%(dbname)s] %(levelname)s:%(name)s:%(message)s' + format = '%(asctime)s %(pid)s %(levelname)s %(dbname)s %(name)s: %(message)s' if tools.config['syslog']: # SysLog Handler @@ -229,11 +188,51 @@ def init_logger(): formatter = DBFormatter(format) handler.setFormatter(formatter) - # add the handler to the root logger - logger = logging.getLogger() - logger.handlers = [] - logger.addHandler(handler) - logger.setLevel(int(tools.config['log_level'] or '0')) + # Configure handlers + default_config = [ + 'openerp.netsvc.rpc.request:INFO', + 'openerp.netsvc.rpc.response:INFO', + 'openerp.addons.web.common.http:INFO', + 'openerp.addons.web.common.openerplib:INFO', + 'openerp.sql_db:INFO', + ':INFO', + ] + + if tools.config['log_level'] == 'info': + pseudo_config = [] + elif tools.config['log_level'] == 'debug_rpc': + pseudo_config = ['openerp:DEBUG','openerp.netsvc.rpc.request:DEBUG'] + elif tools.config['log_level'] == 'debug_rpc_answer': + pseudo_config = ['openerp:DEBUG','openerp.netsvc.rpc.request:DEBUG', 'openerp.netsvc.rpc.response:DEBUG'] + elif tools.config['log_level'] == 'debug': + pseudo_config = ['openerp:DEBUG'] + elif tools.config['log_level'] == 'test': + pseudo_config = ['openerp:TEST'] + elif tools.config['log_level'] == 'warn': + pseudo_config = ['openerp:WARNING'] + elif tools.config['log_level'] == 'error': + pseudo_config = ['openerp:ERROR'] + elif tools.config['log_level'] == 'critical': + pseudo_config = ['openerp:CRITICAL'] + elif tools.config['log_level'] == 'debug_sql': + pseudo_config = ['openerp.sql_db:DEBUG'] + else: + pseudo_config = [] + + logconfig = tools.config['log_handler'] + + for logconfig_item in default_config + pseudo_config + logconfig: + loggername, level = logconfig_item.split(':') + level = getattr(logging, level, logging.INFO) + logger = logging.getLogger(loggername) + logger.handlers = [] + logger.setLevel(level) + logger.addHandler(handler) + if loggername != '': + logger.propagate = False + + for logconfig_item in default_config + pseudo_config + logconfig: + _logger.debug('logger level set: "%s"', logconfig_item) # A alternative logging scheme for automated runs of the # server intended to test it. @@ -243,85 +242,11 @@ def init_alternative_logger(): if record.levelno > 20: print record.levelno, record.pathname, record.msg handler = H() - logger = logging.getLogger() - logger.handlers = [] + # Add the handler to the 'openerp' logger. + logger = logging.getLogger('openerp') logger.addHandler(handler) logger.setLevel(logging.ERROR) -class Agent(object): - """Singleton that keeps track of cancellable tasks to run at a given - timestamp. - The tasks are caracterised by: - * a timestamp - * the database on which the task run - * the function to call - * the arguments and keyword arguments to pass to the function - - Implementation details: - Tasks are stored as list, allowing the cancellation by setting - the timestamp to 0. - A heapq is used to store tasks, so we don't need to sort - tasks ourself. - """ - __tasks = [] - __tasks_by_db = {} - _logger = logging.getLogger('netsvc.agent') - - @classmethod - def setAlarm(cls, function, timestamp, db_name, *args, **kwargs): - task = [timestamp, db_name, function, args, kwargs] - heapq.heappush(cls.__tasks, task) - cls.__tasks_by_db.setdefault(db_name, []).append(task) - - @classmethod - def cancel(cls, db_name): - """Cancel all tasks for a given database. If None is passed, all tasks are cancelled""" - cls._logger.debug("Cancel timers for %s db", db_name or 'all') - if db_name is None: - cls.__tasks, cls.__tasks_by_db = [], {} - else: - if db_name in cls.__tasks_by_db: - for task in cls.__tasks_by_db[db_name]: - task[0] = 0 - - @classmethod - def quit(cls): - cls.cancel(None) - - @classmethod - def runner(cls): - """Neverending function (intended to be ran in a dedicated thread) that - checks every 60 seconds tasks to run. TODO: make configurable - """ - current_thread = threading.currentThread() - while True: - while cls.__tasks and cls.__tasks[0][0] < time.time(): - task = heapq.heappop(cls.__tasks) - timestamp, dbname, function, args, kwargs = task - cls.__tasks_by_db[dbname].remove(task) - if not timestamp: - # null timestamp -> cancelled task - continue - current_thread.dbname = dbname # hack hack - cls._logger.debug("Run %s.%s(*%s, **%s)", function.im_class.__name__, function.func_name, args, kwargs) - delattr(current_thread, 'dbname') - task_thread = threading.Thread(target=function, name='netsvc.Agent.task', args=args, kwargs=kwargs) - # force non-daemon task threads (the runner thread must be daemon, and this property is inherited by default) - task_thread.setDaemon(False) - task_thread.start() - time.sleep(1) - time.sleep(60) - -def start_agent(): - agent_runner = threading.Thread(target=Agent.runner, name="netsvc.Agent.runner") - # the agent runner is a typical daemon thread, that will never quit and must be - # terminated when the main process exits - with no consequence (the processing - # threads it spawns are not marked daemon) - agent_runner.setDaemon(True) - agent_runner.start() - -import traceback - class Server: """ Generic interface for all servers with an event loop etc. Override this to impement http, net-rpc etc. servers. @@ -340,9 +265,6 @@ class Server: # all I/O blocking operations _busywait_timeout = 0.5 - - __logger = logging.getLogger('server') - def __init__(self): Server.__servers.append(self) if Server.__is_started: @@ -357,8 +279,8 @@ class Server: t.start() def start(self): - self.__logger.debug("called stub Server.start") - + _logger.debug("called stub Server.start") + def _late_start(self): self.start() for thr in Server.__starter_threads: @@ -366,7 +288,7 @@ class Server: Server.__starter_threads.remove(thr) def stop(self): - self.__logger.debug("called stub Server.stop") + _logger.debug("called stub Server.stop") def stats(self): """ This function should return statistics about the server """ @@ -376,7 +298,7 @@ class Server: def startAll(cls): if cls.__is_started: return - cls.__logger.info("Starting %d services" % len(cls.__servers)) + _logger.info("Starting %d services" % len(cls.__servers)) for srv in cls.__servers: srv.start() cls.__is_started = True @@ -385,7 +307,7 @@ class Server: def quitAll(cls): if not cls.__is_started: return - cls.__logger.info("Stopping %d services" % len(cls.__servers)) + _logger.info("Stopping %d services" % len(cls.__servers)) for thr in cls.__starter_threads: if not thr.finished.is_set(): thr.cancel() @@ -404,55 +326,67 @@ class Server: def _close_socket(self): close_socket(self.socket) -class OpenERPDispatcherException(Exception): - def __init__(self, exception, traceback): - self.exception = exception - self.traceback = traceback - def replace_request_password(args): # password is always 3rd argument in a request, we replace it in RPC logs # so it's easier to forward logs for diagnostics/debugging purposes... - args = list(args) if len(args) > 2: + args = list(args) args[2] = '*' - return args - -def log(title, msg, channel=logging.DEBUG_RPC, depth=None, fn=""): - logger = logging.getLogger(title) - if logger.isEnabledFor(channel): - indent='' - indent_after=' '*len(fn) - for line in (fn+pformat(msg, depth=depth)).split('\n'): - logger.log(channel, indent+line) - indent=indent_after - -class OpenERPDispatcher: - def log(self, title, msg, channel=logging.DEBUG_RPC, depth=None, fn=""): - log(title, msg, channel=channel, depth=depth, fn=fn) - def dispatch(self, service_name, method, params): - try: - auth = getattr(self, 'auth_provider', None) - logger = logging.getLogger('result') - start_time = end_time = 0 - if logger.isEnabledFor(logging.DEBUG_RPC_ANSWER): - self.log('service', tuple(replace_request_password(params)), depth=None, fn='%s.%s'%(service_name,method)) - if logger.isEnabledFor(logging.DEBUG_RPC): - start_time = time.time() - result = ExportService.getService(service_name).dispatch(method, auth, params) - if logger.isEnabledFor(logging.DEBUG_RPC): - end_time = time.time() - if not logger.isEnabledFor(logging.DEBUG_RPC_ANSWER): - self.log('service (%.3fs)' % (end_time - start_time), tuple(replace_request_password(params)), depth=1, fn='%s.%s'%(service_name,method)) - self.log('execution time', '%.3fs' % (end_time - start_time), channel=logging.DEBUG_RPC_ANSWER) - self.log('result', result, channel=logging.DEBUG_RPC_ANSWER) - return result - except Exception, e: - self.log('exception', tools.exception_to_unicode(e)) - tb = getattr(e, 'traceback', sys.exc_info()) - tb_s = cgitb.text(tb) - if tools.config['debug_mode'] and isinstance(tb, types.TracebackType): - import pdb - pdb.post_mortem(tb[2]) - raise OpenERPDispatcherException(e, tb_s) + return tuple(args) + +def log(logger, level, prefix, msg, depth=None): + indent='' + indent_after=' '*len(prefix) + for line in (prefix+pformat(msg, depth=depth)).split('\n'): + logger.log(level, indent+line) + indent=indent_after + +def dispatch_rpc(service_name, method, params): + """ Handle a RPC call. + + This is pure Python code, the actual marshalling (from/to XML-RPC or + NET-RPC) is done in a upper layer. + """ + try: + rpc_request = logging.getLogger(__name__ + '.rpc.request') + rpc_response = logging.getLogger(__name__ + '.rpc.response') + rpc_request_flag = rpc_request.isEnabledFor(logging.DEBUG) + rpc_response_flag = rpc_response.isEnabledFor(logging.DEBUG) + if rpc_request_flag or rpc_response_flag: + start_time = time.time() + if rpc_request and rpc_response_flag: + log(rpc_request,logging.DEBUG,'%s.%s'%(service_name,method), replace_request_password(params)) + + threading.current_thread().uid = None + threading.current_thread().dbname = None + result = ExportService.getService(service_name).dispatch(method, params) + + if rpc_request_flag or rpc_response_flag: + end_time = time.time() + if rpc_response_flag: + log(rpc_response,logging.DEBUG,'%s.%s time:%.3fs '%(service_name,method,end_time - start_time), result) + else: + log(rpc_request,logging.DEBUG,'%s.%s time:%.3fs '%(service_name,method,end_time - start_time), replace_request_password(params), depth=1) + + return result + except openerp.exceptions.AccessError: + raise + except openerp.exceptions.AccessDenied: + raise + except openerp.exceptions.Warning: + raise + except openerp.exceptions.DeferredException, e: + _logger.error(tools.exception_to_unicode(e)) + post_mortem(e.traceback) + raise + except Exception, e: + _logger.error(tools.exception_to_unicode(e)) + post_mortem(sys.exc_info()) + raise + +def post_mortem(info): + if tools.config['debug_mode'] and isinstance(info[2], types.TracebackType): + import pdb + pdb.post_mortem(info[2]) # vim:expandtab:smartindent:tabstop=4:softtabstop=4:shiftwidth=4: