X-Git-Url: http://git.inspyration.org/?a=blobdiff_plain;f=openerp%2Fnetsvc.py;h=c1120763ad43448d2a0a8a96b5bdd02dab830259;hb=16383036868f6f25276d67f50cd61e0cdf321a5e;hp=6125f2218b3be2336f9ec2fd28bf2379ea8226aa;hpb=ee12a9c9c54984b3e9b09bdb86007e8d87adb778;p=odoo%2Fodoo.git diff --git a/openerp/netsvc.py b/openerp/netsvc.py index 6125f22..c112076 100644 --- a/openerp/netsvc.py +++ b/openerp/netsvc.py @@ -21,7 +21,6 @@ ############################################################################## import errno -import heapq import logging import logging.handlers import os @@ -31,12 +30,14 @@ import socket import sys import threading import time +import traceback 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 def close_socket(sock): """ Closes a socket instance cleanly @@ -60,11 +61,9 @@ def close_socket(sock): #.apidoc title: Common Services: netsvc #.apidoc module-mods: member-order: bysource -def abort_response(error, description, origin, details): - if not tools.config['debug_mode']: - raise Exception("%s -- %s\n\n%s"%(origin, description, details)) - else: - raise +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 @@ -94,16 +93,13 @@ def LocalService(name): 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 = {} _logger = logging.getLogger('web-services') @@ -118,14 +114,8 @@ class ExportService(object): # 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, auth, params): + def dispatch(self, method, 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 @@ -218,83 +208,6 @@ def init_alternative_logger(): 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 characterised 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. @@ -331,7 +244,7 @@ class Server: def start(self): self.__logger.debug("called stub Server.start") - + def _late_start(self): self.start() for thr in Server.__starter_threads: @@ -377,11 +290,6 @@ 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... @@ -399,38 +307,47 @@ def log(title, msg, channel=logging.DEBUG_RPC, depth=None, fn=""): logger.log(channel, indent+line) indent=indent_after -# This class is used to dispatch a RPC to a service. So it is used -# for both XMLRPC (with a SimpleXMLRPCRequestHandler), and NETRPC. -# The service (ExportService) will then dispatch on the method name. -# This can be re-written as a single function -# def dispatch(self, service_name, method, params, auth_provider). -class OpenERPDispatcher: - def log(self, title, msg, channel=logging.DEBUG_RPC, depth=None, fn=""): +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. + """ + def _log(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 = "".join(traceback.format_exception(*tb)) - if tools.config['debug_mode'] and isinstance(tb, types.TracebackType): - import pdb - pdb.post_mortem(tb[2]) - raise OpenERPDispatcherException(e, tb_s) + try: + logger = logging.getLogger('result') + start_time = end_time = 0 + if logger.isEnabledFor(logging.DEBUG_RPC_ANSWER): + _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, params) + if logger.isEnabledFor(logging.DEBUG_RPC): + end_time = time.time() + if not logger.isEnabledFor(logging.DEBUG_RPC_ANSWER): + _log('service (%.3fs)' % (end_time - start_time), tuple(replace_request_password(params)), depth=1, fn='%s.%s'%(service_name,method)) + _log('execution time', '%.3fs' % (end_time - start_time), channel=logging.DEBUG_RPC_ANSWER) + _log('result', result, channel=logging.DEBUG_RPC_ANSWER) + return result + except openerp.exceptions.AccessError: + raise + except openerp.exceptions.AccessDenied: + raise + except openerp.exceptions.Warning: + raise + except openerp.exceptions.DeferredException, e: + _log('exception', tools.exception_to_unicode(e)) + post_mortem(e.traceback) + raise + except Exception, e: + _log('exception', 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: