def _prepare_security_group(cls): """Security-group preparation""" sec_group_name = data_utils.rand_name("securitygroup-") group_desc = sec_group_name + " security group description " security_group = cls.ec2_client.create_security_group( sec_group_name, group_desc) if security_group is None or security_group.name is None: raise base.TestCasePreparationError("Can't create security group") cls.addResourceCleanUp(cls.destroy_security_group_wait, security_group) result = cls.ec2_client.authorize_security_group(sec_group_name, ip_protocol="icmp", cidr_ip="0.0.0.0/0", from_port=-1, to_port=-1) if not result: raise base.TestCasePreparationError( "Can`t authorize security group") result = cls.ec2_client.authorize_security_group(sec_group_name, ip_protocol="tcp", cidr_ip="0.0.0.0/0", from_port=22, to_port=22) if not result: raise base.TestCasePreparationError( "Can`t authorize security group") return security_group
def test_022_check_broadcast_visible(self): """Is broadcast traffic visible?""" if self.ctx.instance3 is None: self.skipTest("Instance 3 was not initialized") with self.TcpDumpRunner(self.ctx.instance3, self.ssh_user, self.keypair, "ip broadcast") as tdump: ssh = remote_client.RemoteClient(self.instance1.ip_address, self.ssh_user, pkey=self.keypair.material) ssh.exec_command("echo ping |" "socat - UDP4-DATAGRAM:255.255.255.255:6666," "broadcast") if not tdump.stop(): raise base.TestCasePreparationError() resp = tdump.get_result() captured = "" for line in resp.splitlines(): if line.endswith(" captured"): captured = line break tokens = captured.split() packets = int(tokens[0]) self.assertEqual(0, packets)
def test_013_check_dhcp_lease(self): """Whether IP address was obtained by dhcp?""" if self.ctx.instance3 is None: self.skipTest("Instance 3 was not initialized") ssh = remote_client.RemoteClient(self.ctx.instance3.ip_address, self.ssh_user, pkey=self.keypair.material) resp = ssh.exec_command("ps -eo comm,args | grep -m 1 dhclient") args = resp.split() if len(args) <= 2 or not args[0].startswith('dhclient'): raise base.TestCasePreparationError() is_lf = False lease_file = "/var/lib/dhcp/dhclient.leases" for arg in args: if is_lf: lease_file = arg is_lf = False elif arg == "-lf": is_lf = True resp = ssh.exec_command("test -f %s && echo 1 || echo 0" % lease_file) self.assertEqual(1, int(resp)) self.ctx.lease_file = lease_file resp = ssh.exec_command("grep 'fixed-address ' %s | tail -n 1 | " "awk '{ print $2 }' | sed -e 's/;//'" % lease_file) lines = resp.splitlines() self.assertEqual(1, len(lines)) self.assertEqual(self.ctx.instance3.private_ip_address, lines[0]) date = ssh.exec_command("date -u +%Y/%m/%d%H:%M:%S") self.assertTrue(date) resp = ssh.exec_command("grep 'renew ' %s | tail -n 1 | " "awk '{ print $3$4 }' | sed -e 's/;//'" % lease_file) self.assertLess(date, resp)
def _run_instance(cls, subnet, private_ip=None): params = { "key_name": cls.keypair.name, "instance_type": cls.instance_type, "placement": cls.zone, "subnet_id": subnet.id, } if private_ip: params["private_ip_address"] = str(private_ip) reservation = cls.vpc_client.run_instances(cls.image_id, **params) if reservation is None: raise base.TestCasePreparationError() cls.addResourceCleanUp(cls.destroy_reservation, reservation) if len(reservation.instances) != 1: raise base.TestCasePreparationError() instance = reservation.instances[0] return instance
def test_012_check_dhcp_grant_ip(self): """Whether dhcp provide IP address?""" instance = self._run_instance(self.subnet) state = self.waitInstanceState(instance, "running") if state != "running": raise base.TestCasePreparationError() self.assertTrue(instance.private_ip_address) instance.ip_address = self._prepare_public_ip(instance) self.ctx.instance3 = instance
def _prepare_key_pair(cls): """Key-pair preparation""" keypair_name = data_utils.rand_name("keypair-") keypair = cls.ec2_client.create_key_pair(keypair_name) if keypair is None or keypair.name is None: raise base.TestCasePreparationError("Can`t create keypair") cls.addResourceCleanUp(cls.ec2_client.delete_key_pair, keypair_name) return keypair
def _prepare_public_ip(cls, instance, network_interface_id=None): """Public IP preparation""" ip_address = instance.ip_address if ip_address is None or ip_address == instance.private_ip_address: domain = "vpc" if instance.vpc_id is not None else None address = cls.ec2_client.allocate_address(domain) if address is None or not address.public_ip: raise base.TestCasePreparationError("Can't allocate public IP") if domain is None: # NOTE(ft): this is temporary workaround for OS # it must be removed after VPC integration cls.addResourceCleanUp(address.delete) status = address.associate(instance.id) if not status: raise base.TestCasePreparationError( "Can't associate IP with instance") cls.addResourceCleanUp(address.disassociate) else: cls.addResourceCleanUp(cls.ec2_client.release_address, allocation_id=address.allocation_id) if network_interface_id: status = cls.ec2_client.associate_address( allocation_id=address.allocation_id, network_interface_id=network_interface_id) else: status = cls.ec2_client.associate_address( instance.id, allocation_id=address.allocation_id) if not status: raise base.TestCasePreparationError( "Can't associate IP with instance") addresses = cls.ec2_client.get_all_addresses( allocation_ids=[address.allocation_id]) if addresses is None or len(addresses) != 1: raise base.TestCasePreparationError( "Can't get address by allocation_id") address = addresses[0] cls.addResourceCleanUp(cls.ec2_client.disassociate_address, association_id=address.association_id) instance.update() ip_address = address.public_ip return ip_address
def install_iperf(instance): try: ssh = remote_client.RemoteClient(instance.ip_address, cls.ssh_user, pkey=cls.keypair.material) except exceptions.SSHTimeout: raise base.TestCasePreparationError() ssh.exec_command("sudo apt-get update && sudo apt-get upgrade -y") ssh.exec_command("sudo apt-get update") ssh.exec_command("sudo apt-get install iperf")
def setUpClass(cls): super(VPC_Benchmark, cls).setUpClass() cls.keypair = cls._prepare_key_pair() subnet = cls._prepare_vpc(cls.vpc_cidr, cls.subnet_cidr) reservation = cls.vpc_client.run_instances( cls.image_id, min_count=2, max_count=2, key_name=cls.keypair.name, instance_type=cls.instance_type, placement=cls.zone, subnet_id=subnet.id) if reservation is None: raise base.TestCasePreparationError() cls.addResourceCleanUp(cls.destroy_reservation, reservation) if len(reservation.instances) != 2: raise base.TestCasePreparationError() cls.instance1 = reservation.instances[0] cls.instance2 = reservation.instances[1] cls._wait_instance_state(cls.instance1, "running") cls._wait_instance_state(cls.instance2, "running") cls._prepare_public_ip(cls.instance1) cls._prepare_public_ip(cls.instance2) def install_iperf(instance): try: ssh = remote_client.RemoteClient(instance.ip_address, cls.ssh_user, pkey=cls.keypair.material) except exceptions.SSHTimeout: raise base.TestCasePreparationError() ssh.exec_command("sudo apt-get update && sudo apt-get upgrade -y") ssh.exec_command("sudo apt-get update") ssh.exec_command("sudo apt-get install iperf") install_iperf(cls.instance1) install_iperf(cls.instance2) cfg = cls.config.cloudscaling cls.network_performance_class = cfg.network_performance_class cls._load_benchmark_data("AWS_VPC_Benchmark")
def _wait_instance_state(cls, instance, final_set): if not isinstance(final_set, set): final_set = set((final_set, )) final_set |= cls.gone_set lfunction = cls.get_lfunction_gone(instance) state = boto_wait.state_wait(lfunction, final_set, cls.valid_instance_state) if state not in final_set: raise base.TestCasePreparationError("Error in waiting for " "instance(state = '%s')" % state)
def _tune_vpc(cls, vpc): ig = cls.vpc_client.create_internet_gateway() if ig is None or not ig.id: raise base.TestCasePreparationError() cls.addResourceCleanUp(cls._destroy_internet_gateway, ig) status = cls.vpc_client.attach_internet_gateway(ig.id, vpc.id) if not status: raise base.TestCasePreparationError() rtables = cls.vpc_client.get_all_route_tables(filters=[("vpc-id", vpc.id)]) if rtables is None or len(rtables) != 1: raise base.TestCasePreparationError() status = cls.vpc_client.create_route(rtables[0].id, "0.0.0.0/0", gateway_id=ig.id) if not status: raise base.TestCasePreparationError() secgroups = cls.vpc_client.get_all_security_groups( filters={"vpc-id": vpc.id}) if secgroups is None or len(secgroups) != 1: raise base.TestCasePreparationError() status = cls.vpc_client.authorize_security_group( group_id=secgroups[0].id, ip_protocol="-1", from_port=-1, to_port=-1, cidr_ip="0.0.0.0/0") if not status: raise base.TestCasePreparationError()
def _prepare_vpc(cls, vpc_cidr, sn_cidr): # NOTE(Alex) The following code is introduced for OpenStack # and potentially requires fix in boto. See details in # test_vpc_nat_scenario. dhcp_opts = cls.vpc_client.create_dhcp_options( domain_name_servers=['8.8.8.8']) if dhcp_opts is None or not dhcp_opts.id: raise base.TestCasePreparationError() cls.addResourceCleanUp(cls.vpc_client.delete_dhcp_options, dhcp_opts.id) vpc = cls.vpc_client.create_vpc(str(vpc_cidr)) if vpc is None or not vpc.id: raise base.TestCasePreparationError() cls.addResourceCleanUp(cls.vpc_client.delete_vpc, vpc.id) if not cls.vpc_client.associate_dhcp_options(dhcp_opts.id, vpc.id): raise base.TestCasePreparationError() cls._tune_vpc(vpc) sn = cls.vpc_client.create_subnet(vpc.id, str(sn_cidr), cls.zone) if sn is None or not sn.id: raise base.TestCasePreparationError() cls.addResourceCleanUp(cls._delete_subnet_wait, sn) return sn
def test_021_check_traffic_visibility(self): """Are other VMs visible?""" if self.ctx.instance3 is None: self.skipTest("Instance 3 was not initialized") with self.TcpDumpRunner(self.ctx.instance3, self.ssh_user, self.keypair, "ip proto \\\\icmp") as tdump: ssh = remote_client.RemoteClient(self.instance1.ip_address, self.ssh_user, pkey=self.keypair.material) ssh.exec_command("ping -c 1 %s" % self.instance2.private_ip_address) if not tdump.stop(): raise base.TestCasePreparationError() resp = tdump.get_result() for line in resp.splitlines(): if line.endswith("packets captured"): captured = line break tokens = captured.split() packets = int(tokens[0]) self.assertEqual(0, packets)
def _prepare_ebs_image(cls): if cls.config.cloudscaling.ebs_image_id: return cls.config.cloudscaling.ebs_image_id if not cls.config.cloudscaling.image_id_ami: raise cls.skipException("".join( ("EC2 ", cls.__name__, ": requires image_id_ami setting"))) if not cls.config.service_available.cinder: skip_msg = ("%s skipped as Cinder is not available" % cls.__name__) raise cls.skipException(skip_msg) if not cls.config.service_available.nova: skip_msg = ("%s skipped as nova is not available" % cls.__name__) raise cls.skipException(skip_msg) admin_creds = auth.get_default_credentials('compute_admin') os = base_clients.Manager(admin_creds, interface='json') cls.os = os cls.volumes_client = os.volumes_client cls.servers_client = os.servers_client cls.images_client = os.images_client cls.snapshots_client = os.snapshots_client # NOTE(apavlov): create volume resp, volume = cls.volumes_client.create_volume( VOLUME_SIZE, display_name="aws_volume") assert 200 == resp.status cls.addResourceCleanUp(cls._delete_volume, volume['id']) cls.volumes_client.wait_for_volume_status(volume['id'], 'available') # NOTE(apavlov): boot instance bdm = [{ "volume_id": volume['id'], "delete_on_termination": "1", "device_name": "/dev/vda" }] resp, server = cls.servers_client.create_server( "aws_instance", cls.config.cloudscaling.image_id_ami, cls.config.compute.flavor_ref, block_device_mapping=bdm) assert 202 == resp.status rc_server = cls.addResourceCleanUp(cls.servers_client.delete_server, server['id']) cls.servers_client.wait_for_server_status(server['id'], 'ACTIVE') # NOTE(apavlov): create image from instance image_name = data_utils.rand_name("aws_ebs_image-") resp, _ = cls.images_client.create_image(server['id'], image_name) assert 202 == resp.status cls.image_id = resp["location"].split('/')[-1] cls.addResourceCleanUp(cls.images_client.delete_image, cls.image_id) # NOTE(apavlov): delete instance cls.cancelResourceCleanUp(rc_server) cls.servers_client.delete_server(server['id']) cls.servers_client.wait_for_server_termination(server['id']) images = cls.ec2_client.get_all_images() for image in images: if image_name in image.location: return image.id raise base.TestCasePreparationError("Can't find ebs image.")