Return to XmlRpcProxy.py CVS log

Up to [Repository] / XMLRpcTools

Annotation of XMLRpcTools/XmlRpcProxy.py, revision 1.1

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: 
        !            92:         # clean arguments
        !            93:         args = [ re.sub(self.rpc_arg_expr,'',a) for a in argv]
        !            94:             
        !            95:         # call the method self.id on the server with the args
        !            96:         return getattr(server, self.id)(*args)
        !            97:         
        !            98:     __call__ = eval
        !            99:     
        !           100: 
        !           101:     mainConfigForm = PageTemplateFile('zpt/manageXmlRpcProxyMethod',globals())
        !           102:         
        !           103:     def mainConfig(self,rpc_arg_expr=None,RESPONSE=None):
        !           104:         """main config"""
        !           105:                 
        !           106:         if rpc_arg_expr is not None:
        !           107:             self.rpc_arg_expr = rpc_arg_expr
        !           108:         
        !           109:         if RESPONSE:
        !           110:             RESPONSE.redirect("/manage_main")
        !           111:             
        !           112: 
        !           113: def manage_addXmlRpcProxyMethodForm(self):
        !           114:     """add the XmlRpcProxyFolder"""
        !           115:     pt=PageTemplateFile('zpt/addXmlRpcProxyMethod',globals()).__of__(self)
        !           116:     return pt()
        !           117: 
        !           118: def manage_addXmlRpcProxyMethod(self,id,rpc_arg_expr,RESPONSE=None):
        !           119:     """add the basket"""
        !           120:     ob=XmlRpcProxyMethod(id,rpc_arg_expr)
        !           121:     self._setObject(id, ob)
        !           122:     
        !           123:     if RESPONSE is not None:
        !           124:         RESPONSE.redirect('manage_main')
        !           125: 
        !           126: 
        !           127: 
        !           128: # init classes
        !           129: InitializeClass(XmlRpcProxyFolder)
        !           130: InitializeClass(XmlRpcProxyMethod)