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, )]