def check_volume_mounts(cluster, pod, log_msg_prefix=''): utils.log_debug( "{}Run 'sudo zpool list' and make sure that '{}' is there".format( log_msg_prefix, ZFS_POOL), LOG) _, out, _ = cluster.ssh_exec(pod.node, 'zpool list', sudo=True) utils.assert_in(ZFS_POOL, out) for pv in pod.pvs: pod_owner = cluster.users.get(name=pod.owner) pv_mountpoint = os.path.join(ZFS_POOL_MOUNTPOINT, str(pod_owner.get('id')), pv.name) pool_path = os.path.join(ZFS_POOL, str(pod_owner.get('id')), pv.name) utils.log_debug( "{}Run 'zfs list' and check that '{}' is there".format( log_msg_prefix, pv.name), LOG) _, out, _ = cluster.ssh_exec(pod.node, 'zfs list', sudo=True) utils.assert_in(pv.name, out) # This may look redundant, but it's here only to be consistent with # test inside TestRail utils.log_debug( "{}Make sure that '{}' is mounted".format(log_msg_prefix, pv.name), LOG) assert_volume_mounts(cluster, pv_mountpoint, pod.node, utils.assert_in) utils.log_debug( "{}Make sure that '{}' has a correct mountpoint".format( log_msg_prefix, pv.name), LOG) assert_zfs_mount_points(cluster, pool_path, pv_mountpoint, node=pod.node, assertion=utils.assert_in)
def check_custom_port(cluster, port, proto, is_open=False): msg = "Check that port: '{proto}:{port}' on node '{node}' is '{state}'" for node in cluster.node_names: utils.log_debug( msg.format(proto=proto, port=port, node=node, state='open' if is_open else 'closed'), LOG) node_ip = cluster.nodes.get_node_data(node).get('ip') if proto == 'tcp' and is_open: with paramiko_expect_http_server(cluster, node, port): sleep(SERVER_START_WAIT_TIMEOUT) res = unregistered_host_port_check(node_ip, port) utils.assert_in('Directory listing for /', res) elif proto == 'tcp' and not is_open: with paramiko_expect_http_server(cluster, node, port), \ utils.assert_raises(NonZeroRetCodeException, expected_ret_codes=CURL_CONNECTION_ERRORS): sleep(SERVER_START_WAIT_TIMEOUT) unregistered_host_port_check(node_ip, port) elif proto == 'udp' and is_open: with paramiko_expect_udp_server(cluster, node, port): sleep(SERVER_START_WAIT_TIMEOUT) out = unregistered_host_udp_check(node_ip, port) utils.assert_eq('PONG', out) else: with paramiko_expect_udp_server(cluster, node, port), \ utils.assert_raises( NonZeroRetCodeException, 'socket.timeout: timed out'): sleep(SERVER_START_WAIT_TIMEOUT) unregistered_host_udp_check(node_ip, port)
def test_pod_lands_on_correct_node_after_change_kubetype(cluster): for node, kube_type in [('node1', 'Standard'), ('node2', 'Tiny'), ('node3', 'High memory')]: info = cluster.nodes.get_node_info(node) assert_eq(info['kube_id'], kube_type_to_int(kube_type)) pod = cluster.pods.create("nginx", "test_nginx_pod", kube_type='Tiny', wait_ports=True, healthcheck=True, wait_for_status='running', open_all_ports=True) assert_eq(pod.node, 'node2') pod.change_kubetype(kube_type=1) pod.wait_for_status('running') pod.wait_for_ports() pod.healthcheck() assert_eq(pod.node, 'node1') pod.change_kubetype(kube_type=2) pod.wait_for_status('running') pod.wait_for_ports() pod.healthcheck() assert_in(pod.node, 'node3')
def healthcheck(self): self._generic_healthcheck() self.wait_http_resp() page = self.do_GET(path='/installer/') assert_in( u"Installing Gallery is easy. " "We just need a place to put your photos", page)
def healthcheck(self): if not (self.open_all_ports or self.ports): raise Exception( "Cannot perform nginx healthcheck without public IP") self._generic_healthcheck() # if shared IP is used, 404 is returned in a response to GET on # pod's domain name for up to 40 seconds after pod is started utils.retry(self.do_GET, tries=5, interval=10) utils.assert_in("Welcome to nginx!", self.do_GET())
def healthcheck(self): self._generic_healthcheck() spec = self.get_spec() env = {e['name']: e['value'] for e in spec['containers'][0]['env']} user = env['POSTGRES_USER'] passwd = env['POSTGRES_PASSWORD'] db = DB(dbname=user, host=self.host, port=5432, user=user, passwd=passwd) sql = "create table test_table(id serial primary key, name varchar)" db.query(sql) assert_in('public.test_table', db.get_tables())
def test_pod_migrate_on_correct_node_after_change_kubetype(cluster): for node, kube_type in [('node1', 'Standard'), ('node2', 'Tiny'), ('node3', 'High memory')]: info = cluster.nodes.get_node_info(node) assert_eq(info['kube_id'], kube_type_to_int(kube_type)) # type: (KDIntegrationTestAPI) -> None # We have issue related to using non-unique disk names within # same CEPH pool (AC-3831). That is why name is randomized. pv_name = gen_rnd_ceph_pv_name() mount_path = '/usr/share/nginx/html' # It is possible to create an nginx pod together with new PV pv = cluster.pvs.add("dummy", pv_name, mount_path) pod = cluster.pods.create("nginx", "test_nginx_pod", pvs=[pv], kube_type='Tiny', start=True, wait_for_status='running', wait_ports=True, open_all_ports=True) assert_eq(pv.exists(), True) assert_eq(pod.node, 'node2') c_id = pod.get_container_id(container_image='nginx') pod.docker_exec(c_id, 'echo -n TEST > {path}/test.txt'.format(path=mount_path)) ret = pod.do_GET(path='/test.txt') assert_eq('TEST', ret) pod.change_kubetype(kube_type=1) pod.wait_for_status('running') pod.wait_for_ports() ret = pod.do_GET(path='/test.txt') assert_eq('TEST', ret) assert_in(pod.node, ['node1', 'node4']) pod.change_kubetype(kube_type=2) pod.wait_for_status('running') pod.wait_for_ports() ret = pod.do_GET(path='/test.txt') assert_eq('TEST', ret) assert_eq(pod.node, 'node3') # It's possible to remove PV created together with pod pod.delete() pv.delete() assert_eq(pv.exists(), not True)
def test_pod_with_pv_restore(cluster): """Test that pod with PVs can be restored. :type cluster: KDIntegrationTestAPI """ file_name = BACKUP_FILES[NGINX_WITH_PV] backup_url = "http://node1/backups" path_template = '{owner_id}/{volume_name}.tar.gz' # Test that pod with persistent volume can be restored pod = cluster.pods.restore(USER, file_path=file_name, pv_backups_location=backup_url, pv_backups_path_template=path_template, wait_for_status="running") pod.wait_for_ports() assert_in("This page has been restored from tar.gz", pod.do_GET(path='/restored_location/')) old_id = pod.pod_id # Test that pod isn't removed if pod with same name is restored with # --force-not-delete flag with assert_raises(NonZeroRetCodeException, 'Pod with name .* already exists'): cluster.pods.restore(USER, file_path=file_name, pv_backups_location=backup_url, pv_backups_path_template=path_template, flags="--force-not-delete") # If pod has't been restored, it's id should not be changed assert_eq(old_id, pod.pod_id) # Test that pod is removed together with disks if pod with same name # and same disks names is restored with --force-delete flag path_template = '{owner_name}/{volume_name}.zip' pod2 = cluster.pods.restore(USER, file_path=file_name, pv_backups_location=backup_url, pv_backups_path_template=path_template, flags="--force-delete", return_as_json=True) # If pod was restored than it's id should distinguish from id of pod # with same name, that has just been removed assert_not_eq(old_id, pod2.pod_id) pod2.wait_for_ports() assert_in("This page has been restored from zip", pod.do_GET(path='/restored_location/'))
def _open_custom_ports(self): try: self.cluster.kdctl('allowed-ports open {} {}'.format( self.TCP_PORT_TO_OPEN, 'tcp')) self.cluster.kdctl('allowed-ports open {} {}'.format( self.UDP_PORT_TO_OPEN, 'udp')) _, out, _ = self.cluster.kdctl('allowed-ports list', out_as_dict=True) custom_ports = out['data'] # Make sure that two ports are opened assert_eq(len(custom_ports), 2) # Make sure that both ports opened correctly assert_in(dict(port=self.TCP_PORT_TO_OPEN, protocol='tcp'), custom_ports) assert_in(dict(port=self.UDP_PORT_TO_OPEN, protocol='udp'), custom_ports) except (NonZeroRetCodeException, AssertionError) as e: log_debug("Couldn't open ports. Reason: {}".format(e))
def create(self, image, name, kube_type="Standard", kubes=1, open_all_ports=False, ports_to_open=(), restart_policy="Always", pvs=None, start=True, wait_ports=False, healthcheck=False, wait_for_status=None, owner='test_user', password=None, domain=None): """ Create new pod in kuberdock :param open_all_ports: if true, open all ports of image (does not mean these are Public IP ports, depends on a cluster setup) :param ports_to_open: if open_all_ports is False, open only the ports from this list :return: object via which Kuberdock pod can be managed """ utils.assert_in(kube_type, ("Tiny", "Standard", "High memory")) utils.assert_in(restart_policy, ("Always", "Never", "OnFailure")) pod = KDPod.create(self.cluster, image, name, kube_type, kubes, open_all_ports, restart_policy, pvs, owner, owner or password, ports_to_open, domain) if start: pod.start() if wait_for_status: pod.wait_for_status(wait_for_status) if wait_ports: pod.wait_for_ports() if healthcheck: pod.healthcheck() return pod
def test_add_new_block_device(cluster): """ Add a new block device into ZFS pool (Non-AWS) """ for node in cluster.node_names: utils.log_debug("Add new block device to node '{}'".format(node), LOG) # NOTE: Generate a new file each time, so that if test is run on a # cluster multiple times nothing is broken, otherwise if we attach two # volumes with the same name, ZFS pool will be broken. # FIXME: Tried to detach the volume after the test is complete, but # couldn't figure out how to do it properly. of_path = utils.get_rnd_low_string(prefix='/tmp/dev', length=5) write_file_cmd = 'dd if=/dev/zero of="{}" bs=64M count=10'.format( of_path) cluster.ssh_exec(node, write_file_cmd) add_bl_device_cmd = ('node-storage add-volume --hostname {} ' '--devices {}'.format(node, of_path)) cluster.manage(add_bl_device_cmd) utils.log_debug("Make sure a new block device is added", LOG) _, out, _ = cluster.ssh_exec(node, 'zpool status', sudo=True) utils.assert_in(of_path, out)
def healthcheck(self): self._generic_healthcheck() self.wait_http_resp() page = self.do_GET(path='/index.php/install/') assert_in(u"Magento is a trademark of Magento Inc.", page)
def healthcheck(self): self._generic_healthcheck() self.wait_http_resp() page = self.do_GET(path='/web/database/selector') assert_in(u"Fill in this form to create an Odoo database.", page)
def healthcheck(self): self._generic_healthcheck() self.wait_http_resp() page = self.do_GET(path='/wp-admin/install.php') assert_in(u"WordPress › Installation", page)
def healthcheck(self): self._generic_healthcheck() self.wait_http_resp() page = self.do_GET(path='/install.php') assert_in(u"Sugar Setup Wizard:", page) assert_in(u"Welcome to the SugarCRM", page)
def healthcheck(self): self._generic_healthcheck() self.wait_http_resp() assert_in("Welcome to your new DokuWiki", self.do_GET(path='/doku.php?id=wiki:welcome'))
def healthcheck(self): self._generic_healthcheck() self.wait_http_resp() page = self.do_GET(path='/install/index.php') assert_in(u"Welcome to phpBB3!", page)
def healthcheck(self): self._generic_healthcheck() self.wait_http_resp() page = self.do_GET(path='/server_databases.php') assert_in(u"information_schema", page) assert_in(u"mydata", page)
def healthcheck(self): self._generic_healthcheck() self.wait_http_resp() page = self.do_GET() assert_in(u"Koken - Setup", page)
def healthcheck(self): self._generic_healthcheck() self.wait_http_resp() page = self.do_GET() assert_in(u"ownCloud", page) assert_in(u"web services under your control", page)
def healthcheck(self): self._generic_healthcheck() self.wait_http_resp() page = self.do_GET(path='/install/index.php') assert_in(u"Please read the OpenCart licence agreement", page)
def healthcheck(self): self._generic_healthcheck() self.wait_http_resp() page = self.do_GET(path='/index.php?r=installer/welcome') assert_in(u"LimeSurvey installer", page)
def healthcheck(self): self._generic_healthcheck() self.wait_http_resp() page = self.do_GET(path='/install/index.php') assert_in(u"MyBB Installation Wizard", page)
def healthcheck(self): self._generic_healthcheck() self.wait_http_resp() page = self.do_GET(path='/admin/install.php') assert_in(u"Administration - Installation - MantisBT", page)
def healthcheck(self): self._generic_healthcheck() self.wait_http_resp() # Change assertion string after fix AC-4487 page = self.do_GET(path='/core/install.php') assert_in("Drupal", page)
def healthcheck(self): self._generic_healthcheck() self.wait_http_resp() assert_in("Redmine", self.do_GET(port=self.HTTP_PORT))
def healthcheck(self): self._generic_healthcheck() self.wait_http_resp() page = self.do_GET(path='/installation/index.php') assert_in(u"Joomla! - Open Source Content Management", page)