def request(self, host, handler, request_body, verbose):
"""
Make an xmlrpc request.
"""
headers = {
'User-Agent': self.user_agent,
'Content-Type': 'text/xml',
}
url = self._build_url(host, handler)
try:
resp = self.session.post(url,
data=request_body,
headers=headers,
proxies=self.session.proxies)
resp.raise_for_status()
except requests.exceptions.HTTPError as e:
if e.response.status_code == 407: # Proxy Authentication Required
handle_proxy_407(url, self.session)
# Try again
return self.request(host, handler, request_body, verbose)
else:
raise
except requests.exceptions.ConnectionError as e:
# requests isn't so nice here. For whatever reason, https gives this
# error and http gives the above error. Also, there is no status_code
# attribute here. We have to just check if it looks like 407. See
# https://github.com/kennethreitz/requests/issues/2061.
if "407" in str(e): # Proxy Authentication Required
handle_proxy_407(url, self.session)
# Try again
return self.request(host, handler, request_body, verbose)
else:
raise
except requests.RequestException as e:
raise ProtocolError(url, resp.status_code, str(e), resp.headers)
else:
return self.parse_response(resp)
def single_request(self, host, handler, request_body, verbose=False):
try:
proxy = urllib.request.ProxyHandler(
{"http": "http://{}:{}@{}:{}".format(*self.proxy)})
opener = urllib.request.build_opener(proxy)
URL = self.host + "/RPC2"
resp = opener.open(URL, request_body)
if resp.status == 200:
self.verbose = verbose
return self.parse_response(resp)
except Fault as f:
print(f)
raise
except Exception:
self.close()
raise
if resp.getheader("content-length", ""):
resp.read()
raise ProtocolError(host + handler, resp.status, resp.reason,
dict(resp.getheaders()))
def _request_helper(self, url, request_body):
"""
A helper method to assist in making a request and provide a parsed
response.
"""
response = None
# pylint: disable=try-except-raise
try:
response = self.session.post(url,
data=request_body,
**self.request_defaults)
# We expect utf-8 from the server
response.encoding = 'UTF-8'
# update/set any cookies
if self._cookiejar is not None:
for cookie in response.cookies:
self._cookiejar.set_cookie(cookie)
if self._cookiejar.filename is not None:
# Save is required only if we have a filename
self._cookiejar.save()
response.raise_for_status()
return self.parse_response(response)
except requests.RequestException as e:
if not response:
raise
raise ProtocolError(url, response.status_code, str(e),
response.headers)
except Fault:
raise
except Exception:
e = BugzillaError(str(sys.exc_info()[1]))
# pylint: disable=attribute-defined-outside-init
e.__traceback__ = sys.exc_info()[2]
# pylint: enable=attribute-defined-outside-init
raise e
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)
response = h.getresponse()
if response.status != 200:
raise ProtocolError(host + handler, response.status,
response.reason, response.msg.headers)
payload = response.read()
parser, unmarshaller = self.getparser()
parser.feed(payload)
parser.close()
return unmarshaller.close()