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 = as_string(encodestring(as_bytes(unencoded)))
encoded = encoded.replace('\012', '')
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 request(self, host, handler, request_body, verbose):
"""
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,
cert=self.cert,
verify=self.verify,
timeout=self.timeout)
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 request(self, host, handler, request_body, verbose):
"""
Make an xmlrpc request.
"""
headers = {
'User-Agent': self.user_agent,
#Proxy-Connection': 'Keep-Alive',
#'Content-Range': 'bytes oxy1.0/-1',
'Accept': 'text/xml',
'Content-Type': 'text/xml'
}
url = self._build_url(host, handler)
try:
resp = requests.post(url, data=request_body, headers=headers)
except ValueError:
raise
except Exception:
raise # something went wrong
else:
try:
resp.raise_for_status()
except requests.RequestException as e:
raise xmlrpc.ProtocolError(url, resp.status_code, str(e),
resp.headers)
else:
return self.parse_response(resp)
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)
# print(f"generated url: {# url}")
kwargs = {}
if StrictVersion(requests.__version__) >= StrictVersion('0.8.8'):
kwargs['verify'] = True
else:
if self.use_https:
warnings.warn(
'using https transport but no certificate '
'verification. (Hint: upgrade requests package.)')
try:
resp = requests.post(url,
data=request_body,
headers=headers,
**kwargs)
except ValueError:
raise
except Exception:
raise # something went wrong
else:
try:
resp.raise_for_status()
except requests.RequestException as e:
raise xmlrpc.ProtocolError(url, resp.status_code, str(e),
resp.headers)
else:
return self.parse_response(resp)
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 xmlrpc_client.Fault:
raise
except Exception:
self.close()
raise
#discard any response data and raise exception
if response.getheader("content-length", 0):
response.read()
raise xmlrpc_client.ProtocolError(
host + handler,
response.status,
response.reason,
response.msg,
)
def request(self, host, handler, request_body, verbose):
"""
Make an xmlrpc request.
"""
client = self.session or requests
headers = {
'User-Agent': self.user_agent,
'Content-Type': 'text/xml',
}
url = self._build_url(host, handler)
try:
resp = client.post(url,
data=request_body,
headers=headers,
timeout=self.timeout)
except ValueError:
raise
except Exception:
raise # something went wrong
else:
try:
resp.raise_for_status()
except requests.RequestException as e:
raise xmlrpc.ProtocolError(url, resp.status_code, str(e),
resp.headers)
else:
return self.parse_response(resp)
def request(self, host, handler, request_body, verbose=False):
parser, unmarshaller = self.getparser()
response = self.client.post(handler, request_body, 'text/xml')
if response.status_code != 200:
raise xmlrpclib.ProtocolError(
'%s%s' % (host, handler),
response.status_code,
httplib.responses.get(response.status_code, ''),
dict(response.items()),
)
parser.feed(response.content)
return unmarshaller.close()
def request(self, host, handler, request_body, verbose):
"""
Make an xmlrpc request.
"""
headers = {'User-Agent': self.user_agent}
url = self._build_url(host, handler)
resp = requests.post(url, data=request_body, headers=headers)
try:
resp.raise_for_status()
except requests.RequestException as e:
raise xmlrpc.ProtocolError(url, resp.status_code, str(e),
resp.headers)
else:
return self.parse_response(resp)
def single_request(self, host, handler, request_body, verbose=0):
if "@" in host:
auth_details, host = host.rsplit("@", 1)
self.auth_trac(host, auth_details)
headers = {
"User-Agent": self.user_agent,
"Content-Type": self._content_type
}
if self._extra_headers:
headers.update(dict(self._extra_headers))
response = self.session.get(self.get_url(host, handler),
data=request_body,
headers=headers)
if response.ok:
self.verbose = verbose
return self.parse_response(response)
response.close()
raise client.ProtocolError(host + handler, response.status_codes,
response.reason, "")
def single_request(self, host, handler, request_body, verbose=0):
# issue XML-RPC request
try:
connection = self.send_request(host, handler, request_body, False)
response = connection.getresponse()
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):
"""Replace the xmlrpc request function.
Process xmlrpc request via requests library.
Args:
host: Target host
handler: Target PRC handler.
request_body: XML-RPC request body.
verbose: Debugging flag.
Returns:
Parsed response.
Raises:
RequestException: Error in requests
"""
if verbose:
self._debug()
if not self._check_ssl_cert:
disable_warnings()
headers = {
'User-Agent': self.user_agent,
'Content-Type': 'text/xml',
}
# Need to be done because the schema(http or https) is lost in
# xmlrpc.Transport's init.
if self._use_https:
url = "https://{host}{handler}".format(host=host, handler=handler)
else:
url = "http://{host}{handler}".format(host=host, handler=handler)
# TODO Construct kwargs query instead
try:
if self._authtype == "basic":
response = requests.post(url,
data=request_body,
headers=headers,
verify=self._check_ssl_cert,
auth=HTTPBasicAuth(
self._username, self._password),
proxies=self._proxies)
elif self._authtype == "digest":
response = requests.post(url,
data=request_body,
headers=headers,
verify=self._check_ssl_cert,
auth=HTTPDigestAuth(
self._username, self._password),
proxies=self._proxies)
else:
response = requests.post(url,
data=request_body,
headers=headers,
verify=self._check_ssl_cert,
proxies=self._proxies)
response.raise_for_status()
except RequestException as error:
raise xmlrpc_client.ProtocolError(url, error.message,
traceback.format_exc(),
response.headers)
return self.parse_response(response)
