def request(self, host, handler, request_body, verbose=0):
# issue XML-RPC request
h = self.make_connection(host)
if verbose:
h.set_debuglevel(1)
tries = 0
atype = None
realm = None
while(tries < 3):
self.send_request(h, handler, request_body)
self.send_host(h, host)
self.send_user_agent(h)
if atype:
# This line will bork if self.setAuthClient has not
# been issued. That is a programming error, fix your code!
auths = self._auth_client.getAuth(atype, realm)
_logger.debug("sending authorization: %s", auths)
h.putheader('Authorization', auths)
self.send_content(h, request_body)
resp = h._conn.getresponse()
# except BadStatusLine, e:
tries += 1
if resp.status == 401:
if 'www-authenticate' in resp.msg:
(atype,realm) = resp.msg.getheader('www-authenticate').split(' ',1)
data1 = resp.read()
if data1:
log.warning("Why have data on a 401 auth. message?")
if realm.startswith('realm="') and realm.endswith('"'):
realm = realm[7:-1]
_logger.debug("Resp: %r %r", resp.version,resp.isclosed(), resp.will_close)
_logger.debug("Want to do auth %s for realm %s", atype, realm)
if atype != 'Basic':
raise ProtocolError(host+handler, 403,
"Unknown authentication method: %s" % atype, resp.msg)
continue # with the outer while loop
else:
raise ProtocolError(host+handler, 403,
'Server-incomplete authentication', resp.msg)
if resp.status != 200:
raise ProtocolError( host + handler,
resp.status, resp.reason, resp.msg )
self.verbose = verbose
try:
sock = h._conn.sock
except AttributeError:
sock = None
return self._parse_response(h.getfile(), sock, resp)
raise ProtocolError(host+handler, 403, "No authentication.",'')
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 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 __has_valid_connection(self, needs_extended_permissions=True):
"""
Checks whether the connection is valid and whether the user
has the required permissions.
"""
if not self.is_valid_connection:
raise ProtocolError(url=self.url,
errcode=404,
errmsg='Not found',
headers=None)
if needs_extended_permissions and self.get_only:
raise ProtocolError(url=self.url,
errcode=401,
errmsg='Authorization Required.',
headers=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)
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 ProtocolError(
host + handler,
errcode, errmsg,
headers
)
self.setCookie(headers.getheaders('set-cookie'))
self.verbose = verbose
try:
sock = h._conn.sock
except AttributeError:
sock = None
return self._parse_response(h.getfile(), sock)
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_content(h, request_body)
response = h.getresponse(buffering=True)
if response.status == 200:
self.verbose = verbose
return self.parse_response(response)
except 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 ProtocolError(
host + handler,
response.status,
response.reason,
response.msg,
)
def request(self, host, handler, request_body, verbose=0):
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 ProtocolError(host + handler, errcode, errmsg, headers)
self.verbose = verbose
try:
sock = h._conn.sock
except AttributeError:
sock = None
# ADDED
self.cookie = headers.get('set-cookie') or self.cookie
logger.debug('CookieTransportHelper, request, cookie=%s' %
(self.cookie, ))
# END ADDED
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)
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 ProtocolError(host + handler, errcode, errmsg, headers)
# do not print the response body
self.verbose = False
return self.parse_response(h.getfile())
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)
resp = h._conn.getresponse()
# TODO: except BadStatusLine, e:
errcode, errmsg, headers = resp.status, resp.reason, resp.msg
if errcode != 200:
raise 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, resp)
def request(self, host, handler, request_body, verbose=0):
'''
Send a complete request, and parse the response.
@param host Target host.
@param handler Target PRC handler.
@param request_body XML-RPC request body.
@param verbose Debugging flag.
@return XML response.
'''
# issue XML-RPC request
self.verbose = verbose
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_auth(h, self.proxy_username, self.proxy_password)
self.send_user_agent(h)
self.send_content(h, request_body)
errcode, errmsg, headers = h.getreply()
if errcode != 200:
raise ProtocolError(host + handler, errcode, errmsg, headers)
return self.parse_response(h.getfile())
def single_request(self, host, handler, request_body, verbose=0):
# Based on Python 2.7's xmllib.Transport.single_request
try:
h = self.make_connection(host)
if verbose:
h.set_debuglevel(1)
self.get_auth_info()
while True:
if six.PY2:
# pylint: disable=no-value-for-parameter
self.send_request(h, handler, request_body)
# pylint: enable=no-value-for-parameter
self.send_host(h, host)
self.send_user_agent(h)
self.send_content(h, request_body)
response = h.getresponse(buffering=True)
else:
self.__send_request(h, host, handler, request_body,
verbose)
response = h.getresponse()
if response.status != 200:
# Must read response (even if it is empty)
# before sending another request.
#
# https://docs.python.org/3/library/http.client.html
# #http.client.HTTPConnection.getresponse
#
# https://pagure.io/freeipa/issue/7752
#
response.read()
if response.status == 401:
if not self._auth_complete(response):
continue
raise ProtocolError(host + handler, response.status,
response.reason, response.msg)
self.verbose = verbose
if not self._auth_complete(response):
continue
return self.parse_response(response)
except gssapi.exceptions.GSSError as e:
self._handle_exception(e)
except RemoteDisconnected:
# keep-alive connection was terminated by remote peer, close
# connection and let transport handle reconnect for us.
self.close()
logger.debug("HTTP server has closed connection (%s)", host)
raise
except BaseException as e:
# Unexpected exception may leave connections in a bad state.
self.close()
logger.debug("HTTP connection destroyed (%s)", host, exc_info=True)
raise
def send_content(self, connection, request_body):
try:
return SafeTransport.send_content(self, connection, request_body)
except socket.error, e:
# BBB: On Python < 2.7, HTTP connection is wrapped
raise ProtocolError(
getattr(connection, '_conn', connection).host, -1,
"Could not connect to server", None)
def values(self, key, channels, start_sec, start_nano, end_sec, end_nano,
count, interpolation):
check_type(key, int, 'INT')
check_type(channels, (list, tuple), 'ARRAY')
for value in [
start_sec, start_nano, end_sec, end_nano, count, interpolation
]:
if not isinstance(value, int):
raise ProtocolError('cr01arc01/cgi-bin/ArchiveDataServer.cgi',
codes.xmlrpc.INTERNAL,
'Internal Server Error', None)
if not 0 <= interpolation <= 4:
raise Fault(codes.archiver.ARGUMENT_ERROR,
'Invalid how={0}'.format(interpolation))
if interpolation != 0:
raise Exception('Only raw interpolation is supported by'
'MockArchiver.')
key = str(key)
self._check_key(key)
archive_data = self._archives[key]['data']
return_data = []
start = start_sec + 1e-9 * start_nano
end = end_sec + 1e-9 * end_nano
for channel in channels:
try:
channel_data = archive_data[channel].copy()
channel_values = channel_data['values']
for index, value in enumerate(channel_values):
time = value['secs'] + 1e-9 * value['nano']
if not start <= time <= end:
channel_values.pop(index)
del channel_values[count:]
except KeyError:
channel_data = {
'count': 1,
'meta': {
'alarm_high': 0.0,
'alarm_low': 0.0,
'disp_high': 10.0,
'disp_low': 0.0,
'prec': 1,
'type': 1,
'units': '<NO DATA>',
'warn_high': 0.0,
'warn_low': 0.0
},
'name': channel,
'type': 1,
'values': []
}
return_data.append(channel_data)
return return_data
def single_request(self, host, handler, request_body, verbose=0):
# Based on Python 2.7's xmllib.Transport.single_request
try:
h = self.make_connection(host)
if verbose:
h.set_debuglevel(1)
self.get_auth_info()
while True:
if six.PY2:
# pylint: disable=no-value-for-parameter
self.send_request(h, handler, request_body)
# pylint: enable=no-value-for-parameter
self.send_host(h, host)
self.send_user_agent(h)
self.send_content(h, request_body)
response = h.getresponse(buffering=True)
else:
self.__send_request(h, host, handler, request_body, verbose)
response = h.getresponse()
if response.status != 200:
if (response.getheader("content-length", 0)):
response.read()
if response.status == 401:
if not self._auth_complete(response):
continue
raise ProtocolError(
host + handler,
response.status, response.reason,
response.msg)
self.verbose = verbose
if not self._auth_complete(response):
continue
return self.parse_response(response)
except gssapi.exceptions.GSSError as e:
self._handle_exception(e)
except RemoteDisconnected:
# keep-alive connection was terminated by remote peer, close
# connection and let transport handle reconnect for us.
self.close()
logger.debug("HTTP server has closed connection (%s)", host)
raise
except BaseException as e:
# Unexpected exception may leave connections in a bad state.
self.close()
logger.debug("HTTP connection destroyed (%s)",
host, exc_info=True)
raise
def _request(self, trans, method, path, uparams, request_body):
"""
@param trans a TCPTransport object
"""
# issue XML-RPC request
max_tries = getattr(trans, "_auth_tries", 3)
tries = 0
host = trans._http_host
h = None
while(tries < max_tries):
resp = None
if not h:
h = trans.make_connection(host)
tries += 1
try:
h.putrequest(method, path+uparams, skip_accept_encoding=1)
trans.send_host(h, host)
trans.send_user_agent(h)
except httplib.CannotSendRequest:
if h: h.close()
continue
if trans._auth_client:
trans._auth_client.putRequest(trans._auth_type, trans._auth_realm,
h, host, path)
trans.send_content(h, request_body)
try:
resp = h.getresponse()
except httplib.BadStatusLine, e:
if e.line and e.line != "''": # BadStatusLine does a repr(line)
# something else, not a broken connection
raise
if h: h.close()
if resp: resp.close()
continue
try:
if trans._auth_client:
aresp = trans._auth_client.parseResponse(resp, trans, host+path)
if resp.status == 401 and aresp:
continue
if resp.status == 401:
raise ProtocolError(host+path, 403,
'Server-incomplete authentication', resp.msg)
except Exception:
if resp: resp.close()
raise
return resp # as is, the whole object, open
def request(self, host, handler, request_body, verbose=0):
self.verbose = verbose
response = self.client.post(handler,
request_body,
content_type="text/xml")
status_code, msg, headers = response.status_code, STATUS_CODE_TEXT.get(
response.status_code, str(response.status_code)), response.items()
if response.status_code != 200:
raise ProtocolError(host + handler, status_code, msg, headers)
return self._parse_response(response.content, None)
def request(self, host, handler, request_body, verbose=False):
parser, unmarshaller = getparser()
response = self.client.post(handler, request_body, 'text/xml')
if response.status_code != 200:
raise ProtocolError(
'%s%s' % (host, handler),
response.status_code,
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,
'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 request(self, host, handler, request_body, verbose=0):
# issue XML-RPC request
try:
h = self.make_connection(host)
if verbose:
h.set_debuglevel(1)
self.send_request(h, handler, request_body)
except httplib.CannotSendRequest:
# try once more..
if h: h.close()
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)
resp = None
try:
resp = h._conn.getresponse()
# TODO: except BadStatusLine, e:
errcode, errmsg, headers = resp.status, resp.reason, resp.msg
if errcode != 200:
raise ProtocolError(host + handler, errcode, errmsg, headers)
self.verbose = verbose
try:
sock = h._conn.sock
except AttributeError:
sock = None
return self._parse_response(resp)
finally:
if resp: resp.close()
def single_request(self, host, handler, request_body, verbose=0):
# This method is almost the same as:
# http://hg.python.org/cpython/file/2.7/Lib/xmlrpclib.py#l1281
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(buffering=True)
## for debugging:
#print(host, handler)
#print(request_body)
#print(response.getheaders())
#print(response.read())
if response.status == 200:
self.verbose = verbose
cookie_header = response.getheader('set-cookie')
if cookie_header: self.__cookie = cookie_header
return self.parse_response(response)
except 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 ProtocolError(
host + handler,
response.status,
response.reason,
response.msg,
)
def single_request(self, host, handler, request_body, verbose=0):
# Based on Python 2.7's xmllib.Transport.single_request
try:
h = SSLTransport.make_connection(self, host)
if verbose:
h.set_debuglevel(1)
while True:
if six.PY2:
# pylint: disable=no-value-for-parameter
self.send_request(h, handler, request_body)
# pylint: enable=no-value-for-parameter
self.send_host(h, host)
self.send_user_agent(h)
self.send_content(h, request_body)
response = h.getresponse(buffering=True)
else:
self.__send_request(h, host, handler, request_body,
verbose)
response = h.getresponse()
if response.status != 200:
if (response.getheader("content-length", 0)):
response.read()
if response.status == 401:
if not self._auth_complete(response):
continue
raise ProtocolError(host + handler, response.status,
response.reason, response.msg)
self.verbose = verbose
if not self._auth_complete(response):
continue
return self.parse_response(response)
except gssapi.exceptions.GSSError as e:
self._handle_exception(e)
finally:
self.close()
def request(self, host, handler, request_body, verbose=0):
"""Make an XMLRPC request.
Uses the configured proxy server to make the connection.
"""
url = urlunparse((self.scheme, host, handler, '', '', ''))
headers = {'Content-type': 'text/xml'}
request = Request(url, request_body, headers)
try:
response = self.opener.open(request, timeout=self.timeout).read()
except HTTPError as he:
raise ProtocolError(request.get_full_url(), he.code, he.msg,
he.hdrs)
else:
traceback_info(response)
# In Python2.6 the api is self._parse_response, in 2.7 it is
# self.parse_response and no longer takes the 'sock' argument
parse = getattr(self, '_parse_response', None)
if parse is not None:
# Compatibility with python 2.6
return parse(StringIO(response), None)
return self.parse_response(StringIO(response))
def request(self, host, handler, request_body, verbose=0):
req = 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)
# 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 ProtocolError(self.uri, resp.status, resp.reason, resp.msg)
def request(self, host, handler, request_body, verbose=0):
"""Make an XMLRPC request.
Uses the configured proxy server to make the connection.
"""
url = urlunparse((self.scheme, host, handler, '', '', ''))
# httplib can raise a UnicodeDecodeError when using a Unicode
# URL, a non-ASCII body and a proxy. http://bugs.python.org/issue12398
url = six.ensure_binary(url)
try:
with override_timeout(self.timeout):
response = urlfetch(
url, method='POST', headers={'Content-Type': 'text/xml'},
data=request_body, cookies=self.cookie_jar,
hooks={'response': repost_on_redirect_hook},
use_proxy=True)
except requests.HTTPError as e:
raise ProtocolError(
url.decode('utf-8'), e.response.status_code, e.response.reason,
e.response.headers)
else:
traceback_info(response.text)
return self.parse_response(BytesIO(response.content))
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()
def request(self, host, handler, request_body, verbose=0):
# Override the xmlrpc request object so we have more control over
# the response and can sift through the response headers.
# 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._conn.getresponse()
if response.status == 200:
self.verbose = verbose
return self.parse_response(response)
except Fault:
raise
except Exception:
# All unexpected errors leave connection in
# a strange state, so we clear it.
h.close()
raise
#discard any response data and raise exception
if (response.getheader("content-length", 0)):
response.read()
raise ProtocolError(
host + handler,
response.status,
response.reason,
response.msg,
)
def request(self, host, handler, request_body, verbose=0):
# issue XML-RPC request
max_tries = getattr(self, "_auth_tries", 3)
tries = 0
atype = None
realm = None
h = None
while (tries < max_tries):
if not h:
h = self.make_connection(host)
if verbose:
h.set_debuglevel(1)
tries += 1
try:
self.send_request(h, handler, request_body)
self.send_host(h, host)
self.send_user_agent(h)
except httplib.CannotSendRequest:
if h: h.close()
continue
if atype:
# This line will bork if self.setAuthClient has not
# been issued. That is a programming error, fix your code!
auths = self._auth_client.getAuth(atype, realm)
h.putheader('Authorization', auths)
self.send_content(h, request_body)
resp = h._conn.getresponse()
# except BadStatusLine, e:
if resp.status == 401:
if 'www-authenticate' in resp.msg:
(atype,
realm) = resp.msg.getheader('www-authenticate').split(
' ', 1)
data1 = resp.read()
if realm.startswith('realm="') and realm.endswith('"'):
realm = realm[7:-1]
# print "Resp:", resp.version,resp.isclosed(), resp.will_close
#print "Want to do auth %s for realm %s" % (atype, realm)
if atype != 'Basic':
raise ProtocolError(
host + handler, 403,
"Unknown authentication method: %s" % atype,
resp.msg)
continue # with the outer while loop
else:
raise ProtocolError(host + handler, 403,
'Server-incomplete authentication',
resp.msg)
if resp.status != 200:
raise ProtocolError(host + handler, resp.status, resp.reason,
resp.msg)
self.verbose = verbose
try:
sock = h._conn.sock
except AttributeError:
sock = None
return self._parse_response(resp)
raise ProtocolError(host + handler, 403, "No authentication", '')
def request(self, path, params=None, data=None, request_type="JSON", callback=None):
""" A complete HTTP request on this side-channel
@param path string path, shall begin with '/'
@param params dictionary of parameters, to be url-encoded (TODO)
@param data raw data, to be encoded according to `request_type`
@param request_type {JSON|...} affects content-type and request method
@param callback function(response) to be called instead of default processor
This function, by default, will process the returned content according
to its "Content-Type". Will raise an exception on 4xx or 5xx errors.
If you want to manipulate the response, do provide a `callback`, where
you can read the status and http headers.
"""
self._logger.debug("request for %s", path)
body = None
content_type = 'text/plain'
uparams = ''
if params:
assert isinstance(params, dict), type(params)
params = params.copy()
for k, v in params.items():
if isinstance(v, unicode):
params[k] = v.encode('utf-8')
uparams = '?'+urllib.urlencode(params)
path = self._base_path + path
if not data:
method = 'GET'
elif request_type == 'JSON':
method = 'POST'
content_type = 'application/json'
body = json.dumps(data, cls=json_helpers.JsonEncoder2)
else:
raise NotImplementedError("Request type: %s" %request_type)
resp = None
saved_content_type = None
try:
conn = self.__session.connections.borrow(self.__session.conn_timeout)
# override the transport , restore later
saved_content_type = conn._transport._content_type
conn._transport._content_type = content_type
resp = self._request(conn._transport, method, path, uparams, body)
if callback:
return callback(resp)
else:
if resp.status == 204:
resp.read() # just in case there is content, in violation of RFC
return True
elif resp.status != 200:
resp.read()
raise ProtocolError(conn.host + path,
resp.status, resp.reason, resp.msg )
return self._decode_response(resp)
finally:
if conn and conn._transport:
conn._transport._content_type = saved_content_type
if resp: resp.close()
self.__session.connections.free(conn)
def values(
self,
key,
channels,
start_sec,
start_nano,
end_sec,
end_nano,
count,
interpolation,
):
check_type(key, int, "INT")
check_type(channels, (list, tuple), "ARRAY")
for value in [
start_sec, start_nano, end_sec, end_nano, count, interpolation
]:
if not isinstance(value, int):
raise ProtocolError(
"cr01arc01/cgi-bin/ArchiveDataServer.cgi",
codes.xmlrpc.INTERNAL,
"Internal Server Error",
None,
)
if not 0 <= interpolation <= 4:
raise Fault(codes.archiver.ARGUMENT_ERROR,
"Invalid how={0}".format(interpolation))
if interpolation != 0:
raise Exception(
"Only raw interpolation is supported by MockArchiver.")
key = str(key)
self._check_key(key)
archive_data = self._archives[key]["data"]
return_data = []
start = start_sec + 1e-9 * start_nano
end = end_sec + 1e-9 * end_nano
for channel in channels:
try:
channel_data = archive_data[channel].copy()
channel_values = channel_data["values"]
for index, value in enumerate(channel_values):
time = value["secs"] + 1e-9 * value["nano"]
if not start <= time <= end:
channel_values.pop(index)
del channel_values[count:]
except KeyError:
channel_data = {
"count": 1,
"meta": {
"alarm_high": 0.0,
"alarm_low": 0.0,
"disp_high": 10.0,
"disp_low": 0.0,
"prec": 1,
"type": 1,
"units": "<NO DATA>",
"warn_high": 0.0,
"warn_low": 0.0,
},
"name": channel,
"type": 1,
"values": [],
}
return_data.append(channel_data)
return return_data
class SideChannel(object):
"""Out of band request, re-using libclient transport
"""
_logger = logging.getLogger('RPC.side-channel')
def __init__(self, session, base_path=""):
assert isinstance(session, Session)
self.__session = session
self._base_path = base_path % session.conn_args
def _request(self, trans, method, path, uparams, request_body):
"""
@param trans a TCPTransport object
"""
# issue XML-RPC request
max_tries = getattr(trans, "_auth_tries", 3)
tries = 0
host = trans._http_host
h = None
while(tries < max_tries):
resp = None
if not h:
h = trans.make_connection(host)
tries += 1
try:
h.putrequest(method, path+uparams, skip_accept_encoding=1)
trans.send_host(h, host)
trans.send_user_agent(h)
except httplib.CannotSendRequest:
if h: h.close()
continue
if trans._auth_client:
trans._auth_client.putRequest(trans._auth_type, trans._auth_realm,
h, host, path)
trans.send_content(h, request_body)
try:
resp = h.getresponse()
except httplib.BadStatusLine, e:
if e.line and e.line != "''": # BadStatusLine does a repr(line)
# something else, not a broken connection
raise
if h: h.close()
if resp: resp.close()
continue
try:
if trans._auth_client:
aresp = trans._auth_client.parseResponse(resp, trans, host+path)
if resp.status == 401 and aresp:
continue
if resp.status == 401:
raise ProtocolError(host+path, 403,
'Server-incomplete authentication', resp.msg)
except Exception:
if resp: resp.close()
raise
return resp # as is, the whole object, open
raise ProtocolError(host+path, 403, "No authentication",'')
def _getExternalBugTrackersAndWatches(self, bug_tracker, bug_watches):
raise ProtocolError(
"http://example.com/", self.error_code, "Borked", "")
