def process_execution_results(self, response, decoder=None):
self.handle_cql_execution_errors(response)
if not isinstance(response, ResultMessage):
raise cql.InternalError('Query execution resulted in %s!?' %
(response, ))
if response.kind == ResultMessage.KIND_PREPARED:
raise cql.InternalError(
'Query execution resulted in prepared query!?')
self.rs_idx = 0
self.description = None
self.result = []
self.name_info = ()
if response.kind == ResultMessage.KIND_VOID:
self.description = _VOID_DESCRIPTION
elif response.kind == ResultMessage.KIND_SET_KS:
self._connection.keyspace_changed(response.results)
self.description = _VOID_DESCRIPTION
elif response.kind == ResultMessage.KIND_ROWS:
schema = response.results.column_metadata
self.decoder = (decoder or self.default_decoder)(schema)
self.result = response.results.rows
if self.result:
self.get_metadata_info(self.result[0])
else:
raise Exception('unknown response kind %s: %s' %
(response.kind, response))
self.rowcount = len(self.result)
def establish_connection(self):
self.conn_ready = False
s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
s.connect((self.host, self.port))
self.socketf = s.makefile(bufsize=0)
self.sockfd = s
self.open_socket = True
supported = self.wait_for_request(OptionsMessage())
self.supported_cql_versions = supported.cqlversions
self.remote_supported_compressions = supported.options['COMPRESSION']
if self.cql_version:
if self.cql_version not in self.supported_cql_versions:
raise ProgrammingError("cql_version %r is not supported by"
" remote (w/ native protocol). Supported"
" versions: %r"
% (self.cql_version, self.supported_cql_versions))
else:
self.cql_version = self.supported_cql_versions[0]
opts = {}
compresstype = None
if self.compression:
overlap = set(locally_supported_compressions) \
& set(self.remote_supported_compressions)
if len(overlap) == 0:
warn("No available compression types supported on both ends."
" locally supported: %r. remotely supported: %r"
% (locally_supported_compressions,
self.remote_supported_compressions))
else:
compresstype = iter(overlap).next() # choose any
opts['COMPRESSION'] = compresstype
compr, decompr = locally_supported_compressions[compresstype]
# set the decompressor here, but set the compressor only after
# a successful Ready message
self.decompressor = decompr
sm = StartupMessage(cqlversion=self.cql_version, options=opts)
startup_response = self.wait_for_request(sm)
while True:
if isinstance(startup_response, ReadyMessage):
self.conn_ready = True
if compresstype:
self.compressor = compr
break
if isinstance(startup_response, AuthenticateMessage):
self.authenticator = startup_response.authenticator
if self.credentials is None:
raise ProgrammingError('Remote end requires authentication.')
cm = CredentialsMessage(creds=self.credentials)
startup_response = self.wait_for_request(cm)
elif isinstance(startup_response, ErrorMessage):
raise ProgrammingError("Server did not accept credentials. %s"
% startup_response.summarymsg())
else:
raise cql.InternalError("Unexpected response %r during connection setup"
% startup_response)
def prepare_query(self, query):
pquery, paramnames = prepare_query(query)
prepared = self._connection.wait_for_request(PrepareMessage(query=pquery))
if isinstance(prepared, ErrorMessage):
raise cql.Error('Query preparation failed: %s' % prepared.summarymsg())
if prepared.kind != ResultMessage.KIND_PREPARED:
raise cql.InternalError('Query preparation did not result in prepared query')
queryid, colspecs = prepared.results
kss, cfs, names, ctypes = zip(*colspecs)
return PreparedQuery(query, queryid, ctypes, paramnames)
def establish_connection(self):
self.conn_ready = False
s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
s.connect((self.host, self.port))
self.socketf = s.makefile(bufsize=0)
self.sockfd = s
self.open_socket = True
supported = self.wait_for_request(OptionsMessage())
self.supported_cql_versions = supported.cqlversions
self.supported_compressions = supported.options['COMPRESSION']
if self.cql_version:
if self.cql_version not in self.supported_cql_versions:
raise ProgrammingError(
"cql_version %r is not supported by"
" remote (w/ native protocol). Supported"
" versions: %r" %
(self.cql_version, self.supported_cql_versions))
else:
self.cql_version = self.supported_cql_versions[0]
opts = {}
if self.compression:
if self.compression not in self.supported_compressions:
raise ProgrammingError(
"Compression type %r is not supported by"
" remote. Supported compression types: %r" %
(self.compression, self.supported_compressions))
# XXX: Remove this once some compressions are supported
raise NotImplementedError(
"CQL driver does not yet support compression")
opts['COMPRESSION'] = self.compression
sm = StartupMessage(cqlversion=self.cql_version, options=opts)
startup_response = self.wait_for_request(sm)
while True:
if isinstance(startup_response, ReadyMessage):
self.conn_ready = True
break
if isinstance(startup_response, AuthenticateMessage):
self.authenticator = startup_response.authenticator
if self.credentials is None:
raise ProgrammingError(
'Remote end requires authentication.')
cm = CredentialsMessage(creds=self.credentials)
startup_response = self.wait_for_request(cm)
elif isinstance(startup_response, ErrorMessage):
raise ProgrammingError(
"Server did not accept credentials. %s" %
startup_response.summarymsg())
else:
raise cql.InternalError(
"Unexpected response %r during connection setup" %
startup_response)
def read_inet(f):
size = read_byte(f)
addrbytes = f.read(size)
port = read_int(f)
if size == 4:
addrfam = socket.AF_INET
elif size == 16:
addrfam = socket.AF_INET6
else:
raise cql.InternalError("bad inet address: %r" % (addrbytes, ))
return (socket.inet_ntop(addrfam, addrbytes), port)
def read(self, readlen):
data = ''
while readlen > 0:
add = self.sock.recv(readlen)
print '[received %r]' % (add,)
if add == '':
raise cql.InternalError("short read of %s bytes (%s expected)"
% (len(data), len(data) + readlen))
data += add
readlen -= len(add)
return data
def __checksock(self):
if not self.open_socket:
raise cql.InternalError("Cursor belonging to %s has been closed." %
(self.parent_connection, ))
client = self.parent_connection.client
response = client.execute_cql_query(compressed_q,
request_compression)
except InvalidRequestException, ire:
raise cql.ProgrammingError("Bad Request: %s" % ire.why)
except SchemaDisagreementException, sde:
raise cql.IntegrityError(
"Schema versions disagree, (try again later).")
except UnavailableException:
raise cql.OperationalError("Unable to complete request: one or "
"more nodes were unavailable.")
except TimedOutException:
raise cql.OperationalError(
"Request did not complete within rpc_timeout.")
except TApplicationException, tapp:
raise cql.InternalError("Internal application error")
if self._schema_update_needed and isinstance(self.decoder,
SchemaDecoder):
self.decoder.schema = self.__get_schema()
if response.type == CqlResultType.ROWS:
self.result = response.rows
self.rs_idx = 0
self.rowcount = len(self.result)
if self.result:
self.description = self.decoder.decode_description(
self._query_ks, self._query_cf, self.result[0])
if response.type == CqlResultType.INT:
self.result = [(response.num, )]
