Return to XMLRpcTools.py CVS log

Up to [Repository] / XMLRpcTools

added outputUnicode to eval to be able to get undecoded response (from http)

from OFS.SimpleItem import SimpleItem
import xmlrpclib
import httplib
from Products.PageTemplates.PageTemplateFile import PageTemplateFile
import os.path
from Globals import package_home
import re

class XMLRpcServerProxy(SimpleItem):
    """makes servery proxy available for zope"""
    
    meta_type="XMLRpcServerProxy"
    
    rpc_no_arg_expr='[^A-z0-9]'
    
    manage_options= (
        {'label':'Main Config','action':'mainConfigHTML'},
        )+ SimpleItem.manage_options

    def __init__(self,id,serverUrl,use_xmlrpc=True):
        """init server proxy"""
        self.id=id
        self.serverUrl=serverUrl
        self.use_xmlrpc = use_xmlrpc
        
        
    def ServerProxy(self,serverUrl=None):
        """get the proxy"""
        if not serverUrl:
            serverUrl=self.serverUrl
      
        if self.use_xmlrpc:
            pr = xmlrpclib.ServerProxy(serverUrl)
        else:
            pr = httplib.HTTPConnection(serverUrl)
       
        return pr
    
    
    def eval(self,method,argument,outputUnicode=True):
        """do proxy request"""
        server=self.ServerProxy()
        
        if self.use_xmlrpc:
            # for XML-RPC methods only letters are allowed
            method=re.sub('[^A-z0-9_]','',method)
            # clean argument
            argument=re.sub(self.rpc_no_arg_expr,'',argument)
            
            cmd="""server.%s('%s')"""%(method,argument)
           
            return eval(cmd)
        else:
            # HTTP
            # TODO: check arguments
            uri = method
            if argument:
                uri += '?' + argument
            
            #print "GET: ", uri
            server.request("GET", uri)
            resp = server.getresponse()
            data = resp.read()
            #print "GOT: ", resp.status, ", ", resp.reason, " = ", data
            if outputUnicode:
                return data.decode('UTF-8')
            else:
                return data
        
    def eval2(self,method,argument1,argument2,outputUnicode=True):
        """do proxy request"""
        server=self.ServerProxy()
        
        if self.use_xmlrpc:
            # for XML-RPC methods only letters are allowed
            method=re.sub('[^A-z0-9_]','',method)
            # clean argument
            argument1=re.sub(self.rpc_no_arg_expr,'',argument1)
            argument2=re.sub(self.rpc_no_arg_expr,'',argument2)
            
            cmd="""server.%s('%s','%s')"""%(method,argument1,argument2)
           
            return eval(cmd)
        else:
            # HTTP
            # TODO: check arguments
            uri = method
            if argument1:
                uri += '?' + argument1 + argument2
            
            #print "GET: ", uri
            server.request("GET", uri)
            resp = server.getresponse()
            data = resp.read()
            #print "GOT: ", resp.status, ", ", resp.reason, " = ", data
            
            if outputUnicode:
                return data.decode('UTF-8')
            else:
                return data
        
    
    def mainConfigHTML(self):
        """main config form"""
        pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','manageXMLRpcServerProxy.zpt')).__of__(self)
        return pt()
    
    def mainConfig(self,serverUrl,use_xmlrpc=True,rpc_no_arg_expr=None,RESPONSE=None):
        """main config"""
        
        self.serverUrl=serverUrl
        
        if use_xmlrpc and use_xmlrpc != "no":
            use_xmlrpc = True
        else:
            use_xmlrpc = False
        
        self.use_xmlrpc=use_xmlrpc
        
        if rpc_no_arg_expr is not None:
            self.rpc_no_arg_expr = rpc_no_arg_expr
        
        if RESPONSE:
            RESPONSE.redirect("manage_main")
            

def manage_addXMLRpcServerProxyForm(self):
    """add the XMLRpcServerProxy"""
    pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','addXMLRpcServerProxy.zpt')).__of__(self)
    return pt()

def manage_addXMLRpcServerProxy(self,id,serverUrl,use_xmlrpc=True,rpc_no_arg_expr=None,RESPONSE=None):
    """add the XMLRpcServerProxy"""
    if use_xmlrpc is not None and use_xmlrpc != "no":
        use_xmlrpc = True
    else:
        use_xmlrpc = False
        
    ob=XMLRpcServerProxy(id,serverUrl,use_xmlrpc)
    
    if rpc_no_arg_expr is not None:
        ob.rpc_no_arg_expr = rpc_no_arg_expr
        
    self._setObject(id, ob)
    
    if RESPONSE is not None:
        RESPONSE.redirect('manage_main')