Return to XMLRpcTools.py CVS log

Up to [Repository] / XMLRpcTools

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

    1: 
    2: from OFS.SimpleItem import SimpleItem
    3: import xmlrpclib
    4: import httplib
    5: from Products.PageTemplates.PageTemplateFile import PageTemplateFile
    6: import os.path
    7: from Globals import package_home
    8: import re
    9: 
   10: class XMLRpcServerProxy(SimpleItem):
   11:     """makes servery proxy available for zope"""
   12:     
   13:     meta_type="XMLRpcServerProxy"
   14:     
   15:     rpc_no_arg_expr='[^A-z0-9]'
   16:     
   17:     manage_options= (
   18:         {'label':'Main Config','action':'mainConfigHTML'},
   19:         )+ SimpleItem.manage_options
   20: 
   21:     def __init__(self,id,serverUrl,use_xmlrpc=True):
   22:         """init server proxy"""
   23:         self.id=id
   24:         self.serverUrl=serverUrl
   25:         self.use_xmlrpc = use_xmlrpc
   26:         
   27:         
   28:     def ServerProxy(self,serverUrl=None):
   29:         """get the proxy"""
   30:         if not serverUrl:
   31:             serverUrl=self.serverUrl
   32:       
   33:         if self.use_xmlrpc:
   34:             pr = xmlrpclib.ServerProxy(serverUrl)
   35:         else:
   36:             pr = httplib.HTTPConnection(serverUrl)
   37:        
   38:         return pr
   39:     
   40:     
   41:     def eval(self,method,argument,outputUnicode=True):
   42:         """do proxy request"""
   43:         server=self.ServerProxy()
   44:         
   45:         if self.use_xmlrpc:
   46:             # for XML-RPC methods only letters are allowed
   47:             method=re.sub('[^A-z0-9_]','',method)
   48:             # clean argument
   49:             argument=re.sub(self.rpc_no_arg_expr,'',argument)
   50:             
   51:             cmd="""server.%s('%s')"""%(method,argument)
   52:            
   53:             return eval(cmd)
   54:         else:
   55:             # HTTP
   56:             # TODO: check arguments
   57:             uri = method
   58:             if argument:
   59:                 uri += '?' + argument
   60:             
   61:             #print "GET: ", uri
   62:             server.request("GET", uri)
   63:             resp = server.getresponse()
   64:             data = resp.read()
   65:             #print "GOT: ", resp.status, ", ", resp.reason, " = ", data
   66:             if outputUnicode:
   67:                 return data.decode('UTF-8')
   68:             else:
   69:                 return data
   70:         
   71:     def eval2(self,method,argument1,argument2,outputUnicode=True):
   72:         """do proxy request"""
   73:         server=self.ServerProxy()
   74:         
   75:         if self.use_xmlrpc:
   76:             # for XML-RPC methods only letters are allowed
   77:             method=re.sub('[^A-z0-9_]','',method)
   78:             # clean argument
   79:             argument1=re.sub(self.rpc_no_arg_expr,'',argument1)
   80:             argument2=re.sub(self.rpc_no_arg_expr,'',argument2)
   81:             
   82:             cmd="""server.%s('%s','%s')"""%(method,argument1,argument2)
   83:            
   84:             return eval(cmd)
   85:         else:
   86:             # HTTP
   87:             # TODO: check arguments
   88:             uri = method
   89:             if argument1:
   90:                 uri += '?' + argument1 + argument2
   91:             
   92:             #print "GET: ", uri
   93:             server.request("GET", uri)
   94:             resp = server.getresponse()
   95:             data = resp.read()
   96:             #print "GOT: ", resp.status, ", ", resp.reason, " = ", data
   97:             
   98:             if outputUnicode:
   99:                 return data.decode('UTF-8')
  100:             else:
  101:                 return data
  102:         
  103:     
  104:     def mainConfigHTML(self):
  105:         """main config form"""
  106:         pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','manageXMLRpcServerProxy.zpt')).__of__(self)
  107:         return pt()
  108:     
  109:     def mainConfig(self,serverUrl,use_xmlrpc=True,rpc_no_arg_expr=None,RESPONSE=None):
  110:         """main config"""
  111:         
  112:         self.serverUrl=serverUrl
  113:         
  114:         if use_xmlrpc and use_xmlrpc != "no":
  115:             use_xmlrpc = True
  116:         else:
  117:             use_xmlrpc = False
  118:         
  119:         self.use_xmlrpc=use_xmlrpc
  120:         
  121:         if rpc_no_arg_expr is not None:
  122:             self.rpc_no_arg_expr = rpc_no_arg_expr
  123:         
  124:         if RESPONSE:
  125:             RESPONSE.redirect("manage_main")
  126:             
  127: 
  128: def manage_addXMLRpcServerProxyForm(self):
  129:     """add the XMLRpcServerProxy"""
  130:     pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','addXMLRpcServerProxy.zpt')).__of__(self)
  131:     return pt()
  132: 
  133: def manage_addXMLRpcServerProxy(self,id,serverUrl,use_xmlrpc=True,rpc_no_arg_expr=None,RESPONSE=None):
  134:     """add the XMLRpcServerProxy"""
  135:     if use_xmlrpc is not None and use_xmlrpc != "no":
  136:         use_xmlrpc = True
  137:     else:
  138:         use_xmlrpc = False
  139:         
  140:     ob=XMLRpcServerProxy(id,serverUrl,use_xmlrpc)
  141:     
  142:     if rpc_no_arg_expr is not None:
  143:         ob.rpc_no_arg_expr = rpc_no_arg_expr
  144:         
  145:     self._setObject(id, ob)
  146:     
  147:     if RESPONSE is not None:
  148:         RESPONSE.redirect('manage_main')
  149: