def test_001_create_home(self):
home_config = {
'device0': {
'type': 'generic_node_image',
'capability': ['Thread', 'WiFi'],
'rcp_mode': True,
},
'device1': {
'type': 'wifi_ap',
'base_image': 'mac80211_ap_image'
}
}
if self.weave_crt_path is not None:
home_config['device0']['capability'].append('Weave')
home_config['device0']['weave_config_file'] = self.weave_crt_path
home_id = self.home.create_home(home_config)
self.assertEqual(home_id, self.home.home_id)
description = self.home.get_home_devices()
generic_node_id = next(node_id
for node_id, desc in description.items()
if desc['type'] == 'generic_node_image')
wifi_ap_id = next(node_id for node_id, desc in description.items()
if desc['type'] == 'wifi_ap')
self.assertIsNotNone(generic_node_id)
self.assertIsNotNone(wifi_ap_id)
sleep_time(self.home.logger, 20,
"waiting for processes to be launched")
self.__verify_process_in_container(generic_node_id, 'otbr-agent')
self.__verify_process_in_container(generic_node_id, 'wpa_supplicant')
if self.weave_crt_path is not None:
self.__verify_process_in_container(generic_node_id, 'nldaemon')
def load_kernel_mac80211_hwsim(radios=DEFAULT_RADIOS):
logger = CirqueLog.get_cirque_logger()
logger.info(
"kernel module mac80211_hwsim is not loaded, loading now...")
ret = utils.host_run(logger,
"modprobe mac80211_hwsim \
radios={}".format(radios))
if ret.returncode != 0:
raise LoadKernelError("unable to load module mac80211_hwsim!!")
utils.sleep_time(logger, 5, "loading mac80211_hwsim module")
def __connect_to_desired_wifi(self, docker_node, ssid, psk):
docker_node.logger.info("connecting to desired ssid: {}".format(ssid))
docker_node.logger.info("flushing wlan0 ip address...")
ret = docker_node.container.exec_run(
"sh -c 'wpa_passphrase {} {} >> \
/etc/wpa_supplicant/wpa_supplicant.conf'".format(ssid, psk))
ret = docker_node.container.exec_run('killall wpa_supplicant')
ret = self.wifi_capability.start_wpa_supplicant_service(docker_node)
self.assertEqual(ret.exit_code, 0)
utils.sleep_time(docker_node.logger, 2, 'restart wpa_supplicant')
self.__request_ip_addr_from_dhcp_server(docker_node)
def client_sample(weave_cert_path):
CirqueLog.setup_cirque_logger()
logger = CirqueLog.get_cirque_logger()
with grpc.insecure_channel('localhost:50051') as channel:
stub = service_pb2_grpc.CirqueServiceStub(channel)
home_id = stub.CreateCirqueHome(
service_pb2.CreateCirqueHomeRequest()).home_id
mount_capability = MountCapability()
mount_capability.mount_pairs.append(
MountPair(host_path=os.path.abspath(os.path.relpath(__file__)),
target_path='/tmp/test'))
device_0_id = stub.CreateCirqueDevice(
service_pb2.CreateCirqueDeviceRequest(
home_id=home_id,
specification=device_pb2.DeviceSpecification(
device_type='test',
base_image='sdk_border_router',
weave_capability=WeaveCapability(
weave_certificate_path=weave_cert_path),
thread_capability=ThreadCapability(),
wifi_capability=WiFiCapability(),
xvnc_capability=XvncCapability(localhost=True),
mount_capability=mount_capability))).device.device_id
device_1_id = stub.CreateCirqueDevice(
service_pb2.CreateCirqueDeviceRequest(
home_id=home_id,
specification=device_pb2.DeviceSpecification(
device_type='mobile',
base_image='mobile_node_image',
interactive_capability=InteractiveCapability(),
lan_access_capability=LanAccessCapability(),
))).device.device_id
device_info = stub.QueryCirqueDevice(
service_pb2.QueryCirqueDeviceRequest(home_id=home_id,
device_id=device_1_id))
logger.info(device_info)
logger.info('Waiting for device to fully launch')
sleep_time(logger, 10)
logs = stub.GetCirqueDeviceLog(
service_pb2.GetCirqueDeviceLogRequest(home_id=home_id,
device_id=device_0_id,
tail=10))
logger.info(logs.log)
stub.StopCirqueDevice(
service_pb2.StopCirqueDeviceRequest(home_id=home_id,
device_id=device_0_id))
stub.StopCirqueDevice(
service_pb2.StopCirqueDeviceRequest(home_id=home_id,
device_id=device_1_id))
stub.StopCirqueHome(service_pb2.StopCirqueHomeRequest(home_id=home_id))
def run(self):
kwargs = {'stdin_open': True, 'cap_add': ['NET_ADMIN']}
if self.container_name:
kwargs.update({'name': self.container_name})
super().run(**kwargs)
self.logger.info('Creating WiFi AP node: {}'.format(self.name))
self.__setup_namespace_networking_env()
self.__setup_network_forward_rules()
self.__update_hostapd_ssid()
self.__update_hostapd_password()
self.__run_hostapd()
self.__run_dnsmasq()
utils.sleep_time(self.logger, 2, "creating WiFi AP node")
def test_002_add_device(self):
device_config = {
'type': 'generic_node_image',
'capability': ['Thread', 'WiFi'],
'rcp_mode': True,
}
if self.weave_crt_path is not None:
device_config['capability'].append('Weave')
device_config['weave_config_file'] = self.weave_crt_path
node_id = self.home.add_device(device_config)
self.assertIsNotNone(node_id)
self.home.logger.info('{}'.format(device_config))
sleep_time(self.home.logger, 20,
"waiting for processes to be launched")
self.__verify_process_in_container(node_id, 'otbr-agent')
self.__verify_process_in_container(node_id, 'wpa_supplicant')