def test_01_create_redundant_VPC_2tiers_4VMs_4IPs_4PF_ACL(self): """ Create a redundant VPC with two networks with two VMs in each network """ self.logger.debug( "Starting test_01_create_redundant_VPC_2tiers_4VMs_4IPs_4PF_ACL") self.query_routers() net_off = get_default_network_offering(self.apiclient) self.networks.append(self.create_network(net_off, "10.1.1.1")) net_off_no_lb = get_default_network_offering_no_load_balancer( self.apiclient) self.networks.append(self.create_network(net_off_no_lb, "10.1.2.1")) self.check_routers_state() self.add_nat_rules() self.do_vpc_test(False) self.stop_router_by_type("MASTER") self.check_routers_state(1) self.do_vpc_test(False) self.delete_nat_rules() self.check_routers_state(count=1) self.do_vpc_test(True) self.delete_public_ip() self.start_routers() self.add_nat_rules() self.check_routers_state() self.do_vpc_test(False)
def setUpClass(cls, redundant=False): cls.logger = MarvinLog(MarvinLog.LOGGER_TEST).get_logger() test_client = super(TestVpcVpn, cls).getClsTestClient() cls.apiclient = test_client.getApiClient() cls.services = test_client.getParsedTestDataConfig() cls.zone = get_zone(cls.apiclient, test_client.getZoneForTests()) cls.domain = get_domain(cls.apiclient) cls.vpc_offering = get_default_redundant_vpc_offering(cls.apiclient) if redundant else get_default_vpc_offering(cls.apiclient) cls.logger.debug("VPC Offering '%s' selected", cls.vpc_offering.name) cls.network_offering = get_default_network_offering(cls.apiclient) cls.logger.debug("Network Offering '%s' selected", cls.network_offering.name) cls.virtual_machine_offering = get_default_virtual_machine_offering(cls.apiclient) cls.logger.debug("Virtual Machine Offering '%s' selected", cls.virtual_machine_offering.name) cls.account = Account.create(cls.apiclient, services=cls.services["account"]) cls.logger.debug("Successfully created account: %s, id: %s" % (cls.account.name, cls.account.id)) cls.hypervisor = test_client.getHypervisorInfo() cls._cleanup = [cls.account] cls.template = get_template( cls.apiclient, cls.zone.id ) return
def perform_password_service_tests(self, vpc_off): if vpc_off is None: self.logger.debug("No need to create a VPC, creating isolated network") network_1 = self.createIsolatedNetwork() vpc_1 = None else: self.logger.debug("Creating VPC with offering ID %s" % vpc_off.id) vpc_1 = self.createVPC(vpc_off, cidr='10.0.0.0/16') self.logger.debug("Creating network inside VPC") net_off = get_default_network_offering(self.apiclient) network_1 = self.createNetwork(vpc_1, net_off, gateway='10.0.0.1') acl1 = self.createACL(vpc_1) self.createACLItem(acl1.id, cidr="0.0.0.0/0") self.replaceNetworkAcl(acl1.id, network_1) routers = list_routers(self.apiclient, account=self.account.name, domainid=self.account.domainid) for router in routers: self._perform_password_service_test(router, network_1) # Do the same after restart with cleanup if vpc_off is None: self.restart_network_with_cleanup(network_1, True) else: self.restart_vpc_with_cleanup(vpc_1, True) self.logger.debug("Getting the router info again after the cleanup (router names / ip addresses changed)") routers = list_routers(self.apiclient, account=self.account.name, domainid=self.account.domainid) self.assertEqual(isinstance(routers, list), True, "Check for list routers response return valid data") self.logger.debug("Check whether routers are happy") for router in routers: self._perform_password_service_test(router, network_1)
def test_01_create_redundant_VPC_2tiers_4VMs_4IPs_4PF_ACL(self): """ Create a redundant VPC with two networks with two VMs in each network """ self.logger.debug("Starting test_01_create_redundant_VPC_2tiers_4VMs_4IPs_4PF_ACL") self.query_routers() net_off = get_default_network_offering(self.apiclient) self.networks.append(self.create_network(net_off, "10.1.1.1")) net_off_no_lb = get_default_network_offering_no_load_balancer(self.apiclient) self.networks.append(self.create_network(net_off_no_lb, "10.1.2.1")) self.check_routers_state() self.add_nat_rules() self.do_vpc_test(False) self.stop_router_by_type("MASTER") self.check_routers_state(1) self.do_vpc_test(False) self.delete_nat_rules() self.check_routers_state(count=1) self.do_vpc_test(True) self.delete_public_ip() self.start_routers() self.add_nat_rules() self.check_routers_state() self.do_vpc_test(False)
def perform_dnsmasq_service_dns_tests(self, vpc_off): self.logger.debug("Creating VPC with offering ID %s" % vpc_off.id) vpc_1 = self.createVPC(vpc_off, cidr='10.0.0.0/16') self.logger.debug("Creating network inside VPC") net_off = get_default_network_offering(self.apiclient) network_1 = self.createNetwork(vpc_1, net_off, gateway='10.0.0.1') acl1 = self.createACL(vpc_1) self.createACLItem(acl1.id, cidr="0.0.0.0/0") self.replaceNetworkAcl(acl1.id, network_1) routers = list_routers(self.apiclient, account=self.account.name, domainid=self.account.domainid) for router in routers: if router.redundantstate == 'MASTER' or len(routers) == 1: self._perform_dnsmasq_service_dns_test(router, network_1) # Do the same after restart with cleanup self.restart_vpc_with_cleanup(vpc_1, True) self.logger.debug("Getting the router info again after the cleanup (router names / ip addresses changed)") routers = list_routers(self.apiclient, account=self.account.name, domainid=self.account.domainid) self.assertEqual(isinstance(routers, list), True, "Check for list routers response return valid data") self.logger.debug("Check whether routers are happy") for router in routers: if router.redundantstate == 'MASTER' or len(routers) == 1: self._perform_dnsmasq_service_dns_test(router, network_1)
def perform_password_service_tests(self, vpc_off): self.enable_template_password( template_id=self.template.id, passwordenabled=True) self.logger.debug("Creating VPC with offering ID %s" % vpc_off.id) vpc_1 = self.createVPC(vpc_off, cidr='10.0.0.0/16') self.logger.debug("Creating network inside VPC") net_off = get_default_network_offering(self.apiclient) network_1 = self.createNetwork(vpc_1, net_off, gateway='10.0.0.1') acl1 = self.createACL(vpc_1) self.createACLItem(acl1.id, cidr="0.0.0.0/0") self.replaceNetworkAcl(acl1.id, network_1) routers = list_routers(self.apiclient, account=self.account.name, domainid=self.account.domainid) for router in routers: if router.redundantstate == 'MASTER' or len(routers) == 1: self._perform_password_service_test(router, network_1) # Do the same after restart with cleanup self.restart_vpc_with_cleanup(vpc_1, True) self.logger.debug("Getting the router info again after the cleanup (router names / ip addresses changed)") routers = list_routers(self.apiclient, account=self.account.name, domainid=self.account.domainid) self.assertEqual(isinstance(routers, list), True, "Check for list routers response return valid data") self.logger.debug("Check whether routers are happy") for router in routers: if router.redundantstate == 'MASTER' or len(routers) == 1: self._perform_password_service_test(router, network_1) self.enable_template_password( template_id=self.template.id, passwordenabled=False)
def test_04_rvpc_multi_tiers(self): """ Create a redundant VPC with 3 Tiers, 3 VMs, 3 PF rules""" self.logger.debug("Starting test_05_rvpc_multi_tiers") self.query_routers() net_off = get_default_network_offering(self.apiclient) network1 = self.create_network(net_off, "10.1.1.1", nr_vms=1) self.networks.append(network1) net_off_no_lb = get_default_network_offering_no_load_balancer( self.apiclient) self.networks.append( self.create_network(net_off_no_lb, "10.1.2.1", nr_vms=1)) network2 = self.create_network(net_off_no_lb, "10.1.3.1", nr_vms=1) self.networks.append(network2) self.check_routers_state() self.add_nat_rules() self.do_vpc_test(False) self.destroy_vm(network1) network1.get_net().delete(self.apiclient) self.networks.remove(network1) self.check_routers_state(status_to_check="MASTER") self.do_vpc_test(False) self.destroy_vm(network2) network2.get_net().delete(self.apiclient) self.networks.remove(network2) self.check_routers_state(status_to_check="MASTER") self.do_vpc_test(False)
def test_01_VPC_nics_after_destroy(self): """ Create a VPC with two networks with one VM in each network and test nics after destroy""" self.logger.debug("Starting test_01_VPC_nics_after_destroy") self.query_routers() net_off = get_default_network_offering(self.apiclient) net1 = self.create_network(net_off, "10.1.1.1") net_off_no_lb = get_default_network_offering_no_load_balancer( self.apiclient) net2 = self.create_network(net_off_no_lb, "10.1.2.1") self.networks.append(net1) self.networks.append(net2) self.add_nat_rules() self.check_ssh_into_vm() self.destroy_routers() time.sleep(30) net1.add_vm(self.deployvm_in_network(net1.get_net())) self.query_routers() self.add_nat_rules() self.check_ssh_into_vm()
def _test_04_rvpc_multi_tiers(self): """ Create a redundant VPC with 3 Tiers, 3 VMs, 3 PF rules""" self.logger.debug("Starting test_04_rvpc_multi_tiers") self.query_routers() net_off = get_default_network_offering(self.apiclient) network1 = self.create_network(net_off, "10.1.1.1", nr_vms=1) self.networks.append(network1) net_off_no_lb = get_default_network_offering_no_load_balancer(self.apiclient) self.networks.append(self.create_network(net_off_no_lb, "10.1.2.1", nr_vms=1)) network2 = self.create_network(net_off_no_lb, "10.1.3.1", nr_vms=1) self.networks.append(network2) self.check_routers_state() self.add_nat_rules() self.do_vpc_test(False) self.destroy_vm(network1) network1.get_net().delete(self.apiclient) self.networks.remove(network1) self.check_routers_state(status_to_check="MASTER") self.do_vpc_test(False) self.destroy_vm(network2) network2.get_net().delete(self.apiclient) self.networks.remove(network2) self.check_routers_state(status_to_check="MASTER") self.do_vpc_test(False)
def test_04_rvpc_network_garbage_collector_nics(self): """ Create a redundant VPC with 1 Tier, 1 VM, 1 ACL, 1 PF and test Network GC Nics""" self.logger.debug("Starting test_04_rvpc_network_garbage_collector_nics") self.query_routers() net_off = get_default_network_offering(self.apiclient) self.networks.append(self.create_network(net_off, "10.1.1.1", nr_vms=1)) self.check_routers_state() self.add_nat_rules() self.do_vpc_test(False) self.stop_vm() gc_wait = Configurations.list(self.apiclient, name="network.gc.wait") gc_interval = Configurations.list(self.apiclient, name="network.gc.interval") self.logger.debug("network.gc.wait is ==> %s" % gc_wait) self.logger.debug("network.gc.interval is ==> %s" % gc_wait) total_sleep = 120 if gc_wait and gc_interval: total_sleep = int(gc_wait[0].value) + int(gc_interval[0].value) else: self.logger.debug("Could not retrieve the keys 'network.gc.interval' and 'network.gc.wait'. Sleeping for 2 minutes.") time.sleep(total_sleep * 3) self.check_routers_interface(interface_to_check="eth2", expected_exists=False) self.start_vm() self.check_routers_state(status_to_check="MASTER") self.check_routers_interface(interface_to_check="eth2", expected_exists=True)
def setUpClass(cls): cls.logger = MarvinLog(MarvinLog.LOGGER_TEST).get_logger() # We want to fail quicker if it's failure socket.setdefaulttimeout(60) cls.testClient = super(TestRouterIpTablesPolicies, cls).getClsTestClient() cls.apiclient = cls.testClient.getApiClient() cls.services = cls.testClient.getParsedTestDataConfig() # Get Zone, Domain and templates cls.domain = get_domain(cls.apiclient) cls.zone = get_zone(cls.apiclient, cls.testClient.getZoneForTests()) cls.template = get_template( cls.apiclient, cls.zone.id ) cls.services["vpc"]["cidr"] = '10.1.1.1/16' cls.services["virtual_machine"]["zoneid"] = cls.zone.id cls.services["virtual_machine"]["template"] = cls.template.id cls.vpc_offering = get_default_vpc_offering(cls.apiclient) cls.logger.debug("VPC Offering '%s' selected", cls.vpc_offering.name) cls.network_offering = get_default_network_offering(cls.apiclient) cls.logger.debug("Network Offering '%s' selected", cls.network_offering.name) cls.default_allow_acl = get_network_acl(cls.apiclient, 'default_allow') cls.logger.debug("ACL '%s' selected", cls.default_allow_acl.name) cls.account = Account.create( cls.apiclient, cls.services["account"], admin=True, domainid=cls.domain.id) cls.vpc1 = VPC.create(cls.apiclient, cls.services['vpcs']['vpc1'], vpcofferingid=cls.vpc_offering.id, zoneid=cls.zone.id, domainid=cls.domain.id, account=cls.account.name) cls.logger.debug("VPC '%s' created, CIDR: %s", cls.vpc1.name, cls.vpc1.cidr) cls.network1 = Network.create(cls.apiclient, cls.services['networks']['network1'], networkofferingid=cls.network_offering.id, aclid=cls.default_allow_acl.id, vpcid=cls.vpc1.id, zoneid=cls.zone.id, domainid=cls.domain.id, accountid=cls.account.name) cls.logger.debug("Network '%s' created, CIDR: %s, Gateway: %s", cls.network1.name, cls.network1.cidr, cls.network1.gateway) cls.service_offering = get_default_virtual_machine_offering(cls.apiclient) cls.entity_manager = EntityManager(cls.apiclient, cls.services, cls.service_offering, cls.account, cls.zone, cls.network1, cls.logger) cls._cleanup = [cls.account] return
def test_01_single_VPC_iptables_policies(self): """ Test iptables default INPUT/FORWARD policies on VPC router """ self.logger.debug("Starting test_01_single_VPC_iptables_policies") routers = self.entity_manager.query_routers() self.assertEqual( isinstance(routers, list), True, "Check for list routers response return valid data") net_off = get_default_network_offering(self.apiclient) self.entity_manager.create_network(net_off, self.vpc.id, "10.1.1.1") net_off_no_lb = get_default_network_offering_no_load_balancer(self.apiclient) self.entity_manager.create_network(net_off_no_lb, self.vpc.id, "10.1.2.1") self.entity_manager.add_nat_rules(self.vpc.id) self.entity_manager.do_vpc_test() for router in routers: if not router.isredundantrouter and router.vpcid: hosts = list_hosts( self.apiclient, id=router.hostid) self.assertEqual( isinstance(hosts, list), True, "Check for list hosts response return valid data") host = hosts[0] host.user = self.services["configurableData"]["host"]["username"] host.passwd = self.services["configurableData"]["host"]["password"] host.port = self.services["configurableData"]["host"]["port"] tables = [self.services["configurableData"]["input"], self.services["configurableData"]["forward"]] for table in tables: try: result = get_process_status( host.ipaddress, host.port, host.user, host.passwd, router.linklocalip, 'iptables -L %s' % table) except KeyError: self.skipTest( "Provide a marvin config file with host\ credentials to run %s" % self._testMethodName) self.logger.debug("iptables -L %s: %s" % (table, result)) res = str(result) self.assertEqual( res.count("policy DROP"), 1, "%s Default Policy should be DROP" % table)
def test_01_single_VPC_iptables_policies(self): """ Test iptables default INPUT/FORWARD policies on VPC router """ self.logger.debug("Starting test_01_single_VPC_iptables_policies") routers = self.entity_manager.query_routers() self.assertEqual( isinstance(routers, list), True, "Check for list routers response return valid data") net_off = get_default_network_offering(self.apiclient) self.entity_manager.create_network(net_off, self.vpc.id, "10.1.1.1") net_off_no_lb = get_default_network_offering_no_load_balancer(self.apiclient) self.entity_manager.create_network(net_off_no_lb, self.vpc.id, "10.1.2.1") self.entity_manager.add_nat_rules(self.vpc.id) self.entity_manager.do_vpc_test() for router in routers: if not router.isredundantrouter and router.vpcid: hosts = list_hosts( self.apiclient, id=router.hostid) self.assertEqual( isinstance(hosts, list), True, "Check for list hosts response return valid data") host = hosts[0] host.user = self.services["configurableData"]["host"]["username"] host.passwd = self.services["configurableData"]["host"]["password"] host.port = self.services["configurableData"]["host"]["port"] tables = [self.services["configurableData"]["input"], self.services["configurableData"]["forward"]] for table in tables: try: result = get_process_status( host.ipaddress, host.port, host.user, host.passwd, router.linklocalip, 'iptables -L %s' % table) except KeyError: self.skipTest( "Provide a marvin config file with host\ credentials to run %s" % self._testMethodName) self.logger.debug("iptables -L %s: %s" % (table, result)) res = str(result) self.assertEqual( res.count("DROP"), 1, "%s Default Policy should be DROP" % table)
def _test_02_redundant_VPC_default_routes(self): """ Create a redundant VPC with two networks with two VMs in each network and check default routes""" self.logger.debug("Starting test_02_redundant_VPC_default_routes") self.query_routers() net_off = get_default_network_offering(self.apiclient) self.networks.append(self.create_network(net_off, "10.1.1.1")) net_off_no_lb = get_default_network_offering_no_load_balancer(self.apiclient) self.networks.append(self.create_network(net_off_no_lb, "10.1.2.1")) self.check_routers_state() self.add_nat_rules() self.do_default_routes_test()
def test_02_redundant_VPC_default_routes(self): """ Create a redundant VPC with two networks with two VMs in each network and check default routes""" self.logger.debug("Starting test_02_redundant_VPC_default_routes") self.query_routers() net_off = get_default_network_offering(self.apiclient) self.networks.append(self.create_network(net_off, "10.1.1.1")) net_off_no_lb = get_default_network_offering_no_load_balancer(self.apiclient) self.networks.append(self.create_network(net_off_no_lb, "10.1.2.1")) self.check_routers_state() self.add_nat_rules() self.do_default_routes_test()
def test_02_VPC_default_routes(self): """ Create a VPC with two networks with one VM in each network and test default routes""" self.logger.debug("Starting test_02_VPC_default_routes") self.query_routers() net_off = get_default_network_offering(self.apiclient) net1 = self.create_network(net_off, "10.1.1.1") net_off_no_lb = get_default_network_offering_no_load_balancer(self.apiclient) net2 = self.create_network(net_off_no_lb, "10.1.2.1") self.networks.append(net1) self.networks.append(net2) self.add_nat_rules() self.do_default_routes_test()
def test_02_VPC_default_routes(self): """ Create a VPC with two networks with one VM in each network and test default routes""" self.logger.debug("Starting test_02_VPC_default_routes") self.query_routers() net_off = get_default_network_offering(self.apiclient) net1 = self.create_network(net_off, "10.1.1.1") net_off_no_lb = get_default_network_offering_no_load_balancer( self.apiclient) net2 = self.create_network(net_off_no_lb, "10.1.2.1") self.networks.append(net1) self.networks.append(net2) self.add_nat_rules() self.do_default_routes_test()
def _test_03_create_redundant_VPC_1tier_2VMs_2IPs_2PF_ACL_reboot_routers(self): """ Create a redundant VPC with two networks with two VMs in each network """ self.logger.debug("Starting test_01_create_redundant_VPC_2tiers_4VMs_4IPs_4PF_ACL") self.query_routers() net_off = get_default_network_offering(self.apiclient) self.networks.append(self.create_network(net_off, "10.1.1.1")) self.check_routers_state() self.add_nat_rules() self.do_vpc_test(False) self.reboot_router_by_type("MASTER") self.check_routers_state() self.do_vpc_test(False) self.reboot_router_by_type("MASTER") self.check_routers_state() self.do_vpc_test(False)
def test_03_create_redundant_VPC_1tier_2VMs_2IPs_2PF_ACL_reboot_routers(self): """ Create a redundant VPC with two networks with two VMs in each network """ self.logger.debug("Starting test_01_create_redundant_VPC_2tiers_4VMs_4IPs_4PF_ACL") self.query_routers() net_off = get_default_network_offering(self.apiclient) self.networks.append(self.create_network(net_off, "10.1.1.1")) self.check_routers_state() self.add_nat_rules() self.do_vpc_test(False) self.reboot_router_by_type("MASTER") self.check_routers_state() self.do_vpc_test(False) self.reboot_router_by_type("MASTER") self.check_routers_state() self.do_vpc_test(False)
def setUpClass(cls, redundant=False): cls.logger = MarvinLog(MarvinLog.LOGGER_TEST).get_logger() test_client = super(TestVpcVpn, cls).getClsTestClient() cls.apiclient = test_client.getApiClient() cls.services = test_client.getParsedTestDataConfig() cls.zone = get_zone(cls.apiclient, test_client.getZoneForTests()) cls.domain = get_domain(cls.apiclient) cls.vpc_offering = get_default_redundant_vpc_offering( cls.apiclient) if redundant else get_default_vpc_offering( cls.apiclient) cls.logger.debug("VPC Offering '%s' selected", cls.vpc_offering.name) cls.network_offering = get_default_network_offering(cls.apiclient) cls.logger.debug("Network Offering '%s' selected", cls.network_offering.name) cls.virtual_machine_offering = get_default_virtual_machine_offering( cls.apiclient) cls.logger.debug("Virtual Machine Offering '%s' selected", cls.virtual_machine_offering.name) cls.account = Account.create(cls.apiclient, services=cls.services["account"]) cls.logger.debug("Successfully created account: %s, id: %s" % (cls.account.name, cls.account.id)) cls.hypervisor = test_client.getHypervisorInfo() cls._cleanup = [cls.account] cls.template = get_template(cls.apiclient, cls.zone.id) return
def test_01_VPC_nics_after_destroy(self): """ Create a VPC with two networks with one VM in each network and test nics after destroy""" self.logger.debug("Starting test_01_VPC_nics_after_destroy") self.query_routers() net_off = get_default_network_offering(self.apiclient) net1 = self.create_network(net_off, "10.1.1.1") net_off_no_lb = get_default_network_offering_no_load_balancer(self.apiclient) net2 = self.create_network(net_off_no_lb, "10.1.2.1") self.networks.append(net1) self.networks.append(net2) self.add_nat_rules() self.check_ssh_into_vm() self.destroy_routers() time.sleep(30) net1.add_vm(self.deployvm_in_network(net1.get_net())) self.query_routers() self.add_nat_rules() self.check_ssh_into_vm()
def setUpClass(cls): cls.logger = MarvinLog(MarvinLog.LOGGER_TEST).get_logger() testClient = super(TestLoadBalance, cls).getClsTestClient() cls.apiclient = testClient.getApiClient() cls.services = testClient.getParsedTestDataConfig() # Get Zone, Domain and templates cls.domain = get_domain(cls.apiclient) cls.zone = get_zone(cls.apiclient, testClient.getZoneForTests()) cls.template = get_template( cls.apiclient, cls.zone.id ) if cls.template == FAILED: assert False, "get_template() failed to return template with description %s" % cls.services["ostype"] cls.services["virtual_machine"]["zoneid"] = cls.zone.id # Create an account, network, VM and IP addresses cls.account = Account.create( cls.apiclient, cls.services["account"], admin=True, domainid=cls.domain.id ) cls.service_offering = get_default_virtual_machine_offering(cls.apiclient) cls.network_offering = get_default_network_offering(cls.apiclient) cls.logger.debug("Network Offering '%s' selected", cls.network_offering.name) cls.vpc_offering = get_default_vpc_offering(cls.apiclient) cls.logger.debug("VPC Offering '%s' selected", cls.vpc_offering.name) cls.vpc1 = VPC.create(cls.apiclient, cls.services['vpcs']['vpc1'], vpcofferingid=cls.vpc_offering.id, zoneid=cls.zone.id, domainid=cls.domain.id, account=cls.account.name) cls.logger.debug("VPC '%s' created, CIDR: %s", cls.vpc1.name, cls.vpc1.cidr) cls.default_allow_acl = get_network_acl(cls.apiclient, 'default_allow') cls.logger.debug("ACL '%s' selected", cls.default_allow_acl.name) cls.network1 = Network.create(cls.apiclient, cls.services['networks']['network1'], networkofferingid=cls.network_offering.id, aclid=cls.default_allow_acl.id, vpcid=cls.vpc1.id, zoneid=cls.zone.id, domainid=cls.domain.id, accountid=cls.account.name) cls.logger.debug("Network '%s' created, CIDR: %s, Gateway: %s", cls.network1.name, cls.network1.cidr, cls.network1.gateway) cls.vm_1 = VirtualMachine.create( cls.apiclient, cls.services["virtual_machine"], templateid=cls.template.id, accountid=cls.account.name, domainid=cls.account.domainid, serviceofferingid=cls.service_offering.id, networkids=[cls.network1.id] ) cls.vm_2 = VirtualMachine.create( cls.apiclient, cls.services["virtual_machine"], templateid=cls.template.id, accountid=cls.account.name, domainid=cls.account.domainid, serviceofferingid=cls.service_offering.id, networkids=[cls.network1.id] ) cls.vm_3 = VirtualMachine.create( cls.apiclient, cls.services["virtual_machine"], templateid=cls.template.id, accountid=cls.account.name, domainid=cls.account.domainid, serviceofferingid=cls.service_offering.id, networkids=[cls.network1.id] ) cls.non_src_nat_ip = PublicIPAddress.create(cls.apiclient, zoneid=cls.zone.id, domainid=cls.account.domainid, accountid=cls.account.name, vpcid=cls.vpc1.id, networkid=cls.network1.id) cls.logger.debug("Public IP '%s' acquired, VPC: %s, Network: %s", cls.non_src_nat_ip.ipaddress.ipaddress, cls.vpc1.name, cls.network1.name) command = replaceNetworkACLList.replaceNetworkACLListCmd() command.aclid = cls.default_allow_acl.id command.publicipid = cls.non_src_nat_ip.ipaddress.id cls.apiclient.replaceNetworkACLList(command) cls._cleanup = [ cls.account ]
def setUpClass(cls): cls.logger = MarvinLog(MarvinLog.LOGGER_TEST).get_logger() # We want to fail quicker if it's failure socket.setdefaulttimeout(60) cls.testClient = super(TestRouterIpTablesPolicies, cls).getClsTestClient() cls.apiclient = cls.testClient.getApiClient() cls.services = cls.testClient.getParsedTestDataConfig() # Get Zone, Domain and templates cls.domain = get_domain(cls.apiclient) cls.zone = get_zone(cls.apiclient, cls.testClient.getZoneForTests()) cls.template = get_template(cls.apiclient, cls.zone.id) cls.services["vpc"]["cidr"] = '10.1.1.1/16' cls.services["virtual_machine"]["zoneid"] = cls.zone.id cls.services["virtual_machine"]["template"] = cls.template.id cls.vpc_offering = get_default_vpc_offering(cls.apiclient) cls.logger.debug("VPC Offering '%s' selected", cls.vpc_offering.name) cls.network_offering = get_default_network_offering(cls.apiclient) cls.logger.debug("Network Offering '%s' selected", cls.network_offering.name) cls.default_allow_acl = get_network_acl(cls.apiclient, 'default_allow') cls.logger.debug("ACL '%s' selected", cls.default_allow_acl.name) cls.account = Account.create(cls.apiclient, cls.services["account"], admin=True, domainid=cls.domain.id) cls.vpc1 = VPC.create(cls.apiclient, cls.services['vpcs']['vpc1'], vpcofferingid=cls.vpc_offering.id, zoneid=cls.zone.id, domainid=cls.domain.id, account=cls.account.name) cls.logger.debug("VPC '%s' created, CIDR: %s", cls.vpc1.name, cls.vpc1.cidr) cls.network1 = Network.create( cls.apiclient, cls.services['networks']['network1'], networkofferingid=cls.network_offering.id, aclid=cls.default_allow_acl.id, vpcid=cls.vpc1.id, zoneid=cls.zone.id, domainid=cls.domain.id, accountid=cls.account.name) cls.logger.debug("Network '%s' created, CIDR: %s, Gateway: %s", cls.network1.name, cls.network1.cidr, cls.network1.gateway) cls.service_offering = get_default_virtual_machine_offering( cls.apiclient) cls.entity_manager = EntityManager(cls.apiclient, cls.services, cls.service_offering, cls.account, cls.zone, cls.network1, cls.logger) cls._cleanup = [cls.account] return
def setUp(self): self.logger = MarvinLog(MarvinLog.LOGGER_TEST).get_logger() self.apiclient = self.testClient.getApiClient() self.services = self.testClient.getParsedTestDataConfig() self.vpc_offering = get_default_vpc_offering(self.apiclient) self.network_offering = get_default_network_offering(self.apiclient) # Get Zone, Domain and templates self.domain = get_domain(self.apiclient) self.zone = get_zone(self.apiclient, self.testClient.getZoneForTests()) template = get_template( self.apiclient, self.zone.id ) self.services["virtual_machine"]["zoneid"] = self.zone.id # Create an account, network, VM, Port forwarding rule, LB rules self.account = Account.create( self.apiclient, self.services["account"], admin=True, domainid=self.domain.id ) self.service_offering = get_default_virtual_machine_offering(self.apiclient) self.vpc = VPC.create( self.apiclient, self.services["vpc"], vpcofferingid=self.vpc_offering.id, zoneid=self.zone.id, account=self.account.name, domainid=self.account.domainid) ntwk = Network.create( api_client=self.apiclient, services=self.services["network_1"], accountid=self.account.name, domainid=self.domain.id, networkofferingid=self.network_offering.id, zoneid=self.zone.id, vpcid=self.vpc.id ) networkids = [] networkids.append(ntwk.id) self.virtual_machine = VirtualMachine.create( self.apiclient, self.services["virtual_machine"], templateid=template.id, accountid=self.account.name, domainid=self.account.domainid, serviceofferingid=self.service_offering.id, networkids=networkids ) self.ip_address = PublicIPAddress.create( self.apiclient, self.account.name, self.zone.id, self.account.domainid, vpcid=self.vpc.id ) ip_addrs = list_public_ip( self.apiclient, account=self.account.name, domainid=self.account.domainid, issourcenat=False ) try: self.ip_addr = ip_addrs[0] except Exception as e: raise Exception( "Failed: During acquiring source NAT for account: %s, :%s" % (self.account.name, e)) self.nat_rule = NATRule.create( self.apiclient, self.virtual_machine, self.services["natrule"], self.ip_addr.id, networkid=ntwk.id ) self.lb_rule = LoadBalancerRule.create( self.apiclient, self.services["lbrule"], self.ip_addr.id, accountid=self.account.name, networkid=ntwk.id ) self.cleanup = [ self.virtual_machine, self.account ] return
def setUpClass(cls): cls.logger = MarvinLog(MarvinLog.LOGGER_TEST).get_logger() testClient = super(TestLoadBalance, cls).getClsTestClient() cls.apiclient = testClient.getApiClient() cls.services = testClient.getParsedTestDataConfig() # Get Zone, Domain and templates cls.domain = get_domain(cls.apiclient) cls.zone = get_zone(cls.apiclient, testClient.getZoneForTests()) cls.template = get_template(cls.apiclient, cls.zone.id) if cls.template == FAILED: assert False, "get_template() failed to return template with description %s" % cls.services[ "ostype"] cls.services["virtual_machine"]["zoneid"] = cls.zone.id # Create an account, network, VM and IP addresses cls.account = Account.create(cls.apiclient, cls.services["account"], admin=True, domainid=cls.domain.id) cls.service_offering = get_default_virtual_machine_offering( cls.apiclient) cls.network_offering = get_default_network_offering(cls.apiclient) cls.logger.debug("Network Offering '%s' selected", cls.network_offering.name) cls.vpc_offering = get_default_vpc_offering(cls.apiclient) cls.logger.debug("VPC Offering '%s' selected", cls.vpc_offering.name) cls.vpc1 = VPC.create(cls.apiclient, cls.services['vpcs']['vpc1'], vpcofferingid=cls.vpc_offering.id, zoneid=cls.zone.id, domainid=cls.domain.id, account=cls.account.name) cls.logger.debug("VPC '%s' created, CIDR: %s", cls.vpc1.name, cls.vpc1.cidr) cls.default_allow_acl = get_network_acl(cls.apiclient, 'default_allow') cls.logger.debug("ACL '%s' selected", cls.default_allow_acl.name) cls.network1 = Network.create( cls.apiclient, cls.services['networks']['network1'], networkofferingid=cls.network_offering.id, aclid=cls.default_allow_acl.id, vpcid=cls.vpc1.id, zoneid=cls.zone.id, domainid=cls.domain.id, accountid=cls.account.name) cls.logger.debug("Network '%s' created, CIDR: %s, Gateway: %s", cls.network1.name, cls.network1.cidr, cls.network1.gateway) cls.vm_1 = VirtualMachine.create( cls.apiclient, cls.services["virtual_machine"], templateid=cls.template.id, accountid=cls.account.name, domainid=cls.account.domainid, serviceofferingid=cls.service_offering.id, networkids=[cls.network1.id]) cls.vm_2 = VirtualMachine.create( cls.apiclient, cls.services["virtual_machine"], templateid=cls.template.id, accountid=cls.account.name, domainid=cls.account.domainid, serviceofferingid=cls.service_offering.id, networkids=[cls.network1.id]) cls.vm_3 = VirtualMachine.create( cls.apiclient, cls.services["virtual_machine"], templateid=cls.template.id, accountid=cls.account.name, domainid=cls.account.domainid, serviceofferingid=cls.service_offering.id, networkids=[cls.network1.id]) cls.non_src_nat_ip = PublicIPAddress.create( cls.apiclient, zoneid=cls.zone.id, domainid=cls.account.domainid, accountid=cls.account.name, vpcid=cls.vpc1.id, networkid=cls.network1.id) cls.logger.debug("Public IP '%s' acquired, VPC: %s, Network: %s", cls.non_src_nat_ip.ipaddress.ipaddress, cls.vpc1.name, cls.network1.name) command = replaceNetworkACLList.replaceNetworkACLListCmd() command.aclid = cls.default_allow_acl.id command.publicipid = cls.non_src_nat_ip.ipaddress.id cls.apiclient.replaceNetworkACLList(command) cls._cleanup = [cls.account]
def setUp(self): self.logger = MarvinLog(MarvinLog.LOGGER_TEST).get_logger() self.apiclient = self.testClient.getApiClient() self.services = self.testClient.getParsedTestDataConfig() self.vpc_offering = get_default_vpc_offering(self.apiclient) self.network_offering = get_default_network_offering(self.apiclient) # Get Zone, Domain and templates self.domain = get_domain(self.apiclient) self.zone = get_zone(self.apiclient, self.testClient.getZoneForTests()) template = get_template(self.apiclient, self.zone.id) self.services["virtual_machine"]["zoneid"] = self.zone.id # Create an account, network, VM, Port forwarding rule, LB rules self.account = Account.create(self.apiclient, self.services["account"], admin=True, domainid=self.domain.id) self.service_offering = get_default_virtual_machine_offering( self.apiclient) self.vpc = VPC.create(self.apiclient, self.services["vpc"], vpcofferingid=self.vpc_offering.id, zoneid=self.zone.id, account=self.account.name, domainid=self.account.domainid) ntwk = Network.create(api_client=self.apiclient, services=self.services["network_1"], accountid=self.account.name, domainid=self.domain.id, networkofferingid=self.network_offering.id, zoneid=self.zone.id, vpcid=self.vpc.id) networkids = [] networkids.append(ntwk.id) self.virtual_machine = VirtualMachine.create( self.apiclient, self.services["virtual_machine"], templateid=template.id, accountid=self.account.name, domainid=self.account.domainid, serviceofferingid=self.service_offering.id, networkids=networkids) self.ip_address = PublicIPAddress.create(self.apiclient, self.account.name, self.zone.id, self.account.domainid, vpcid=self.vpc.id) ip_addrs = list_public_ip(self.apiclient, account=self.account.name, domainid=self.account.domainid, issourcenat=False) try: self.ip_addr = ip_addrs[0] except Exception as e: raise Exception( "Failed: During acquiring source NAT for account: %s, :%s" % (self.account.name, e)) self.nat_rule = NATRule.create(self.apiclient, self.virtual_machine, self.services["natrule"], self.ip_addr.id, networkid=ntwk.id) self.lb_rule = LoadBalancerRule.create(self.apiclient, self.services["lbrule"], self.ip_addr.id, accountid=self.account.name, networkid=ntwk.id) self.cleanup = [self.virtual_machine, self.account] return
def setUp(self): self.logger = MarvinLog(MarvinLog.LOGGER_TEST).get_logger() self.apiclient = self.testClient.getApiClient() self.services = self.testClient.getParsedTestDataConfig() # Get Zone, Domain and templates self.domain = get_domain(self.apiclient) self.zone = get_zone(self.apiclient, self.testClient.getZoneForTests()) template = get_template( self.apiclient, self.zone.id ) self.services["virtual_machine"]["zoneid"] = self.zone.id # Create an account, network, VM and IP addresses self.account = Account.create( self.apiclient, self.services["account"], admin=True, domainid=self.domain.id ) self.vpc_offering = get_default_vpc_offering(self.apiclient) self.logger.debug("VPC Offering '%s' selected", self.vpc_offering.name) self.network_offering = get_default_network_offering(self.apiclient) self.logger.debug("Network Offering '%s' selected", self.network_offering.name) self.virtual_machine_offering = get_default_virtual_machine_offering(self.apiclient) self.logger.debug("Virtual Machine Offering '%s' selected", self.virtual_machine_offering.name) self.default_allow_acl = get_network_acl(self.apiclient, 'default_allow') self.logger.debug("ACL '%s' selected", self.default_allow_acl.name) self.template = get_template(self.apiclient, self.zone.id) self.logger.debug("Template '%s' selected" % self.template.name) self.vpc1 = VPC.create(self.apiclient, self.services['vpcs']['vpc1'], vpcofferingid=self.vpc_offering.id, zoneid=self.zone.id, domainid=self.domain.id, account=self.account.name) self.logger.debug("VPC '%s' created, CIDR: %s", self.vpc1.name, self.vpc1.cidr) self.network1 = Network.create(self.apiclient, self.services['networks']['network1'], networkofferingid=self.network_offering.id, aclid=self.default_allow_acl.id, vpcid=self.vpc1.id, zoneid=self.zone.id, domainid=self.domain.id, accountid=self.account.name) self.logger.debug("Network '%s' created, CIDR: %s, Gateway: %s", self.network1.name, self.network1.cidr, self.network1.gateway) self.vm1 = VirtualMachine.create(self.apiclient, self.services['vms']['vm1'], templateid=self.template.id, serviceofferingid=self.virtual_machine_offering.id, networkids=[self.network1.id], zoneid=self.zone.id, domainid=self.domain.id, accountid=self.account.name) self.logger.debug("VM '%s' created, Network: %s, IP %s", self.vm1.name, self.network1.name, self.vm1.nic[0].ipaddress) src_nat_ip_addrs = list_public_ip( self.apiclient, account=self.account.name, domainid=self.account.domainid ) try: src_nat_ip_addr = src_nat_ip_addrs[0] except Exception as e: self.fail("SSH failed for VM with IP: %s %s" % (src_nat_ip_addr.ipaddress, e)) self.lb_rule = LoadBalancerRule.create( self.apiclient, self.services["lbrule"], src_nat_ip_addr.id, self.account.name, self.network1.id, self.vpc1.id ) self.lb_rule.assign(self.apiclient, [self.vm1]) self.nat_rule = NATRule.create( self.apiclient, self.vm1, self.services["natrule"], src_nat_ip_addr.id ) self.cleanup = [] return
def setup_infra(cls, redundant=False): if len(cls.class_cleanup) > 0: cleanup_resources(cls.api_client, cls.class_cleanup, cls.logger) cls.class_cleanup = [] cls.zone = get_zone(cls.api_client, cls.test_client.getZoneForTests()) cls.logger.debug("Zone '%s' selected" % cls.zone.name) cls.domain = get_domain(cls.api_client) cls.logger.debug("Domain '%s' selected" % cls.domain.name) cls.template = get_template(cls.api_client, cls.zone.id) cls.logger.debug("Template '%s' selected" % cls.template.name) cls.account = Account.create(cls.api_client, cls.attributes['account'], admin=True, domainid=cls.domain.id) cls.class_cleanup += [cls.account] cls.logger.debug("Account '%s' created", cls.account.name) cls.vpc_offering = get_default_redundant_vpc_offering( cls.api_client) if redundant else get_default_vpc_offering( cls.api_client) cls.logger.debug("VPC Offering '%s' selected", cls.vpc_offering.name) cls.network_offering = get_default_network_offering(cls.api_client) cls.logger.debug("Network Offering '%s' selected", cls.network_offering.name) cls.virtual_machine_offering = get_default_virtual_machine_offering( cls.api_client) cls.logger.debug("Virtual Machine Offering '%s' selected", cls.virtual_machine_offering.name) cls.default_allow_acl = get_network_acl(cls.api_client, 'default_allow') cls.logger.debug("ACL '%s' selected", cls.default_allow_acl.name) cls.default_deny_acl = get_network_acl(cls.api_client, 'default_deny') cls.logger.debug("ACL '%s' selected", cls.default_deny_acl.name) cls.vpc1 = VPC.create(cls.api_client, cls.attributes['vpcs']['vpc1'], vpcofferingid=cls.vpc_offering.id, zoneid=cls.zone.id, domainid=cls.domain.id, account=cls.account.name) cls.logger.debug("VPC '%s' created, CIDR: %s", cls.vpc1.name, cls.vpc1.cidr) cls.network1 = Network.create( cls.api_client, cls.attributes['networks']['network1'], networkofferingid=cls.network_offering.id, aclid=cls.default_allow_acl.id, vpcid=cls.vpc1.id, zoneid=cls.zone.id, domainid=cls.domain.id, accountid=cls.account.name) cls.logger.debug("Network '%s' created, CIDR: %s, Gateway: %s", cls.network1.name, cls.network1.cidr, cls.network1.gateway) cls.vm1 = VirtualMachine.create( cls.api_client, cls.attributes['vms']['vm1'], templateid=cls.template.id, serviceofferingid=cls.virtual_machine_offering.id, networkids=[cls.network1.id], zoneid=cls.zone.id, domainid=cls.domain.id, accountid=cls.account.name) cls.logger.debug("VM '%s' created, Network: %s, IP %s", cls.vm1.name, cls.network1.name, cls.vm1.nic[0].ipaddress) cls.public_ip1 = PublicIPAddress.create(cls.api_client, zoneid=cls.zone.id, domainid=cls.account.domainid, accountid=cls.account.name, vpcid=cls.vpc1.id, networkid=cls.network1.id) cls.logger.debug("Public IP '%s' acquired, VPC: %s, Network: %s", cls.public_ip1.ipaddress.ipaddress, cls.vpc1.name, cls.network1.name) cls.nat_rule1 = NATRule.create(cls.api_client, cls.vm1, cls.attributes['nat_rule'], vpcid=cls.vpc1.id, networkid=cls.network1.id, ipaddressid=cls.public_ip1.ipaddress.id) cls.logger.debug("Port Forwarding Rule '%s (%s) %s => %s' created", cls.nat_rule1.ipaddress, cls.nat_rule1.protocol, cls.nat_rule1.publicport, cls.nat_rule1.privateport)
def setup_infra(cls, redundant=False): if len(cls.class_cleanup) > 0: cleanup_resources(cls.api_client, cls.class_cleanup, cls.logger) cls.class_cleanup = [] cls.zone = get_zone(cls.api_client, cls.test_client.getZoneForTests()) cls.logger.debug("Zone '%s' selected" % cls.zone.name) cls.domain = get_domain(cls.api_client) cls.logger.debug("Domain '%s' selected" % cls.domain.name) cls.template = get_template( cls.api_client, cls.zone.id) cls.logger.debug("Template '%s' selected" % cls.template.name) cls.account = Account.create( cls.api_client, cls.attributes['account'], admin=True, domainid=cls.domain.id) cls.class_cleanup += [cls.account] cls.logger.debug("Account '%s' created", cls.account.name) cls.vpc_offering = get_default_redundant_vpc_offering(cls.api_client) if redundant else get_default_vpc_offering(cls.api_client) cls.logger.debug("VPC Offering '%s' selected", cls.vpc_offering.name) cls.network_offering = get_default_network_offering(cls.api_client) cls.logger.debug("Network Offering '%s' selected", cls.network_offering.name) cls.virtual_machine_offering = get_default_virtual_machine_offering(cls.api_client) cls.logger.debug("Virtual Machine Offering '%s' selected", cls.virtual_machine_offering.name) cls.private_network_offering = get_default_private_network_offering(cls.api_client) cls.logger.debug("Private Network Offering '%s' selected", cls.private_network_offering.name) cls.default_allow_acl = get_network_acl(cls.api_client, 'default_allow') cls.logger.debug("ACL '%s' selected", cls.default_allow_acl.name) cls.vpc1 = VPC.create(cls.api_client, cls.attributes['vpcs']['vpc1'], vpcofferingid=cls.vpc_offering.id, zoneid=cls.zone.id, domainid=cls.domain.id, account=cls.account.name) cls.logger.debug("VPC '%s' created, CIDR: %s", cls.vpc1.name, cls.vpc1.cidr) cls.network1 = Network.create(cls.api_client, cls.attributes['networks']['network1'], networkofferingid=cls.network_offering.id, aclid=cls.default_allow_acl.id, vpcid=cls.vpc1.id, zoneid=cls.zone.id, domainid=cls.domain.id, accountid=cls.account.name) cls.logger.debug("Network '%s' created, CIDR: %s, Gateway: %s", cls.network1.name, cls.network1.cidr, cls.network1.gateway) cls.vm1 = VirtualMachine.create(cls.api_client, cls.attributes['vms']['vm1'], templateid=cls.template.id, serviceofferingid=cls.virtual_machine_offering.id, networkids=[cls.network1.id], zoneid=cls.zone.id, domainid=cls.domain.id, accountid=cls.account.name) cls.logger.debug("VM '%s' created, Network: %s, IP %s", cls.vm1.name, cls.network1.name, cls.vm1.nic[0].ipaddress) cls.public_ip1 = PublicIPAddress.create(cls.api_client, zoneid=cls.zone.id, domainid=cls.account.domainid, accountid=cls.account.name, vpcid=cls.vpc1.id, networkid=cls.network1.id) cls.logger.debug("Public IP '%s' acquired, VPC: %s, Network: %s", cls.public_ip1.ipaddress.ipaddress, cls.vpc1.name, cls.network1.name) cls.nat_rule1 = NATRule.create(cls.api_client, cls.vm1, cls.attributes['nat_rule'], vpcid=cls.vpc1.id, networkid=cls.network1.id, ipaddressid=cls.public_ip1.ipaddress.id) cls.logger.debug("Port Forwarding Rule '%s (%s) %s => %s' created", cls.nat_rule1.ipaddress, cls.nat_rule1.protocol, cls.nat_rule1.publicport, cls.nat_rule1.privateport) cls.vpc2 = VPC.create(cls.api_client, cls.attributes['vpcs']['vpc2'], vpcofferingid=cls.vpc_offering.id, zoneid=cls.zone.id, domainid=cls.domain.id, account=cls.account.name) cls.logger.debug("VPC '%s' created, CIDR: %s", cls.vpc2.name, cls.vpc2.cidr) cls.network2 = Network.create(cls.api_client, cls.attributes['networks']['network3'], networkofferingid=cls.network_offering.id, aclid=cls.default_allow_acl.id, vpcid=cls.vpc2.id, zoneid=cls.zone.id, domainid=cls.domain.id, accountid=cls.account.name) cls.logger.debug("Network '%s' created, CIDR: %s, Gateway: %s", cls.network2.name, cls.network2.cidr, cls.network2.gateway) cls.vm2 = VirtualMachine.create(cls.api_client, cls.attributes['vms']['vm2'], templateid=cls.template.id, serviceofferingid=cls.virtual_machine_offering.id, networkids=[cls.network2.id], zoneid=cls.zone.id, domainid=cls.domain.id, accountid=cls.account.name) cls.logger.debug("VM '%s' created, Network: %s, IP: %s", cls.vm2.name, cls.network2.name, cls.vm2.nic[0].ipaddress) cls.public_ip2 = PublicIPAddress.create(cls.api_client, zoneid=cls.zone.id, domainid=cls.account.domainid, accountid=cls.account.name, vpcid=cls.vpc2.id, networkid=cls.network2.id) cls.logger.debug("Public IP '%s' acquired, VPC: %s, Network: %s", cls.public_ip2.ipaddress.ipaddress, cls.vpc2.name, cls.network2.name) cls.nat_rule2 = NATRule.create(cls.api_client, cls.vm2, cls.attributes['nat_rule'], vpcid=cls.vpc2.id, networkid=cls.network2.id, ipaddressid=cls.public_ip2.ipaddress.id) cls.logger.debug("Port Forwarding Rule '%s (%s) %s => %s' created", cls.nat_rule2.ipaddress, cls.nat_rule2.protocol, cls.nat_rule2.publicport, cls.nat_rule2.privateport) cls.private_gateways_network = Network.create(cls.api_client, cls.attributes['networks']['private_gateways_network'], networkofferingid=cls.private_network_offering.id, aclid=cls.default_allow_acl.id, zoneid=cls.zone.id, domainid=cls.domain.id, accountid=cls.account.name) cls.logger.debug("Network '%s' created, CIDR: %s", cls.private_gateways_network.name, cls.private_gateways_network.cidr) cls.private_gateway1 = PrivateGateway.create(cls.api_client, ipaddress=cls.attributes['private_gateways']['private_gateway1'], networkid=cls.private_gateways_network.id, aclid=cls.default_allow_acl.id, vpcid=cls.vpc1.id) cls.logger.debug("Private Gateway '%s' created, Network: %s, VPC: %s", cls.private_gateway1.ipaddress, cls.private_gateways_network.name, cls.vpc1.name) cls.static_route1 = StaticRoute.create(cls.api_client, cls.attributes['static_routes']['static_route1'], vpcid=cls.vpc1.id) cls.logger.debug("Static Route '%s => %s' created, VPC: %s", cls.static_route1.cidr, cls.static_route1.nexthop, cls.vpc1.name) cls.private_gateway2 = PrivateGateway.create(cls.api_client, ipaddress=cls.attributes['private_gateways']['private_gateway2'], networkid=cls.private_gateways_network.id, aclid=cls.default_allow_acl.id, vpcid=cls.vpc2.id) cls.logger.debug("Private Gateway '%s' created, Network: %s, VPC: %s", cls.private_gateway2.ipaddress, cls.private_gateways_network.name, cls.vpc2.name) cls.static_route2 = StaticRoute.create(cls.api_client, cls.attributes['static_routes']['static_route2'], vpcid=cls.vpc2.id) cls.logger.debug("Static Route '%s => %s' created, VPC: %s", cls.static_route2.cidr, cls.static_route2.nexthop, cls.vpc2.name)