Return to XmlRpcProxy.py CVS log

Up to [Repository] / XMLRpcTools

Annotation of XMLRpcTools/XmlRpcProxy.py, revision 1.3

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:     
                     77:     manage_options= (
                     78:         {'label':'Main Config','action':'mainConfigForm'},
                     79:         )+ SimpleItem.manage_options
                     80: 
                     81:     
                     82:     def __init__(self,id,rpc_arg_expr=None):
                     83:         """init server proxy"""
                     84:         self.id=id
                     85:         if rpc_arg_expr:
                     86:             self.rpc_arg_expr = rpc_arg_expr
                     87: 
                     88:     def eval(self,*argv):
                     89:         """do proxy request"""
                     90:         server=self.aq_parent.getProxy()
                     91: 
1.3     ! casties    92:         if self.rpc_arg_expr:
        !            93:             # clean arguments
        !            94:             args = [ re.sub(self.rpc_arg_expr,'',a) for a in argv]
1.1       casties    95:             
                     96:         # call the method self.id on the server with the args
                     97:         return getattr(server, self.id)(*args)
                     98:         
                     99:     __call__ = eval
                    100:     
                    101: 
                    102:     mainConfigForm = PageTemplateFile('zpt/manageXmlRpcProxyMethod',globals())
                    103:         
                    104:     def mainConfig(self,rpc_arg_expr=None,RESPONSE=None):
                    105:         """main config"""
                    106:                 
                    107:         if rpc_arg_expr is not None:
                    108:             self.rpc_arg_expr = rpc_arg_expr
                    109:         
                    110:         if RESPONSE:
1.2       casties   111:             RESPONSE.redirect("manage_main")
1.1       casties   112:             
                    113: 
                    114: def manage_addXmlRpcProxyMethodForm(self):
                    115:     """add the XmlRpcProxyFolder"""
                    116:     pt=PageTemplateFile('zpt/addXmlRpcProxyMethod',globals()).__of__(self)
                    117:     return pt()
                    118: 
                    119: def manage_addXmlRpcProxyMethod(self,id,rpc_arg_expr,RESPONSE=None):
                    120:     """add the basket"""
                    121:     ob=XmlRpcProxyMethod(id,rpc_arg_expr)
                    122:     self._setObject(id, ob)
                    123:     
                    124:     if RESPONSE is not None:
                    125:         RESPONSE.redirect('manage_main')
                    126: 
                    127: 
                    128: 
                    129: # init classes
                    130: InitializeClass(XmlRpcProxyFolder)
                    131: InitializeClass(XmlRpcProxyMethod)