def _apply(self, request_data, expected_response_type=None):
logger.debug("Sending request\n%s", pprint.pformat(request_data))
request_name = request_data.__class__.__name__
message = common_pb2.WireMessage()
message.name = 'org.apache.calcite.avatica.proto.Requests${}'.format(request_name)
message.wrapped_message = request_data.SerializeToString()
body = message.SerializeToString()
headers = {'content-type': 'application/x-google-protobuf'}
response = self._post_request(body, headers)
response_body = response.read()
if response.status != httplib.OK:
logger.debug("Received response\n%s", response_body)
if b'<html>' in response_body:
parse_error_page(response_body)
else:
# assume the response is in protobuf format
parse_error_protobuf(response_body)
raise errors.InterfaceError('RPC request returned invalid status code', response.status)
message = common_pb2.WireMessage()
message.ParseFromString(response_body)
logger.debug("Received response\n%s", message)
if expected_response_type is None:
expected_response_type = request_name.replace('Request', 'Response')
expected_response_type = 'org.apache.calcite.avatica.proto.Responses$' + expected_response_type
if message.name != expected_response_type:
raise errors.InterfaceError('unexpected response type "{}"'.format(message.name))
return message.wrapped_message
def _post_request(self, body, headers):
retry_count = self.max_retries
while True:
logger.debug("POST %s %r %r", self.url.path, body, headers)
try:
self.connection.request('POST',
self.url.path,
body=body,
headers=headers)
response = self.connection.getresponse()
except httplib.HTTPException as e:
if retry_count > 0:
delay = math.exp(-retry_count)
logger.debug(
"HTTP protocol error, will retry in %s seconds...",
delay,
exc_info=True)
self.close()
self.connect()
time.sleep(delay)
retry_count -= 1
continue
raise errors.InterfaceError('RPC request failed', cause=e)
else:
if response.status == httplib.SERVICE_UNAVAILABLE:
if retry_count > 0:
delay = math.exp(-retry_count)
logger.debug(
"Service unavailable, will retry in %s seconds...",
delay,
exc_info=True)
time.sleep(delay)
retry_count -= 1
continue
return response
def _post_request(self, body, headers):
retry_count = self.max_retries
while True:
logger.debug("POST %s %r %r", self.url.geturl(), body, headers)
requestArgs = {'data': body, 'stream': True, 'headers': headers}
if self.auth is not None:
requestArgs.update(auth=self.auth)
if self.verify is not None:
requestArgs.update(verify=self.verify)
try:
response = requests.request('post', self.url.geturl(), **requestArgs)
except requests.HTTPError as e:
if retry_count > 0:
delay = math.exp(-retry_count)
logger.debug("HTTP protocol error, will retry in %s seconds...", delay, exc_info=True)
time.sleep(delay)
retry_count -= 1
continue
raise errors.InterfaceError('RPC request failed', cause=e)
else:
if response.status_code == requests.codes.service_unavailable:
if retry_count > 0:
delay = math.exp(-retry_count)
logger.debug("Service unavailable, will retry in %s seconds...", delay, exc_info=True)
time.sleep(delay)
retry_count -= 1
continue
return response
def connect(self):
"""Opens a HTTP connection to the RPC server."""
logger.debug("Opening connection to %s:%s", self.url.hostname, self.url.port)
try:
self.connection = httplib.HTTPConnection(self.url.hostname, self.url.port)
self.connection.connect()
except (httplib.HTTPException, socket.error) as e:
raise errors.InterfaceError('Unable to connect to the specified service', e)
def _post_request(self, body, headers):
# Create the session if we haven't before
if not self.session:
logger.debug("Creating a new Session")
self.session = requests.Session()
self.session.headers.update(headers)
self.session.stream = True
if self.auth is not None:
self.session.auth = self.auth
retry_count = self.max_retries
while True:
logger.debug("POST %s %r %r", self.url.geturl(), body,
self.session.headers)
requestArgs = {'data': body}
# Setting verify on the Session is not the same as setting it
# as a request arg
if self.verify is not None:
requestArgs.update(verify=self.verify)
try:
response = self.session.post(self.url.geturl(), **requestArgs)
except requests.HTTPError as e:
if retry_count > 0:
delay = math.exp(-retry_count)
logger.debug(
"HTTP protocol error, will retry in %s seconds...",
delay,
exc_info=True)
time.sleep(delay)
retry_count -= 1
continue
raise errors.InterfaceError('RPC request failed', cause=e)
else:
if response.status_code == requests.codes.service_unavailable:
if retry_count > 0:
delay = math.exp(-retry_count)
logger.debug(
"Service unavailable, will retry in %s seconds...",
delay,
exc_info=True)
time.sleep(delay)
retry_count -= 1
continue
return response
def _post_request(self, body, headers):
retry_count = self.max_retries
while True:
logger.debug("POST %s %r %r", self.url.geturl(), body, headers)
try:
if self.auth == "SPNEGO":
#response = requests.request('post', self.url.geturl(), data=body, stream=True, headers=headers, auth=HTTPSPNEGOAuth(mutual_authentication=OPTIONAL))
response = requests.request(
'post',
self.url.geturl(),
data=body,
stream=True,
headers=headers,
auth=HTTPKerberosAuth(
mutual_authentication=OPTIONAL,
mech_oid=kerberos.GSS_MECH_OID_SPNEGO),
timeout=7200)
else:
response = requests.request('post',
self.url.geturl(),
data=body,
stream=True,
headers=headers,
timeout=7200)
except requests.HTTPError as e:
if retry_count > 0:
delay = math.exp(-retry_count)
logger.debug(
"HTTP protocol error, will retry in %s seconds...",
delay,
exc_info=True)
time.sleep(delay)
retry_count -= 1
continue
raise errors.InterfaceError('RPC request failed', cause=e)
else:
if response.status_code == requests.codes.service_unavailable:
if retry_count > 0:
delay = math.exp(-retry_count)
logger.debug(
"Service unavailable, will retry in %s seconds...",
delay,
exc_info=True)
time.sleep(delay)
retry_count -= 1
continue
return response
def _apply(self,
request_data,
expected_response_type=None,
keepalive_callback=None):
logger.debug("Sending request\n%s", pprint.pformat(request_data))
class FakeFloat(float):
# XXX there has to be a better way to do this
def __init__(self, value):
self.value = value
def __repr__(self):
return str(self.value)
def default(obj):
if isinstance(obj, Decimal):
return FakeFloat(obj)
raise TypeError
if self.version >= AVATICA_1_4_0:
body = json.dumps(request_data, default=default)
headers = {'content-type': 'application/json'}
else:
body = None
headers = {'request': json.dumps(request_data, default=default)}
logger.debug("POST %s %r %r", self.url.path, body, headers)
try:
print "pre request"
self.connection.request('POST',
self.url.path,
body=body,
headers=headers)
print "post request"
if keepalive_callback != None:
while True:
print "pre select"
readable, _, _ = select.select([self.connection.sock], [],
[], 0.5)
if readable:
print self.connection.sock
print dir(self.connection.sock)
print "post select"
print "Ready"
break
else:
print "Waiting"
if keepalive_callback() == False:
print "Terminating"
e = Exception()
raise errors.InterfaceError(
"RPC request terminated", cause=e)
# response = None
# print "pre getresponse"
response = self.connection.getresponse()
# print "end getresponse"
except httplib.HTTPException as e:
raise errors.InterfaceError('RPC request failed', cause=e)
# print "before response.read()"
print "Start read"
response_body = response.read()
print "End read"
# print "after response.read()"
if response.status != httplib.OK:
logger.debug("Received response\n%s", response_body)
if '<html>' in response_body:
parse_error_page(response_body)
raise errors.InterfaceError(
'RPC request returned invalid status code', response.status)
noop = lambda x: x
try:
response_data = json.loads(response_body, parse_float=noop)
except ValueError as e:
logger.debug("Received response\n%s", response_body)
raise errors.InterfaceError('valid JSON document', cause=e)
# logger.debug("Received response\n%s", pprint.pformat(response_data))
if 'response' not in response_data:
raise errors.InterfaceError('missing response type')
if expected_response_type is None:
expected_response_type = request_data['request']
if response_data['response'] != expected_response_type:
raise errors.InterfaceError('unexpected response type "{}"'.format(
response_data['response']))
return response_data
