def get_stub(self):
if self.stub is None:
self.stub = \
voltha_pb2.VolthaGlobalServiceStub(self.get_channel()) \
if self.global_request else \
voltha_pb2.VolthaLocalServiceStub(self.get_channel())
return self.stub
def test_02_cross_instances_dispatch(self):
def prompt(input_func, text):
val = input_func(text)
return val
def prompt_for_return(text):
return raw_input(text)
# Start the voltha ensemble with a single voltha instance
self._stop_and_remove_all_containers()
sleep(5) # A small wait for the system to settle down
self.start_all_containers()
self.set_rest_endpoint()
# Scale voltha to 3 instances and setup the voltha grpc assigments
self._scale_voltha(3)
sleep(20) # A small wait for the system to settle down
voltha_instances = orch.get_all_instances_of_service(
vcore_svc_name[orch_env], port_name='grpc')
self.assertEqual(len(voltha_instances), 3)
self.ponsim_voltha_stub_local = voltha_pb2.VolthaLocalServiceStub(
self.get_channel(self._get_grpc_address(voltha_instances[2])))
self.ponsim_voltha_stub_global = voltha_pb2.VolthaGlobalServiceStub(
self.get_channel(self._get_grpc_address(voltha_instances[2])))
self.simulated_voltha_stub_local = voltha_pb2.VolthaLocalServiceStub(
self.get_channel(self._get_grpc_address(voltha_instances[1])))
self.simulated_voltha_stub_global = voltha_pb2.VolthaGlobalServiceStub(
self.get_channel(self._get_grpc_address(voltha_instances[1])))
self.empty_voltha_stub_local = voltha_pb2.VolthaLocalServiceStub(
self.get_channel(self._get_grpc_address(voltha_instances[0])))
self.empty_voltha_stub_global = voltha_pb2.VolthaGlobalServiceStub(
self.get_channel(self._get_grpc_address(voltha_instances[0])))
if orch_env == ENV_DOCKER_COMPOSE:
# Prompt the user to start ponsim
# Get the user to start PONSIM as root
prompt(prompt_for_return,
'\nStart PONSIM as root in another window ...')
prompt(prompt_for_return,
'\nEnsure port forwarding is set on ponmgnt ...')
# Test 1:
# A. Get the list of adapters using a global stub
# B. Get the list of adapters using a local stub
# C. Verify that the two lists are the same
adapters_g = self._get_adapters_grpc(self.ponsim_voltha_stub_global)
adapters_l = self._get_adapters_grpc(self.empty_voltha_stub_local)
assert adapters_g == adapters_l
# Test 2:
# A. Provision a pomsim olt using the ponsim_voltha_stub
# B. Enable the posim olt using the simulated_voltha_stub
# C. Wait for onu discovery using the empty_voltha_stub
ponsim_olt = self._provision_ponsim_olt_grpc(
self.ponsim_voltha_stub_local)
ponsim_logical_device_id = self._enable_device_grpc(
self.simulated_voltha_stub_global, ponsim_olt.id)
self._wait_for_onu_discovery_grpc(self.empty_voltha_stub_global,
ponsim_olt.id,
count=4)
# Test 3:
# A. Provision a simulated olt using the simulated_voltha_stub
# B. Enable the simulated olt using the ponsim_voltha_stub
# C. Wait for onu discovery using the empty_voltha_stub
simulated_olt = self._provision_simulated_olt_grpc(
self.simulated_voltha_stub_local)
simulated_logical_device_id = self._enable_device_grpc(
self.ponsim_voltha_stub_global, simulated_olt.id)
self._wait_for_onu_discovery_grpc(self.empty_voltha_stub_global,
simulated_olt.id,
count=4)
# Test 4:
# Verify that we have at least 8 devices created using the global
# REST and also via direct grpc in the empty stub
devices_via_rest = self._list_devices_rest(8)['items']
devices_via_global_grpc = self._get_devices_grpc(
self.empty_voltha_stub_global)
assert len(devices_via_rest) == len(devices_via_global_grpc)
# Test 5:
# A. Create 2 Alarms filters using REST
# B. Ensure it is present across all instances
# C. Ensure when requesting the alarm filters we do not get
# duplicate results
alarm_filter1 = self._create_device_filter_rest(ponsim_olt.id)
alarm_filter2 = self._create_device_filter_rest(simulated_olt.id)
global_filters = self._get_alarm_filters_rest()
filter = self._get_alarm_filters_grpc(self.simulated_voltha_stub_local)
assert global_filters == MessageToDict(filter)
filter = self._get_alarm_filters_grpc(self.ponsim_voltha_stub_local)
assert global_filters == MessageToDict(filter)
filter = self._get_alarm_filters_grpc(self.empty_voltha_stub_local)
assert global_filters == MessageToDict(filter)
filter = self._get_alarm_filters_grpc(self.empty_voltha_stub_global)
assert global_filters == MessageToDict(filter)
# Test 6:
# A. Delete an alarm filter
# B. Ensure that filter is deleted from all instances
self._remove_device_filter_rest(alarm_filter1['id'])
previous_filters = global_filters
global_filters = self._get_alarm_filters_rest()
assert global_filters != previous_filters
filter = self._get_alarm_filters_grpc(self.simulated_voltha_stub_local)
assert global_filters == MessageToDict(filter)
filter = self._get_alarm_filters_grpc(self.ponsim_voltha_stub_local)
assert global_filters == MessageToDict(filter)
filter = self._get_alarm_filters_grpc(self.empty_voltha_stub_local)
assert global_filters == MessageToDict(filter)
filter = self._get_alarm_filters_grpc(self.empty_voltha_stub_global)
assert global_filters == MessageToDict(filter)
# Test 7:
# A. Simulate EAPOL install on ponsim instance using grpc
# B. Validate the flows using global REST
# C. Retrieve the flows from global grpc using empty voltha instance
self._install_eapol_flow_grpc(self.ponsim_voltha_stub_local,
ponsim_logical_device_id)
self._verify_olt_eapol_flow_rest(ponsim_olt.id)
res = self._get_olt_flows_grpc(self.empty_voltha_stub_global,
ponsim_logical_device_id)
# Test 8:
# A. Create xPON objects instance using REST
# B. Ensuring that Channeltermination is present on specific instances
# C. Ensuring that other xPON objects are present in all instances
for item in xpon_scenario:
for key, value in item.items():
_obj_action = [val for val in key.split('-')]
_type_config = obj_type_config[_obj_action[0]]
if _obj_action[1] == "mod":
continue
if _obj_action[0] == "cterm":
if _obj_action[1] == "add":
#Ponsim OLT
self._create_xpon_object_rest(_type_config, value,
ponsim_olt.id)
self._verify_xpon_object_on_device(
_type_config, self.ponsim_voltha_stub_global,
ponsim_olt.id)
self._delete_xpon_object_rest(_type_config, value,
ponsim_olt.id)
#Simulated OLT
self._create_xpon_object_rest(_type_config, value,
simulated_olt.id)
self._verify_xpon_object_on_device(
_type_config, self.simulated_voltha_stub_global,
simulated_olt.id)
self._delete_xpon_object_rest(_type_config, value,
simulated_olt.id)
elif _obj_action[1] == "del":
continue
else:
if _obj_action[1] == "add":
self._create_xpon_object_rest(_type_config, value)
#Checking with Ponsim OLT
self._verify_xpon_object_on_device(
_type_config, self.ponsim_voltha_stub_global)
#Checking with empty instance
self._verify_xpon_object_on_device(
_type_config, self.empty_voltha_stub_global)
#Checking with Simulated OLT
self._verify_xpon_object_on_device(
_type_config, self.simulated_voltha_stub_global)
elif _obj_action[1] == "del":
self._delete_xpon_object_rest(_type_config, value)
def test_02_cross_instances_dispatch(self):
def prompt(input_func, text):
val = input_func(text)
return val
def prompt_for_return(text):
return raw_input(text)
# Start the voltha ensemble with a single voltha instance
self._stop_and_remove_all_containers()
sleep(5) # A small wait for the system to settle down
self.start_all_containers()
self.set_rest_endpoint()
self.set_kafka_endpoint()
# Scale voltha to 3 instances and setup the voltha grpc assigments
self._scale_voltha(3)
sleep(10) # A small wait for the system to settle down
voltha_instances = get_all_instances_of_service(
LOCAL_CONSUL, 'vcore-grpc')
self.assertEqual(len(voltha_instances), 3)
self.ponsim_voltha_stub_local = voltha_pb2.VolthaLocalServiceStub(
self.get_channel(self._get_grpc_address(voltha_instances[2])))
self.ponsim_voltha_stub_global = voltha_pb2.VolthaGlobalServiceStub(
self.get_channel(self._get_grpc_address(voltha_instances[2])))
self.simulated_voltha_stub_local = voltha_pb2.VolthaLocalServiceStub(
self.get_channel(self._get_grpc_address(voltha_instances[1])))
self.simulated_voltha_stub_global = voltha_pb2.VolthaGlobalServiceStub(
self.get_channel(self._get_grpc_address(voltha_instances[1])))
self.empty_voltha_stub_local = voltha_pb2.VolthaLocalServiceStub(
self.get_channel(self._get_grpc_address(voltha_instances[0])))
self.empty_voltha_stub_global = voltha_pb2.VolthaGlobalServiceStub(
self.get_channel(self._get_grpc_address(voltha_instances[0])))
# Prompt the user to start ponsim
# Get the user to start PONSIM as root
prompt(prompt_for_return,
'\nStart PONSIM as root in another window ...')
prompt(prompt_for_return,
'\nEnsure port forwarding is set on ponmgnt ...')
# Test 1:
# A. Get the list of adapters using a global stub
# B. Get the list of adapters using a local stub
# C. Verify that the two lists are the same
adapters_g = self._get_adapters_grpc(self.ponsim_voltha_stub_global)
adapters_l = self._get_adapters_grpc(self.empty_voltha_stub_local)
assert adapters_g == adapters_l
# Test 2:
# A. Provision a pomsim olt using the ponsim_voltha_stub
# B. Enable the posim olt using the simulated_voltha_stub
# C. Wait for onu discovery using the empty_voltha_stub
ponsim_olt = self._provision_ponsim_olt_grpc(
self.ponsim_voltha_stub_local)
ponsim_logical_device_id = self._enable_device_grpc(
self.simulated_voltha_stub_global, ponsim_olt.id)
self._wait_for_onu_discovery_grpc(self.empty_voltha_stub_global,
ponsim_olt.id,
count=4)
# Test 3:
# A. Provision a simulated olt using the simulated_voltha_stub
# B. Enable the simulated olt using the ponsim_voltha_stub
# C. Wait for onu discovery using the empty_voltha_stub
simulated_olt = self._provision_simulated_olt_grpc(
self.simulated_voltha_stub_local)
simulated_logical_device_id = self._enable_device_grpc(
self.ponsim_voltha_stub_global, simulated_olt.id)
self._wait_for_onu_discovery_grpc(self.empty_voltha_stub_global,
simulated_olt.id,
count=4)
# Test 4:
# Verify that we have at least 8 devices created using the global
# REST and also via direct grpc in the empty stub
devices_via_rest = self._list_devices_rest(8)['items']
devices_via_global_grpc = self._get_devices_grpc(
self.empty_voltha_stub_global)
assert len(devices_via_rest) == len(devices_via_global_grpc)
# Test 5:
# A. Create 2 Alarms filters using REST
# B. Ensure it is present across all instances
# C. Ensure when requesting the alarm filters we do not get
# duplicate results
alarm_filter1 = self._create_device_filter_rest(ponsim_olt.id)
alarm_filter2 = self._create_device_filter_rest(simulated_olt.id)
global_filters = self._get_alarm_filters_rest()
filter = self._get_alarm_filters_grpc(self.simulated_voltha_stub_local)
assert global_filters == MessageToDict(filter)
filter = self._get_alarm_filters_grpc(self.ponsim_voltha_stub_local)
assert global_filters == MessageToDict(filter)
filter = self._get_alarm_filters_grpc(self.empty_voltha_stub_local)
assert global_filters == MessageToDict(filter)
filter = self._get_alarm_filters_grpc(self.empty_voltha_stub_global)
assert global_filters == MessageToDict(filter)
# Test 6:
# A. Delete an alarm filter
# B. Ensure that filter is deleted from all instances
self._remove_device_filter_rest(alarm_filter1['id'])
previous_filters = global_filters
global_filters = self._get_alarm_filters_rest()
assert global_filters != previous_filters
filter = self._get_alarm_filters_grpc(self.simulated_voltha_stub_local)
assert global_filters == MessageToDict(filter)
filter = self._get_alarm_filters_grpc(self.ponsim_voltha_stub_local)
assert global_filters == MessageToDict(filter)
filter = self._get_alarm_filters_grpc(self.empty_voltha_stub_local)
assert global_filters == MessageToDict(filter)
filter = self._get_alarm_filters_grpc(self.empty_voltha_stub_global)
assert global_filters == MessageToDict(filter)
# Test 7:
# A. Simulate EAPOL install on ponsim instance using grpc
# B. Validate the flows using global REST
# C. Retrieve the flows from global grpc using empty voltha instance
self._install_eapol_flow_grpc(self.ponsim_voltha_stub_local,
ponsim_logical_device_id)
self._verify_olt_eapol_flow_rest(ponsim_olt.id)
res = self._get_olt_flows_grpc(self.empty_voltha_stub_global,
ponsim_logical_device_id)