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_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_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_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_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_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_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 _ros_kvm_init(**kwargs):
nonlocal virtual_name
virtual_name = _id_generator()
mac = _mac_generator()
_manage_path()
if kwargs.get('is_kernel_parameters'):
kernel_parameters = kwargs.get('kernel_parameters')
xml_for_virtual = KERNEL_PARAMETERS_XML.format(
virtual_name=virtual_name,
mac_address=mac,
v_name_for_source=virtual_name,
kernel_parameters=kernel_parameters)
else:
if kwargs.get('is_second_hd'):
second_drive_name = virtual_name + '_second'
# Create second_drive
_create_qcow2('2', second_drive_name)
second_driver_gist = SECOND_DRIVE_XML_GIST.format(second_drive_name=second_drive_name)
else:
second_driver_gist = ''
if kwargs.get('is_network_gist'):
network_xml_gist = NETWORK_XML_GIST
else:
network_xml_gist = ''
xml_for_virtual = KVM_XML.format(virtual_name=virtual_name,
mac_address=mac,
v_name_for_source=virtual_name,
second_driver_gist=second_driver_gist,
network_xml_gist=network_xml_gist)
# region Create qcow2
if kwargs.get('is_b2d'):
_create_b2d_qcow2('10', virtual_name)
else:
_create_qcow2('10', virtual_name)
# endregion
nonlocal conn
conn = libvirt.open('qemu:///system')
if not conn:
raise Exception('Failed to open connection to qemu:///system')
else:
nonlocal dom
nonlocal is_define_xml
is_define_xml = kwargs.get('is_define_xml')
if is_define_xml:
dom = conn.defineXML(xml_for_virtual)
dom.create()
else:
dom = conn.createXML(xml_for_virtual)
ip = _get_ip(mac)
if ip:
if kwargs.get('is_install_to_hard_drive'):
cloud_config = kwargs.get('cloud_config')
client = connection(ip=ip, seconds=kwargs.get('seconds_for_install'))
_install_to_hdrive(cloud_config, client, kwargs.get('extra_install_args'))
time.sleep(30)
ssh = connection(ip, seconds=kwargs.get('seconds_for_reconnect'))
return ssh, ip, virtual_name, dom
else:
return None