def __validate_pwd(self, home_dir, ks_pwd):
keystore = ''
for fname in os.listdir(home_dir):
if fname.endswith('.ks'):
keystore = os.path.join(home_dir, fname)
break
if not keystore:
if not ks_pwd:
return
raise Exception('Key storage does not found at %s'%home_dir)
init_keystore(keystore, ks_pwd)
def test01_monitor(self):
client = MongoClient("mongodb://127.0.0.1/%s"%MONITOR_DB)
mgmt_db = client.get_default_database()
up_oper = mgmt_db[DBK_NOTIFICATIONS].find({DBK_NOTIFY_TOPIC: 'UpgradeNodeOperation call'})
self.assertEqual(up_oper.count(), 0)
events = mgmt_db[DBK_NOTIFICATIONS].find({DBK_NOTIFY_TOPIC: 'NodeUp'})
self.assertEqual(events.count(), 3)
#p = subprocess.Popen(['/usr/bin/python', './fabnet_core/bin/fri-caller', 'TopologyCognition', ADDRESSES[0], '{}', 'async'])
key_storage = init_keystore(KS_PATH, KS_PASSWD)
client = FriClient(key_storage)
packet_obj = FabnetPacketRequest(method='TopologyCognition')
ret_code, msg = client.call(ADDRESSES[0], packet_obj)
self.assertEqual(ret_code, 0, msg)
time.sleep(2)
nodes_info = mgmt_db[DBK_NODES].find({})
self.assertEqual(nodes_info.count(), 4)
#for node in nodes_info:
# print node
node_info = mgmt_db[DBK_NODES].find_one({DBK_NODEADDR: ADDRESSES[0]})
self.assertEqual(node_info[DBK_NODEADDR], ADDRESSES[0])
self.assertEqual(node_info[DBK_ID], 'NODE1900')
self.assertTrue(node_info[DBK_STATUS]==1)
self.assertTrue(len(node_info[DBK_UPPERS]) >= 2)
self.assertTrue(node_info[DBK_SUPERIORS] >= 2)
self.assertTrue(float(node_info[DBK_STATISTIC]['SystemInfo']['loadavg_10']) > 0)
def _wait_node(self, node):
idx = None
for i, addr in enumerate(ADDRESSES):
if addr == node:
idx = i
if idx is None:
raise Exception('address %s does not found!'%node)
proc = PROCESSES[idx]
key_storage = init_keystore(KS_PATH, KS_PASSWD)
client = FriClient(key_storage)
while True:
if not os.path.exists('/proc/%s'%proc.pid):
raise Exception('Node process for %s does not found!')
for line in open("/proc/%d/status" % proc.pid).readlines():
if line.startswith("State:"):
status = line.split(":",1)[1].strip().split(' ')[0]
if status == 'Z':
raise Exception('Node died at %s'%node)
packet_obj = FabnetPacketRequest(method='NodeStatistic', sync=True)
ret_packet = client.call_sync(node, packet_obj)
if ret_packet.ret_code:
print ret_packet.ret_message
print 'Node does not init FRI server yet. Waiting it...'
time.sleep(.5)
continue
break
def __init__(self, hostname, port, home_dir, node_name='anonymous_node',
ks_path=None, ks_passwd=None, node_type=None,
bind_host='0.0.0.0', config={}):
self.hostname = hostname
self.bind_host = bind_host
self.port = port
self.home_dir = home_dir
self.node_name = node_name
self.node_type = node_type
self.config = config
self.__auth_key = hashlib.sha1(str(uuid.uuid4())).hexdigest()
config_file = os.path.join(home_dir, CONFIG_FILE_NAME)
Config.load(config_file)
self.config.update(Config.get_config_dict())
if ks_path:
self.keystore = init_keystore(ks_path, ks_passwd)
ca_files = self.keystore.autodetect_ca(home_dir)
if ca_files:
logger.info('CA certificates detected at: %s'%(' '.join(ca_files),))
else:
logger.warning('No one CA certificate autodetected')
else:
self.keystore = None
self.server = None
self.operator_process = None
self.osproc_stat = None
cur_thread = threading.current_thread()
cur_thread.setName('%s-main'%self.node_name)
self.operators_map = {'base': Operator}
self.operators_map.update( PluginsManager.get_operators() )
def __init__(self, hostname, port, home_dir, node_name='anonymous_node', ks_path=None, ks_passwd=None):
self.hostname = hostname
self.port = port
self.home_dir = home_dir
self.node_name = node_name
if ks_path:
self.keystore = init_keystore(ks_path, ks_passwd)
else:
self.keystore = None
self.server = None
def test01_basic(self):
client_ks = init_keystore(USER1_KS, USER_PWD)
nimbus = Nimbus(client_ks, '127.0.0.1:1771')
data_block = 'test data'*1000*10
key = nimbus.put_data_block(data_block)
binary = nimbus.get_data_block(key)
self.assertEqual(data_block, binary.data())
nimbus.delete_data_block(key)
with self.assertRaises(NimbusError):
nimbus.get_data_block(key)
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 __init__(self, hostname, port, home_dir, node_name='anonymous_node',
ks_path=None, ks_passwd=None, node_type=None,
bind_host='0.0.0.0', config={}):
self.hostname = hostname
self.bind_host = bind_host
self.port = port
self.home_dir = home_dir
self.node_name = node_name
self.node_type = node_type
self.config = config
self.oper_client = OperatorClient(self.node_name)
if ks_path:
self.keystore = init_keystore(ks_path, ks_passwd)
else:
self.keystore = None
self.server = None
self.operator_process = None
self.osproc_stat = None
cur_thread = threading.current_thread()
cur_thread.setName('%s-main'%self.node_name)
def _check_stat(self, address):
key_storage = init_keystore(KS_PATH, KS_PASSWD)
client = FriClient(key_storage)
while True:
try:
packet_obj = FabnetPacketRequest(method='NodeStatistic', sync=True)
ret_packet = client.call_sync(address, packet_obj)
if ret_packet.ret_code:
time.sleep(.5)
continue
uppers_balance = int(ret_packet.ret_parameters['NeighboursInfo'][u'uppers_balance'])
superiors_balance = int(ret_packet.ret_parameters['NeighboursInfo'][u'superiors_balance'])
if uppers_balance >= 0 and superiors_balance >= 0:
return
else:
print 'Node %s is not balanced yet! Waiting...'%address
time.sleep(.5)
except Exception, err:
logger.error('ERROR: %s'%err)
raise err
def test_node(self):
try:
server = None
address = '127.0.0.1:1987'
if os.path.exists('/tmp/test_node_stat'):
os.system('rm -rf /tmp/test_node_stat')
os.system('mkdir /tmp/test_node_stat')
os.system('cp ./tests/cert/test_certs.ca /tmp/test_node_stat/')
node = Node('127.0.0.1', 1987, '/tmp/test_node_stat', 'node_stat_test',
ks_path=VALID_STORAGE, ks_passwd=PASSWD, node_type='BASE')
node.start(None)
server = node
time.sleep(1)
packet = { 'method': 'NodeStatistic',
'sender': '',
'parameters': {'reset_op_stat': True, 'test_val': '232eq'},
'sync': True}
packet_obj = FabnetPacketRequest(**packet)
reset_op_stat = packet_obj.bool_get('reset_op_stat')
self.assertEqual(reset_op_stat, True)
self.assertEqual(packet_obj.bool_get('reset_op_stat2', False), False)
with self.assertRaises(FriException):
packet_obj.bool_get('reset_op_stat2')
self.assertEqual(packet_obj.int_get('reset_op_stat'), 1)
self.assertEqual(packet_obj.str_get('reset_op_stat'), 'True')
with self.assertRaises(FriException):
packet_obj.int_get('test_val')
packet_obj.str_get('test_val')
key_storage = init_keystore(VALID_STORAGE, PASSWD)
client = FriClient(key_storage)
self.assertEqual(client.get_session_id(), None)
ret_packet = client.call_sync('127.0.0.1:1987', packet_obj)
self.assertNotEqual(client.get_session_id(), None)
time.sleep(1.5)
packet['parameters']['base_info'] = True
packet_obj = FabnetPacketRequest(**packet)
ret_packet = client.call_sync('127.0.0.1:1987', packet_obj)
self.assertEqual(isinstance(ret_packet, FabnetPacketResponse), True)
self.assertEqual(ret_packet.ret_code, 0, ret_packet.ret_message)
print json.dumps(ret_packet.ret_parameters)
self.assertEqual(ret_packet.ret_parameters['BaseInfo']['node_name'], 'node_stat_test')
self.assertEqual(ret_packet.ret_parameters['BaseInfo']['home_dir'], '/tmp/test_node_stat')
self.assertEqual(ret_packet.ret_parameters['BaseInfo']['node_types'], ['base'])
self.assertEqual(int(ret_packet.ret_parameters['NeighboursInfo']['uppers_balance']), -1)
self.assertEqual(int(ret_packet.ret_parameters['NeighboursInfo']['superiors_balance']), -1)
self.assertTrue(float(ret_packet.ret_parameters['SystemInfo']['loadavg_5']) >= 0)
self.assertTrue(float(ret_packet.ret_parameters['SystemInfo']['loadavg_10']) >= 0)
self.assertTrue(float(ret_packet.ret_parameters['SystemInfo']['loadavg_15']) >= 0)
self.assertTrue(len(ret_packet.ret_parameters['SystemInfo']['core_version'])>0)
self.assertTrue(len(ret_packet.ret_parameters['SystemInfo']['node_version'])>0)
self.assertTrue(len(ret_packet.ret_parameters['SystemInfo']['installed_version'])>0)
self.assertTrue(len(ret_packet.ret_parameters['SystemInfo']['uptime']) > 0)
self.assertTrue(float(ret_packet.ret_parameters['FriAgentWMStat']['workers']) > 0)
self.assertTrue(float(ret_packet.ret_parameters['FriAgentWMStat']['busy']) == 0)
self.assertTrue(float(ret_packet.ret_parameters['OperatorWorkerWMStat']['workers']) > 0)
self.assertTrue(float(ret_packet.ret_parameters['OperatorWorkerWMStat']['busy']) >= 1)
self.assertTrue(float(ret_packet.ret_parameters['OperationsProcessorWMStat']['workers']) > 0)
self.assertTrue(float(ret_packet.ret_parameters['OperationsProcessorWMStat']['busy']) == 0)
self.assertTrue(float(ret_packet.ret_parameters['FriServerProcStat']['threads']) > 0)
self.assertTrue(float(ret_packet.ret_parameters['FriServerProcStat']['memory']) > 1000)
self.assertTrue(float(ret_packet.ret_parameters['OperatorProcStat']['threads']) > 0)
self.assertTrue(float(ret_packet.ret_parameters['OperatorProcStat']['memory']) > 1000)
self.assertTrue(float(ret_packet.ret_parameters['OperationsProcessorProcStat']['threads']) > 0)
self.assertTrue(float(ret_packet.ret_parameters['OperationsProcessorProcStat']['memory']) > 1000)
self.assertTrue(ret_packet.ret_parameters['OperationsProcTime']['NodeStatistic'] > 0)
self.assertEqual(ret_packet.ret_parameters['OperationsProcTime']['TopologyCognition'], 0)
time.sleep(.2)
finally:
if server:
server.stop()
def test01_with_ssl(self):
KeyStorage.install_ca_certs(CA_CERTS)
ks = init_keystore(VALID_STORAGE, PASSWD)
self.__defferent_calls(ks)
