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')
