def encode_request(name, job_id, predicate, mapper, combiner_factory, reducer_factory, set_name, 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, set_name, 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_str(set_name)
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, key):
""" Encode request into client_message"""
client_message = ClientMessage(payload_size=calculate_size(name, key))
client_message.set_message_type(REQUEST_TYPE)
client_message.set_retryable(RETRYABLE)
client_message.append_str(name)
client_message.append_data(key)
client_message.update_frame_length()
return client_message
def encode_request(name, value):
""" Encode request into client_message"""
client_message = ClientMessage(payload_size=calculate_size(name, value))
client_message.set_message_type(REQUEST_TYPE)
client_message.set_retryable(RETRYABLE)
client_message.append_str(name)
client_message.append_data(value)
client_message.update_frame_length()
return client_message
def encode_request(name, expected):
""" Encode request into client_message"""
client_message = ClientMessage(payload_size=calculate_size(name, expected))
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.update_frame_length()
return client_message
def encode_request(name, txn_id, thread_id, item):
""" Encode request into client_message"""
client_message = ClientMessage(payload_size=calculate_size(name, txn_id, thread_id, item))
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.update_frame_length()
return client_message
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, 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, 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
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, entry_processor, key, thread_id):
""" Encode request into client_message"""
client_message = ClientMessage(payload_size=calculate_size(name, entry_processor, key, thread_id))
client_message.set_message_type(REQUEST_TYPE)
client_message.set_retryable(RETRYABLE)
client_message.append_str(name)
client_message.append_data(entry_processor)
client_message.append_data(key)
client_message.append_long(thread_id)
client_message.update_frame_length()
return client_message
def encode_request(name, data_list):
""" Encode request into client_message"""
client_message = ClientMessage(payload_size=calculate_size(name, data_list))
client_message.set_message_type(REQUEST_TYPE)
client_message.set_retryable(RETRYABLE)
client_message.append_str(name)
client_message.append_int(len(data_list))
for data_list_item in data_list:
client_message.append_data(data_list_item)
client_message.update_frame_length()
return client_message
def encode_request(name, txn_id, thread_id, item):
""" Encode request into client_message"""
client_message = ClientMessage(payload_size=calculate_size(name, txn_id, thread_id, item))
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.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(value)
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, include_value, listener_flags, local_only):
""" Encode request into client_message"""
client_message = ClientMessage(payload_size=calculate_size(name, key, 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_data(key)
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
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
def encode_request(name, key, thread_id, lease, timeout, reference_id):
""" Encode request into client_message"""
client_message = ClientMessage(payload_size=calculate_size(
name, key, thread_id, lease, timeout, reference_id))
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.append_long(reference_id)
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, 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(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(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(credentials, uuid, owner_uuid, is_owner_connection, client_type, serialization_version, client_hazelcast_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_hazelcast_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.append_str(client_hazelcast_version)
client_message.update_frame_length()
return client_message
