def process(self, packet):
"""In this method should be implemented logic of processing
reuqest packet from sender node
@param packet - object of FabnetPacketRequest class
@return object of FabnetPacketResponse
or None for disabling packet response to sender
"""
key = packet.parameters.get('key', None)
replica_count = packet.parameters.get('replica_count', None)
if key is None:
return FabnetPacketResponse(ret_code=RC_ERROR,
ret_message='Key is not found in request packet!')
if replica_count is None:
return FabnetPacketResponse(ret_code=RC_ERROR,
ret_message='Replica count should be passed to GetKeysInfo operation')
self._validate_key(key)
keys = KeyUtils.get_all_keys(key, replica_count)
is_replica = False
ret_keys = []
for key in keys:
long_key = self._validate_key(key)
range_obj = self.operator.ranges_table.find(long_key)
if not range_obj:
logger.warning('[GetKeysInfoOperation] Internal error: No hash range found for key=%s!'%key)
else:
ret_keys.append((key, is_replica, range_obj.node_address))
is_replica = True
return FabnetPacketResponse(ret_parameters={'keys_info': ret_keys})
def process(self, packet):
"""In this method should be implemented logic of processing
reuqest packet from sender node
@param packet - object of FabnetPacketRequest class
@return object of FabnetPacketResponse
or None for disabling packet response to sender
"""
key = packet.parameters.get('key', None)
replica_count = packet.parameters.get('replica_count', None)
if key is None:
return FabnetPacketResponse(ret_code=RC_ERROR,
ret_message='Key is not found in request packet!')
if replica_count is None:
return FabnetPacketResponse(ret_code=RC_ERROR,
ret_message='Replica count should be passed to GetData operation')
self._validate_key(key)
keys = KeyUtils.get_all_keys(key, replica_count)
data = None
checksum = None
is_replica = False
for key in keys:
long_key = self._validate_key(key)
range_obj = self.operator.find_range(long_key)
if not range_obj:
logger.warning('[ClientGetOperation] Internal error: No hash range found for key=%s!'%key)
else:
_, _, node_address = range_obj
resp = self._init_operation(node_address, 'GetDataBlock', {'key': key, 'is_replica': is_replica, \
'user_id': packet.session_id}, sync=True)
if resp.ret_code == RC_PERMISSION_DENIED:
return FabnetPacketResponse(ret_code=RC_PERMISSION_DENIED, ret_message=resp.ret_message)
elif resp.ret_code:
logger.warning('[ClientGetOperation] GetDataBlock error from %s: %s'%(node_address, resp.ret_message))
else:
data = resp.binary_data
checksum = resp.ret_parameters['checksum']
break
is_replica = True
if data is None:
return FabnetPacketResponse(ret_code=RC_NO_DATA, ret_message='No data found!')
return FabnetPacketResponse(binary_data=data, ret_parameters={'checksum': checksum})
def __process_data_block(self, key, raw_data, is_replica=False):
self.__processed_local_blocks += 1
try:
raw_header = raw_data.read(DataBlockHeader.HEADER_LEN)
primary_key, replica_count, checksum, user_id, stored_dt = DataBlockHeader.unpack(raw_header)
if not is_replica:
if key != primary_key:
raise Exception("Primary key is invalid: %s != %s" % (key, primary_key))
data_keys = KeyUtils.get_all_keys(primary_key, replica_count)
if is_replica:
if key not in data_keys:
raise Exception("Replica key is invalid: %s" % key)
except Exception, err:
self.__invalid_local_blocks += 1
logger.error("[RepairDataBlocks] %s" % err)
return
