def echo_worker(name, err_queue):
cl = OperatorClient('test_node')
msg = 'Hello, I am %s'%name
for i in xrange(100):
ret_msg = cl.echo(msg)
if ret_msg != msg:
error = '%s != %s'%(ret_msg, msg)
print 'ERROR: %s'%error
err_queue.put(error)
def test_topology_cognition(self):
servers = []
addresses = []
#os.system('rm /tmp/fabnet_topology.db')
try:
for i in range(1900, 1900+NODES_COUNT):
address = '127.0.0.1:%s'%i
if not addresses:
neighbour = None
else:
neighbour = random.choice(addresses)
server = TestServerThread(i, neighbour)
server.start()
servers.append(server)
addresses.append(address)
time.sleep(1.5)
time.sleep(1)
packet = { 'method': 'TopologyCognition',
'sender': None,
'parameters': {}}
packet_obj = FabnetPacketRequest(**packet)
fri_client = FriClient()
addr = random.choice(addresses)
fri_client.call(addr, packet_obj)
time.sleep(1)
operator = OperatorClient('node%s'%addr.split(':')[-1])
home_dir = operator.get_home_dir()
db = SafeJsonFile(os.path.join(home_dir, 'fabnet_topology.db'))
nodes = db.read()
print 'NODES LIST: %s'%str(nodes)
for i in range(1900, 1900+NODES_COUNT):
address = '127.0.0.1:%s'%i
self.assertTrue(nodes.has_key(address))
self.assertTrue(len(nodes[address]['uppers']) >= 2)
self.assertTrue(len(nodes[address]['superiors']) >= 2)
self.assertEqual(nodes[address]['node_name'], 'node%s'%i)
finally:
for server in servers:
if server:
server.stop()
server.join()
time.sleep(1)
def run(self):
os.system('cp ./tests/ks/certs.ca %s'%self.home_dir)
address = '127.0.0.1:%s'%self.port
if self.is_monitor:
node_type = 'TestMonitor'
else:
node_type = 'DHT'
config = {'INIT_DHT_WAIT_NEIGHBOUR_TIMEOUT': 0.1,
'MONITOR_DHT_RANGES_TIMEOUT': 1,
'CHECK_HASH_TABLE_TIMEOUT': 1,
'WAIT_FILE_MD_TIMEDELTA': 0.1,
'WAIT_DHT_TABLE_UPDATE': 0.2}
config.update(self.config)
node = Node('127.0.0.1', self.port, self.home_dir, 'node_%s'%self.port,
ks_path=self.ks_path, ks_passwd=PASSWD, node_type=node_type, config=config)
node.set_auth_key(None)
node.start(self.neighbour)
self.__lock.acquire()
try:
self.operator = OperatorClient('node_%s'%self.port)
self.stopped = False
finally:
self.__lock.release()
while not self.stopped:
time.sleep(0.1)
node.stop()
def test01_ret_struct(self):
proc = OperatorProcess(Operator, None, None, None, None, server_name='test_node')
proc.start()
time.sleep(1)
try:
cl = OperatorClient('test_node')
ret = cl.test_ret_struct('test message', 123456)
self.assertEqual(len(ret), 2)
self.assertEqual(ret[0], 'str_param=test message, int_param=123456')
self.assertEqual(ret[1], {'s':'test message', 'i':123456})
ret = cl.test_object(FabnetPacketRequest(method='TestMethod', parameters={'tst': 213}))
self.assertEqual(ret.ret_code, 0, ret.ret_message)
try:
cl.raise_exception('test exception')
except Exception, err:
from fabnet.core.fri_base import FriException
self.assertEqual(err.__class__, FriException)
self.assertEqual(str(err), 'test exception')
else:
def __init__(self, operations_classes, server_name, key_storage=None, op_auth_key=None):
self.__operations = {}
self.operator_cl = OperatorClient(server_name, op_auth_key)
self.__self_address = self.operator_cl.get_self_address()
home_dir = self.operator_cl.get_home_dir()
self.__key_storage = key_storage
self.__fri_client = FriClient(key_storage)
for op_class in operations_classes:
if not issubclass(op_class, OperationBase):
raise Exception('Class %s does not inherit OperationBase class'%op_class)
logger.debug('registering %s operation class...'% op_class.__name__)
lock = RLock()
operation = op_class(self.operator_cl, self.__fri_client, self.__self_address, home_dir, lock)
operation.get_operation_object = self.__get_operation_object
self.__operations[op_class.get_name()] = operation
def __init__(self, operations_classes, server_name, key_storage=None):
self.__operations = {}
self.__op_stat = None
self.operator_cl = OperatorClient(server_name)
self.__self_address = self.operator_cl.get_self_address()
home_dir = self.operator_cl.get_home_dir()
if key_storage:
cert = key_storage.get_node_cert()
ckey = key_storage.get_node_cert_key()
else:
cert = ckey = None
self.__fri_client = FriClient(bool(cert), cert, ckey)
for op_class in operations_classes:
if not issubclass(op_class, OperationBase):
raise Exception('Class %s does not inherit OperationBase class'%op_class)
logger.debug('registering %s operation class...'% op_class.__name__)
lock = RLock()
operation = op_class(self.operator_cl, self.__fri_client, self.__self_address, home_dir, lock)
self.__operations[op_class.get_name()] = operation
class OperationsManager:
def __init__(self, operations_classes, server_name, key_storage=None):
self.__operations = {}
self.__op_stat = None
self.operator_cl = OperatorClient(server_name)
self.__self_address = self.operator_cl.get_self_address()
home_dir = self.operator_cl.get_home_dir()
if key_storage:
cert = key_storage.get_node_cert()
ckey = key_storage.get_node_cert_key()
else:
cert = ckey = None
self.__fri_client = FriClient(bool(cert), cert, ckey)
for op_class in operations_classes:
if not issubclass(op_class, OperationBase):
raise Exception('Class %s does not inherit OperationBase class'%op_class)
logger.debug('registering %s operation class...'% op_class.__name__)
lock = RLock()
operation = op_class(self.operator_cl, self.__fri_client, self.__self_address, home_dir, lock)
self.__operations[op_class.get_name()] = operation
def set_operation_stat(self, op_stat):
self.__op_stat = op_stat
def process(self, packet, role):
"""process request fabnet packet
@param packet - object of FabnetPacketRequest class
@param role - requestor role (None for disable auth)
"""
t0 = None
try:
rcode = self.operator_cl.register_request(packet.message_id, packet.method, packet.sender)
if rcode == RC_ALREADY_PROCESSED:
return
if packet.method == KEEP_ALIVE_METHOD:
return FabnetPacketResponse(ret_code=rcode)
if self.__op_stat is not None:
t0 = datetime.now()
operation_obj = self.__operations.get(packet.method, None)
if operation_obj is None:
if packet.is_multicast:
#transit packet
self.operator_cl.call_to_neighbours(packet.message_id, packet.method, packet.parameters, packet.is_multicast)
return
else:
raise Exception('Method "%s" does not implemented! Available methods: %s'%(packet.method, self.__operations.keys()))
operation_obj.check_role(role)
packet.role = role
logger.debug('processing %s'%packet)
message_id = packet.message_id
n_packet = operation_obj.before_resend(packet)
if n_packet:
self.operator_cl.call_to_neighbours(message_id, packet.method, packet.parameters, packet.is_multicast)
s_packet = operation_obj.process(packet)
if s_packet:
s_packet.message_id = packet.message_id
s_packet.from_node = self.__self_address
return s_packet
except PermissionDeniedException, err:
return FabnetPacketResponse(from_node=self.__self_address,
message_id=packet.message_id, ret_code=RC_PERMISSION_DENIED,
ret_message='Permission denied!')
except Exception, err:
err_packet = FabnetPacketResponse(from_node=self.__self_address,
message_id=packet.message_id,
ret_code=1, ret_message= '[OpPROC] %s'%err)
logger.write = logger.debug
traceback.print_exc(file=logger)
logger.error('[OperationsManager.process] %s'%err)
return err_packet
def test_discovery_operation(self):
server1 = server2 = server3 = None
#os.system('rm /tmp/fabnet_topology.db')
try:
server1 = TestServerThread(1986)
server1.start()
server2 = TestServerThread(1987, '127.0.0.1:1986')
time.sleep(1.5)
server2.start()
server3 = TestServerThread(1988, '127.0.0.1:1986')
time.sleep(1.5)
server3.start()
time.sleep(2.5)
operator = OperatorClient('node1986')
operator1 = OperatorClient('node1987')
operator2 = OperatorClient('node1988')
self.assertEqual(sorted(operator.get_neighbours(NT_UPPER)), ['127.0.0.1:1987', '127.0.0.1:1988'])
self.assertEqual(sorted(operator.get_neighbours(NT_SUPERIOR)), ['127.0.0.1:1987', '127.0.0.1:1988'])
self.assertEqual(sorted(operator1.get_neighbours(NT_UPPER)), ['127.0.0.1:1986', '127.0.0.1:1988'])
self.assertEqual(sorted(operator1.get_neighbours(NT_SUPERIOR)), ['127.0.0.1:1986', '127.0.0.1:1988'])
self.assertEqual(sorted(operator2.get_neighbours(NT_UPPER)), ['127.0.0.1:1986', '127.0.0.1:1987'])
self.assertEqual(sorted(operator2.get_neighbours(NT_SUPERIOR)), ['127.0.0.1:1986', '127.0.0.1:1987'])
server1.stop()
server1.join()
server1 = None
time.sleep(2)
self.assertEqual(operator1.get_neighbours(NT_UPPER), ['127.0.0.1:1988'])
self.assertEqual(operator1.get_neighbours(NT_SUPERIOR), ['127.0.0.1:1988'])
self.assertEqual(operator2.get_neighbours(NT_UPPER), ['127.0.0.1:1987'])
self.assertEqual(operator2.get_neighbours(NT_SUPERIOR), ['127.0.0.1:1987'])
finally:
try:
if server1:
server1.stop()
server1.join()
except Exception, err:
print 'ERROR while stopping server1: %s'%err
time.sleep(1)
try:
if server2:
server2.stop()
server2.join()
except Exception, err:
print 'ERROR while stopping server2: %s'%err
class TestServerThread(threading.Thread):
def __init__(self, port, home_dir, neighbour=None, is_monitor=False, \
config={}, ks_path='', clear_home=True):
threading.Thread.__init__(self)
if clear_home and os.path.exists(home_dir):
shutil.rmtree(home_dir)
if not os.path.exists(home_dir):
os.mkdir(home_dir)
self.port = port
self.home_dir = home_dir
self.stopped = True
self.operator = None
self.neighbour = neighbour
self.config = config
self.is_monitor = is_monitor
self.ks_path = ks_path
self.ks = None if not ks_path else init_keystore(ks_path, PASSWD)
self.__lock = threading.Lock()
def run(self):
os.system('cp ./tests/ks/certs.ca %s'%self.home_dir)
address = '127.0.0.1:%s'%self.port
if self.is_monitor:
node_type = 'TestMonitor'
else:
node_type = 'DHT'
config = {'INIT_DHT_WAIT_NEIGHBOUR_TIMEOUT': 0.1,
'MONITOR_DHT_RANGES_TIMEOUT': 1,
'CHECK_HASH_TABLE_TIMEOUT': 1,
'WAIT_FILE_MD_TIMEDELTA': 0.1,
'WAIT_DHT_TABLE_UPDATE': 0.2}
config.update(self.config)
node = Node('127.0.0.1', self.port, self.home_dir, 'node_%s'%self.port,
ks_path=self.ks_path, ks_passwd=PASSWD, node_type=node_type, config=config)
node.set_auth_key(None)
node.start(self.neighbour)
self.__lock.acquire()
try:
self.operator = OperatorClient('node_%s'%self.port)
self.stopped = False
finally:
self.__lock.release()
while not self.stopped:
time.sleep(0.1)
node.stop()
def stop(self):
self.stopped = True
self.join()
def wait_oper_status(self, status, errmsg=''):
for i in xrange(20):
if self.get_status() == status:
return
time.sleep(.25)
raise Exception('[%s].wait_oper_status(%s) timeouted! %s'%(self.port, status, errmsg))
def get_range_dir(self):
return os.path.join(self.home_dir, 'dht_range/%s'%FSMappedDHTRange.DBCT_MASTER)
def get_replicas_dir(self):
return os.path.join(self.home_dir, 'dht_range/%s'%FSMappedDHTRange.DBCT_REPLICA)
def get_tmp_dir(self):
return os.path.join(self.home_dir, 'dht_range/%s'%FSMappedDHTRange.DBCT_TEMP)
def get_stat(self):
packet_obj = FabnetPacketRequest(method='NodeStatistic')
client = FriClient(self.ks)
ret_packet = client.call_sync('127.0.0.1:%s'%self.port, packet_obj)
if ret_packet.ret_code != 0:
raise Exception('cant get node statistic. details: %s'%ret_packet.ret_message)
return ret_packet.ret_parameters
def get_status(self):
self.__lock.acquire()
try:
if self.operator is None:
return None
return self.operator.get_status()
finally:
self.__lock.release()
def put_data_block(self, data, key, dbct=FSMappedDHTRange.DBCT_MASTER, user_id_hash='', \
careful_save=False, init_block=False, stored_unixtime=None):
params = {'key': key, 'dbct': dbct, 'user_id_hash': user_id_hash, 'init_block': init_block,\
'carefully_save': careful_save, 'stored_unixtime': stored_unixtime}
req = FabnetPacketRequest(method='PutDataBlock',\
binary_data=data, parameters=params)
client = FriClient(self.ks)
resp = client.call_sync('127.0.0.1:%s'%self.port, req)
return resp
def put(self, data, wait_writes=3, init_block=True, client_ks=None, key=None, replica_count=2):
if not client_ks:
client_ks = self.ks
client = FriClient(client_ks)
params = {'wait_writes_count': wait_writes, 'replica_count': replica_count, \
'init_block': init_block, 'key': key}
data = RamBasedBinaryData(data, 20)
packet_obj = FabnetPacketRequest(method='ClientPutData', parameters=params, binary_data=data, sync=True)
#print '========SENDING DATA BLOCK %s (%s chunks)'%(packet_obj, data.chunks_count())
ret_packet = client.call_sync('127.0.0.1:%s'%self.port, packet_obj)
#print '========SENDED DATA BLOCK'
return ret_packet
def get_keys_info(self, key, replica_count=2):
client = FriClient(self.ks)
packet = FabnetPacketRequest(method='GetKeysInfo', \
parameters={'key': key, 'replica_count': replica_count}, sync=True)
ret_packet = client.call_sync('127.0.0.1:%s'%self.port, packet)
if ret_packet.ret_code != 0:
raise Exception('GetKeysInfo error: %s'%ret_packet.ret_message)
keys_info = ret_packet.ret_parameters['keys_info']
return keys_info
def get_data_block(self, key, dbct=FSMappedDHTRange.DBCT_MASTER, client_ks=None, user_id_hash=''):
params = {'key': key, 'dbct': dbct, 'user_id_hash': user_id_hash}
req = FabnetPacketRequest(method='GetDataBlock', parameters=params)
client = FriClient(client_ks)
resp = client.call_sync('127.0.0.1:%s'%self.port, req)
return resp
def delete(self, key, client_ks=None, replica_count=2):
client = FriClient(client_ks)
params = {'key': key, 'replica_count': replica_count}
packet_obj = FabnetPacketRequest(method='ClientDeleteData', parameters=params, sync=True)
ret_packet = client.call_sync('127.0.0.1:%s'%self.port, packet_obj)
return ret_packet
def check_data_block(self, key, dbct=FSMappedDHTRange.DBCT_MASTER, checksum=None):
client = FriClient(self.ks)
params = {'key': key, 'dbct': dbct, 'checksum': checksum}
packet_obj = FabnetPacketRequest(method='CheckDataBlock', parameters=params)
ret_packet = client.call_sync('127.0.0.1:%s'%self.port, packet_obj)
return ret_packet
def update_user_md(self, user_id_hash, storage_size):
client = FriClient(self.ks)
params = {'user_id_hash': user_id_hash, 'storage_size': storage_size}
packet_obj = FabnetPacketRequest(method='UpdateUserProfile', parameters=params)
ret_packet = client.call_sync('127.0.0.1:%s'%self.port, packet_obj)
return ret_packet
def update_md(self, user_id_hash, add_list, rm_list=[]):
client = FriClient(self.ks)
params = {'user_id_hash': user_id_hash, 'add_list': add_list, 'rm_list': rm_list}
packet_obj = FabnetPacketRequest(method='UpdateMetadata', parameters=params)
ret_packet = client.call_sync('127.0.0.1:%s'%self.port, packet_obj)
return ret_packet
def put_object_part(self, obj_path, data, seek=0, wait_writes=3, init_block=True, client_ks=None, key=None, replica_count=2):
if not client_ks:
client_ks = self.ks
client = FriClient(client_ks)
params = {'wait_writes_count': wait_writes, 'replica_count': replica_count, \
'init_block': init_block, 'key': key, 'obj_path': obj_path, 'seek': seek}
data = RamBasedBinaryData(data, 20)
packet_obj = FabnetPacketRequest(method='PutObjectPart', parameters=params, binary_data=data, sync=True)
#print '========SENDING DATA BLOCK %s (%s chunks)'%(packet_obj, data.chunks_count())
ret_packet = client.call_sync('127.0.0.1:%s'%self.port, packet_obj)
#print '========SENDED DATA BLOCK'
return ret_packet
def get_object_info(self, obj_path, client_ks, req_user_info=True):
params = {'obj_path': obj_path, 'req_user_info': req_user_info}
req = FabnetPacketRequest(method='GetObjectInfo', parameters=params)
client = FriClient(client_ks)
resp = client.call_sync('127.0.0.1:%s'%self.port, req)
return resp
def get(self, key, client_ks=None):
client = FriClient(client_ks)
params = {'key': key, 'replica_count': 2}
packet_obj = FabnetPacketRequest(method='ClientGetData', parameters=params, sync=True)
ret_packet = client.call_sync('127.0.0.1:%s'%self.port, packet_obj)
return ret_packet
class TestServerThread(threading.Thread):
SESSION_ID = 1234322321
def __init__(self, port, home_dir, neighbour=None, is_monitor=False, config={}):
threading.Thread.__init__(self)
self.port = port
self.home_dir = home_dir
self.stopped = True
self.operator = None
self.neighbour = neighbour
self.config = config
self.is_monitor = is_monitor
self.__lock = threading.Lock()
def run(self):
address = '127.0.0.1:%s'%self.port
if self.is_monitor:
node_type = 'Monitor'
else:
node_type = 'DHT'
config = {'WAIT_RANGE_TIMEOUT': 0.1,
'INIT_DHT_WAIT_NEIGHBOUR_TIMEOUT': 0.1,
'MONITOR_DHT_RANGES_TIMEOUT': 1,
'CHECK_HASH_TABLE_TIMEOUT': 1,
'WAIT_FILE_MD_TIMEDELTA': 0.1,
'WAIT_DHT_TABLE_UPDATE': 0.2}
config.update(self.config)
node = Node('127.0.0.1', self.port, self.home_dir, 'node_%s'%self.port,
ks_path=None, ks_passwd=None, node_type=node_type, config=config)
node.start(self.neighbour)
self.__lock.acquire()
try:
self.operator = OperatorClient('node_%s'%self.port)
self.stopped = False
finally:
self.__lock.release()
while not self.stopped:
time.sleep(0.1)
node.stop()
def stop(self):
self.stopped = True
self.join()
def get_stat(self):
packet_obj = FabnetPacketRequest(method='NodeStatistic', sync=True)
client = FriClient()
ret_packet = client.call_sync('127.0.0.1:%s'%self.port, packet_obj)
if ret_packet.ret_code != 0:
raise Exception('cant get node statistic. details: %s'%ret_packet.ret_message)
return ret_packet.ret_parameters
def put_data_block(self, data, key, is_replica=False, npkey=False, user_id=0):
checksum = hashlib.sha1(data).hexdigest()
params = {'key': key, 'checksum': checksum, 'is_replica':is_replica, \
'carefully_save': True, 'replica_count': 2, 'user_id': user_id}
if not npkey:
params['primary_key'] = key
req = FabnetPacketRequest(method='PutDataBlock',\
binary_data=data, sync=True,
parameters=params)
client = FriClient()
resp = client.call_sync('127.0.0.1:%s'%self.port, req)
return resp
def get_data_block(self, key, is_replica=False, user_id=0):
params = {'key': key, 'is_replica':is_replica}
req = FabnetPacketRequest(method='GetDataBlock',\
sync=True, parameters=params)
client = FriClient(session_id=user_id or self.SESSION_ID)
resp = client.call_sync('127.0.0.1:%s'%self.port, req)
if resp.ret_code == constants.RC_NO_DATA:
return None
if resp.ret_code != 0:
raise Exception('GetDataBlock operation failed on %s. Details: %s'%('127.0.0.1:%s'%self.port, resp.ret_message))
return resp.binary_data
def put(self, data, wait_writes=3):
client = FriClient(session_id=self.SESSION_ID)
checksum = hashlib.sha1(data).hexdigest()
params = {'checksum': checksum, 'wait_writes_count': wait_writes, 'replica_count':2}
data = RamBasedBinaryData(data, 20)
packet_obj = FabnetPacketRequest(method='ClientPutData', parameters=params, binary_data=data, sync=True)
#print '========SENDING DATA BLOCK %s (%s chunks)'%(packet_obj, data.chunks_count())
ret_packet = client.call_sync('127.0.0.1:%s'%self.port, packet_obj)
#print '========SENDED DATA BLOCK'
if ret_packet.ret_code != 0:
raise Exception('put data failed: %s'%ret_packet.ret_message)
return ret_packet.ret_parameters['key']
def get(self, key):
client = FriClient(session_id=self.SESSION_ID)
params = {'key': key, 'replica_count': 2}
packet_obj = FabnetPacketRequest(method='ClientGetData', parameters=params, sync=True)
ret_packet = client.call_sync('127.0.0.1:%s'%self.port, packet_obj)
return ret_packet
def delete(self, key, session_id=None):
client = FriClient(session_id=session_id or self.SESSION_ID)
params = {'key': key, 'replica_count': 2}
packet_obj = FabnetPacketRequest(method='ClientDeleteData', parameters=params, sync=True)
ret_packet = client.call_sync('127.0.0.1:%s'%self.port, packet_obj)
return ret_packet
def get_range_dir(self):
stat = self.get_stat()
h_start = stat['DHTInfo']['range_start']
h_end = stat['DHTInfo']['range_end']
return os.path.join(self.home_dir, 'dht_range/%s_%s'%(h_start, h_end))
def get_keys_info(self, key):
client = FriClient(session_id=self.SESSION_ID)
packet = FabnetPacketRequest(method='GetKeysInfo', \
parameters={'key': key, 'replica_count': 2}, sync=True)
ret_packet = client.call_sync('127.0.0.1:%s'%self.port, packet)
keys_info = ret_packet.ret_parameters['keys_info']
return keys_info
def get_replicas_dir(self):
return os.path.join(self.home_dir, 'dht_range/replica_data')
def get_tmp_dir(self):
return os.path.join(self.home_dir, 'dht_range/tmp')
def get_status(self):
self.__lock.acquire()
try:
if self.operator is None:
return None
return self.operator.get_status()
finally:
self.__lock.release()
