def _kerberos_client_request(self, host, handler, errcode, errmsg,
headers):
"""Kerberos auth - create a client request string"""
# check if "Negotiate" challenge is present in headers
negotiate = [
i.lower() for i in headers.get("WWW-Authenticate", "").split(", ")
]
if "negotiate" not in negotiate:
# negotiate not supported, raise 401 error
raise xmlrpclib.ProtocolError(host + handler, errcode, errmsg,
headers)
# initialize GSSAPI
service = "HTTP@%s" % host
rc, vc = kerberos.authGSSClientInit(service)
if rc != 1:
errmsg = "KERBEROS: Could not initialize GSSAPI"
raise xmlrpclib.ProtocolError(host + handler, errcode, errmsg,
headers)
# do a client step
rc = kerberos.authGSSClientStep(vc, "")
if rc != 0:
errmsg = "KERBEROS: Client step failed"
raise xmlrpclib.ProtocolError(host + handler, errcode, errmsg,
headers)
return vc, kerberos.authGSSClientResponse(vc)
def _kerberos_verify_response(self, vc, host, handler, errcode, errmsg, headers):
"""Kerberos auth - verify client identity"""
# verify that headers contain WWW-Authenticate header
auth_header = headers.get("WWW-Authenticate", None)
if auth_header is None:
errcode = 401
errmsg = "KERBEROS: No WWW-Authenticate header in second HTTP response"
raise xmlrpclib.ProtocolError(host + handler, errcode, errmsg, headers)
# verify that WWW-Authenticate contains Negotiate
splits = auth_header.split(" ", 1)
if (len(splits) != 2) or (splits[0].lower() != "negotiate"):
errcode = 401
errmsg = "KERBEROS: Incorrect WWW-Authenticate header in second HTTP response: %s" % auth_header
raise xmlrpclib.ProtocolError(host + handler, errcode, errmsg, headers)
# do another client step to verify response from server
errmsg = "KERBEROS: Could not verify server WWW-Authenticate header in second HTTP response"
try:
rc = kerberos.authGSSClientStep(vc, splits[1])
if rc == -1:
errcode = 401
raise xmlrpclib.ProtocolError(host + handler, errcode, errmsg, headers)
except kerberos.GSSError, ex:
errcode = 401
errmsg += ": %s/%s" % (ex[0][0], ex[1][0])
raise xmlrpclib.ProtocolError(host + handler, errcode, errmsg, headers)
def request(self, host, handler, request_body, verbose=0):
# issue XML-RPC request
h = self.make_connection(host)
if verbose:
h.set_debuglevel(1)
self.send_request(h, handler, request_body)
self.send_host(h, host)
self.send_user_agent(h)
if self.cookie is not None:
h.putheader("Cookie", self.cookie)
self.send_content(h, request_body)
errcode, errmsg, headers = h.getreply()
self.cookie = headers.getheader('set-cookie') or self.cookie
if errcode != 200:
raise xmlrpclib.ProtocolError(
host + handler,
errcode, errmsg,
headers
)
# do not print the response body
self.verbose = False
return self.parse_response(h.getfile())
class GAEXMLRPCTransport(object):
"""Handles an HTTP transaction to an XML-RPC server."""
def __init__(self):
pass
def request(self, host, handler, request_body, verbose=0):
result = None
url = 'http://%s%s' % (host, handler)
try:
response = urlfetch.fetch(url,
payload=request_body,
method=urlfetch.POST,
headers={'Content-Type': 'text/xml'})
except Exception, e:
msg = 'Failed to fetch %s, caused by: %s' % (url, traceback.format_exc())
logging.error(msg)
raise xmlrpclib.ProtocolError(host + handler, 500, msg, {})
if response.status_code != 200:
logging.error('%s returned status code %s' %
(url, response.status_code))
raise xmlrpclib.ProtocolError(host + handler,
response.status_code,
"",
response.headers)
else:
result = self.__parse_response(response.content)
return result
def request(self, host, handler, request_body, verbose=0):
if not self.connection:
host, extra_headers, x509 = self.get_host_info(host)
self.connection = httplib.HTTPSConnection(host)
self.headers = {
"User-Agent": self.user_agent,
"Content-Type": "text/xml",
"Accept": "text/xml"
}
if extra_headers:
for key, item in extra_headers:
self.headers[key] = item
self.headers["Content-Length"] = str(len(request_body))
self.connection.request("POST", handler, request_body, self.headers)
r = self.connection.getresponse()
if r.status != 200:
self.connection.close()
self.connection = None
raise xmlrpclib.ProtocolError(host + handler, r.status, r.reason,
"")
data = r.read()
p, u = self.getparser()
p.feed(data)
p.close()
return u.close()
def _request(self, host, handler, request_body, verbose=0):
# issue XML-RPC request
h = self.cache.get_connection()
try:
self.set_connection_params(h)
h.add_data(request_body)
response = pycurllib.urlopen(h, close=False)
#errcode, errmsg, headers = h.getreply()
errcode = response.code
errmsg = response.msg
headers = "N/A"
if errcode != 200:
raise xmlrpclib.ProtocolError(host + handler, errcode, errmsg,
headers)
self.verbose = verbose
r = self._parse_response(response)
finally:
self.cache.put_connection(h)
return r
def handle_error(self):
t, v, nil = sys.exc_info()
self.deferred.runErrback(
xmlrpclib.ProtocolError(self.host, '500',
"Socket Error (%s:%s)" % (t, v) , {})
)
self.close()
def request(
self,
host,
handler,
request_body,
verbose=0,
):
h = getattr(self, "make_connection_" + PYVERSION)(host)
if verbose:
h.set_debuglevel(1)
# ADDED: construct the URL and Request object for proper cookie handling
request_url = '%s://%s/' % (self.scheme, host)
cookie_request = urllib2.Request(request_url)
self.send_request(h, handler, request_body)
self.send_host(h, host)
self.send_cookies(h, cookie_request) # ADDED. creates cookiejar if None.
self.send_user_agent(h)
self.send_content(h, request_body)
(errcode, errmsg, headers) = h.getreply()
# ADDED: parse headers and get cookies here
# fake a response object that we can fill with the headers above
class CookieResponse:
def __init__(self, headers):
self.headers = headers
def info(self):
return self.headers
cookie_response = CookieResponse(headers)
# Okay, extract the cookies from the headers
self.cookiejar.extract_cookies(cookie_response, cookie_request)
# And write back any changes
if hasattr(self.cookiejar, 'save'):
self.cookiejar.save(self.cookiejar.filename)
if errcode != 200:
raise xmlrpclib.ProtocolError(host + handler, errcode,
errmsg, headers)
self.verbose = verbose
try:
sock = h._conn.sock
except AttributeError:
sock = None
return getattr(self, "_parse_response_" + PYVERSION)(h.getfile(), sock)
def request(self, host, handler, request_body, verbose=0):
# issue XML-RPC request
h = self.make_connection(host)
if verbose:
h.set_debuglevel(1)
self.send_request(h, handler, request_body)
self.send_host(h, host)
if not self.mysessid is None:
h.putheader("Cookie", "%s=%s" % (self.SESSION_ID_STRING,self.mysessid) )
self.send_user_agent(h)
self.send_content(h, request_body)
errcode, errmsg, headers = h.getreply()
if self.mysessid is None:
self.mycookies = self.parseCookies( headers.getheader('set-cookie') )
if self.mycookies.has_key(self.SESSION_ID_STRING):
self.mysessid = self.mycookies[self.SESSION_ID_STRING]
if errcode != 200:
raise xmlrpclib.ProtocolError(
host + handler,
errcode, errmsg,
headers
)
self.verbose = verbose
try:
sock = h._conn.sock
except AttributeError:
sock = None
return self._parse_response(h.getfile(), sock)
def request(self, host, handler, request_body, verbose=0):
# issue XML-RPC request
h = self.make_connection(host)
if verbose:
h.set_debuglevel(1)
self.send_request(h, handler, request_body)
self.send_host(h, host)
self.send_user_agent(h)
self.send_content(h, request_body)
r = h.getresponse()
errcode = r.status
errmsg = r.reason
headers = r.msg
# Creati g cookie jar
cresponse = CookieResponse(headers)
crequest = CookieRequest('https://' + host + '/')
if '<methodName>base.ldapAuth</methodName>' in request_body:
cj = LWPCookieJar()
cj.extract_cookies(cresponse, crequest)
if len(cj):
cj.save(COOKIES_FILE, ignore_discard=True, ignore_expires=True)
os.chmod(COOKIES_FILE, stat.S_IRUSR | stat.S_IWUSR)
if errcode != 200:
raise xmlrpclib.ProtocolError(host + handler, errcode, errmsg,
headers)
self.verbose = verbose
return self.parse_response(r)
def retrieve(url, cacert=None, postdata=None, timeout=90):
# command = ('/usr/bin/curl', '--fail', '--silent')
command = (
'/usr/bin/curl',
'--fail',
)
if cacert: command += ('--cacert', cacert)
if postdata: command += ('--data', '@-')
if timeout:
command += ('--max-time', str(timeout))
command += ('--connect-timeout', str(timeout))
command += (url, )
if verbose:
print 'Invoking ', command
if postdata: print 'with postdata=', postdata
p = Sopen(command, stdin=PIPE, stdout=PIPE, stderr=PIPE, close_fds=True)
if postdata: p.stdin.write(postdata)
p.stdin.close()
sout, sin, serr = select([p.stdout, p.stderr], [], [], timeout)
if len(sout) == 0 and len(sin) == 0 and len(serr) == 0:
logger.verbose("curlwrapper: timed out after %s" % timeout)
p.kill(signal.SIGKILL)
data = p.stdout.read()
err = p.stderr.read()
rc = p.wait()
if rc != 0:
# when this triggers, the error sometimes doesn't get printed
logger.log("curlwrapper: retrieve, got stderr <%s>" % err)
raise xmlrpclib.ProtocolError(url, rc, err, postdata)
else:
return data
def single_request(self, host, handler, request_body, verbose=0):
# issue XML-RPC request
h = self.make_connection(host)
if verbose:
h.set_debuglevel(1)
try:
self.send_request(h, handler, request_body)
self.send_host(h, host)
self.send_user_agent(h)
self.send_auth(h)
self.send_content(h, request_body)
response = h.getresponse(buffering=True)
if response.status == 200:
self.verbose = verbose
return self.parse_response(response)
except xmlrpclib.Fault:
raise
except Exception:
self.close()
raise
#discard any response data and raise exception
if response.getheader("content-length", 0):
response.read()
raise xmlrpclib.ProtocolError(
host + handler,
response.status,
response.reason,
response.msg,
)
def request(self, host, handler, request_body, verbose=0):
"""Request via urlfetch instead of socket connection.
Args:
host: string hostname.
handler: string '/RPC2', defined in xmlrpclib.
request_body: string XML-RPC request body.
verbose: integer, defined in xmlrpclib, unused here.
Returns:
ServerProxy instance.
Raises:
ProtocolError: if urlfetch.fetch fails or returns an HTTP status
code other than 200.
"""
result = None
url = '%s://%s%s' % (self.PROTOCOL, host, handler)
headers = {
'Content-Type': 'text/xml',
'use_intranet': 'yes',
'X-secureDataConnector-RouteDomain': 'google.com'
}
if self.DEBUG_HEADERS:
headers['X-secureDataConnectorDebug'] = 'text'
try:
response = urlfetch.fetch(url,
payload=request_body,
method=urlfetch.POST,
headers=headers,
deadline=10)
except urlfetch.Error, error:
raise xmlrpclib.ProtocolError(host + handler, 500, error, {})
def request(self, arg_host, handler,
request_body, verbose=0):
# issue XML-RPC request
self.verbose = verbose
myHttp = httplib.HTTP(arg_host)
myHttp.putrequest("POST", handler)
# required by HTTP/1.1
myHttp.putheader("Host", arg_host)
# required by XML-RPC
myHttp.putheader("User-Agent", self.user_agent)
myHttp.putheader("Content-Type", "text/xml")
myHttp.putheader("Content-Length", str(len(request_body)))
# basic auth
if self.username is not None and self.password is not None:
myHttp.putheader("AUTHORIZATION", "Basic %s" %
encodestring("%s:%s" % (self.username, self.password)
).replace("\012", ""))
myHttp.endheaders()
if request_body:
myHttp.send(request_body)
errcode, errmsg, headers = myHttp.getreply()
if errcode != 200:
raise xmlrpclib.ProtocolError(arg_host + handler,
errcode, errmsg, headers)
return self.parse_response(myHttp.getfile())
def request(self, host, handler, request_body, verbose=0):
# issue XML-RPC request
if self.proxy != "":
h = self.make_connection(self.proxy)
else:
h = self.make_connection(host)
if verbose:
h.set_debuglevel(1)
if self.proxy != "":
self.send_request(h, "http://" + host + handler, request_body)
else:
self.send_request(h, handler, request_body)
self.send_host(h, host)
self.send_user_agent(h)
self.send_content(h, request_body)
errcode, errmsg, headers = h.getreply()
if errcode != 200:
raise xmlrpclib.ProtocolError(host + handler, errcode, errmsg,
headers)
self.verbose = verbose
return self.parse_response(h.getfile())
def request(self, host, handler, request_body, verbose=0):
if not self.connection:
self.connection = self._get_connection()
self.headers = {
"User-Agent": self.user_agent,
"Content-Type": "text/xml",
"Accept": "text/xml"
}
# basic auth
if self.username is not None and self.password is not None:
unencoded = "%s:%s" % (self.username, self.password)
encoded = base64.encodestring(unencoded).replace('\n', '')
self.headers["Authorization"] = "Basic %s" % encoded
self.headers["Content-Length"] = str(len(request_body))
self.connection.request('POST', handler, request_body, self.headers)
r = self.connection.getresponse()
if r.status != 200:
self.connection.close()
self.connection = None
raise xmlrpclib.ProtocolError(host + handler, r.status, r.reason,
'')
data = r.read()
p, u = self.getparser()
p.feed(data)
p.close()
return u.close()
def connect(self):
# Set the connection with the proxy
HTTPProxyConnection.connect(self)
# Use the stock HTTPConnection putrequest
host = "%s:%s" % (self._host, self._port)
HTTPConnection.putrequest(self, "CONNECT", host)
# Add proxy-specific stuff
self._add_proxy_headers()
# And send the request
HTTPConnection.endheaders(self)
# Save the response class
response_class = self.response_class
# And replace the response class with our own one, which does not
# close the connection after
self.response_class = HTTPSProxyResponse
response = HTTPConnection.getresponse(self)
# Restore the response class
self.response_class = response_class
# Close the response object manually
response.close()
if response.status != 200:
# Close the connection manually
self.close()
raise xmlrpclib.ProtocolError(host, response.status,
response.reason, response.msg)
self.sock = SSL.SSLSocket(self.sock, self.trusted_certs)
self.sock.init_ssl()
def request(self, host, handler, request_body, verbose=0):
"""
Make an xmlrpc request.
"""
headers = {'User-Agent': self.user_agent}
url = self._build_url(host, handler)
try:
resp = requests.post(url,
data=request_body,
headers=headers,
stream=True,
timeout=self.timeout,
proxies=self.proxies,
verify=self.verify)
except ValueError:
raise
except Exception:
raise # something went wrong
else:
try:
resp.raise_for_status()
except requests.RequestException as e:
raise xmlrpclib.ProtocolError(url, resp.status_code, str(e),
resp.headers)
else:
self.verbose = verbose
return self.parse_response(resp.raw)
def _single_request(self, host, handler, request_body, verbose=0):
# issue XML-RPC request
request_url = "%s://%s/" % (self.scheme, host)
cookie_request = urllib2.Request(request_url)
h = self.make_connection(host)
self.verbose = verbose
if verbose:
h.set_debuglevel(1)
try:
self.send_request(h, handler, request_body)
self.send_host(h, host)
self.send_cookies(h, cookie_request)
self.send_user_agent(h)
self.send_content(h, request_body)
response = h.getresponse(buffering=True)
if response.status == 401 and USE_KERBEROS:
vc, challenge = self._kerberos_client_request(
host, handler, response.status, response.reason,
response.msg)
# discard any response data
if (response.getheader("content-length", 0)):
response.read()
# retry the original request & add the Authorization header:
self.send_request(h, handler, request_body)
self._extra_headers = [("Authorization",
"Negotiate %s" % challenge)]
self.send_host(h, host)
self.send_user_agent(h)
self.send_content(h, request_body)
self._extra_headers = []
response = h.getresponse(buffering=True)
self._kerberos_verify_response(vc, host, handler,
response.status,
response.reason, response.msg)
if response.status == 200:
self.verbose = verbose
self._save_cookies(response.msg, cookie_request)
return self.parse_response(response)
except xmlrpclib.Fault:
raise
except Exception:
# All unexpected errors leave connection in
# a strange state, so we clear it.
if hasattr(self, 'close'):
self.close()
raise
# discard any response data and raise exception
if (response.getheader("content-length", 0)):
response.read()
raise xmlrpclib.ProtocolError(host + handler, response.status,
response.reason, response.msg)
def request(self, host, handler, request_body, verbose=0):
request = "POST %s HTTP/1.0\n" % (handler, )
request += "Content-Length: %i\n" % len(request_body)
request += "Content-Type: text/xml\n"
host, extra_headers, x509 = self.get_host_info(host)
if extra_headers:
request += "Authorization: %s\n" \
% (dict(extra_headers)["Authorization"],)
request += "\n" + request_body
response = HTTPCaller()(request, handle_errors=self.handleErrors)
errcode = response.getStatus()
errmsg = response.getStatusString()
# This is not the same way that the normal transport deals
# with the headers.
headers = response.getHeaders()
if errcode != 200:
raise xmlrpclib.ProtocolError(host + handler, errcode, errmsg,
headers)
return self._parse_response(StringIO.StringIO(response.getBody()),
sock=None)
def request(self, host, handler, request_body, verbose=0):
# issue XML-RPC request
h = self.make_connection(host)
if verbose:
h.set_debuglevel(1)
try:
self.send_request(h, handler, request_body)
self.send_host(h, host)
self.send_user_agent(h)
self.send_content(h, request_body)
response = h.getresponse()
if response.status == 200:
self.verbose = verbose
return self.parse_response(response)
except xmlrpclib.Fault:
raise
except Exception:
# All unexpected errors leave connection in
# a strange state, so we clear it.
self.close()
raise
#discard any response data and raise exception
if (response.getheader("content-length", 0)):
response.read()
raise xmlrpclib.ProtocolError(
host + handler,
response.status, response.reason,
response.msg,
)
def request(self, host, handler, request_body, verbose=None):
# issue XML-RPC request
h = httplib.HTTP(host)
h.putrequest("POST", handler)
# required by HTTP/1.1
h.putheader("Host", host)
# required by XML-RPC
h.putheader("User-Agent", self.user_agent)
h.putheader("Content-Type", "text/xml")
h.putheader("Content-Length", str(len(request_body)))
# basic auth
if self.username is not None and self.password is not None:
h.putheader(
"AUTHORIZATION", "Basic %s" % string.replace(
encodestring("%s:%s" %
(self.username, self.password)), "\012", ""))
h.endheaders()
if request_body:
h.send(request_body)
errcode, errmsg, headers = h.getreply()
print errcode, errmsg, headers
if errcode != 200:
raise xmlrpclib.ProtocolError(host + handler, errcode, errmsg,
headers)
return self.parse_response(h.getfile())
def send_http(self, host, handler="/RPC2"):
if not self.__processed:
raise NotProcessed
self._host = host
if self._connection is None:
raise Exception("No connection object found")
self._connection.connect()
# wrap self data into binary object, otherwise HTTPConnection.request
# will encode it as ISO-8859-1 https://docs.python.org/3/library/http.client.html#httpconnection-objects
self._connection.request(self.method,
handler,
body=bstr(self.data),
headers=self.headers)
response = self._connection.getresponse()
if not self.response_acceptable(response):
raise xmlrpclib.ProtocolError("%s %s" % (self._host, handler),
response.status, response.reason,
response.msg)
# A response object has read() and close() methods, so we can safely
# pass the whole object back
return response.msg, response
def patched_request(self, host, handler, request_body, verbose=0):
req = urllib2.Request(self.uri)
req.add_header('User-Agent', self.user_agent)
req.add_header('Content-Type', 'text/xml')
if hasattr(self, 'accept_gzip_encoding') and \
self.accept_gzip_encoding:
req.add_header('Accept-Encoding', 'gzip')
req.add_data(request_body)
resp = self.opener.open(req, timeout=longer_timeout)
# In Python 2, resp is a urllib.addinfourl instance,
# which does not
# have the getheader method that parse_response expects.
if not hasattr(resp, 'getheader'):
resp.getheader = resp.headers.getheader
if resp.code == 200:
self.verbose = verbose
return self.parse_response(resp)
resp.close()
raise xmlrpclib.ProtocolError(self.uri, resp.status,
resp.reason, resp.msg)
def request(self, host, handler, request_body, verbose=0):
# issue XML-RPC request
h = self.make_connection(host)
if verbose:
h.set_debuglevel(1)
self.send_request(h, handler, request_body)
self.send_host(h, host)
self.send_user_agent(h)
self.send_content(h, request_body)
errcode, errmsg, headers = h.getreply()
if errcode != 200:
raise xmlrpclib.ProtocolError(host + handler, errcode, errmsg,
headers)
self.verbose = verbose
# Here's where we differ from the superclass. It says:
# try:
# sock = h._conn.sock
# except AttributeError:
# sock = None
# return self._parse_response(h.getfile(), sock)
return self.parse_response(h.getfile())
def request(self, *args, **kwargs):
if len(args) == 2:
uri, body = args
handler = uri.path
username = uri.userpass[0]
password = uri.userpass[1]
host = str(uri.hostport.host.name)
full_url = str(uri)
else:
uri, handler, body = args
username = uri._substArgs['user']
password = uri._substArgs['password']
host = uri._substArgs['host']
full_url = uri + handler
verbose = kwargs.get('verbose', 0)
method = util.xmlrpcLoad(body)[1]
self.calls.append((username, password, host, handler, method))
if self.fail:
raise xmlrpclib.ProtocolError(full_url, 500,
'Totally Awesome Error', {})
return ()
def request(self, host, handler, request_body, verbose=0):
'''
Handle the request
'''
host_connection = self.make_connection(host)
if verbose:
host_connection.set_debuglevel(1)
# ADDED: construct the URL and Request object for proper cookie handling
request_url = "%s://%s/" % (self.scheme, host)
cookie_request = urllib2.Request(request_url)
self.send_request(host_connection, handler, request_body)
self.send_host(host_connection, host)
# ADDED. creates cookiejar if None.
self.send_cookies(host_connection, cookie_request)
self.send_user_agent(host_connection)
self.send_content(host_connection, request_body)
errcode, errmsg, headers = host_connection.getreply()
# ADDED: parse headers and get cookies here
class CookieResponse:
'''
fake a response object that we can fill with the headers above
'''
def __init__(self, headers):
self.headers = headers
def info(self):
return self.headers
cookie_response = CookieResponse(headers)
# Okay, extract the cookies from the headers
self.cookiejar.extract_cookies(cookie_response, cookie_request)
# And write back any changes
# DH THIS DOESN'T WORK
# self.cookiejar.save(self.cookiejar.filename)
if errcode != 200:
raise xmlrpclib.ProtocolError(
host + handler,
errcode, errmsg,
headers
)
self.verbose = verbose
try:
sock = host_connection._conn.sock
except AttributeError:
sock = None
return self._parse_response(host_connection.getfile(), sock)
def _check_return(self, host, handler, httpcode, buf):
"""Check for SSL certs validity"""
if httpcode == 60:
raise xmlrpclib.ProtocolError(
host + handler,
httpcode,
"SSL certificate validation failed",
None)
def request(self, host, handler, request_body, verbose=0):
"""
Send a complete request, and parse the response. See xmlrpclib.py.
:Parameters:
host : str
target host
handler : str
RPC handler on server (i.e., path to handler)
request_body : str
XML-RPC request body
verbose : bool/int
debugging flag. Ignored by this implementation
:rtype: dict
:return: parsed response, as key/value pairs
"""
# issue XML-RPC request
result = None
url = 'http://%s%s' % (host, handler)
try:
response = urlfetch.fetch(url,
payload=request_body,
method=urlfetch.POST,
headers={'Content-Type': 'text/xml'})
except:
msg = 'Failed to fetch %s' % url
raise xmlrpclib.ProtocolError(host + handler, 500, msg, {})
if response.status_code != 200:
logging.error('%s returned status code %s' %
(url, response.status_code))
raise xmlrpclib.ProtocolError(host + handler,
response.status_code,
"",
response.headers)
else:
result = self.__parse_response(response.content)
return result
class UrlfetchTransport(xmlrpclib.Transport):
"""Handles an HTTP request to an XML-RPC server using urlfetch."""
PROTOCOL = 'http'
DEBUG_RESPONSE = False
DEBUG_HEADERS = False
# pylint: disable-msg=W0613
# Disable warning for unused argument.
def request(self, host, handler, request_body, verbose=0):
"""Request via urlfetch instead of socket connection.
Args:
host: string hostname.
handler: string '/RPC2', defined in xmlrpclib.
request_body: string XML-RPC request body.
verbose: integer, defined in xmlrpclib, unused here.
Returns:
ServerProxy instance.
Raises:
ProtocolError: if urlfetch.fetch fails or returns an HTTP status
code other than 200.
"""
result = None
url = '%s://%s%s' % (self.PROTOCOL, host, handler)
headers = {
'Content-Type': 'text/xml',
'use_intranet': 'yes',
'X-secureDataConnector-RouteDomain': 'google.com'
}
if self.DEBUG_HEADERS:
headers['X-secureDataConnectorDebug'] = 'text'
try:
response = urlfetch.fetch(url,
payload=request_body,
method=urlfetch.POST,
headers=headers,
deadline=10)
except urlfetch.Error, error:
raise xmlrpclib.ProtocolError(host + handler, 500, error, {})
if response.status_code != 200:
raise xmlrpclib.ProtocolError(host + handler, response.status_code,
'', response.headers)
else:
if response:
if self.DEBUG_RESPONSE:
logging.debug('Response from xmlrpc call: %s',
response.content)
result = self._parse_response(response.content)
else:
logging.warning(
'urlfetch.fetch of %s returned nothing.'
' This may be due to access restrictions'
' in sdc.', url)
return result
