Return to XmlRpcProxy.py CVS log

Up to [Repository] / XMLRpcTools

Annotation of XMLRpcTools/XmlRpcProxy.py, revision 1.6

1.1       casties     1: 
                      2: from OFS.SimpleItem import SimpleItem
                      3: from OFS.Folder import Folder
                      4: from Globals import InitializeClass
                      5: import xmlrpclib
                      6: import httplib
                      7: from Products.PageTemplates.PageTemplateFile import PageTemplateFile
                      8: import os.path
                      9: from Globals import package_home
                     10: import re
                     11: import logging
                     12: 
                     13: class XmlRpcProxyFolder(Folder):
                     14:     """XML-RPC server proxy folder containing XmlRpcProxyMethods"""
                     15:     
                     16:     meta_type = 'XmlRpcProxyFolder'
                     17:     
                     18:     # base URL to the server
                     19:     serverUrl = None
                     20:     
                     21:     # server proxy object
                     22:     _v_proxy = None
                     23:     
                     24:     manage_options= Folder.manage_options + (
                     25:         {'label':'Main Config','action':'mainConfigForm'},
                     26:         )
                     27: 
                     28:     def __init__(self,id,serverUrl):
                     29:         """init server proxy"""
                     30:         self.id=id
                     31:         self.serverUrl=serverUrl
                     32:         
                     33:         
                     34:     def getProxy(self):
                     35:         """get the proxy"""
                     36:         if not self.serverUrl:
                     37:             return None
                     38:       
                     39:         # TODO cache proxy and add alive test
                     40:         self._v_proxy = xmlrpclib.ServerProxy(self.serverUrl)
                     41:        
                     42:         return self._v_proxy
                     43:         
                     44:     mainConfigForm = PageTemplateFile('zpt/manageXmlRpcProxyFolder',globals())
                     45:     
                     46:     def mainConfig(self,serverUrl,RESPONSE=None):
                     47:         """main config"""
                     48:         
                     49:         self.serverUrl=serverUrl
                     50:         
                     51:         if RESPONSE:
                     52:             RESPONSE.redirect("manage_main")
                     53:             
                     54: 
                     55: def manage_addXmlRpcProxyFolderForm(self):
                     56:     """add the XmlRpcProxyFolder"""
                     57:     pt=PageTemplateFile('zpt/addXmlRpcProxyFolder',globals()).__of__(self)
                     58:     return pt()
                     59: 
                     60: def manage_addXmlRpcProxyFolder(self,id,serverUrl,RESPONSE=None):
                     61:     """add the basket"""
                     62:     ob=XmlRpcProxyFolder(id,serverUrl)
                     63:     self._setObject(id, ob)
                     64:     
                     65:     if RESPONSE is not None:
                     66:         RESPONSE.redirect('manage_main')
                     67: 
                     68: 
                     69: 
                     70: class XmlRpcProxyMethod(SimpleItem):
                     71:     """XML-RPC server proxy method. the id is also the remote method name"""
                     72:     
                     73:     meta_type="XmlRpcProxyMethod"
                     74:     
                     75:     rpc_arg_expr='[^A-z0-9]'
                     76:     
1.5       casties    77:     num_retries=0
                     78:     
1.1       casties    79:     manage_options= (
                     80:         {'label':'Main Config','action':'mainConfigForm'},
                     81:         )+ SimpleItem.manage_options
                     82: 
                     83:     
1.5       casties    84:     def __init__(self,id,rpc_arg_expr=None,num_retries=0):
1.1       casties    85:         """init server proxy"""
                     86:         self.id=id
1.5       casties    87:         self.num_retries = num_retries
1.1       casties    88:         if rpc_arg_expr:
                     89:             self.rpc_arg_expr = rpc_arg_expr
                     90: 
                     91:     def eval(self,*argv):
                     92:         """do proxy request"""
                     93:         server=self.aq_parent.getProxy()
                     94: 
1.3       casties    95:         if self.rpc_arg_expr:
                     96:             # clean arguments
                     97:             args = [ re.sub(self.rpc_arg_expr,'',a) for a in argv]
1.4       casties    98:         else:
                     99:             args = argv
1.1       casties   100:             
1.5       casties   101:         i = 0
                    102:         while True:
                    103:             try:
                    104:                 # call the method self.id on the server with the args
1.6     ! casties   105:                 logging.debug("XmlRpcProxyMethod: server=%s method=%s args=%s"%(server, self.id, repr(args)))
1.5       casties   106:                 return getattr(server, self.id)(*args)
                    107:         
                    108:             except:
                    109:                 # should we catch only specific exceptions?
1.6     ! casties   110:                 logging.error("XmlRpcProxyMethod: error!")
1.5       casties   111:                 if i >= self.num_retries:
                    112:                     # pass on exception
                    113:                     raise
                    114:             i += 1
                    115: 
1.1       casties   116:         
                    117:     __call__ = eval
                    118:     
                    119: 
                    120:     mainConfigForm = PageTemplateFile('zpt/manageXmlRpcProxyMethod',globals())
                    121:         
1.5       casties   122:     def mainConfig(self,rpc_arg_expr=None,num_retries=0,RESPONSE=None):
1.1       casties   123:         """main config"""
1.5       casties   124:         
                    125:         self.num_retries = num_retries
1.1       casties   126:         if rpc_arg_expr is not None:
                    127:             self.rpc_arg_expr = rpc_arg_expr
                    128:         
                    129:         if RESPONSE:
1.2       casties   130:             RESPONSE.redirect("manage_main")
1.1       casties   131:             
                    132: 
                    133: def manage_addXmlRpcProxyMethodForm(self):
                    134:     """add the XmlRpcProxyFolder"""
                    135:     pt=PageTemplateFile('zpt/addXmlRpcProxyMethod',globals()).__of__(self)
                    136:     return pt()
                    137: 
1.5       casties   138: def manage_addXmlRpcProxyMethod(self,id,rpc_arg_expr,num_retries,RESPONSE=None):
1.1       casties   139:     """add the basket"""
1.5       casties   140:     ob=XmlRpcProxyMethod(id,rpc_arg_expr,num_retries)
1.1       casties   141:     self._setObject(id, ob)
                    142:     
                    143:     if RESPONSE is not None:
                    144:         RESPONSE.redirect('manage_main')
                    145: 
                    146: 
                    147: 
                    148: # init classes
                    149: InitializeClass(XmlRpcProxyFolder)
                    150: InitializeClass(XmlRpcProxyMethod)