def test02_dht_init_fail(self): server = server1 = None try: home1 = '/tmp/node_1986_home' home2 = '/tmp/node_1987_home' if os.path.exists(home1): shutil.rmtree(home1) os.mkdir(home1) if os.path.exists(home2): shutil.rmtree(home2) os.mkdir(home2) server = TestServerThread(1986, home1) server.start() time.sleep(1) server1 = TestServerThread(1987, home2, neighbour='127.0.0.1:1986', config={'DHT_CYCLE_TRY_COUNT':20, 'ALLOW_USED_SIZE_PERCENTS':0}) server1.start() time.sleep(1.5) self.assertNotEqual(server1.operator.get_status(), DS_NORMALWORK) for i in xrange(3): try: server.operator.split_range(0, 100500) break except Exception, err: time.sleep(.1) time.sleep(.2) server.operator.join_subranges() time.sleep(.2) server1.operator.update_config({'DHT': {'ALLOW_USED_SIZE_PERCENTS':70}}) self.__wait_oper_status(server1, DS_NORMALWORK, server1.operator.get_config()) data_block = 'Hello, fabregas! '*100 checksum = hashlib.sha1(data_block).hexdigest() header1 = DataBlockHeader.pack('0000000000000000000000000000000000000000', 2, checksum) self.assertEqual(len(header1), DataBlockHeader.HEADER_LEN) time.sleep(1) server1.put_data_block(data_block, MAX_HASH/2+100) resp = server1.put_data_block(header1+data_block, MAX_HASH/2+100, npkey=True) self.assertEqual(resp.ret_code, RC_OLD_DATA, resp.ret_message) data = server1.get_data_block(MAX_HASH/2+100) self.assertEqual(data.data(), data_block)
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 """ primary_key = packet.parameters.get('primary_key', None) replica_count = packet.parameters.get('replica_count', None) key = packet.parameters.get('key', None) checksum = packet.parameters.get('checksum', None) is_replica = packet.parameters.get('is_replica', False) user_id = packet.parameters.get('user_id', None) carefully_save = packet.parameters.get('carefully_save', False) if not packet.binary_data: return FabnetPacketResponse(ret_code=RC_ERROR, ret_message='Binary data does not found!') if key is None: return FabnetPacketResponse(ret_code=RC_ERROR, ret_message='key does not found!') key = KeyUtils.to_hex(key) data_list = [] if primary_key: primary_key = KeyUtils.to_hex(primary_key) if replica_count is None: return FabnetPacketResponse(ret_code=RC_ERROR, ret_message='replica count for data block does not found!') if checksum is None: return FabnetPacketResponse(ret_code=RC_ERROR, ret_message='data checksum does not found!') if user_id is None: return FabnetPacketResponse(ret_code=RC_ERROR, ret_message='user_id does not found!') header = DataBlockHeader.pack(primary_key, replica_count, checksum, user_id) data_list.append(header) data_list.append(packet.binary_data) tempfile_path = self.operator.get_tempfile() try: tempfile = TmpFile(tempfile_path, data_list) self.operator.put_data_block(key, tempfile_path, is_replica, carefully_save) except FSHashRangesOldDataDetected, err: return FabnetPacketResponse(ret_code=RC_OLD_DATA, ret_message=str(err))
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 """ if not packet.binary_data: return FabnetPacketResponse(ret_code=RC_ERROR, ret_message='No binary data found!') key = packet.parameters.get('key', None) if key is not None: self._validate_key(key) replica_count = int(packet.parameters.get('replica_count', MIN_REPLICA_COUNT)) wait_writes_count = int(packet.parameters.get('wait_writes_count', 1)) if wait_writes_count <= 0: wait_writes_count = 1 if wait_writes_count > (replica_count+1): return FabnetPacketResponse(ret_code=RC_ERROR, ret_message='Cant waiting more replicas than saving!') if replica_count < MIN_REPLICA_COUNT: return FabnetPacketResponse(ret_code=RC_ERROR, ret_message='Minimum replica count is equal to %s!'%MIN_REPLICA_COUNT) succ_count = 0 carefully_save = True is_replica = False errors = [] local_save = None keys = KeyUtils.generate_new_keys(self.node_name, replica_count, prime_key=key) tempfile_path = self.operator.get_tempfile() tempfile = TmpFile(tempfile_path, packet.binary_data, seek=DataBlockHeader.HEADER_LEN) checksum = tempfile.checksum() header = DataBlockHeader.pack(keys[0], replica_count, checksum, packet.session_id) tempfile.write(header, seek=0) for key in keys: h_range = self.operator.find_range(key) if not h_range: logger.info('[ClientPutOperation] Internal error: No hash range found for key=%s!'%key) else: _, _, node_address = h_range params = {'key': key, 'is_replica': is_replica, 'replica_count': replica_count, 'carefully_save': carefully_save} if succ_count >= wait_writes_count: binary_data_pointer = BinaryDataPointer(tempfile.hardlink(), remove_on_close=True) self._init_operation(node_address, 'PutDataBlock', params, binary_data=binary_data_pointer) else: if self.self_address == node_address and local_save is None: local_save = (key, is_replica) succ_count += 1 else: resp = self._init_operation(node_address, 'PutDataBlock', params, sync=True, binary_data=tempfile.chunks()) if resp.ret_code != RC_OK: logger.error('[ClientPutOperation] PutDataBlock error from %s: %s'%(node_address, resp.ret_message)) errors.append('From %s: %s'%(node_address, resp.ret_message)) else: succ_count += 1 is_replica = True try: if local_save: key, is_replica = local_save self.operator.put_data_block(key, tempfile.file_path(), is_replica, carefully_save) except Exception, err: succ_count -= 1 msg = 'Saving data block to local range is failed: %s'%err logger.error(msg) errors.append(msg)