def encode_request(name): """ Encode request into client_message""" client_message = ClientMessage(payload_size=calculate_size(name)) client_message.set_message_type(REQUEST_TYPE) client_message.set_retryable(RETRYABLE) client_message.append_str(name) client_message.update_frame_length() return client_message
def handle_read(self): self.input_buffer += self.recv(BUFFER_SIZE) self.logger.debug("Read %d bytes", len(self.input_buffer)) # split frames while len(self.input_buffer) > 0: self.logger.debug("Reading the message") complete = self.read_from() if not complete: self.logger.debug("message is not complete") break self._message_handler(self.message) self.message = ClientMessage(buff="")
def __init__(self, address, message_handler): asyncore.dispatcher.__init__(self) self._address = (address.host, address.port) self.logger = logging.getLogger("Connection{%s:%d}" % self._address) self._message_handler = message_handler self.create_socket(socket.AF_INET, socket.SOCK_STREAM) self.endpoint = None self.connect(self._address) self._write_queue = Queue() self._write_queue.put("CB2") self.input_buffer = "" self.message = ClientMessage(buff="")
def encode_request(name, values): """ Encode request into client_message""" client_message = ClientMessage(payload_size=calculate_size(name, values)) client_message.set_message_type(REQUEST_TYPE) client_message.set_retryable(RETRYABLE) client_message.append_str(name) client_message.append_int(len(values)) for values_item in values: client_message.append_data(values_item) client_message.update_frame_length() return client_message
def encode_request(name, uuid, callable, address): """ Encode request into client_message""" client_message = ClientMessage(payload_size=calculate_size(name, uuid, callable, address)) client_message.set_message_type(REQUEST_TYPE) client_message.set_retryable(RETRYABLE) client_message.append_str(name) client_message.append_str(uuid) client_message.append_data(callable) AddressCodec.encode(client_message, address) client_message.update_frame_length() return client_message
RESPONSE_TYPE = 106 RETRYABLE = True def calculate_size(name, from, to): """ Calculates the request payload size""" data_size = 0 data_size += calculate_size_str(name) data_size += INT_SIZE_IN_BYTES data_size += INT_SIZE_IN_BYTES return data_size def encode_request(name, from, to): """ Encode request into client_message""" client_message = ClientMessage(payload_size=calculate_size(name, from, to)) client_message.set_message_type(REQUEST_TYPE) client_message.set_retryable(RETRYABLE) client_message.append_str(name) client_message.append_int(from) client_message.append_int(to) client_message.update_frame_length() return client_message def decode_response(client_message): """ Decode response from client message""" parameters = dict(response=None) response_size = client_message.read_int() response = [] for response_index in xrange(0, response_size):
def encode_request(uuid, partition_id, interrupt): """ Encode request into client_message""" client_message = ClientMessage(payload_size=calculate_size(uuid, partition_id, interrupt)) client_message.set_message_type(REQUEST_TYPE) client_message.set_retryable(RETRYABLE) client_message.append_str(uuid) client_message.append_int(partition_id) client_message.append_bool(interrupt) client_message.update_frame_length() return client_message
def encode_request(transaction_id, thread_id): """ Encode request into client_message""" client_message = ClientMessage( payload_size=calculate_size(transaction_id, thread_id)) client_message.set_message_type(REQUEST_TYPE) client_message.set_retryable(RETRYABLE) client_message.append_str(transaction_id) client_message.append_long(thread_id) client_message.update_frame_length() return client_message
def encode_request(username, password, uuid, owner_uuid, is_owner_connection, client_type, serialization_version): """ Encode request into client_message""" client_message = ClientMessage(payload_size=calculate_size(username, password, uuid, owner_uuid, is_owner_connection, client_type, serialization_version)) client_message.set_message_type(REQUEST_TYPE) client_message.set_retryable(RETRYABLE) client_message.append_str(username) client_message.append_str(password) client_message.append_bool(uuid is None) if uuid is not None: client_message.append_str(uuid) client_message.append_bool(owner_uuid is None) if owner_uuid is not None: client_message.append_str(owner_uuid) client_message.append_bool(is_owner_connection) client_message.append_str(client_type) client_message.append_byte(serialization_version) client_message.update_frame_length() return client_message
def encode_request(transaction_id, thread_id): """ Encode request into client_message""" client_message = ClientMessage(payload_size=calculate_size(transaction_id, thread_id)) client_message.set_message_type(REQUEST_TYPE) client_message.set_retryable(RETRYABLE) client_message.append_str(transaction_id) client_message.append_long(thread_id) client_message.update_frame_length() return client_message
def encode_request(name, entries): """ Encode request into client_message""" client_message = ClientMessage(payload_size=calculate_size(name, entries)) client_message.set_message_type(REQUEST_TYPE) client_message.set_retryable(RETRYABLE) client_message.append_str(name) client_message.append_int(len(entries)) for key, value in entries.iteritems(): client_message.append_data(key) client_message.append_data(val) client_message.update_frame_length() return client_message
def encode_request(name, entries): """ Encode request into client_message""" client_message = ClientMessage(payload_size=calculate_size(name, entries)) client_message.set_message_type(REQUEST_TYPE) client_message.set_retryable(RETRYABLE) client_message.append_str(name) client_message.append_int(len(entries)) for key, value in six.iteritems(entries): client_message.append_data(key) client_message.append_data(value) client_message.update_frame_length() return client_message
def encode_request(name, replica_timestamps, target_replica): """ Encode request into client_message""" client_message = ClientMessage( payload_size=calculate_size(name, replica_timestamps, target_replica)) client_message.set_message_type(REQUEST_TYPE) client_message.set_retryable(RETRYABLE) client_message.append_str(name) client_message.append_int(len(replica_timestamps)) for replica_timestamps_item in replica_timestamps: key = replica_timestamps_item[0] val = replica_timestamps_item[1] client_message.append_str(key) client_message.append_long(val) AddressCodec.encode(client_message, target_replica) client_message.update_frame_length() return client_message
def encode_request(name, new_value): """ Encode request into client_message""" client_message = ClientMessage( payload_size=calculate_size(name, new_value)) client_message.set_message_type(REQUEST_TYPE) client_message.set_retryable(RETRYABLE) client_message.append_str(name) client_message.append_bool(new_value is None) if new_value is not None: client_message.append_data(new_value) client_message.update_frame_length() return client_message
def encode_request(name, key, local_only): """ Encode request into client_message""" client_message = ClientMessage( payload_size=calculate_size(name, key, local_only)) client_message.set_message_type(REQUEST_TYPE) client_message.set_retryable(RETRYABLE) client_message.append_str(name) client_message.append_data(key) client_message.append_bool(local_only) client_message.update_frame_length() return client_message
def encode_request(name, key, value, thread_id, ttl): """ Encode request into client_message""" client_message = ClientMessage(payload_size=calculate_size(name, key, value, thread_id, ttl)) client_message.set_message_type(REQUEST_TYPE) client_message.set_retryable(RETRYABLE) client_message.append_str(name) client_message.append_data(key) client_message.append_data(value) client_message.append_long(thread_id) client_message.append_long(ttl) client_message.update_frame_length() return client_message
def encode_request(name, txn_id, thread_id, predicate): """ Encode request into client_message""" client_message = ClientMessage( payload_size=calculate_size(name, txn_id, thread_id, predicate)) client_message.set_message_type(REQUEST_TYPE) client_message.set_retryable(RETRYABLE) client_message.append_str(name) client_message.append_str(txn_id) client_message.append_long(thread_id) client_message.append_data(predicate) client_message.update_frame_length() return client_message
def encode_request(name, attribute, ordered): """ Encode request into client_message""" client_message = ClientMessage( payload_size=calculate_size(name, attribute, ordered)) client_message.set_message_type(REQUEST_TYPE) client_message.set_retryable(RETRYABLE) client_message.append_str(name) client_message.append_str(attribute) client_message.append_bool(ordered) client_message.update_frame_length() return client_message
def encode_request(name, include_value, listener_flags, local_only): """ Encode request into client_message""" client_message = ClientMessage(payload_size=calculate_size(name, include_value, listener_flags, local_only)) client_message.set_message_type(REQUEST_TYPE) client_message.set_retryable(RETRYABLE) client_message.append_str(name) client_message.append_bool(include_value) client_message.append_int(listener_flags) client_message.append_bool(local_only) client_message.update_frame_length() return client_message
class Connection(asyncore.dispatcher): def __init__(self, address, message_handler): asyncore.dispatcher.__init__(self) self._address = (address.host, address.port) self.logger = logging.getLogger("Connection{%s:%d}" % self._address) self._message_handler = message_handler self.create_socket(socket.AF_INET, socket.SOCK_STREAM) self.endpoint = None self.connect(self._address) self._write_queue = Queue() self._write_queue.put("CB2") self.input_buffer = "" self.message = ClientMessage(buff="") def handle_connect(self): self.logger.debug("Connected to %s", self._address) def handle_read(self): self.input_buffer += self.recv(BUFFER_SIZE) self.logger.debug("Read %d bytes", len(self.input_buffer)) # split frames while len(self.input_buffer) > 0: self.logger.debug("Reading the message") complete = self.read_from() if not complete: self.logger.debug("message is not complete") break self._message_handler(self.message) self.message = ClientMessage(buff="") def read_from(self): if len(self.input_buffer) < INT_SIZE_IN_BYTES: self.logger.debug("Frame size couldn't be read") return False self.message.buffer += self.input_buffer[0:INT_SIZE_IN_BYTES] self.input_buffer = self.input_buffer[INT_SIZE_IN_BYTES:] while len(self.input_buffer) > 0 and not self.message_complete(): to_read = self.message.get_frame_length() - len(self.message.buffer) self.logger.debug("Data to be read %s , buffer size : %s ", to_read, len(self.input_buffer)) if to_read > len(self.input_buffer): self.message.buffer += self.input_buffer self.input_buffer = "" return False else: self.message.buffer += self.input_buffer[:to_read] self.input_buffer = self.input_buffer[to_read:] return True def message_complete(self): return len(self.message.buffer) == self.message.get_frame_length() def handle_write(self): self._initiate_send() def handle_close(self): self.logger.debug("handle_close") self.close() def writable(self): return not self._write_queue.empty() def _initiate_send(self): try: item = self._write_queue.get_nowait() except Empty: return sent = self.send(item) self.logger.debug("Written " + str(sent) + " bytes") # TODO: check if everything was sent def send_message(self, message): message.add_flag(BEGIN_END_FLAG) self._write_queue.put(message.buffer) self._initiate_send()
def encode_request(name, service_name, target): """ Encode request into client_message""" client_message = ClientMessage(payload_size=calculate_size(name, service_name, target)) client_message.set_message_type(REQUEST_TYPE) client_message.set_retryable(RETRYABLE) client_message.append_str(name) client_message.append_str(service_name) AddressCodec.encode(client_message, target) client_message.update_frame_length() return client_message
def encode_request(name, value_list): """ Encode request into client_message""" client_message = ClientMessage( payload_size=calculate_size(name, value_list)) client_message.set_message_type(REQUEST_TYPE) client_message.set_retryable(RETRYABLE) client_message.append_str(name) client_message.append_int(len(value_list)) for value_list_item in value_list: client_message.append_data(value_list_item) client_message.update_frame_length() return client_message
def encode_request(name, start_sequence, min_count, max_count, filter): """ Encode request into client_message""" client_message = ClientMessage(payload_size=calculate_size(name, start_sequence, min_count, max_count, filter)) client_message.set_message_type(REQUEST_TYPE) client_message.set_retryable(RETRYABLE) client_message.append_str(name) client_message.append_long(start_sequence) client_message.append_int(min_count) client_message.append_int(max_count) client_message.append_bool(filter is None) if filter is not None: client_message.append_data(filter) client_message.update_frame_length() return client_message
def encode_request(name, expected, updated): """ Encode request into client_message""" client_message = ClientMessage(payload_size=calculate_size(name, expected, updated)) client_message.set_message_type(REQUEST_TYPE) client_message.set_retryable(RETRYABLE) client_message.append_str(name) client_message.append_bool(expected is None) if expected is not None: client_message.append_data(expected) client_message.append_bool(updated is None) if updated is not None: client_message.append_data(updated) client_message.update_frame_length() return client_message
def encode_request(name, key, thread_id, lease, timeout): """ Encode request into client_message""" client_message = ClientMessage( payload_size=calculate_size(name, key, thread_id, lease, timeout)) client_message.set_message_type(REQUEST_TYPE) client_message.set_retryable(RETRYABLE) client_message.append_str(name) client_message.append_data(key) client_message.append_long(thread_id) client_message.append_long(lease) client_message.append_long(timeout) client_message.update_frame_length() return client_message
def encode_request(credentials, uuid, owner_uuid, is_owner_connection, client_type, serialization_version): """ Encode request into client_message""" client_message = ClientMessage( payload_size=calculate_size( credentials, uuid, owner_uuid, is_owner_connection, client_type, serialization_version ) ) client_message.set_message_type(REQUEST_TYPE) client_message.set_retryable(RETRYABLE) client_message.append_data(credentials) client_message.append_bool(uuid is None) if uuid is not None: client_message.append_str(uuid) client_message.append_bool(owner_uuid is None) if owner_uuid is not None: client_message.append_str(owner_uuid) client_message.append_bool(is_owner_connection) client_message.append_str(client_type) client_message.append_byte(serialization_version) client_message.update_frame_length() return client_message
def encode_request(name, txn_id, thread_id, item, timeout): """ Encode request into client_message""" client_message = ClientMessage(payload_size=calculate_size(name, txn_id, thread_id, item, timeout)) client_message.set_message_type(REQUEST_TYPE) client_message.set_retryable(RETRYABLE) client_message.append_str(name) client_message.append_str(txn_id) client_message.append_long(thread_id) client_message.append_data(item) client_message.append_long(timeout) client_message.update_frame_length() return client_message
def encode_request(name, service_name): """ Encode request into client_message""" client_message = ClientMessage( payload_size=calculate_size(name, service_name)) client_message.set_message_type(REQUEST_TYPE) client_message.set_retryable(RETRYABLE) client_message.append_str(name) client_message.append_str(service_name) client_message.update_frame_length() return client_message
def encode_request(map_name, cache_name, predicate, batch_size, buffer_size, delay_seconds, populate, coalesce): """ Encode request into client_message""" client_message = ClientMessage(payload_size=calculate_size(map_name, cache_name, predicate, batch_size, buffer_size, delay_seconds, populate, coalesce)) client_message.set_message_type(REQUEST_TYPE) client_message.set_retryable(RETRYABLE) client_message.append_str(map_name) client_message.append_str(cache_name) client_message.append_data(predicate) client_message.append_int(batch_size) client_message.append_int(buffer_size) client_message.append_long(delay_seconds) client_message.append_bool(populate) client_message.append_bool(coalesce) client_message.update_frame_length() return client_message
def encode_request(name, overflow_policy, value): """ Encode request into client_message""" client_message = ClientMessage( payload_size=calculate_size(name, overflow_policy, value)) client_message.set_message_type(REQUEST_TYPE) client_message.set_retryable(RETRYABLE) client_message.append_str(name) client_message.append_int(overflow_policy) client_message.append_data(value) client_message.update_frame_length() return client_message
def encode_request(name, job_id, predicate, mapper, combiner_factory, reducer_factory, key_value_source, chunk_size, keys, topology_changed_strategy): """ Encode request into client_message""" client_message = ClientMessage(payload_size=calculate_size(name, job_id, predicate, mapper, combiner_factory, reducer_factory, key_value_source, chunk_size, keys, topology_changed_strategy)) client_message.set_message_type(REQUEST_TYPE) client_message.set_retryable(RETRYABLE) client_message.append_str(name) client_message.append_str(job_id) client_message.append_bool(predicate is None) if predicate is not None: client_message.append_data(predicate) client_message.append_data(mapper) client_message.append_bool(combiner_factory is None) if combiner_factory is not None: client_message.append_data(combiner_factory) client_message.append_bool(reducer_factory is None) if reducer_factory is not None: client_message.append_data(reducer_factory) client_message.append_data(key_value_source) client_message.append_int(chunk_size) client_message.append_bool(keys is None) if keys is not None: client_message.append_int(len(keys)) for keys_item in keys: client_message.append_data(keys_item) client_message.append_bool(topology_changed_strategy is None) if topology_changed_strategy is not None: client_message.append_str(topology_changed_strategy) client_message.update_frame_length() return client_message
def encode_request(name, keys, replace_existing_values): """ Encode request into client_message""" client_message = ClientMessage(payload_size=calculate_size(name, keys, replace_existing_values)) client_message.set_message_type(REQUEST_TYPE) client_message.set_retryable(RETRYABLE) client_message.append_str(name) client_message.append_int(len(keys)) for keys_item in keys: client_message.append_data(keys_item) client_message.append_bool(replace_existing_values) client_message.update_frame_length() return client_message
def encode_request(name, key, predicate, local_only): """ Encode request into client_message""" client_message = ClientMessage(payload_size=calculate_size(name, key, predicate, local_only)) client_message.set_message_type(REQUEST_TYPE) client_message.set_retryable(RETRYABLE) client_message.append_str(name) client_message.append_data(key) client_message.append_data(predicate) client_message.append_bool(local_only) client_message.update_frame_length() return client_message
def encode_request(name, uuid, callable, partition_id): """ Encode request into client_message""" client_message = ClientMessage( payload_size=calculate_size(name, uuid, callable, partition_id)) client_message.set_message_type(REQUEST_TYPE) client_message.set_retryable(RETRYABLE) client_message.append_str(name) client_message.append_str(uuid) client_message.append_data(callable) client_message.append_int(partition_id) client_message.update_frame_length() return client_message