Merge lp:~akfypznt56ld-mike/openerp-client-lib/dnservices-release into lp:openerp-client-lib

[Mike]

Added exec_workflow and report functions to Module class
Added global_unpickle to handle NetRPC OpenERP exceptions

Unmerged revisions

37. By Mike on 2012-02-07

Added exec_workflow and report functions, fixed exception handling causing Global Unpickling error

=== modified file 'openerplib/main.py'
--- openerplib/main.py	2012-01-09 09:19:06 +0000
+++ openerplib/main.py	2012-02-07 10:53:18 +0000
@@ -89,7 +89,145 @@
 
     def __init__(self, hostname, port=8069):
         super(XmlRPCSConnector, self).__init__(hostname, port)
+<<<<<<< TREE
         self.url = 'https://%s:%d/xmlrpc' % (hostname, port)
+=======
+        self.url = 'https://%s:%d/xmlrpc' % (self.hostname, self.port)
+
+class NetRPC_Exception(Exception):
+    """
+    Exception for NetRPC errors.
+    """
+    def __init__(self, faultCode, faultString):
+        self.faultCode = faultCode
+        self.faultString = faultString
+        self.args = (faultCode, faultString)
+
+def global_unpickle(modulename, classname):
+  if classname == 'Exception':
+    return Exception
+  
+  _logger.error("Unknown or unhandled pickled instance: %s.%s" % (modulename, classname))
+      
+    
+class NetRPC(object):
+    """
+    Low level class for NetRPC protocol.
+    """
+    def __init__(self, sock=None):
+        if sock is None:
+            self.sock = socket.socket(
+            socket.AF_INET, socket.SOCK_STREAM)
+        else:
+            self.sock = sock
+        self.sock.settimeout(120)
+    def connect(self, host, port=False):
+        if not port:
+            buf = host.split('//')[1]
+            host, port = buf.split(':')
+        self.sock.connect((host, int(port)))
+
+    def disconnect(self):
+        self.sock.shutdown(socket.SHUT_RDWR)
+        self.sock.close()
+
+    def mysend(self, msg, exception=False, traceback=None):
+        msg = pickle.dumps([msg,traceback])
+        size = len(msg)
+        self.sock.send('%8d' % size)
+        self.sock.send(exception and "1" or "0")
+        totalsent = 0
+        while totalsent < size:
+            sent = self.sock.send(msg[totalsent:])
+            if sent == 0:
+                raise RuntimeError, "socket connection broken"
+            totalsent = totalsent + sent
+    
+    def myreceive(self):
+        buf=''
+        while len(buf) < 8:
+            chunk = self.sock.recv(8 - len(buf))
+            if chunk == '':
+                raise RuntimeError, "socket connection broken"
+            buf += chunk
+        size = int(buf)
+        buf = self.sock.recv(1)
+        if buf != "0":
+            exception = buf
+        else:
+            exception = False
+        msg = ''
+        while len(msg) < size:
+            chunk = self.sock.recv(size-len(msg))
+            if chunk == '':
+                raise RuntimeError, "socket connection broken"
+            msg = msg + chunk
+            
+        
+        msgio = StringIO.StringIO(msg)
+        
+        unpickler = pickle.Unpickler(msgio)
+        unpickler.find_global = global_unpickle
+        
+        res = unpickler.load()
+        
+        if isinstance(res[0],Exception):
+            if exception:
+                raise NetRPC_Exception(str(res[0]), str(res[1]))
+            raise res[0]
+        else:
+            return res[0]
+
+class NetRPCConnector(Connector):
+    """
+    A type of connector that uses the NetRPC protocol.
+    """
+
+    PROTOCOL = 'netrpc'
+    
+    __logger = _getChildLogger(_logger, 'connector.netrpc')
+
+    def __init__(self, hostname, port=8070):
+        """
+        Initialize by specifying the hostname and the port.
+        :param hostname: The hostname of the computer holding the instance of OpenERP.
+        :param port: The port used by the OpenERP instance for NetRPC (default to 8070).
+        """
+        Connector.__init__(self, hostname, port)
+
+    def send(self, service_name, method, *args):
+        socket = NetRPC()
+        socket.connect(self.hostname, self.port)
+        socket.mysend((service_name, method, )+args)
+        result = socket.myreceive()
+        socket.disconnect()
+        return result
+
+class LocalConnector(Connector):
+    """
+    A type of connector that uses the XMLRPC protocol.
+    """
+    PROTOCOL = 'local'
+    
+    __logger = _getChildLogger(_logger, 'connector.local')
+
+    def __init__(self):
+        pass
+
+    def send(self, service_name, method, *args):
+        import openerp
+        # TODO Exception handling
+        # This will be changed to be xmlrpc compatible
+        # OpenERPWarning code 1
+        # OpenERPException code 2
+        try:
+            result = openerp.netsvc.dispatch_rpc(service_name, method, args)
+        except:
+            exc_type, exc_value, exc_tb = sys.exc_info()
+            fault = xmlrpclib.Fault(1, "%s:%s" % (exc_type, exc_value))
+            raise fault
+        return result
+>>>>>>> MERGE-SOURCE
 
 class Service(object):
     """
@@ -275,6 +413,42 @@
         records = self.read(record_ids, fields or [], context or {})
         return records
 
+    def exec_workflow(self, method, *args):
+        self.connection.check_login(False)
+        self.__logger.debug(args)
+        result = self.connection.get_service('object').exec_workflow(
+                                                    self.connection.database,
+                                                    self.connection.user_id,
+                                                    self.connection.password,
+                                                    self.model_name,
+                                                    method,
+                                                    *args)
+        self.__logger.debug('result: %r', result)
+        return result
+
+    def report(self, *args):
+        self.connection.check_login(False)
+        self.__logger.debug(args)
+        result = self.connection.get_service('report').report(
+                                                    self.connection.database,
+                                                    self.connection.user_id,
+                                                    self.connection.password,
+                                                    self.model_name,
+                                                    *args)
+        self.__logger.debug('result: %r', result)
+
+        return result
+
+    def report_get(self, *args):
+        self.connection.check_login(False)
+        self.__logger.debug(args)
+        result = self.connection.get_service('report').report_get(
+                                                    self.connection.database,
+                                                    self.connection.user_id,
+                                                    self.connection.password,
+                                                    *args)
+        return result
+
 def get_connector(hostname=None, protocol="xmlrpc", port="auto"):
     """
     A shortcut method to easily create a connector to a remote server using XMLRPC.