[19] | 1 | # The contents of this file are subject to the Mozilla Public |
---|
| 2 | # License Version 1.1 (the "License"); you may not use this file |
---|
| 3 | # except in compliance with the License. You may obtain a copy of |
---|
| 4 | # the License at http://www.mozilla.org/MPL/ |
---|
| 5 | # |
---|
| 6 | # Software distributed under the License is distributed on an "AS |
---|
| 7 | # IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or |
---|
| 8 | # implied. See the License for the specific language governing |
---|
| 9 | # rights and limitations under the License. |
---|
| 10 | # |
---|
| 11 | # The Original Code is XMLRPCMethod version 1.0. |
---|
| 12 | # |
---|
| 13 | # The Initial Developer of the Original Code is European Environment |
---|
| 14 | # Agency (EEA). Portions created by Finsiel Romania are |
---|
| 15 | # Copyright (C) European Environment Agency. All |
---|
| 16 | # Rights Reserved. |
---|
| 17 | # |
---|
| 18 | # Contributor(s): |
---|
| 19 | # Soren Roug, EEA |
---|
| 20 | # Cornel Nitu, Finsiel Romania |
---|
| 21 | |
---|
| 22 | """ XMLRPC Method Product |
---|
| 23 | |
---|
| 24 | This product provides support for remote methods. |
---|
| 25 | """ |
---|
| 26 | __version__='$Revision: 1.11 $'[11:-2] |
---|
| 27 | import xmlrpclib, httplib |
---|
| 28 | from base64 import encodestring |
---|
| 29 | from string import split, join, lower, replace |
---|
| 30 | import sys, os, stat, traceback |
---|
| 31 | from cgi import escape |
---|
| 32 | from urllib import splithost, splitpasswd, splittype, splituser |
---|
| 33 | from threading import Thread |
---|
| 34 | |
---|
| 35 | from Globals import Persistent, DTMLFile, MessageDialog, HTML |
---|
| 36 | import OFS.SimpleItem, Acquisition |
---|
| 37 | from OFS.Cache import Cacheable |
---|
| 38 | import AccessControl.Role |
---|
| 39 | from OFS.SimpleItem import pretty_tb |
---|
| 40 | from App.Management import Navigation |
---|
| 41 | |
---|
| 42 | _marker = [] # Create a new marker object |
---|
| 43 | |
---|
| 44 | manage_addXMLRPCMethodForm=DTMLFile('dtml/methodAdd', globals()) |
---|
| 45 | |
---|
| 46 | def manage_addXMLRPCMethod(self, id, title, remoteurl, function, timeout, REQUEST=None): |
---|
| 47 | """ Add an external method to a folder |
---|
| 48 | |
---|
| 49 | An addition to the standard object-creation arguments, |
---|
| 50 | 'id' and title, the following arguments are defined: |
---|
| 51 | |
---|
| 52 | method -- The name of the remote method. This can be a |
---|
| 53 | an ordinary Python function, or a bound method. |
---|
| 54 | |
---|
| 55 | remoteurl -- The URL of the RPC dispatcher to call. |
---|
| 56 | """ |
---|
| 57 | id=str(id) |
---|
| 58 | title=str(title) |
---|
| 59 | remoteurl=str(remoteurl) |
---|
| 60 | function=str(function) |
---|
| 61 | timeout=float(timeout) |
---|
| 62 | |
---|
| 63 | i=XMLRPCMethod(id,title,remoteurl,function,timeout) |
---|
| 64 | self._setObject(id,i) |
---|
| 65 | return self.manage_main(self,REQUEST) |
---|
| 66 | |
---|
| 67 | class XMLRPCMethod(OFS.SimpleItem.Item, Persistent, Acquisition.Explicit, |
---|
| 68 | AccessControl.Role.RoleManager, Navigation, Cacheable): |
---|
| 69 | """ Web-callable functions that encapsulate remote methods. |
---|
| 70 | |
---|
| 71 | """ |
---|
| 72 | |
---|
| 73 | meta_type='XMLRPC Method' |
---|
| 74 | |
---|
| 75 | ZopeTime=Acquisition.Acquired |
---|
| 76 | HelpSys=Acquisition.Acquired |
---|
| 77 | |
---|
| 78 | manage_options=( |
---|
| 79 | ( |
---|
| 80 | {'label':'Properties', 'action':'manage_main', |
---|
| 81 | 'help':('XMLRPCMethod','XMLRPC-Method_Properties.stx')}, |
---|
| 82 | {'label':'Test', 'action':'', |
---|
| 83 | 'help':('XMLRPCMethod','XMLRPC-Method_Try-It.stx')}, |
---|
| 84 | ) |
---|
| 85 | +OFS.SimpleItem.Item.manage_options |
---|
| 86 | +AccessControl.Role.RoleManager.manage_options |
---|
| 87 | +Cacheable.manage_options |
---|
| 88 | ) |
---|
| 89 | |
---|
| 90 | __ac_permissions__=( |
---|
| 91 | ('View management screens', ('manage_main',)), |
---|
| 92 | ('Change XMLRPC Methods', ('manage_edit',)), |
---|
| 93 | ('View', ('__call__','')), |
---|
| 94 | ) |
---|
| 95 | |
---|
| 96 | def __init__(self, id, title, remoteurl, function,timeout): |
---|
| 97 | self.id=id |
---|
| 98 | self.manage_edit(title, remoteurl, function,timeout) |
---|
| 99 | |
---|
| 100 | def __setstate__(self,state): |
---|
| 101 | XMLRPCMethod.inheritedAttribute('__setstate__')(self, state) |
---|
| 102 | if not hasattr(self,'_timeout'): |
---|
| 103 | self._timeout = 5.0 |
---|
| 104 | |
---|
| 105 | manage_main=DTMLFile('dtml/methodEdit', globals()) |
---|
| 106 | |
---|
| 107 | def manage_edit(self, title, remoteurl, function, timeout, REQUEST=None): |
---|
| 108 | """Change the external method |
---|
| 109 | |
---|
| 110 | See the description of manage_addXMLRPCMethod for a |
---|
| 111 | description of the arguments 'remoteurl' and 'function'. |
---|
| 112 | """ |
---|
| 113 | title=str(title) |
---|
| 114 | remoteurl=str(remoteurl) |
---|
| 115 | function=str(function) |
---|
| 116 | timeout=float(timeout) |
---|
| 117 | |
---|
| 118 | self.title=title |
---|
| 119 | if remoteurl: |
---|
| 120 | urltype, url = splittype(remoteurl) |
---|
| 121 | if urltype != "http": |
---|
| 122 | raise IOError, "Only http scheme supported" |
---|
| 123 | |
---|
| 124 | host, selector = splithost(url) |
---|
| 125 | |
---|
| 126 | if not host: raise IOError, ('http error', 'No host given') |
---|
| 127 | |
---|
| 128 | self._remoteurl = remoteurl |
---|
| 129 | self._function = function |
---|
| 130 | self._timeout = timeout |
---|
| 131 | self.ZCacheable_invalidate() |
---|
| 132 | if REQUEST: |
---|
| 133 | message="XMLRPC Method Created." |
---|
| 134 | return self.manage_main(self,REQUEST,manage_tabs_message=message) |
---|
| 135 | |
---|
| 136 | def __call__(self, *args): |
---|
| 137 | """ Call an XMLRPC Method """ |
---|
| 138 | |
---|
| 139 | __traceback_info__ = args |
---|
| 140 | # Retrieve the value from the cache. |
---|
| 141 | keyset = None |
---|
| 142 | if self.ZCacheable_isCachingEnabled(): |
---|
| 143 | # Strange; I can't just use args |
---|
| 144 | keyset = { '*':args } |
---|
| 145 | # Prepare a cache key. |
---|
| 146 | results = self.ZCacheable_get(keywords=keyset, default=_marker) |
---|
| 147 | if results is not _marker: |
---|
| 148 | return results |
---|
| 149 | |
---|
| 150 | ut = RPCThread(self._remoteurl, self._function, args=args) |
---|
| 151 | ut.start() |
---|
| 152 | ut.join(self._timeout) |
---|
| 153 | |
---|
| 154 | results = ut.getresult() |
---|
| 155 | if keyset is not None: |
---|
| 156 | if results is not None: |
---|
| 157 | self.ZCacheable_set(results, keywords=keyset) |
---|
| 158 | return results |
---|
| 159 | |
---|
| 160 | def function(self): return self._function |
---|
| 161 | def remoteurl(self): return self._remoteurl |
---|
| 162 | def timeout(self): return self._timeout |
---|
| 163 | |
---|
| 164 | class RPCThread(Thread): |
---|
| 165 | |
---|
| 166 | def __init__(self,remoteurl,function,args=()): |
---|
| 167 | Thread.__init__(self) |
---|
| 168 | self.args=args |
---|
| 169 | self.result = None |
---|
| 170 | self.rpcerror = None |
---|
| 171 | self.remoteurl = remoteurl |
---|
| 172 | self.function = function |
---|
| 173 | |
---|
| 174 | def getresult(self): |
---|
| 175 | if self.rpcerror: |
---|
| 176 | raise IOError, escape(self.rpcerror) |
---|
| 177 | else: |
---|
| 178 | return self.result |
---|
| 179 | |
---|
| 180 | def run(self): |
---|
| 181 | self.rpcerror = None |
---|
| 182 | urltype, url = splittype(self.remoteurl) |
---|
| 183 | if urltype != "http": |
---|
| 184 | self.rpcerror = "Only http scheme supported" |
---|
| 185 | raise IOError, "Only http scheme supported" |
---|
| 186 | |
---|
| 187 | host, selector = splithost(url) |
---|
| 188 | |
---|
| 189 | if not host: raise IOError, ('http error', 'No host given') |
---|
| 190 | |
---|
| 191 | user_passwd, host = splituser(host) |
---|
| 192 | |
---|
| 193 | url = "http://"+ host + selector |
---|
| 194 | |
---|
| 195 | if user_passwd: |
---|
| 196 | server = xmlrpclib.Server(url, BasicAuthTransport(user_passwd)) |
---|
| 197 | else: |
---|
| 198 | server = xmlrpclib.Server(url) |
---|
| 199 | f = server.__getattr__(self.function) |
---|
| 200 | try: res = apply(f,self.args) |
---|
| 201 | except (xmlrpclib.Fault,xmlrpclib.ProtocolError,xmlrpclib.ResponseError), v: |
---|
| 202 | self.rpcerror = str(v) |
---|
| 203 | #raise IOError, escape(self.rpcerror) |
---|
| 204 | else: |
---|
| 205 | self.result = res |
---|
| 206 | |
---|
| 207 | |
---|
| 208 | class BasicAuthTransport(xmlrpclib.Transport): |
---|
| 209 | def __init__(self, userpassword=None): |
---|
| 210 | self.userpassword=userpassword |
---|
| 211 | |
---|
| 212 | def request(self, host, handler, request_body): |
---|
| 213 | """ issue XML-RPC request """ |
---|
| 214 | |
---|
| 215 | h = httplib.HTTP(host) |
---|
| 216 | h.putrequest("POST", handler) |
---|
| 217 | |
---|
| 218 | # required by HTTP/1.1 |
---|
| 219 | h.putheader("Host", host) |
---|
| 220 | |
---|
| 221 | # required by XML-RPC |
---|
| 222 | h.putheader("User-Agent", self.user_agent) |
---|
| 223 | h.putheader("Content-Type", "text/xml") |
---|
| 224 | h.putheader("Content-Length", str(len(request_body))) |
---|
| 225 | |
---|
| 226 | # basic auth |
---|
| 227 | if self.userpassword is not None: |
---|
| 228 | h.putheader("AUTHORIZATION", "Basic %s" % replace( |
---|
| 229 | encodestring("%s" % (self.userpassword)), |
---|
| 230 | "\012", "")) |
---|
| 231 | h.endheaders() |
---|
| 232 | |
---|
| 233 | if request_body: |
---|
| 234 | h.send(request_body) |
---|
| 235 | |
---|
| 236 | errcode, errmsg, headers = h.getreply() |
---|
| 237 | |
---|
| 238 | if errcode != 200: |
---|
| 239 | raise xmlrpclib.ProtocolError( |
---|
| 240 | host + handler, |
---|
| 241 | errcode, errmsg, |
---|
| 242 | headers |
---|
| 243 | ) |
---|
| 244 | |
---|
| 245 | return self.parse_response(h.getfile()) |
---|