def test_ros_config_ssh_authorized_keys(ros_kvm_init, cloud_config_url): kwargs = dict(cloud_config='{url}default.yml'.format(url=cloud_config_url), is_install_to_hard_drive=True) tuple_return = ros_kvm_init(**kwargs) client = tuple_return[0] output_get_ssh_authkey = executor(client, 'sudo ros config get ssh_authorized_keys') output_cat_ssh_authkey = executor(client, 'cat ~/.ssh/authorized_keys') assert (output_cat_ssh_authkey in output_get_ssh_authkey)
def test_cli_config_merge(ros_kvm_init, cloud_config_url): kwargs = dict(cloud_config='{url}default.yml'.format(url=cloud_config_url), is_install_to_hard_drive=True) tuple_return = ros_kvm_init(**kwargs) client = tuple_return[0] c_set_console = ''' echo "#cloud-config" >> config.yml echo "rancher: " >> config.yml echo " console: debian" >> config.yml ''' executor(client, c_set_console) executor(client, 'cat config.yml | sudo ros config merge') output_get_console = executor(client, 'sudo ros config get rancher.console') assert ('debian' in output_get_console) c_set_debug = ''' echo "#cloud-config" >> config1.yml echo "rancher: " >> config1.yml echo " debug: true" >> config1.yml ''' executor(client, c_set_debug) executor(client, 'sudo ros config merge -i config1.yml') output_get_debug = executor(client, 'sudo ros config get rancher.debug') assert ('true' in output_get_debug)
def test_network_from_url(ros_kvm_init, cloud_config_url): kwargs = dict( cloud_config='{url}default.yml'.format(url=cloud_config_url), is_install_to_hard_drive=True, extra_install_args= ' --append "rancher.cloud_init.datasources=[url:{datasource_url}]"'. format(datasource_url=data_source_url), is_network_gist=True) tuple_return = ros_kvm_init(**kwargs) client = tuple_return[0] output_br0 = executor(client, 'ip addr show br0 ; echo $?') assert ('0' in output_br0) output_br0_100 = executor(client, 'ip addr show br0.100') assert ('inet 123.123.123.123' in output_br0_100) output_eth1_100 = executor(client, 'ip addr show eth1.100') assert ('master br0' in output_eth1_100) c_get_dns = 'cat /etc/resolv.conf' output_dns = executor(client, c_get_dns) client.close() assert ('search mydomain.com example.com' in output_dns) assert ('nameserver 208.67.222.123' in output_dns) assert ('nameserver 208.67.220.123' in output_dns)
def test_zfs(ros_kvm_init, cloud_config_url): kwargs = dict(cloud_config='{url}default.yml'.format(url=cloud_config_url), is_install_to_hard_drive=True, is_second_hd=True) tuple_return = ros_kvm_init(**kwargs) client = tuple_return[0] c_enable_zfs = 'sudo ros service enable zfs && \ sudo ros service up zfs' executor(client, c_enable_zfs, 1800) o_ls_zfs_mod = executor(client, 'lsmod | grep zfs') assert ('zfs' in o_ls_zfs_mod) # Creating ZFS pools c_create_zfs_pools = 'sudo zpool create zpool1 -m /mnt/zpool1 /dev/vdb && \ sudo cp /etc/* /mnt/zpool1 && \ docker run --rm -it -v /mnt/zpool1/:/data alpine ls -la /data' # ZFS storage for Docker on RancherOS c_use_zfs = 'sudo system-docker stop docker && \ sudo rm -rf /var/lib/docker/* && \ sudo zfs create zpool1/docker && \ sudo zfs list -o name,mountpoint,mounted && \ sudo ros config set rancher.docker.storage_driver "zfs" && \ sudo ros config set rancher.docker.graph /mnt/zpool1/docker && \ sudo system-docker start docker && \ sleep 5' executor(client, c_create_zfs_pools) executor(client, c_use_zfs) o_zpool_ls = executor(client, 'sudo zpool list') o_zfs_ls = executor(client, 'sudo zfs list') o_docker_storage_driver = executor(client, 'docker info --format "{{json .Driver}}"') assert ('zpool1' in o_zpool_ls and 'zpool1' in o_zfs_ls) assert ('zfs' in o_docker_storage_driver)
def test_network_boot_and_cloud_cfg(ros_kvm_init, cloud_config_url): kwargs = dict( cloud_config='{url}test_network_boot_and_cloudcfg.yml'.format( url=cloud_config_url), is_install_to_hard_drive=True, extra_install_args= '--append "rancher.network.interfaces.eth1.address=10.1.0.52/24 ' 'rancher.network.interfaces.eth1.gateway=10.1.0.2 ' 'rancher.network.interfaces.eth0.dhcp=true ' 'rancher.network.interfaces.eth3.dhcp=true"', is_network_gist=True) tuple_return = ros_kvm_init(**kwargs) client = tuple_return[0] # This shows that the boot cmdline wins over the cloud-config output_eth1_ip = executor(client, 'ip address show eth1') assert ('inet 10.1.0.52/24' in output_eth1_ip) output_eth1_gw = executor(client, 'ip route show dev eth1') assert ('default via 10.1.0.2' in output_eth1_gw) output_eth2_ip = executor(client, 'ip address show eth2') assert ('inet 10.31.168.85/24' in output_eth2_ip) # Known issue https://github.com/rancher/os/issues/2587 # output_eth2_gw = executor(client, 'ip route show dev eth2') # assert ('default via 10.31.168.1' in output_eth2_gw) output_eth3_ip = executor(client, 'ip address show eth3') client.close() assert ('inet 192.168.122' in output_eth3_ip)
def test_network_from_cloud_cfg(ros_kvm_init, cloud_config_url): kwargs = dict(cloud_config='{url}test_network_from_cloudcfg.yml'.format( url=cloud_config_url), is_install_to_hard_drive=True, is_network_gist=True) tuple_return = ros_kvm_init(**kwargs) client = tuple_return[0] # Verify vlan output_eth1_100 = executor(client, 'ip address show eth1.100') assert ('eth1.100@eth1' in output_eth1_100) output_foobar = executor(client, 'ip address show foobar') assert ('foobar@eth1' in output_foobar) # Verify Bridging output_eth2 = executor(client, 'ip address show eth2') assert ('master br0' in output_eth2) output_br0 = executor(client, 'ip address show br0') assert ('inet 192.168.122' in output_br0) # Verify mtu output_mtu = executor(client, 'ip address show bond0') assert ('mtu 1450' in output_mtu) # Verify NIC bonding output_bond0 = executor(client, 'ip address show bond0') assert ('inet 192.168.122.252' in output_bond0) output_bond_mode = executor(client, 'cat /sys/class/net/bond0/bonding/mode') assert ('active-backup 1' in output_bond_mode) output_eth3 = executor(client, 'ip address show eth3') assert ('master bond0' in output_eth3) output_eth4 = executor(client, 'ip address show eth4') client.close() assert ('master bond0' in output_eth4)
def test_preload(ros_kvm_init, cloud_config_url): kwargs = dict(cloud_config='{url}default.yml'.format(url=cloud_config_url), is_install_to_hard_drive=True) tuple_return = ros_kvm_init(**kwargs) client = tuple_return[0] ip = tuple_return[1] c_com_img = 'wait-for-docker \ && docker pull busybox \ && sudo docker save -o /var/lib/rancher/preload/system-docker/busybox.tar busybox \ && sudo gzip /var/lib/rancher/preload/system-docker/busybox.tar \ && sudo system-docker pull alpine \ && sudo system-docker save -o /var/lib/rancher/preload/docker/alpine.tar alpine' executor(client, c_com_img) c_ls_sys_docker_img = 'test -f /var/lib/rancher/preload/system-docker/busybox.tar.gz ; ' \ 'echo $?' output_sys_docker = executor(client, c_ls_sys_docker_img).replace('\n', '') assert ('0' == output_sys_docker) c_ls_user_docker_img = 'test -f /var/lib/rancher/preload/docker/alpine.tar ; ' \ 'echo $?' output_user_docker = executor(client, c_ls_user_docker_img).replace('\n', '') assert ('0' == output_user_docker) executor(client, 'sudo reboot') second_client = connection(ip, seconds=30) output_sys_docker = executor(second_client, 'sudo system-docker images | grep busybox') assert ('busybox' in output_sys_docker) time.sleep(10) output_user_docker = executor(second_client, 'docker images | grep alpine') assert ('alpine' in output_user_docker)
def test_modules(ros_kvm_init): command = 'lsmod | grep btrfs' kwargs = dict(is_kernel_parameters=True, kernel_parameters='rancher.state.dev=LABEL=RANCHER_STATE rancher.modules=[btrfs] rancher.state.autoformat=[/dev/sda,/dev/vda]') tuple_return = ros_kvm_init(**kwargs) client = tuple_return[0] output = executor(client, command) assert ('btrfs' in output)
def test_cloud_config_modules(ros_kvm_init, cloud_config_url): kwargs = dict(cloud_config='{url}test_cloud_config_modules.yml'.format(url=cloud_config_url), is_install_to_hard_drive=True) tuple_return = ros_kvm_init(**kwargs) client = tuple_return[0] output = executor(client, 'lsmod | grep btrfs') assert ('btrfs' in output)
def test_network_boot_cfg(ros_kvm_init, cloud_config_url): kwargs = dict( cloud_config='{url}default.yml'.format(url=cloud_config_url), is_install_to_hard_drive=True, extra_install_args= '--append "rancher.network.interfaces.eth1.address=192.168.122.251/24 ' 'rancher.network.interfaces.eth1.gateway=192.168.122.250 ' 'rancher.network.interfaces.eth0.dhcp=true"', is_network_gist=True) tuple_return = ros_kvm_init(**kwargs) client = tuple_return[0] output_eth1 = executor(client, 'ip address show eth1') assert ('inet 192.168.122.251' in output_eth1) output_eth1_gw = executor(client, 'ip route show dev eth1') client.close() assert ('default via 192.168.122.250' in output_eth1_gw)
def test_nonexistent_state(ros_kvm_init): kwargs = dict(kernel_parameters='--no-format ' 'rancher.state.dev=LABEL=NONEXISTENT ' 'rancher.state.autoformat=[/dev/sda,/dev/vda]', is_kernel_parameters=True) tuple_return = ros_kvm_init(**kwargs) client = tuple_return[0] output = executor(client, 'sudo ros config get rancher.state.dev') assert ('LABEL=NONEXISTENT' in output)
def test_bad_state(ros_kvm_init): kwargs = dict( kernel_parameters= '--no-format rancher.state.dev=LABEL=BAD_STATE rancher.state.autoformat=[/dev/sda,/dev/vda]', is_kernel_parameters=True) tuple_return = ros_kvm_init(**kwargs) client = tuple_return[0] output = executor(client, 'mount | grep /var/lib/docker') client.close() assert ('rootfs' in output)
def test_network_cloud_cfg(ros_kvm_init, cloud_config_url): kwargs = dict( cloud_config='{url}test_network_boot_and_cloudcfg.yml'.format( url=cloud_config_url), is_install_to_hard_drive=True, is_network_gist=True) tuple_return = ros_kvm_init(**kwargs) client = tuple_return[0] output_eth1_ip = executor(client, 'ip address show eth1') assert ('inet 10.1.0.41/24' in output_eth1_ip) output_eth1_gw = executor(client, 'ip route show dev eth1') assert ('default via 10.1.0.1' in output_eth1_gw) # Known issue https://github.com/rancher/os/issues/2587 # output_eth2_gw = executor(client, 'ip route show dev eth2') # assert ('default via 10.31.168.1' in output_eth2_gw) output_eth2_ip = executor(client, 'ip address show eth2') client.close() assert ('inet 10.31.168.85/24' in output_eth2_ip)
def test_auto_resize(ros_kvm_init, cloud_config_url): kwargs = dict(cloud_config='{url}default.yml'.format(url=cloud_config_url), is_define_xml=True, is_install_to_hard_drive=True) client, ip, virtual_name, dom = ros_kvm_init(**kwargs) c_get_vda_size = "sudo fdisk -l /dev/vda | head -1 | awk '{print $3}'" c_get_vda1_size = "sudo fdisk -l /dev/vda | grep vda1 | awk '{print $6}'" output_vda_size = executor(client, c_get_vda_size).replace('\n', '') output_vda1_size = executor(client, c_get_vda1_size).replace('\n', '') assert ('10' == output_vda_size) assert ('10G' == output_vda1_size) c_reset_device = 'sudo ros config set rancher.resize_device /dev/vda' executor(client, c_reset_device) # reboot domain dom.shutdown() _confirm_shutdown(dom) _resize_disk(virtual_name, 30) dom.create() second_client = connection(ip, None) output_vda_size = executor(second_client, c_get_vda_size).replace('\n', '') output_vda1_size = executor(second_client, c_get_vda1_size).replace('\n', '') client.close() assert ('40' == output_vda_size) assert ('40G' == output_vda1_size)
def test_oem(ros_kvm_init, cloud_config_url): kwargs = dict(cloud_config='{url}default.yml'.format(url=cloud_config_url), is_install_to_hard_drive=True, is_second_hd=True) tuple_return = ros_kvm_init(**kwargs) client = tuple_return[0] ip = tuple_return[1] c_add_ome_config = 'set -x && ' \ 'set -e && ' \ 'sudo mkfs.ext4 -L RANCHER_OEM /dev/vdb && ' \ 'sudo mount /dev/vdb /mnt &&' \ 'echo -e "#cloud-config \nrancher:\n upgrade:\n url: \'foo\'" > /tmp/oem-config.yml &&' \ 'sudo cp /tmp/oem-config.yml /mnt &&' \ 'sudo umount /mnt' executor(client, c_add_ome_config) executor(client, 'sudo reboot') second_client = connection(ip, None) c_ls_oem = 'ls /usr/share/ros/oem' output_ls_oem = executor(second_client, c_ls_oem) assert ('oem-config.yml' in output_ls_oem) c_get_oem = 'sudo ros config get rancher.upgrade.url' output_get_oem = executor(second_client, c_get_oem) second_client.close() assert ('foo' in output_get_oem)
def test_cloud_init(ros_kvm_init, cloud_config_url): kwargs = dict( cloud_config='{url}test_cloud_init.yml'.format(url=cloud_config_url), is_install_to_hard_drive=True) tuple_return = ros_kvm_init(**kwargs) client = tuple_return[0] ip = tuple_return[1] c_export_config = 'sudo ros c export' output_export_config = executor(client, c_export_config) assert ('debug' in output_export_config) # Create a datasource file locally # test_cloud_init.txt # # cloud-config # rancher: # log: true c_create_ds = 'sudo tee /var/lib/rancher/conf/cloud-config.d/datasources.yml << EOF \ rancher: \ cloud_init: \ datasources: \ - url:https://gist.githubusercontent.com/Aisuko/4914974de1cf2a3d5127fd482e2c001a/raw/\ ed1e30a8a096c6e10d485d02092eaaf8ca8871bd/test_cloud_init.txt \ EOF' # Reboot c_reboot = 'sudo reboot' executor(client, c_create_ds + c_reboot) second_client = connection(ip, None) c_ros_log = 'sudo ros config get rancher.log' output_ros_log = executor(second_client, c_ros_log) if output_ros_log: output_ros_log = output_ros_log.replace('\n', '') second_client.close() assert ('true' == output_ros_log)
def test_network_cmds(ros_kvm_init, cloud_config_url): kwargs = dict( cloud_config='{url}test_network_cmds.yml'.format(url=cloud_config_url), is_install_to_hard_drive=True, is_network_gist=True) tuple_return = ros_kvm_init(**kwargs) client = tuple_return[0] output = executor(client, 'cat /var/log/net.log') net_check_output = '''pre_cmds pre_up eth0 post_up eth0 pre_up eth1 post_up eth1 pre_up eth2 post_up eth2 post_cmds ''' client.close() assert (net_check_output in output)
def test_switch_docker(ros_kvm_init, cloud_config_url): kwargs = dict(cloud_config='{url}default.yml'.format(url=cloud_config_url), is_install_to_hard_drive=True) tuple_return = ros_kvm_init(**kwargs) client = tuple_return[0] output = executor(client, 'sudo ros engine list') list_of_docker = output.split('\n') list_of_docker.pop(-1) # Revert list_of_docker = list_of_docker[::-1] current_version = None special_version = 'docker-1.12.6' special2_version = 'docker-1.13.1' special3_version = 'docker-17.03.2-ce' list_docker_v = [] for number, docker_v in enumerate(list_of_docker): if docker_v.startswith('current '): current_version = docker_v.split(' ')[2] else: list_docker_v.append(docker_v.split(' ')[1]) assert (current_version != None) list_of_checking_docker_v = list_docker_v[:5] + [special_version, special2_version, special3_version] executor(client, 'sudo ros config set rancher.docker.storage_driver overlay2') for docker_v in list_of_checking_docker_v: executor(client, 'sudo ros engine switch {docker_version}'.format(docker_version=docker_v)) time.sleep(20) version = executor(client, 'sudo docker -v', seconds=20) assert (docker_v.replace('docker-', '') in version) executor(client, 'sudo ros engine switch {docker_version}'.format(docker_version=current_version))
def test_check_ssh_config_when_reboot(ros_kvm_init, cloud_config_url): kwargs = dict(cloud_config='{url}default.yml'.format(url=cloud_config_url), is_install_to_hard_drive=True) tuple_return = ros_kvm_init(**kwargs) client = tuple_return[0] ip = tuple_return[1] output = executor(client, 'sudo ros console list | grep -v default') list_of_console = output.split('\n') list_of_console.pop(-1) console_list = [] for console in list_of_console: console_list.append(console.split(' ')[1]) for console_v in console_list: client = connection(ip, None) executor( client, 'sudo ros console switch -f {console_version}'.format( console_version=console_v)) client = connection(ip, None) executor(client, 'sudo reboot') client = connection(ip, None) output_get_current_console = executor( client, 'sudo ros console list | grep current') assert (console_v in output_get_current_console) ssh_config_items = [ 'UseDNS no', 'PermitRootLogin no', 'ServerKeyBits 2048', 'AllowGroups docker' ] for ssh_config_item in ssh_config_items: output_ssh_config = executor( client, 'grep "^{ssh_config_item}" /etc/ssh/sshd_config | wc -l'. format(ssh_config_item=ssh_config_item)).replace('\n', '') assert (int(output_ssh_config) <= 1)
def test_upgrade(ros_kvm_init, cloud_config_url): kwargs = dict(cloud_config='{url}default.yml'.format(url=cloud_config_url), is_install_to_hard_drive=True) tuple_return = ros_kvm_init(**kwargs) client = tuple_return[0] ip = tuple_return[1] output = executor(client, 'sudo ros os list') list_of_os = output.split('\n') current_version = None # Trailing whitespace removed for number, ros_v in enumerate(list_of_os): list_of_os[number] = str(ros_v).rstrip() list_ros_v = [] for number, ros_v in enumerate(list_of_os): if ros_v.endswith('running'): current_version = ros_v.split(' ')[0] else: list_ros_v.append(ros_v.split(' ')[0]) list_ros_check = list_ros_v[:3] for ros_v in list_ros_check: client = connection(ip, None) executor( client, 'sudo ros os upgrade -f -i {os_version}'.format(os_version=ros_v)) client = connection(ip, None) output = executor(client, "sudo ros -v | awk '{print $2}'") if output: output = output.replace('\n', '') assert (output in ros_v) executor( client, 'sudo ros os upgrade -f -i {os_version}'.format( os_version=current_version))
def test_switch_console(ros_kvm_init, cloud_config_url): kwargs = dict(cloud_config='{url}default.yml'.format(url=cloud_config_url), is_install_to_hard_drive=True) tuple_return = ros_kvm_init(**kwargs) client = tuple_return[0] ip = tuple_return[1] output = executor(client, 'sudo ros console list') list_of_console = output.split('\n') list_of_console.pop(-1) current_version = None list_console_v = [] for number, console_v in enumerate(list_of_console): if console_v.startswith('current'): current_version = console_v.split(' ')[2] else: list_console_v.append(console_v.split(' ')[1]) for console_v in list_console_v: client = connection(ip, None) executor( client, 'sudo ros console switch -f {console_version}'.format( console_version=console_v)) client = connection(ip, None) version = executor(client, 'sudo ros console list |grep current') assert (console_v in version) executor( client, 'sudo ros console switch -f {console_version}'.format( console_version=current_version))
def test_ros_local_service(ros_kvm_init, cloud_config_url): kwargs = dict(cloud_config='{url}default.yml'.format(url=cloud_config_url), is_install_to_hard_drive=True) tuple_return = ros_kvm_init(**kwargs) client = tuple_return[0] create_test_image = 'echo "FROM $(sudo system-docker images --format ' "{{.Repository}}:{{.Tag}}" ' | grep os-base)" > Dockerfile' build_test_image = 'sudo system-docker build -t test_image .' executor(client, create_test_image) executor(client, build_test_image) add_contents = 'echo "test:" > test.yml && echo " image: test_image" >> test.yml ' \ '&& echo " entrypoint: ls" >> test.yml && echo " labels:" >> test.yml ' \ '&& echo " io.rancher.os.scope: system" >> test.yml ' \ '&& echo " io.rancher.os.after: console" >> test.yml' executor(client, add_contents) executor(client, 'sudo cp test.yml /var/lib/rancher/conf/test.yml') executor(client, 'sudo ros service enable /var/lib/rancher/conf/test.yml') executor(client, 'sudo ros service up test') output = executor(client, 'sudo ros service logs test') assert ('bin' in output)
def test_set_network_from_network_service(ros_kvm_init, cloud_config_url): kwargs = dict(cloud_config='{url}default.yml'.format(url=cloud_config_url), is_install_to_hard_drive=True, is_network_gist=True) tuple_return = ros_kvm_init(**kwargs) client = tuple_return[0] c_set_network = ''' echo "rancher:" >> config.yml echo " network:" >> config.yml echo " interfaces:" >> config.yml echo " eth2:" >> config.yml echo " dhcp: true" >> config.yml echo " eth3:" >> config.yml echo " dhcp: false" >> config.yml echo " eth1:" >> config.yml echo " address: 192.168.122.253/24" >> config.yml echo " dhcp: false" >> config.yml echo " gateway: 192.168.122.254" >> config.yml echo " mtu: 1500" >> config.yml ''' executor(client, c_set_network) executor(client, 'cat config.yml | sudo ros config merge') executor(client, 'sudo ros service restart network && sleep 5') executor(client, 'sleep 2') output_eth1 = executor(client, 'ip address show eth1') assert ('inet 192.168.122.253' in output_eth1) output_route = executor(client, 'ip route show dev eth1') assert ('default via 192.168.122.254' in output_route) output_eth2 = executor(client, 'ip address show eth2') assert ('inet 192.168.122' in output_eth2) output_eth3 = executor(client, 'ip address show eth3') client.close() assert ('inet 192.168.122' not in output_eth3)
def test_ros_local_service_user(ros_kvm_init, cloud_config_url): kwargs = dict(cloud_config='{url}default.yml'.format(url=cloud_config_url), is_install_to_hard_drive=True) tuple_return = ros_kvm_init(**kwargs) client = tuple_return[0] create_test_image = 'docker pull alpine && echo "FROM alpine" > Dockerfile' executor(client, create_test_image) build_test_image = 'sudo docker build -t test_image_user .' executor(client, build_test_image) add_contents = 'echo "test:" > test.yml && echo " image: test_image_user" >> test.yml ' \ '&& echo " entrypoint: ls" >> test.yml && echo " labels:" >> test.yml ' \ '&& echo " io.rancher.os.scope: user" >> test.yml ' \ '&& echo " io.rancher.os.after: console" >> test.yml' executor(client, add_contents) executor(client, 'sudo cp test.yml /var/lib/rancher/conf/test.yml') executor(client, 'sudo ros service enable /var/lib/rancher/conf/test.yml') executor(client, 'sudo ros service up test') output = executor(client, 'sudo ros service logs test') assert ('bin' in output)
def test_cmdline(ros_kvm_init, cloud_config_url): extra_args = 'cc.hostname=nope rancher.password=three' args = ' --append "cc.something=yes rancher.password=two -- {extra_args}"'.format( extra_args=extra_args) kwargs = dict(cloud_config='{url}default.yml'.format(url=cloud_config_url), extra_install_args=args, is_install_to_hard_drive=True) tuple_return = ros_kvm_init(**kwargs) client = tuple_return[0] hostname = executor(client, 'hostname') assert ('nope\n' == hostname) output_of_cmdline = executor(client, 'cat /proc/cmdline') assert (extra_args not in output_of_cmdline) extra_cmdline = executor( client, 'sudo ros config get rancher.environment.EXTRA_CMDLINE') assert ('/init {extra_args}'.format(extra_args=extra_args) in extra_cmdline) rancher_password = executor(client, 'sudo ros config get rancher.password') assert ('\n' == rancher_password) config_password = executor(client, 'sudo ros config export | grep password') assert ('EXTRA_CMDLINE: /init cc.hostname=nope rancher.password=three' in config_password) test_yml = "echo -e 'test:\n image: alpine\n command: \"echo tell me a secret ${EXTRA_CMDLINE}\"\n labels:\n io.rancher.os.scope: system\n environment:\n - EXTRA_CMDLINE\n'> test.yml" executor(client, test_yml) executor(client, 'sudo mv test.yml /var/lib/rancher/conf/test.yml') executor(client, 'sudo ros service enable /var/lib/rancher/conf/test.yml') executor(client, 'sudo ros service up test') test_content = 'test_1 | tell me a secret /init cc.hostname=nope rancher.password=three\n' output_test = executor(client, 'sudo ros service logs test | grep secret') assert (test_content.replace('\n', '') in output_test)
def test_ssh_key_merge(ros_kvm_init, cloud_config_url): kwargs = dict(cloud_config='{url}default.yml'.format(url=cloud_config_url), is_install_to_hard_drive=True) tuple_return = ros_kvm_init(**kwargs) client = tuple_return[0] set_metadata = 'echo -e ' \ '"SSHPublicKeys: \n "0": zero \n "1": one\n "2": two" ' \ '> /var/lib/rancher/conf/metadata' set_ssh_aut_key = 'echo -e ' \ '"$(sudo ros config get ssh_authorized_keys | head -1)\n- zero\n- one\n- two\n" ' \ '> expected' set_current = 'sudo ros config get ssh_authorized_keys > current_config' executor(client, 'sudo rm /var/lib/rancher/conf/cloud-config.yml') executor(client, 'sudo chmod -R 777 /var/lib/rancher/conf/') executor(client, set_metadata) executor(client, set_ssh_aut_key) executor(client, set_current) output = executor(client, 'diff expected current_config && echo $?').replace( '\n', '') assert (output == '0')