def test_deployvm_multinic(self):
"""Test userdata update when non default nic is without userdata for deploy and update
"""
self.userdata = base64.b64encode(self.userdata)
network1 = Network.create(
self.apiclient,
self.test_data["isolated_network"],
accountid=self.account.name,
domainid=self.account.domainid,
networkofferingid=self.network_offering_all.id,
zoneid=self.zone.id,
)
self.test_data["network_without_acl"]["netmask"] = "255.255.255.128"
network2 = Network.create(
self.apiclient,
self.test_data["network_without_acl"],
accountid=self.account.name,
domainid=self.account.domainid,
networkofferingid=self.network_offering_nouserdata.id,
gateway="10.2.1.1",
zoneid=self.zone.id,
)
deployVmResponse = VirtualMachine.create(
self.apiclient,
services=self.test_data["virtual_machine_userdata"],
accountid=self.account.name,
domainid=self.account.domainid,
serviceofferingid=self.service_offering.id,
networkids=[str(network1.id), str(network2.id)],
templateid=self.template.id,
zoneid=self.zone.id,
)
vms = list_virtual_machines(
self.apiclient, account=self.account.name, domainid=self.account.domainid, id=deployVmResponse.id
)
self.assert_(len(vms) > 0, "There are no Vms deployed in the account %s" % self.account.name)
vm = vms[0]
self.assert_(vm.id == str(deployVmResponse.id), "Vm deployed is different from the test")
self.assert_(vm.state == "Running", "VM is not in Running state")
try:
updateresponse = deployVmResponse.update(self.apiclient, userdata=self.userdata)
except Exception as e:
self.fail("Failed to update userdata: %s" % e)
self.debug("virtual machine update response is: %s" % updateresponse)
def test_02_dedicated_another_network(self):
# Create network
self.network = Network.create(
self.apiclient,
self.services["network"],
accountid=self.account.name,
domainid=self.account.domainid,
networkofferingid=self.network_offering.id,
zoneid=self.zone.id
)
self.debug("Created network: %s" % self.network.id)
self.debug("Trying VM deploy with network created on account: %s" % self.account.name)
with self.assertRaises(Exception):
self.virtual_machine = VirtualMachine.create(
self.apiclient,
self.services["small"],
accountid=self.account.name,
domainid=self.account.domainid,
networkids=self.network.id,
zoneid=self.zone.id,
serviceofferingid=self.service_offering.id
)
return
def create_network(self, net_offerring, gateway='10.1.1.1', vpc=None, nr_vms=2, mark_net_cleanup=True):
if not nr_vms or nr_vms <= 0:
self.fail("At least 1 VM has to be created. You informed nr_vms < 1")
try:
self.logger.debug('Create NetworkOffering')
net_offerring["name"] = "NET_OFF-" + str(gateway)
nw_off = NetworkOffering.create(
self.apiclient,
net_offerring,
conservemode=False)
nw_off.update(self.apiclient, state='Enabled')
self.logger.debug('Created and Enabled NetworkOffering')
self.services["network"]["name"] = "NETWORK-" + str(gateway)
self.logger.debug('Adding Network=%s' % self.services["network"])
obj_network = Network.create(
self.apiclient,
self.services["network"],
accountid=self.account.name,
domainid=self.account.domainid,
networkofferingid=nw_off.id,
zoneid=self.zone.id,
gateway=gateway,
vpcid=vpc.id if vpc else self.vpc.id
)
self.logger.debug("Created network with ID: %s" % obj_network.id)
except Exception, e:
self.fail('Unable to create a Network with offering=%s because of %s ' % (net_offerring, e))
def create_network_tier(self, name, vpcid, gateway, network_offering):
self.services["network"]["name"] = name
self.services["network"]["displaytext"] = name
default_acl = NetworkACLList.list(self.apiclient, name="default_allow")[0]
try:
network = Network.create(
apiclient=self.apiclient,
services=self.services["network"],
accountid=self.account.name,
domainid=self.domain.id,
networkofferingid=network_offering.id,
zoneid=self.zone.id,
vpcid=vpcid,
gateway=gateway,
netmask=self.services["network"]["netmask"],
aclid=default_acl.id
)
self.assertIsNotNone(network, "Network failed to create")
self.logger.debug(
"Created network %s in VPC %s" % (network.id, vpcid))
self.cleanup.insert(0, network)
return network
except Exception as e:
raise Exception("Create network failed: %s" % e)
def create_network(self, net_offerring, gateway='10.1.1.1',vpc=None):
try:
self.debug('Create NetworkOffering')
net_offerring["name"] = "NET_OFF-" + str(gateway)
nw_off = NetworkOffering.create(self.apiclient,
net_offerring,
conservemode=False
)
# Enable Network offering
nw_off.update(self.apiclient, state='Enabled')
self._cleanup.append(nw_off)
self.debug('Created and Enabled NetworkOffering')
self.services["network"]["name"] = "NETWORK-" + str(gateway)
self.debug('Adding Network=%s' % self.services["network"])
obj_network = Network.create(self.apiclient,
self.services["network"],
accountid=self.account.name,
domainid=self.account.domainid,
networkofferingid=nw_off.id,
zoneid=self.zone.id,
gateway=gateway,
vpcid=vpc.id if vpc else self.vpc.id
)
self.debug("Created network with ID: %s" % obj_network.id)
return obj_network
except Exception, e:
self.fail('Unable to create a Network with offering=%s because of %s ' % (net_offerring, e))
def test_vm_nic_adapter_vmxnet3(self):
"""
# 1. Register a template for VMware with nicAdapter vmxnet3
# 2. Deploy a VM using this template
# 3. Create an isolated network
# 4. Add network to VM
# 5. Verify that the NIC adapter for VM for both the nics
# is vmxnet3
"""
if self.hypervisor.lower() not in ["vmware"]:
self.skipTest("This test case is written specifically\
for Vmware hypervisor")
# Register a private template in the account with nic adapter vmxnet3
template = Template.register(
self.userapiclient,
self.testdata["configurableData"]["vmxnet3template"],
zoneid=self.zone.id,
account=self.account.name,
domainid=self.account.domainid,
details=[{"nicAdapter": self.testdata["configurableData"]["vmxnet3template"]["nicadapter"]}]
)
self.cleanup.append(template)
template.download(self.apiclient)
templates = Template.list(
self.userapiclient,
listall=True,
id=template.id,
templatefilter="self")
self.assertEqual(
validateList(templates)[0],
PASS,
"Templates list validation failed")
self.testdata["virtual_machine"]["zoneid"] = self.zone.id
self.testdata["virtual_machine"]["template"] = template.id
virtual_machine = VirtualMachine.create(
self.apiclient,
self.testdata["virtual_machine"],
accountid=self.account.name,
domainid=self.account.domainid,
serviceofferingid=self.service_offering.id)
isolated_network = Network.create(
self.apiclient,
self.testdata["isolated_network"],
self.account.name,
self.account.domainid,
networkofferingid=self.isolated_network_offering.id)
virtual_machine.add_nic(self.apiclient, isolated_network.id)
# TODO: Add steps to check the Nic Adapter type in VCenter
# using VCenter APIs
return
def create_network(self, net_offerring, vpc_id, gateway='10.1.1.1'):
try:
self.logger.debug('Create NetworkOffering')
net_offerring["name"] = "NET_OFF-" + str(gateway)
nw_off = NetworkOffering.create(
self.apiclient,
net_offerring,
conservemode=False)
nw_off.update(self.apiclient, state='Enabled')
self.logger.debug('Created and Enabled NetworkOffering')
self.services["network"]["name"] = "NETWORK-" + str(gateway)
self.logger.debug('Adding Network=%s to VPC ID %s' % (self.services["network"], vpc_id))
obj_network = Network.create(
self.apiclient,
self.services["network"],
accountid=self.account.name,
domainid=self.account.domainid,
networkofferingid=nw_off.id,
zoneid=self.zone.id,
gateway=gateway,
vpcid=vpc_id)
self.logger.debug("Created network with ID: %s" % obj_network.id)
except Exception, e:
raise Exception('Unable to create a Network with offering=%s because of %s ' % (net_offerring, e))
def create_vm(self, pfrule=False, egress_policy=True, RR=False):
self.create_network_offering(egress_policy, RR)
# Creating network using the network offering created
self.debug("Creating network with network offering: %s" % self.network_offering.id)
self.network = Network.create(
self.apiclient,
self.services["network"],
accountid=self.account.name,
domainid=self.account.domainid,
networkofferingid=self.network_offering.id,
zoneid=self.zone.id,
)
self.debug("Created network with ID: %s" % self.network.id)
self.debug("Deploying instance in the account: %s" % self.account.name)
project = None
self.virtual_machine = VirtualMachine.create(
self.apiclient,
self.services["virtual_machine"],
accountid=self.account.name,
domainid=self.domain.id,
serviceofferingid=self.service_offering.id,
mode=self.zone.networktype if pfrule else "basic",
networkids=[str(self.network.id)],
projectid=project.id if project else None,
)
self.debug("Deployed instance %s in account: %s" % (self.virtual_machine.id, self.account.name))
# Checking if VM is running or not, in case it is deployed in error state, test case fails
self.vm_list = list_virtual_machines(self.apiclient, id=self.virtual_machine.id)
self.assertEqual(validateList(self.vm_list)[0], PASS, "vm list validation failed, vm list is %s" % self.vm_list)
self.assertEqual(
str(self.vm_list[0].state).lower(),
"running",
"VM state should be running, it is %s" % self.vm_list[0].state,
)
self.public_ip = PublicIPAddress.create(
self.apiclient,
accountid=self.account.name,
zoneid=self.zone.id,
domainid=self.account.domainid,
networkid=self.network.id,
)
# Open up firewall port for SSH
FireWallRule.create(
self.apiclient,
ipaddressid=self.public_ip.ipaddress.id,
protocol=self.services["natrule"]["protocol"],
cidrlist=["0.0.0.0/0"],
startport=self.services["natrule"]["publicport"],
endport=self.services["natrule"]["publicport"],
)
self.debug("Creating NAT rule for VM ID: %s" % self.virtual_machine.id)
# Create NAT rule
NATRule.create(self.apiclient, self.virtual_machine, self.services["natrule"], self.public_ip.ipaddress.id)
return
def test_maxAccountNetworks(self):
"""Test Limit number of guest account specific networks
"""
# Steps for validation
# 1. Fetch max.account.networks from configurations
# 2. Create an account. Create account more that max.accout.network
# 3. Create network should fail
self.debug("Creating project with '%s' as admin" % self.account.name)
# Create project as a domain admin
project = Project.create(
self.apiclient, self.services["project"], account=self.account.name, domainid=self.account.domainid
)
# Cleanup created project at end of test
self.cleanup.append(project)
self.debug("Created project with domain admin with ID: %s" % project.id)
config = Configurations.list(self.apiclient, name="max.project.networks", listall=True)
self.assertEqual(isinstance(config, list), True, "List configurations hsould have max.project.networks")
config_value = int(config[0].value)
self.debug("max.project.networks: %s" % config_value)
for ctr in range(config_value):
# Creating network using the network offering created
self.debug("Creating network with network offering: %s" % self.network_offering.id)
network = Network.create(
self.apiclient,
self.services["network"],
projectid=project.id,
networkofferingid=self.network_offering.id,
zoneid=self.zone.id,
)
self.debug("Created network with ID: %s" % network.id)
self.debug("Creating network in account already having networks : %s" % config_value)
with self.assertRaises(Exception):
Network.create(
self.apiclient,
self.services["network"],
projectid=project.id,
networkofferingid=self.network_offering.id,
zoneid=self.zone.id,
)
self.debug("Create network failed (as expected)")
return
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_native_to_native_network_migration(self):
"""
Verify Migration for an isolated network nativeOnly
1. create native non-persistent isolated network
2. migrate to other non-persistent isolated network
3. migrate back to first native non-persistent network
4. deploy VM in non-persistent isolated network
5. migrate to native persistent isolated network
6. migrate back to native non-persistent network
"""
isolated_network = Network.create(
self.apiclient,
self.test_data["isolated_network"],
accountid=self.account.name,
domainid=self.account.domainid,
networkofferingid=self.network_offering_all.id,
zoneid=self.zone.id
)
self.migrate_network(
self.network_offering_nouserdata,
isolated_network, resume=False)
self.migrate_network(
self.network_offering_all,
isolated_network, resume=False)
deployVmResponse = VirtualMachine.create(
self.apiclient,
services=self.test_data["virtual_machine_userdata"],
accountid=self.account.name,
domainid=self.account.domainid,
serviceofferingid=self.service_offering.id,
networkids=[str(isolated_network.id)],
templateid=self.template.id,
zoneid=self.zone.id
)
vms = list_virtual_machines(
self.apiclient,
account=self.account.name,
domainid=self.account.domainid,
id=deployVmResponse.id
)
self.assert_(len(vms) > 0, "There are no Vms deployed in the account"
" %s" % self.account.name)
vm = vms[0]
self.assert_(vm.id == str(deployVmResponse.id),
"Vm deployed is different from the test")
self.assert_(vm.state == "Running", "VM is not in Running state")
self.migrate_network(
self.network_offering_nouserdata,
isolated_network, resume=False)
self.migrate_network(
self.network_offering_all,
isolated_network, resume=False)
def test_02_nicira_controller_redirect(self):
"""
Nicira clusters will redirect clients (in this case ACS) to the master node.
This test assumes that a Nicira cluster is present and configured properly, and
that it has at least two controller nodes. The test will check that ASC follows
redirects by:
- adding a Nicira Nvp device that points to one of the cluster's slave controllers,
- create a VM in a Nicira backed network
If all is well, no matter what controller is specified (slaves or master), the vm (and respective router VM)
should be created without issues.
"""
nicira_slave = self.determine_slave_conroller(self.nicira_hosts, self.nicira_master_controller)
self.debug("Nicira slave controller is: %s " % nicira_slave)
nicira_device = NiciraNvp.add(
self.api_client,
None,
self.physical_network_id,
hostname=nicira_slave,
username=self.nicira_credentials['username'],
password=self.nicira_credentials['password'],
transportzoneuuid=self.transport_zone_uuid)
self.test_cleanup.append(nicira_device)
network_services = {
'name' : 'nicira_enabled_network',
'displaytext' : 'nicira_enabled_network',
'zoneid' : self.zone.id,
'networkoffering' : self.network_offering.id
}
network = Network.create(
self.api_client,
network_services,
accountid='admin',
domainid=self.domain.id,
)
self.test_cleanup.append(network)
virtual_machine = VirtualMachine.create(
self.api_client,
self.vm_services['small'],
accountid='admin',
domainid=self.domain.id,
serviceofferingid=self.service_offering.id,
networkids=[network.id],
mode=self.vm_services['mode']
)
self.test_cleanup.append(virtual_machine)
list_vm_response = VirtualMachine.list(self.api_client, id=virtual_machine.id)
self.debug("Verify listVirtualMachines response for virtual machine: %s" % virtual_machine.id)
self.assertEqual(isinstance(list_vm_response, list), True, 'Response did not return a valid list')
self.assertNotEqual(len(list_vm_response), 0, 'List of VMs is empty')
vm_response = list_vm_response[0]
self.assertEqual(vm_response.id, virtual_machine.id, 'Virtual machine in response does not match request')
self.assertEqual(vm_response.state, 'Running', 'VM is not in Running state')
def createNetwork(idx):
offering["name"] = "Test Network%s" % idx
network = Network.create(
self.apiclient,
offering,
self.account.name,
self.account.domainid,
zoneid=self.services["network"]["zoneid"]
)
networks.append(network)
self.cleanup.insert(0, network)
def test_vpcnetwork_nuage(self):
"""Test network VPC for Nuage"""
# 1) Create VPC with Nuage VPC offering
vpcOffering = VpcOffering.list(self.apiclient,name="Nuage VSP VPC offering")
self.assert_(vpcOffering is not None and len(vpcOffering)>0, "Nuage VPC offering not found")
vpc = VPC.create(
apiclient=self.apiclient,
services=self.services["vpc"],
networkDomain="vpc.networkacl",
vpcofferingid=vpcOffering[0].id,
zoneid=self.zone.id,
account=self.account.name,
domainid=self.account.domainid
)
self.assert_(vpc is not None, "VPC creation failed")
# 2) Create ACL
aclgroup = NetworkACLList.create(apiclient=self.apiclient, services={}, name="acl", description="acl", vpcid=vpc.id)
self.assertIsNotNone(aclgroup, "Failed to create NetworkACL list")
self.debug("Created a network ACL list %s" % aclgroup.name)
# 3) Create ACL Item
aclitem = NetworkACL.create(apiclient=self.apiclient, services={},
protocol="TCP", number="10", action="Deny", aclid=aclgroup.id, cidrlist=["0.0.0.0/0"])
self.assertIsNotNone(aclitem, "Network failed to aclItem")
self.debug("Added a network ACL %s to ACL list %s" % (aclitem.id, aclgroup.name))
# 4) Create network with ACL
nwNuage = Network.create(
self.apiclient,
self.services["vpcnetwork"],
accountid=self.account.name,
domainid=self.account.domainid,
networkofferingid=self.network_offering.id,
zoneid=self.zone.id,
vpcid=vpc.id,
aclid=aclgroup.id,
gateway='10.1.0.1'
)
self.debug("Network %s created in VPC %s" %(nwNuage.id, vpc.id))
# 5) Deploy a vm
vm = VirtualMachine.create(
self.apiclient,
self.services["virtual_machine"],
accountid=self.account.name,
domainid=self.account.domainid,
serviceofferingid=self.service_offering.id,
networkids=[str(nwNuage.id)]
)
self.assert_(vm is not None, "VM failed to deploy")
self.assert_(vm.state == 'Running', "VM is not running")
self.debug("VM %s deployed in VPC %s" %(vm.id, vpc.id))
def setUp(self):
self.apiclient = self.testClient.getApiClient()
self.services["network"]["networkoffering"] = self.network_offering.id
self.l2_network = Network.create(
self.apiclient,
self.services["l2-network"],
zoneid=self.zone.id,
networkofferingid=self.network_offering.id
)
self.cleanup = [
self.l2_network]
def setUpClass(cls):
cls.testClient = super(TestIsolatedNetworks, cls).getClsTestClient()
cls.api_client = cls.testClient.getApiClient()
cls.services = cls.testClient.getParsedTestDataConfig()
# Get Zone, Domain and templates
cls.domain = get_domain(cls.api_client)
cls.zone = get_zone(cls.api_client, cls.testClient.getZoneForTests())
cls.services["mode"] = cls.zone.networktype
template = get_template(cls.api_client, cls.zone.id, cls.services["ostype"])
cls.services["virtual_machine"]["zoneid"] = cls.zone.id
# Create an account, network, VM and IP addresses
cls.account = Account.create(cls.api_client, cls.services["account"], admin=True, domainid=cls.domain.id)
cls.service_offering = ServiceOffering.create(cls.api_client, cls.services["service_offering"])
cls.services["network_offering"]["egress_policy"] = "true"
cls.network_offering = NetworkOffering.create(
cls.api_client, cls.services["network_offering"], conservemode=True
)
cls.network_offering.update(cls.api_client, state="Enabled")
cls.network = Network.create(
cls.api_client,
cls.services["network"],
accountid=cls.account.name,
domainid=cls.account.domainid,
networkofferingid=cls.network_offering.id,
zoneid=cls.zone.id,
)
cls.vm_1 = VirtualMachine.create(
cls.api_client,
cls.services["virtual_machine"],
templateid=template.id,
accountid=cls.account.name,
domainid=cls.domain.id,
serviceofferingid=cls.service_offering.id,
networkids=[str(cls.network.id)],
)
cls._cleanup = [cls.vm_1, cls.network, cls.network_offering, cls.service_offering, cls.account]
cls.logger = logging.getLogger("TestIsolatedNetworks")
cls.stream_handler = logging.StreamHandler()
cls.logger.setLevel(logging.DEBUG)
cls.logger.addHandler(cls.stream_handler)
return
def test_04_network_without_domain_CS19303(self):
"""
@Desc: Errors editing a network without a network domain specified
@Steps:
Step1: Create a network offering with SourceNAT,staticNAT and dhcp services
Step2: Verify the network offering creation
Step3: Create an isolated network with the offering created in step1 and without a network domain specified
Step4: Verify the network creation
Step5: Edit the network and verify that updating network should not error out
"""
self.debug(
"Creating n/w offering with SourceNat,StaticNat and DHCP services in VR & conserve mode:off"
)
self.network_offering = NetworkOffering.create(
self.api_client,
self.services["network_offering_withoutDNS"],
conservemode=False
)
self.assertIsNotNone(
self.network_offering,
"Failed to create NO with Sourcenat,staticnat and dhcp only services"
)
self.cleanup.append(self.network_offering)
self.debug("Created n/w offering with ID: %s" % self.network_offering.id)
# Enable Network offering
self.network_offering.update(self.apiclient, state='Enabled')
self.debug("Creating nw without dns service using no id: %s" % self.network_offering.id)
self.network = Network.create(
self.apiclient,
self.services["network"],
accountid=self.account.name,
domainid=self.account.domainid,
networkofferingid=self.network_offering.id,
zoneid=self.zone.id
)
self.assertIsNotNone(
self.network,
"Failed to create network without DNS service and network domain"
)
self.debug("Created network with NO: %s" % self.network_offering.id)
try:
self.network_update = self.network.update(
self.apiclient,
name="NW without nw domain"
)
self.debug("Success:Network update has been successful without network domain")
except Exception as e:
self.fail("Error editing a network without network domain specified: %s" % e)
return
def test_isolated_nw_invalid_gw(self):
self.debug("Trying to create a network with Gateway as 192.168.3.0. This should fail")
with self.assertRaises(Exception):
Network.create(
self.apiclient,
self.services["network"],
self.account.name,
self.account.domainid,
gateway="192.168.3.0",
netmask="255.255.255.0",
)
self.debug("Trying to create a network with Gateway as 192.168.3.255")
with self.assertRaises(Exception):
Network.create(
self.apiclient,
self.services["network"],
self.account.name,
self.account.domainid,
gateway="192.168.3.255",
netmask="255.255.255.0"
)
self.debug("Trying to create a network with Gateway as 192.168.3.0 and Subnet mask as 255.0.255.0")
with self.assertRaises(Exception):
Network.create(
self.apiclient,
self.services["network"],
self.account.name,
self.account.domainid,
gateway="192.168.3.0",
netmask="255.0.255.0",
)
self.debug("Trying to create a network with Subnet mask as 255.0.255.0")
with self.assertRaises(Exception):
Network.create(
self.apiclient,
self.services["network"],
self.account.name,
self.account.domainid,
gateway="192.168.3.1",
netmask="255.0.255.0",
)
return
def deploy_isolatednetwork(self, isolatednetwork_data, account):
self.logger.debug('>>> ISOLATED NETWORK => Creating "%s"...', isolatednetwork_data['name'])
isolatednetwork = Network.create(
self.api_client,
data=isolatednetwork_data,
account=account,
zone=self.zone
)
self.logger.debug('>>> ISOLATED NETWORK => ID: %s => Name: %s => CIDR: %s '
'=> Gateway: %s => Type: %s => Traffic Type: %s => State: %s '
'=> Offering: %s => Physical Network: %s => Domain: %s',
isolatednetwork.id, isolatednetwork.name, isolatednetwork.cidr,
isolatednetwork.gateway, isolatednetwork.type, isolatednetwork.traffictype,
isolatednetwork.state, isolatednetwork.networkofferingid,
isolatednetwork.physicalnetworkid, isolatednetwork.domainid)
def create_guest_network(self):
network_services = {
'name' : 'nicira_enabled_network',
'displaytext' : 'nicira_enabled_network',
'zoneid' : self.zone.id,
'networkoffering' : self.network_offering.id
}
network = Network.create(
self.api_client,
network_services,
accountid='admin',
domainid=self.domain.id,
)
self.test_cleanup.append(network)
return network
def create_Network(self, nw_off, gateway="10.1.1.1", netmask="255.255.255.0", vpc=None, acl_list=None):
self.debug("Creating a network in the account - %s" % self.account.name)
self.test_data["network"]["netmask"] = netmask
network = Network.create(self.api_client,
self.test_data["network"],
accountid=self.account.name,
domainid=self.account.domainid,
networkofferingid=nw_off.id,
zoneid=self.zone.id,
gateway=gateway,
vpcid=vpc.id if vpc else self.vpc.id if hasattr(self, "vpc") else None,
aclid=acl_list.id if acl_list else None
)
self.debug("Created network with ID - %s" % network.id)
self.cleanup.append(network)
return network
def test_baremetal(self):
self.debug("Test create baremetal network offering")
networkoffering = NetworkOffering.create(
self.apiclient, self.services["network_offering"])
networkoffering.update(self.apiclient, state="Enabled")
self.cleanup.append(networkoffering)
physical_network = PhysicalNetwork.list(self.apiclient,
zoneid=self.zoneid)[0]
dhcp_provider = NetworkServiceProvider.list(
self.apiclient,
name="BaremetalDhcpProvider",
physical_network_id=physical_network.id)[0]
NetworkServiceProvider.update(self.apiclient,
id=dhcp_provider.id,
state='Enabled')
pxe_provider = NetworkServiceProvider.list(
self.apiclient,
name="BaremetalPxeProvider",
physical_network_id=physical_network.id)[0]
NetworkServiceProvider.update(self.apiclient,
id=pxe_provider.id,
state='Enabled')
userdata_provider = NetworkServiceProvider.list(
self.apiclient,
name="BaremetalUserdataProvider",
physical_network_id=physical_network.id)[0]
NetworkServiceProvider.update(self.apiclient,
id=userdata_provider.id,
state='Enabled')
network = Network.create(self.apiclient,
self.services["network"],
zoneid=self.zoneid,
networkofferingid=networkoffering.id)
self.cleanup.insert(0, network)
pod = Pod.list(self.apiclient)[0]
cmd = createVlanIpRange.createVlanIpRangeCmd()
cmd.podid = pod.id
cmd.networkid = network.id
cmd.gateway = "10.1.1.1"
cmd.netmask = "255.255.255.0"
cmd.startip = "10.1.1.20"
cmd.endip = "10.1.1.40"
cmd.forVirtualNetwork = "false"
self.apiclient.createVlanIpRange(cmd)
def create_network(self, network_offering, vpc_id, gateway='10.1.1.1'):
try:
self.services["network"]["name"] = "NETWORK-" + str(gateway)
self.logger.debug('Adding Network=%s to VPC ID %s' % (self.services["network"], vpc_id))
obj_network = Network.create(
self.apiclient,
self.services["network"],
accountid=self.account.name,
domainid=self.account.domainid,
networkofferingid=network_offering.id,
zoneid=self.zone.id,
gateway=gateway,
vpcid=vpc_id)
self.logger.debug("Created network with ID: %s" % obj_network.id)
except Exception, e:
raise Exception('Unable to create a Network with offering=%s because of %s ' % (network_offering.id, e))
def create_network(self, network_offering, vpc_id, gateway='10.1.1.1'):
try:
self.services["network"]["name"] = "NETWORK-" + str(gateway)
self.logger.debug('Adding Network=%s to VPC ID %s' % (self.services["network"], vpc_id))
obj_network = Network.create(
self.apiclient,
self.services["network"],
accountid=self.account.name,
domainid=self.account.domainid,
networkofferingid=network_offering.id,
zoneid=self.zone.id,
gateway=gateway,
vpcid=vpc_id)
self.logger.debug("Created network with ID: %s" % obj_network.id)
except Exception, e:
raise Exception('Unable to create a Network with offering=%s because of %s ' % (network_offering.id, e))
def test_01_nicira_controller(self):
nicira_device = NiciraNvp.add(
self.api_client,
None,
self.physical_network_id,
hostname=self.nicira_master_controller,
username=self.nicira_credentials['username'],
password=self.nicira_credentials['password'],
transportzoneuuid=self.transport_zone_uuid)
self.test_cleanup.append(nicira_device)
network_services = {
'name' : 'nicira_enabled_network',
'displaytext' : 'nicira_enabled_network',
'zoneid' : self.zone.id,
'networkoffering' : self.network_offering.id
}
network = Network.create(
self.api_client,
network_services,
accountid='admin',
domainid=self.domain.id,
)
self.test_cleanup.append(network)
virtual_machine = VirtualMachine.create(
self.api_client,
self.vm_services['small'],
accountid='admin',
domainid=self.domain.id,
serviceofferingid=self.service_offering.id,
networkids=[network.id],
mode=self.vm_services['mode']
)
self.test_cleanup.append(virtual_machine)
list_vm_response = VirtualMachine.list(self.api_client, id=virtual_machine.id)
self.debug("Verify listVirtualMachines response for virtual machine: %s" % virtual_machine.id)
self.assertEqual(isinstance(list_vm_response, list), True, 'Response did not return a valid list')
self.assertNotEqual(len(list_vm_response), 0, 'List of VMs is empty')
vm_response = list_vm_response[0]
self.assertEqual(vm_response.id, virtual_machine.id, 'Virtual machine in response does not match request')
self.assertEqual(vm_response.state, 'Running', 'VM is not in Running state')
def setUpClass(cls):
cls.testClient = super(TestDirectDownloadTemplates,
cls).getClsTestClient()
cls.apiclient = cls.testClient.getApiClient()
cls.hypervisor = cls.testClient.getHypervisorInfo()
cls.dbclient = cls.testClient.getDbConnection()
cls.zone = get_zone(cls.apiclient, cls.testClient.getZoneForTests())
cls.pod = get_pod(cls.apiclient, cls.zone.id)
cls.services = cls.testClient.getParsedTestDataConfig()
cls._cleanup = []
cls.hypervisorNotSupported = False
if cls.hypervisor.lower() not in ['kvm', 'lxc']:
cls.hypervisorNotSupported = True
if not cls.hypervisorNotSupported:
cls.services["test_templates"]["kvm"]["directdownload"] = "true"
cls.template = Template.register(
cls.apiclient,
cls.services["test_templates"]["kvm"],
zoneid=cls.zone.id,
hypervisor=cls.hypervisor)
cls._cleanup.append(cls.template)
cls.services["virtual_machine"]["zoneid"] = cls.zone.id
cls.services["virtual_machine"]["template"] = cls.template.id
cls.services["virtual_machine"]["hypervisor"] = cls.hypervisor
cls.service_offering = ServiceOffering.create(
cls.apiclient, cls.services["service_offerings"]["tiny"])
cls._cleanup.append(cls.service_offering)
cls.network_offering = NetworkOffering.create(
cls.apiclient,
cls.services["l2-network_offering"],
)
cls.network_offering.update(cls.apiclient, state='Enabled')
cls.services["network"][
"networkoffering"] = cls.network_offering.id
cls.l2_network = Network.create(
cls.apiclient,
cls.services["l2-network"],
zoneid=cls.zone.id,
networkofferingid=cls.network_offering.id)
cls._cleanup.append(cls.l2_network)
cls._cleanup.append(cls.network_offering)
return
def deploy_network(self, network_data, vpc):
acl = get_network_acl(api_client=self.api_client, name=network_data['aclname'], vpc=vpc)
self.logger.debug('>>> TIER => Creating "%s"...', network_data['name'])
network = Network.create(
self.api_client,
data=network_data,
vpc=vpc,
zone=self.zone,
acl=acl
)
self.logger.debug('>>> TIER => ID: %s => Name: %s => CIDR: %s => Gateway: %s => Type: %s '
'=> Traffic Type: %s => State: %s => Offering: %s => ACL: %s '
'=> Physical Network: %s => VPC: %s => Domain: %s', network.id, network.name,
network.cidr, network.gateway, network.type, network.traffictype, network.state,
network.networkofferingid, network.aclid, network.physicalnetworkid, network.vpcid,
network.domainid)
def deploy_privatenetwork(self, privatenetwork_data, account, domain):
self.logger.debug('>>> PRIVATE GATEWAY NETWORK => Creating "%s"...', privatenetwork_data['name'])
private_gateways_network = Network.create(
api_client=self.api_client,
data=privatenetwork_data,
zone=self.zone,
domain=domain,
account=account
)
self.logger.debug('>>> PRIVATE GATEWAY NETWORK => ID: %s => Name: %s => CIDR: %s => Type: %s '
'=> Traffic Type: %s => State: %s => Offering: %s => Broadcast Domain Type: %s '
'=> Broadcast URI: %s => Physical Network: %s => Domain: %s',
private_gateways_network.id, private_gateways_network.name, private_gateways_network.cidr,
private_gateways_network.type, private_gateways_network.traffictype,
private_gateways_network.state, private_gateways_network.networkofferingid,
private_gateways_network.broadcastdomaintype, private_gateways_network.broadcasturi,
private_gateways_network.physicalnetworkid, private_gateways_network.domainid)
def create_guest_shared_network_uuid_vlanid(self):
network_services = {
'name': 'nicira_enabled_network_shared',
'displaytext': 'nicira_enabled_network_shared',
'zoneid': self.zone.id,
'networkoffering': self.network_offering_shared.id,
'startip': self.nicira_shared_network_iprange.startip,
'endip': self.nicira_shared_network_iprange.endip,
'netmask': self.nicira_shared_network_iprange.netmask,
'gateway': self.nicira_shared_network_iprange.gateway,
'vlan': self.nicira_shared_network_iprange.vlan_uuid
}
network = Network.create(self.api_client,
network_services,
accountid=self.admin_account,
domainid=self.admin_domain.id)
self.test_cleanup.append(network)
return network
def create_Network(self, nw_off, nw_key="network", gateway='10.1.1.1', netmask='255.255.255.0', vpc=None, acl_list=None):
if not hasattr(nw_off, "id"):
nw_off = self.create_NetworkOffering(nw_off)
self.debug('Adding Network=%s' % self.test_data[nw_key])
self.test_data[nw_key]["netmask"] = netmask
obj_network = Network.create(self.api_client,
self.test_data[nw_key],
accountid=self.account.name,
domainid=self.account.domainid,
networkofferingid=nw_off.id,
zoneid=self.zone.id,
gateway=gateway,
vpcid=vpc.id if vpc else self.vpc.id if hasattr(self, "vpc") else None,
aclid=acl_list.id if acl_list else None
)
self.debug("Created network with ID: %s" % obj_network.id)
self.cleanup.append(obj_network)
return obj_network
def create_guest_shared_network_services(self):
network_services = {
'name' : 'nicira_enabled_network_shared',
'displaytext' : 'nicira_enabled_network_shared',
'zoneid' : self.zone.id,
'networkoffering' : self.network_offering_shared.id,
'startip' : self.nicira_shared_network_iprange.startip,
'endip' : self.nicira_shared_network_iprange.endip,
'netmask' : self.nicira_shared_network_iprange.netmask,
'gateway' : self.nicira_shared_network_iprange.gateway
}
network = Network.create(
self.api_client,
network_services,
accountid=self.admin_account,
domainid=self.admin_domain.id,
)
self.test_cleanup.append(network)
return network
def create_shared_network_with_associated_network(self,
apiclient,
domain,
account,
project,
associated_network,
expected=True):
self.services["network2"]["acltype"] = "Account"
self.services["network2"][
"name"] = "Test Network Shared - " + random_gen()
domain_id = None
account_name = None
project_id = None
if domain:
self.services["network2"]["acltype"] = "Domain"
domain_id = domain.id
if account:
self.services["network2"]["acltype"] = "Account"
account_name = account.name
if project:
self.services["network2"]["acltype"] = "Account"
project_id = project.id
associated_network_id = None
if associated_network:
associated_network_id = associated_network.id
try:
network = Network.create(apiclient,
self.services["network2"],
domainid=domain_id,
accountid=account_name,
projectid=project_id,
associatednetworkid=associated_network_id,
zoneid=self.zone.id)
except Exception as ex:
network = None
if expected:
self.fail(
f"Failed to create Shared network, but expected to succeed : {ex}"
)
if network and not expected:
self.fail(
"Shared network is created successfully, but expected to fail")
return network
def create_vpc_tier(self, vpc):
network_services = {
'name': 'nicira_enabled_vpc_tier',
'displaytext': 'nicira_enabled_vpc_tier',
'netmask': '255.255.255.0'
}
self.logger.debug('Creating VPC tier')
network = Network.create(self.api_client,
network_services,
accountid='admin',
domainid=self.domain.id,
networkofferingid=self.vpc_tier_offering.id,
zoneid=self.zone.id,
gateway='10.1.1.1',
vpcid=vpc.id)
self.logger.debug("Created VPC tier with ID: %s" % network.id)
self.test_cleanup.append(network)
return network
def create_vpc_tier_for_account(self,
apiclient,
vpc,
project=None,
gateway='10.1.1.1'):
self.services["network"]["name"] = "Test VPC tier - " + random_gen()
project_id = None
if project:
project_id = project.id
vpc_tier = Network.create(
apiclient,
self.services["network"],
networkofferingid=self.network_offering_vpc.id,
zoneid=self.zone.id,
projectid=project_id,
gateway=gateway,
netmask="255.255.255.0",
vpcid=vpc.id)
return vpc_tier
def create_network(self, network_offering, gateway='10.1.1.1', vpc=None, nr_vms=2):
if not nr_vms or nr_vms <= 0:
self.fail("At least 1 VM has to be created. You informed nr_vms < 1")
try:
self.services["network"]["name"] = "NETWORK-" + str(gateway)
self.logger.debug('Adding Network=%s' % self.services["network"])
network = Network.create(
self.apiclient,
self.services["network"],
accountid=self.account.name,
domainid=self.account.domainid,
networkofferingid=network_offering.id,
zoneid=self.zone.id,
gateway=gateway,
vpcid=vpc.id if vpc else self.vpc.id
)
self.logger.debug("Created network with ID: %s" % network.id)
except Exception, e:
self.fail('Unable to create a Network with offering=%s because of %s ' % (network_offering.id, e))
def create_network(self, network_offering, gateway='10.1.1.1', vpc=None, nr_vms=2):
if not nr_vms or nr_vms <= 0:
self.fail("At least 1 VM has to be created. You informed nr_vms < 1")
try:
self.services["network"]["name"] = "NETWORK-" + str(gateway)
self.logger.debug('Adding Network=%s' % self.services["network"])
network = Network.create(
self.apiclient,
self.services["network"],
accountid=self.account.name,
domainid=self.account.domainid,
networkofferingid=network_offering.id,
zoneid=self.zone.id,
gateway=gateway,
vpcid=vpc.id if vpc else self.vpc.id
)
self.logger.debug("Created network with ID: %s" % network.id)
except Exception, e:
self.fail('Unable to create a Network with offering=%s because of %s ' % (network_offering.id, e))
def deploy_network(self, network_data, vpc):
acl = get_network_acl(api_client=self.api_client,
name=network_data['aclname'],
vpc=vpc)
self.logger.debug('>>> TIER => Creating "%s"...',
network_data['name'])
network = Network.create(self.api_client,
data=network_data,
vpc=vpc,
zone=self.zone,
acl=acl)
self.logger.debug(
'>>> TIER => ID: %s => Name: %s => CIDR: %s => Gateway: %s => Type: %s '
'=> Traffic Type: %s => State: %s => Offering: %s => ACL: %s '
'=> Physical Network: %s => VPC: %s => Domain: %s',
network.id, network.name, network.cidr, network.gateway,
network.type, network.traffictype, network.state,
network.networkofferingid, network.aclid,
network.physicalnetworkid, network.vpcid, network.domainid)
def create_vpc_tier(self, vpc):
network_services = {
'name' : 'nicira_enabled_vpc_tier',
'displaytext' : 'nicira_enabled_vpc_tier',
'netmask' : '255.255.255.0'
}
self.logger.debug('Creating VPC tier')
network = Network.create(
self.api_client,
network_services,
accountid='admin',
domainid=self.domain.id,
networkofferingid=self.vpc_tier_offering.id,
zoneid=self.zone.id,
gateway='10.1.1.1',
vpcid=vpc.id
)
self.logger.debug("Created VPC tier with ID: %s" % network.id)
self.test_cleanup.append(network)
return network
def deploy_privatenetwork(self, privatenetwork_data, account, domain):
self.logger.debug('>>> PRIVATE GATEWAY NETWORK => Creating "%s"...',
privatenetwork_data['name'])
private_gateways_network = Network.create(api_client=self.api_client,
data=privatenetwork_data,
zone=self.zone,
domain=domain,
account=account)
self.logger.debug(
'>>> PRIVATE GATEWAY NETWORK => ID: %s => Name: %s => CIDR: %s => Type: %s '
'=> Traffic Type: %s => State: %s => Offering: %s => Broadcast Domain Type: %s '
'=> Broadcast URI: %s => Physical Network: %s => Domain: %s',
private_gateways_network.id, private_gateways_network.name,
private_gateways_network.cidr, private_gateways_network.type,
private_gateways_network.traffictype,
private_gateways_network.state,
private_gateways_network.networkofferingid,
private_gateways_network.broadcastdomaintype,
private_gateways_network.broadcasturi,
private_gateways_network.physicalnetworkid,
private_gateways_network.domainid)
def test_02_L2_persistent_network(self):
network_vlan = 90
network = Network.create(
self.apiclient,
self.services["l2_network"],
networkofferingid=self.l2_persistent_network_offering.id,
zoneid=self.zone.id,
vlan=network_vlan)
self.cleanup.append(network)
response = verifyNetworkState(self.apiclient, network.id,
"implemented")
exceptionOccurred = response[0]
isNetworkInDesiredState = response[1]
exceptionMessage = response[2]
if (exceptionOccurred or (not isNetworkInDesiredState)):
self.fail(exceptionMessage)
self.assertIsNotNone(network_vlan,
"vlan must not be null for persistent network")
self.validate_persistent_network_resources_created_on_host(
network_vlan)
def test_baremetal(self):
self.debug("Test create baremetal network offering")
networkoffering = NetworkOffering.create(self.apiclient, self.services["network_offering"])
networkoffering.update(self.apiclient, state="Enabled")
self.cleanup.append(networkoffering)
physical_network = PhysicalNetwork.list(self.apiclient, zoneid=self.zoneid)[0];
dhcp_provider = NetworkServiceProvider.list(self.apiclient, name="BaremetalDhcpProvider", physical_network_id=physical_network.id)[0]
NetworkServiceProvider.update(
self.apiclient,
id=dhcp_provider.id,
state='Enabled'
)
pxe_provider = NetworkServiceProvider.list(self.apiclient, name="BaremetalPxeProvider", physical_network_id=physical_network.id)[0]
NetworkServiceProvider.update(
self.apiclient,
id=pxe_provider.id,
state='Enabled'
)
userdata_provider = NetworkServiceProvider.list(self.apiclient, name="BaremetalUserdataProvider", physical_network_id=physical_network.id)[0]
NetworkServiceProvider.update(
self.apiclient,
id=userdata_provider.id,
state='Enabled'
)
network = Network.create(self.apiclient, self.services["network"], zoneid=self.zoneid, networkofferingid=networkoffering.id)
self.cleanup.insert(0, network)
pod = Pod.list(self.apiclient)[0]
cmd = createVlanIpRange.createVlanIpRangeCmd()
cmd.podid = pod.id
cmd.networkid = network.id
cmd.gateway = "10.1.1.1"
cmd.netmask = "255.255.255.0"
cmd.startip = "10.1.1.20"
cmd.endip = "10.1.1.40"
cmd.forVirtualNetwork="false"
self.apiclient.createVlanIpRange(cmd)
def create_network(self, net_offerring, vpc_id, gateway='10.1.1.1'):
try:
self.logger.debug('Create NetworkOffering')
net_offerring["name"] = "NET_OFF-" + str(gateway)
nw_off = NetworkOffering.create(self.apiclient,
net_offerring,
conservemode=False)
nw_off.update(self.apiclient, state='Enabled')
self.logger.debug('Created and Enabled NetworkOffering')
self.services["network"]["name"] = "NETWORK-" + str(gateway)
self.logger.debug('Adding Network=%s to VPC ID %s' %
(self.services["network"], vpc_id))
obj_network = Network.create(self.apiclient,
self.services["network"],
accountid=self.account.name,
domainid=self.account.domainid,
networkofferingid=nw_off.id,
zoneid=self.zone.id,
gateway=gateway,
vpcid=vpc_id)
self.logger.debug("Created network with ID: %s" % obj_network.id)
except Exception as e:
raise Exception(
'Unable to create a Network with offering=%s because of %s ' %
(net_offerring, e))
o = networkO(obj_network)
vm1 = self.deployvm_in_network(obj_network)
self.cleanup.insert(1, obj_network)
self.cleanup.insert(2, nw_off)
o.add_vm(vm1)
self.networks.append(o)
return o
def create_isolated_network_for_account(self,
apiclient,
domain,
account,
project,
expected=True):
self.services["network"][
"name"] = "Test Network Isolated - " + random_gen()
domain_id = None
account_name = None
project_id = None
if domain:
domain_id = domain.id
if account:
account_name = account.name
if project:
project_id = project.id
try:
network = Network.create(
apiclient,
self.services["network"],
domainid=domain_id,
accountid=account_name,
projectid=project_id,
networkofferingid=self.network_offering_isolated.id,
zoneid=self.zone.id)
except Exception as ex:
network = None
if expected:
self.fail(
f"Failed to create Isolated network, but expected to succeed : {ex}"
)
if network and not expected:
self.fail(
"Isolated network is created successfully, but expected to fail"
)
return network
def test_03_deploy_and_destroy_VM_and_verify_network_resources_persist(
self):
network_vlan = 99
network = Network.create(
self.apiclient,
self.services["l2_network"],
networkofferingid=self.l2_persistent_network_offering.id,
zoneid=self.zone.id,
vlan=network_vlan)
self.cleanup.append(network)
response = verifyNetworkState(self.apiclient, network.id,
"implemented")
logger.debug(response)
exceptionOccurred = response[0]
isNetworkInDesiredState = response[1]
exceptionMessage = response[2]
if (exceptionOccurred or (not isNetworkInDesiredState)):
self.fail(exceptionMessage)
self.assertIsNotNone(network_vlan,
"vlan must not be null for persistent network")
try:
virtual_machine = VirtualMachine.create(
self.apiclient,
self.services["virtual_machine"],
networkids=[network.id],
serviceofferingid=self.service_offering.id)
VirtualMachine.delete(virtual_machine,
self.apiclient,
expunge=True)
self.validate_persistent_network_resources_created_on_host(
network_vlan)
except Exception as e:
self.fail("Exception occurred: %s" % e)
return
def test_02_dedicated_another_network(self):
# Create network
self.network = Network.create(
self.apiclient,
self.services["network"],
accountid=self.account.name,
domainid=self.account.domainid,
networkofferingid=self.network_offering.id,
zoneid=self.zone.id)
self.debug("Created network: %s" % self.network.id)
self.debug("Trying VM deploy with network created on account: %s" %
self.account.name)
with self.assertRaises(Exception):
self.virtual_machine = VirtualMachine.create(
self.apiclient,
self.services["small"],
accountid=self.account.name,
domainid=self.account.domainid,
networkids=self.network.id,
zoneid=self.zone.id,
serviceofferingid=self.service_offering.id)
return
def create_network(self,
net_offerring,
gateway='10.1.1.1',
vpc=None,
nr_vms=2,
mark_net_cleanup=True):
if not nr_vms or nr_vms <= 0:
self.fail(
"At least 1 VM has to be created. You informed nr_vms < 1")
try:
self.logger.debug('Create NetworkOffering')
net_offerring["name"] = "NET_OFF-" + str(gateway)
nw_off = NetworkOffering.create(self.apiclient,
net_offerring,
conservemode=False)
nw_off.update(self.apiclient, state='Enabled')
self.logger.debug('Created and Enabled NetworkOffering')
self.services["network"]["name"] = "NETWORK-" + str(gateway)
self.logger.debug('Adding Network=%s' % self.services["network"])
obj_network = Network.create(self.apiclient,
self.services["network"],
accountid=self.account.name,
domainid=self.account.domainid,
networkofferingid=nw_off.id,
zoneid=self.zone.id,
gateway=gateway,
vpcid=vpc.id if vpc else self.vpc.id)
self.logger.debug("Created network with ID: %s" % obj_network.id)
except Exception, e:
self.fail(
'Unable to create a Network with offering=%s because of %s ' %
(net_offerring, e))
def test_16_create_template_volume(self):
"""Test Create template from volume
"""
noffering = NetworkOffering.list(
self.user_api_client,
name="DefaultIsolatedNetworkOfferingWithSourceNatService")
vm2network = Network.create(self.user_api_client,
self.services["network"],
accountid=self.account.name,
domainid=self.account.domainid,
networkofferingid=noffering[0].id,
zoneid=self.zone.id)
list_nw_response = Network.list(self.user_api_client, id=vm2network.id)
self.assertEqual(isinstance(list_nw_response, list), True,
"Check list response returns a valid networks list")
templatevm = VirtualMachine.create(
self.user_api_client,
self.services["small"],
templateid=self.template.id,
accountid=self.account.name,
domainid=self.account.domainid,
networkids=vm2network.id,
serviceofferingid=self.service_offering.id,
mode=self.services['mode'],
startvm="true")
time.sleep(600)
vm_response = VirtualMachine.list(self.user_api_client,
id=templatevm.id)
self.assertNotEqual(len(vm_response), 0,
"Check VMs available in List VMs response")
vm = vm_response[0]
self.assertEqual(vm.state, 'Running',
"Check the state of VM created from Template")
templatevm.stop(self.user_api_client, forced="false")
vm_response = VirtualMachine.list(self.user_api_client,
id=templatevm.id)
vm = vm_response[0]
self.assertEqual(
vm.state, 'Stopped',
"Check the state of VM is in Stopped state before creating the Template"
)
list_volume_response = Volume.list(self.user_api_client,
virtualmachineid=vm.id,
type="ROOT",
listall=True)
#Create template from Virtual machine and Volume ID
roottemplate = Template.create(
self.user_api_client,
self.services["interop"]["template"],
volumeid=list_volume_response[0].id,
account=self.account.name,
domainid=self.domain.id,
)
time.sleep(600)
list_template_response = Template.list(
self.user_api_client,
templatefilter=\
self.services["templatefilter"],
id=roottemplate.id
)
self.assertEqual(isinstance(list_template_response, list), True,
"Check list response returns a valid list")
#Verify template response to check whether template added successfully
self.assertNotEqual(len(list_template_response), 0,
"Check template available in List Templates")
template_response = list_template_response[0]
self.assertEqual(template_response.displaytext,
self.services["interop"]["template"]["displaytext"],
"Check display text of newly created template")
name = template_response.name
self.assertEqual(
name.count(self.services["interop"]["template"]["name"]), 1,
"Check name of newly created template")
templatevm.delete(self.apiclient)
vm2network.delete(self.user_api_client)
vm3network = Network.create(self.user_api_client,
self.services["network"],
accountid=self.account.name,
domainid=self.account.domainid,
networkofferingid=noffering[0].id,
zoneid=self.zone.id)
list_nw_response = Network.list(self.user_api_client, id=vm3network.id)
self.assertEqual(isinstance(list_nw_response, list), True,
"Check list response returns a valid networks list")
templatevm = VirtualMachine.create(
self.user_api_client,
self.services["small"],
templateid=roottemplate.id,
networkids=vm3network.id,
serviceofferingid=self.service_offering.id,
accountid=self.account.name,
domainid=self.account.domainid,
mode=self.services['mode'],
startvm="true")
time.sleep(600)
vm_response = VirtualMachine.list(self.user_api_client,
id=templatevm.id)
self.assertNotEqual(len(vm_response), 0,
"Check VMs available in List VMs response")
vm = vm_response[0]
self.assertEqual(vm.state, 'Running',
"Check the state of VM created from Template")
# Delete the template
roottemplate.delete(self.user_api_client)
list_template_response = Template.list(
self.user_api_client,
templatefilter=\
self.services["template"]["templatefilter"],
id=roottemplate.id,
zoneid=self.zone.id
)
self.assertEqual(list_template_response, None,
"Check template available in List Templates")
templatevm.delete(self.apiclient)
vm3network.delete(self.user_api_client)
return
def test_15_restore_vm_with_template_id(self):
"""
Test restoring Virtual Machine with template id
"""
noffering = NetworkOffering.list(
self.user_api_client,
name="DefaultIsolatedNetworkOfferingWithSourceNatService")
vm1network = Network.create(self.user_api_client,
self.services["network"],
accountid=self.account.name,
domainid=self.account.domainid,
networkofferingid=noffering[0].id,
zoneid=self.zone.id)
list_nw_response = Network.list(self.user_api_client, id=vm1network.id)
self.assertEqual(isinstance(list_nw_response, list), True,
"Check list response returns a valid networks list")
restorevm = VirtualMachine.create(
self.user_api_client,
self.services["small"],
networkids=vm1network.id,
accountid=self.account.name,
domainid=self.account.domainid,
serviceofferingid=self.service_offering.id,
mode=self.services['mode'],
startvm="true")
time.sleep(600)
list_vm_response = VirtualMachine.list(self.user_api_client,
id=restorevm.id)
self.assertEqual(list_vm_response[0].state, "Running",
"Check virtual machine is in running state")
custom_disk_offering = DiskOffering.list(self.user_api_client,
name="custom")
newvolume = Volume.create(self.user_api_client,
self.services["volume"],
zoneid=self.zone.id,
account=self.account.name,
domainid=self.domain.id,
diskofferingid=custom_disk_offering[0].id,
size=1)
# Attach volume to VM
cmd = attachVolume.attachVolumeCmd()
cmd.id = newvolume.id
cmd.virtualmachineid = restorevm.id
cmd.deviceid = 1
vol1 = self.user_api_client.attachVolume(cmd)
cmd = restoreVirtualMachine.restoreVirtualMachineCmd()
cmd.virtualmachineid = restorevm.id
cmd.templateid = self.xtemplate.id
self.user_api_client.restoreVirtualMachine(cmd)
time.sleep(600)
list_vm_response = VirtualMachine.list(self.user_api_client,
id=restorevm.id)
self.assertEqual(isinstance(list_vm_response, list), True,
"Check list response returns a valid list")
self.assertNotEqual(len(list_vm_response), 0,
"Check VM available in List Virtual Machines")
self.assertEqual(list_vm_response[0].state, "Running",
"Check virtual machine is in Stopped state")
restorevm.delete(self.apiclient)
vm1network.delete(self.user_api_client)
return
def test_network_vcs(self):
"""Test Brocade Network and VM Creation
"""
# Validate the following
# 1. Deploy the first VM using a network from the above created
# Network offering.
# 2. Deploy another VM.
# 3. Delete The VMs and the Network
# Creating network using the network offering created
self.debug("Creating network with network offering: %s" %
self.network_offering.id)
self.network = Network.create(
self.apiclient,
self.services["network"],
accountid=self.account.name,
domainid=self.account.domainid,
networkofferingid=self.network_offering.id,
zoneid=self.zone.id)
self.debug("Created network with ID: %s" % self.network.id)
self.debug("Deploying VM in account: %s" % self.account.name)
# Spawn an instance in that network
virtual_machine_1 = VirtualMachine.create(
self.apiclient,
self.services["virtual_machine"],
accountid=self.account.name,
domainid=self.account.domainid,
serviceofferingid=self.service_offering.id,
networkids=[str(self.network.id)])
self.debug("Deployed VM in network: %s" % self.network.id)
list_vm_response = VirtualMachine.list(self.apiclient,
id=virtual_machine_1.id)
self.debug(
"Verify listVirtualMachines response for virtual machine: %s" \
% virtual_machine_1.id
)
self.assertEqual(isinstance(list_vm_response, list), True,
"Check list response returns a valid list")
vm_response = list_vm_response[0]
self.assertEqual(vm_response.state, "Running",
"VM state should be running after deployment")
self.debug("Deploying another VM in account: %s" % self.account.name)
# Spawn an instance in that network
virtual_machine_2 = VirtualMachine.create(
self.apiclient,
self.services["virtual_machine"],
accountid=self.account.name,
domainid=self.account.domainid,
serviceofferingid=self.service_offering.id,
networkids=[str(self.network.id)])
self.debug("Deployed VM in network: %s" % self.network.id)
list_vm_response = VirtualMachine.list(self.apiclient,
id=virtual_machine_2.id)
self.debug(
"Verify listVirtualMachines response for virtual machine: %s" \
% virtual_machine_2.id
)
self.assertEqual(isinstance(list_vm_response, list), True,
"Check list response returns a valid list")
vm_response = list_vm_response[0]
self.assertEqual(vm_response.state, "Running",
"VM state should be running after deployment")
# Deleting a single VM
VirtualMachine.delete(virtual_machine_1, self.apiclient, expunge=True)
# Deleting a single VM
VirtualMachine.delete(virtual_machine_2, self.apiclient, expunge=True)
# Delete Network
Network.delete(self.network, self.apiclient)
return
def test_updating_nics_on_two_shared_networks(self):
"""
Test updating vm nics on two shared networks
Works as follows:
- Create two shared networks, with different IP ranges (eg network1, network2).
- Create two VMs on each shared network (eg vm1 on network1, vm2 on network2) and stop them.
- Add additional IP range to each shared network. The two additional IP ranges have same start IP and end IP,
but different gateway and netmask (eg network1-iprange2, network2-iprange2).
- Update IP address of the two vms, by specifying new IP address on additional IP ranges. The new gateway and
netmask should be updated correctly (eg vm1 on network1-iprange2, vm2 on network2-iprange2).
"""
# - Create two shared networks, with different IP ranges (eg network1, network2).
self.services["shared_network"]["netmask"] = "255.255.255.0"
self.services["shared_network"]["gateway"] = "192.168.1.1"
self.services["shared_network"]["startip"] = "192.168.1.2"
self.services["shared_network"]["endip"] = "192.168.1.20"
self.services["shared_network"]["vlan"] = "111"
testnet = self.services["shared_network"]
self.debug(f"========= network 1 : {testnet}")
self.network1 = Network.create(
self.apiclient,
self.services["shared_network"],
networkofferingid=self.shared_network_offering.id,
zoneid=self.zone.id,
)
self._cleanup.append(self.network1)
self.services["shared_network"]["netmask"] = "255.255.255.0"
self.services["shared_network"]["gateway"] = "192.168.2.1"
self.services["shared_network"]["startip"] = "192.168.2.2"
self.services["shared_network"]["endip"] = "192.168.2.20"
self.services["shared_network"]["vlan"] = "222"
self.network2 = Network.create(
self.apiclient,
self.services["shared_network"],
networkofferingid=self.shared_network_offering.id,
zoneid=self.zone.id,
)
self._cleanup.append(self.network2)
# - Create two VMs on each shared network (eg vm1 on network1, vm2 on network2) and stop them.
vm_data = self.services["virtual_machine"]
self.debug(f"============virtual machine data : {vm_data}")
virtual_machine1 = VirtualMachine.create(
self.apiclient,
self.services["virtual_machine"],
templateid=self.template.id,
serviceofferingid=self.service_offering.id,
networkids=[self.network1.id],
zoneid=self.zone.id)
self.cleanup.append(virtual_machine1)
virtual_machine1.stop(self.apiclient)
virtual_machine2 = VirtualMachine.create(
self.apiclient,
self.services["virtual_machine"],
templateid=self.template.id,
serviceofferingid=self.service_offering.id,
networkids=[self.network2.id],
zoneid=self.zone.id)
self.cleanup.append(virtual_machine2)
virtual_machine2.stop(self.apiclient)
# - Add additional IP range to each shared network. The two additional IP ranges have same start IP and end IP,
# but different gateway and netmask (eg network1-iprange2, network2-iprange2).
self.services["vlan_ip_range"]["netmask"] = "255.255.255.224"
self.services["vlan_ip_range"]["gateway"] = "192.168.3.1"
self.services["vlan_ip_range"]["startip"] = "192.168.3.2"
self.services["vlan_ip_range"]["endip"] = "192.168.3.20"
self.services["vlan_ip_range"]["vlan"] = "111"
range1 = PublicIpRange.create(self.apiclient,
self.services["vlan_ip_range"],
networkid=self.network1.id)
self.debug(f"============range 1 : {range1}")
self.services["vlan_ip_range"]["netmask"] = "255.255.255.192"
self.services["vlan_ip_range"]["gateway"] = "192.168.3.21"
self.services["vlan_ip_range"]["startip"] = "192.168.3.2"
self.services["vlan_ip_range"]["endip"] = "192.168.3.20"
self.services["vlan_ip_range"]["vlan"] = "222"
range2 = PublicIpRange.create(self.apiclient,
self.services["vlan_ip_range"],
networkid=self.network2.id)
# - Update IP address of the two vms, by specifying new IP address on additional IP ranges. The new gateway and
# netmask should be updated correctly (eg vm1 on network1-iprange2, vm2 on network2-iprange2).
nic1id = NIC.list(self.apiclient,
virtualmachineid=virtual_machine1.id,
networkid=self.network1.id)[0].id
NIC.updateIp(self.apiclient, id=nic1id, ipaddress="192.168.3.2")
nics = NIC.list(self.apiclient,
virtualmachineid=virtual_machine1.id,
networkid=self.network1.id)
self.check_nic(nics, self.network1, range1)
nic2id = NIC.list(self.apiclient,
virtualmachineid=virtual_machine2.id,
networkid=self.network2.id)[0].id
NIC.updateIp(self.apiclient, id=nic2id, ipaddress="192.168.3.2")
nics = NIC.list(self.apiclient,
virtualmachineid=virtual_machine2.id,
networkid=self.network2.id)
self.check_nic(nics, self.network2, range2)
return
def setUpClass(cls):
testClient = super(TestAdvancedZoneStoppedVM, cls).getClsTestClient()
cls.apiclient = testClient.getApiClient()
cls.testdata = testClient.getParsedTestDataConfig()
cls.hypervisor = testClient.getHypervisorInfo()
# Get Zone, Domain and templates
cls.domain = get_domain(cls.apiclient)
cls.zone = get_zone(cls.apiclient)
cls._cleanup = []
try:
# Create an account
cls.account = Account.create(cls.apiclient,
cls.testdata["account"],
domainid=cls.domain.id)
cls._cleanup.append(cls.account)
# If local storage is enabled, alter the offerings to use
# localstorage
if cls.zone.localstorageenable:
cls.testdata["service_offering"]["storagetype"] = 'local'
# Create 2 service offerings with different values for
# for cpunumber, cpuspeed, and memory
cls.testdata["service_offering"]["cpunumber"] = 1
cls.testdata["service_offering"]["cpuspeed"] = 128
cls.testdata["service_offering"]["memory"] = 256
cls.service_offering = ServiceOffering.create(
cls.apiclient, cls.testdata["service_offering"])
cls._cleanup.append(cls.service_offering)
cls.testdata["service_offering"]["cpunumber"] = 2
cls.service_offering_2 = ServiceOffering.create(
cls.apiclient, cls.testdata["service_offering"])
cls._cleanup.append(cls.service_offering_2)
# Create isolated network offering
cls.isolated_network_offering = CreateEnabledNetworkOffering(
cls.apiclient, cls.testdata["isolated_network_offering"])
cls._cleanup.append(cls.isolated_network_offering)
cls.networkid = None
if str(cls.zone.networktype).lower() == "advanced":
cls.network = Network.create(
cls.apiclient,
cls.testdata["isolated_network"],
networkofferingid=cls.isolated_network_offering.id,
accountid=cls.account.name,
domainid=cls.account.domainid,
zoneid=cls.zone.id)
cls.networkid = cls.network.id
# Create user api client of the account
cls.userapiclient = testClient.getUserApiClient(
UserName=cls.account.name, DomainName=cls.account.domain)
template = get_template(cls.apiclient, cls.zone.id,
cls.testdata["ostype"])
cls.defaultTemplateId = template.id
# Set Zones and disk offerings
# Check that we are able to login to the created account
respose = User.login(cls.apiclient,
username=cls.account.name,
password=cls.testdata["account"]["password"])
assert respose.sessionkey is not None, \
"Login to the CloudStack should be successful\
response shall have non Null key"
except Exception as e:
cls.tearDownClass()
raise e
return
def test_01_RVR_Network_FW_PF_SSH_default_routes_egress_true(self):
""" Test redundant router internals """
self.logger.debug(
"Starting test_01_RVR_Network_FW_PF_SSH_default_routes_egress_true..."
)
network_offering_egress_true = get_default_redundant_isolated_network_offering_with_egress(
self.apiclient)
self.logger.debug("Creating network with network offering: %s" %
network_offering_egress_true.id)
network = Network.create(
self.apiclient,
self.services["network"],
accountid=self.account.name,
domainid=self.account.domainid,
networkofferingid=network_offering_egress_true.id,
zoneid=self.zone.id)
self.logger.debug("Created network with ID: %s" % network.id)
networks = Network.list(self.apiclient, id=network.id, listall=True)
self.assertEqual(
isinstance(networks, list), True,
"List networks should return a valid response for created network")
self.logger.debug("Deploying VM in account: %s" % self.account.name)
virtual_machine = VirtualMachine.create(
self.apiclient,
self.services["virtual_machine"],
templateid=self.template.id,
accountid=self.account.name,
domainid=self.account.domainid,
serviceofferingid=self.service_offering.id,
networkids=[str(network.id)])
self.logger.debug("Deployed VM in network: %s" % network.id)
self.cleanup.insert(0, network)
self.cleanup.insert(0, virtual_machine)
vms = VirtualMachine.list(self.apiclient,
id=virtual_machine.id,
listall=True)
self.assertEqual(isinstance(vms, list), True,
"List Vms should return a valid list")
vm = vms[0]
self.assertEqual(vm.state, "Running",
"VM should be in running state after deployment")
self.logger.debug("Listing routers for network: %s" % network.name)
routers = Router.list(self.apiclient,
networkid=network.id,
listall=True)
self.assertEqual(
isinstance(routers, list), True,
"list router should return Master and backup routers")
self.assertEqual(
len(routers), 2,
"Length of the list router should be 2 (Backup & master)")
public_ips = list_public_ip(self.apiclient,
account=self.account.name,
domainid=self.account.domainid,
zoneid=self.zone.id)
public_ip = public_ips[0]
self.assertEqual(
isinstance(public_ips, list), True,
"Check for list public IPs response return valid data")
self.logger.debug("Creating Firewall rule for VM ID: %s" %
virtual_machine.id)
FireWallRule.create(
self.apiclient,
ipaddressid=public_ip.id,
protocol=self.services["natrule_ssh"]["protocol"],
cidrlist=['0.0.0.0/0'],
startport=self.services["natrule_ssh"]["publicport"],
endport=self.services["natrule_ssh"]["publicport"])
self.logger.debug("Creating NAT rule for VM ID: %s" %
virtual_machine.id)
nat_rule = NATRule.create(self.apiclient, virtual_machine,
self.services["natrule_ssh"], public_ip.id)
# Test SSH after closing port 22
expected = 1
ssh_command = "ping -c 3 8.8.8.8"
check_string = "3 packets received"
result = self.check_router_command(virtual_machine, nat_rule.ipaddress,
ssh_command, check_string, self)
self.assertEqual(
result, expected,
"Ping to outside world from VM should be successful!")
expected = 1
ssh_command = self.HTTP_COMMAND
check_string = self.HTTP_CHECK_STRING
result = self.check_router_command(virtual_machine, nat_rule.ipaddress,
ssh_command, check_string, self)
self.assertEqual(result, expected, self.HTTP_ASSERT_SUCCESS_MESSAGE)
EgressFireWallRule.create(
self.apiclient,
networkid=network.id,
protocol=self.services["egress_443"]["protocol"],
startport=self.services["egress_443"]["startport"],
endport=self.services["egress_443"]["endport"],
cidrlist=self.services["egress_443"]["cidrlist"])
expected = 0
result = self.check_router_command(virtual_machine, nat_rule.ipaddress,
ssh_command, check_string, self)
self.assertEqual(result, expected, self.HTTP_ASSERT_FAILURE_MESSAGE)
return
def test_3d_gpu_support(self):
"""
# 1. Register a template for VMware with nicAdapter vmxnet3 and 3D GPU details
# 2. Deploy a VM using this template
# 3. Create an isolated network
# 4. Add network to VM
# 5. Verify vm details for 3D GPU details
"""
if self.hypervisor.lower() not in ["vmware"]:
self.skipTest("This test case is written specifically\
for Vmware hypervisor")
# Register a private template in the account with nic adapter vmxnet3
# Also add required 3D GPU details for enabling it
template = Template.register(
self.userapiclient,
self.testdata["configurableData"]["vmxnet3template"],
zoneid=self.zone.id,
account=self.account.name,
domainid=self.account.domainid,
details=[{
"mks.enable3d": "true",
"mks.use3dRenderer": "automatic",
"svga.autodetect": "false",
"svga.vramSize": "131072"
}])
self.cleanup.append(template)
template.download(self.apiclient)
templates = Template.list(self.userapiclient,
listall=True,
id=template.id,
templatefilter="self")
self.assertEqual(
validateList(templates)[0], PASS,
"Templates list validation failed")
self.testdata["virtual_machine"]["zoneid"] = self.zone.id
self.testdata["virtual_machine"]["template"] = template.id
virtual_machine = VirtualMachine.create(
self.apiclient,
self.testdata["virtual_machine"],
accountid=self.account.name,
domainid=self.account.domainid,
templateid=template.id,
serviceofferingid=self.service_offering.id)
isolated_network = Network.create(
self.apiclient,
self.testdata["isolated_network"],
self.account.name,
self.account.domainid,
networkofferingid=self.isolated_network_offering.id)
virtual_machine.add_nic(self.apiclient, isolated_network.id)
qresultset = self.dbclient.execute(
"select id from vm_instance where uuid = '%s';" %
virtual_machine.id)
vm_id = qresultset[0]
qresultset = self.dbclient.execute(
"select name, value from user_vm_details where vm_id = '%d';" %
vm_id)
detailKeys = [x[0] for x in qresultset]
self.assertTrue(
'mks.enable3d' in detailKeys and 'mks.use3dRenderer' in detailKeys
and 'svga.autodetect' in detailKeys
and 'svga.vramSize' in detailKeys,
"VM details do not contain 3D GPU details")
self.assertEquals('true',
qresultset[detailKeys.index('mks.enable3d')][1],
"Expected detail 'mks.enable3d'='true'")
self.assertEquals('automatic',
qresultset[detailKeys.index('mks.use3dRenderer')][1],
"Expected detail 'mks.use3dRenderer'='automatic'")
self.assertEquals('false',
qresultset[detailKeys.index('svga.autodetect')][1],
"Expected detail 'svga.autodetect'='false'")
self.assertEquals('131072',
qresultset[detailKeys.index('svga.vramSize')][1],
"Expected detail 'svga.vramSize'='131072'")
def setUpClass(cls):
cls.logger = logging.getLogger('TestRouterDHCPHosts')
cls.stream_handler = logging.StreamHandler()
cls.logger.setLevel(logging.DEBUG)
cls.logger.addHandler(cls.stream_handler)
cls.testClient = super(TestRouterDHCPHosts, cls).getClsTestClient()
cls.api_client = cls.testClient.getApiClient()
cls.services = cls.testClient.getParsedTestDataConfig()
# Get Zone, Domain and templates
cls.domain = get_domain(cls.api_client)
cls.zone = get_zone(cls.api_client, cls.testClient.getZoneForTests())
cls.services['mode'] = cls.zone.networktype
cls.template = get_template(cls.api_client, cls.zone.id,
cls.services["ostype"])
cls.hostConfig = cls.config.__dict__["zones"][0].__dict__["pods"][
0].__dict__["clusters"][0].__dict__["hosts"][0].__dict__
cls.services["virtual_machine"]["zoneid"] = cls.zone.id
cls.logger.debug("Creating Admin Account for domain %s on zone %s" %
(cls.domain.id, cls.zone.id))
# Create an account, network, VM and IP addresses
cls.account = Account.create(cls.api_client,
cls.services["account"],
admin=True,
domainid=cls.domain.id)
cls.logger.debug("Creating Service Offering on zone %s" %
(cls.zone.id))
cls.service_offering = ServiceOffering.create(
cls.api_client, cls.services["service_offering"])
cls.services["isolated_network_offering"]["egress_policy"] = "true"
cls.logger.debug("Creating Network Offering on zone %s" %
(cls.zone.id))
cls.network_offering = NetworkOffering.create(
cls.api_client,
cls.services["isolated_network_offering"],
conservemode=True)
cls.network_offering.update(cls.api_client, state='Enabled')
cls.logger.debug("Creating Network for Account %s using offering %s" %
(cls.account.name, cls.network_offering.id))
cls.network = Network.create(cls.api_client,
cls.services["network"],
accountid=cls.account.name,
domainid=cls.account.domainid,
networkofferingid=cls.network_offering.id,
zoneid=cls.zone.id)
cls.logger.debug(
"Creating VM1 for Account %s using offering %s with IP 10.1.1.50" %
(cls.account.name, cls.service_offering.id))
cls.vm_1 = VirtualMachine.create(
cls.api_client,
cls.services["virtual_machine"],
templateid=cls.template.id,
accountid=cls.account.name,
domainid=cls.domain.id,
serviceofferingid=cls.service_offering.id,
networkids=[str(cls.network.id)],
ipaddress="10.1.1.50")
cls.logger.debug(
"Creating VM2 for Account %s using offering %s with IP 10.1.1.51" %
(cls.account.name, cls.service_offering.id))
cls.vm_2 = VirtualMachine.create(
cls.api_client,
cls.services["virtual_machine"],
templateid=cls.template.id,
accountid=cls.account.name,
domainid=cls.domain.id,
serviceofferingid=cls.service_offering.id,
networkids=[str(cls.network.id)],
ipaddress="10.1.1.51")
cls.services["natrule1"] = {
"privateport": 22,
"publicport": 222,
"protocol": "TCP"
}
cls.services["natrule2"] = {
"privateport": 22,
"publicport": 223,
"protocol": "TCP"
}
cls.services["configurableData"] = {
"host": {
"port": 22
},
"input": "INPUT",
"forward": "FORWARD"
}
cls._cleanup = [
cls.vm_2, cls.network, cls.network_offering, cls.service_offering,
cls.account
]
return
def test_vm_nic_adapter_vmxnet3(self):
"""
# 1. Register a template for VMware with nicAdapter vmxnet3
# 2. Deploy a VM using this template
# 3. Create an isolated network
# 4. Add network to VM
# 5. Verify that the NIC adapter for VM for both the nics
# is vmxnet3
"""
if self.hypervisor.lower() not in ["vmware"]:
self.skipTest("This test case is written specifically\
for Vmware hypervisor")
# Register a private template in the account with nic adapter vmxnet3
template = Template.register(
self.userapiclient,
self.testdata["configurableData"]["vmxnet3template"],
zoneid=self.zone.id,
account=self.account.name,
domainid=self.account.domainid,
details=[{
"nicAdapter":
self.testdata["configurableData"]["vmxnet3template"]
["nicadapter"]
}])
self.cleanup.append(template)
template.download(self.apiclient)
templates = Template.list(self.userapiclient,
listall=True,
id=template.id,
templatefilter="self")
self.assertEqual(
validateList(templates)[0], PASS,
"Templates list validation failed")
self.testdata["virtual_machine"]["zoneid"] = self.zone.id
self.testdata["virtual_machine"]["template"] = template.id
virtual_machine = VirtualMachine.create(
self.apiclient,
self.testdata["virtual_machine"],
accountid=self.account.name,
domainid=self.account.domainid,
serviceofferingid=self.service_offering.id)
isolated_network = Network.create(
self.apiclient,
self.testdata["isolated_network"],
self.account.name,
self.account.domainid,
networkofferingid=self.isolated_network_offering.id)
virtual_machine.add_nic(self.apiclient, isolated_network.id)
# TODO: Add steps to check the Nic Adapter type in VCenter
# using VCenter APIs
return
def test_01_import_storage_policies(self):
"""Test VMWare storage policies
"""
# Validate the following:
# 1. Import VMWare storage policies - the command should return non-zero result
# 2. List current VMWare storage policies - the command should return non-zero result
# 3. Create service offering with first of the imported policies
# 4. Create disk offering with first of the imported policies
# 5. Create VM using the already created service offering
# 6. Create volume using the already created disk offering
# 7. Attach this volume to our VM
# 8. Detach the volume from our VM
self.hypervisor = self.testClient.getHypervisorInfo()
if self.hypervisor.lower() != "vmware":
self.skipTest(
"VMWare storage policies feature is not supported on %s" %
self.hypervisor.lower())
self.debug("Importing VMWare storage policies")
imported_policies = self.import_vmware_storage_policies(self.apiclient)
if len(imported_policies) == 0:
self.skipTest("There are no VMWare storage policies")
self.debug("Listing VMWare storage policies")
listed_policies = self.list_storage_policies(self.apiclient)
self.assertNotEqual(len(listed_policies), 0,
"Check if list of storage policies is not zero")
self.assertEqual(
len(imported_policies), len(listed_policies),
"Check if the number of imported policies is identical to the number of listed policies"
)
selected_policy = None
for imported_policy in imported_policies:
compatible_pools = self.list_storage_policy_compatible_pools(
self.apiclient, imported_policy.id)
if compatible_pools and len(compatible_pools) > 0:
selected_policy = imported_policy
break
if not selected_policy:
self.skipTest(
"There are no compatible storage pools with the imported policies"
)
# Create service offering with the first storage policy from the list
service_offering = ServiceOffering.create(
self.apiclient,
self.testdata["service_offering"],
storagepolicy=selected_policy.id)
self.cleanup.append(service_offering)
# Create disk offering with the first storage policy from the list
disk_offering = DiskOffering.create(self.apiclient,
self.testdata["disk_offering"],
storagepolicy=selected_policy.id)
self.cleanup.append(disk_offering)
l2_network = Network.create(self.apiclient,
self.testdata["l2-network"],
zoneid=self.zone.id,
networkofferingid=self.network_offering.id)
self.cleanup.append(l2_network)
virtual_machine = VirtualMachine.create(
self.apiclient,
self.testdata["small"],
templateid=self.template.id,
accountid=self.account.name,
domainid=self.account.domainid,
zoneid=self.zone.id,
networkids=l2_network.id,
serviceofferingid=service_offering.id,
)
self.cleanup.append(virtual_machine)
vms = VirtualMachine.list(self.apiclient,
id=virtual_machine.id,
listall=True)
self.assertEqual(
isinstance(vms, list), True,
"listVirtualMachines returned invalid object in response.")
self.assertNotEqual(len(vms), 0,
"listVirtualMachines returned empty list.")
self.debug("Deployed VM on host: %s" % vms[0].hostid)
volume = Volume.create(self.apiclient,
self.testdata["volume"],
account=self.account.name,
domainid=self.account.domainid,
zoneid=self.zone.id,
diskofferingid=disk_offering.id)
self.cleanup.append(volume)
list_volume_response = Volume.list(self.apiclient, id=volume.id)
self.assertEqual(isinstance(list_volume_response, list), True,
"Check list response returns a valid list")
self.assertNotEqual(list_volume_response, None,
"Check if volume exists in ListVolumes")
return
def test_19_template_tag(self):
""" Test creation, listing and deletion tag on templates
"""
if self.hypervisor.lower() in ['lxc']:
self.skipTest(
"template creation from volume feature is not supported on %s"
% self.hypervisor.lower())
try:
noffering = NetworkOffering.list(
self.user_api_client,
name="DefaultIsolatedNetworkOfferingWithSourceNatService")
vm4network = Network.create(self.user_api_client,
self.services["network"],
accountid=self.account.name,
domainid=self.account.domainid,
networkofferingid=noffering[0].id,
zoneid=self.zone.id)
list_nw_response = Network.list(self.user_api_client,
id=vm4network.id)
self.assertEqual(
isinstance(list_nw_response, list), True,
"Check list response returns a valid networks list")
vm_1 = VirtualMachine.create(
self.user_api_client,
self.services["small"],
templateid=self.template.id,
networkids=vm4network.id,
serviceofferingid=self.service_offering.id,
accountid=self.account.name,
domainid=self.account.domainid,
mode=self.services['mode'],
startvm="true")
time.sleep(600)
self.debug("Stopping the virtual machine: %s" % vm_1.name)
# Stop virtual machine
vm_1.stop(self.user_api_client)
except Exception as e:
self.fail("Failed to stop VM: %s" % e)
timeout = self.services["timeout"]
while True:
list_volume = Volume.list(self.user_api_client,
virtualmachineid=vm_1.id,
type='ROOT',
listall=True)
if isinstance(list_volume, list):
break
elif timeout == 0:
raise Exception("List volumes failed.")
time.sleep(5)
timeout = timeout - 1
self.volume = list_volume[0]
self.debug("Creating template from ROOT disk of virtual machine: %s" %
vm_1.name)
# Create template from volume
template = Template.create(self.user_api_client,
self.services["template"], self.volume.id)
self.cleanup.append(template)
self.debug("Created the template(%s). Now restarting the userVm: %s" %
(template.name, vm_1.name))
vm_1.start(self.user_api_client)
self.debug("Creating a tag for the template")
tag = Tag.create(self.user_api_client,
resourceIds=template.id,
resourceType='Template',
tags={'OS': 'windows8'})
self.debug("Tag created: %s" % tag.__dict__)
tags = Tag.list(self.user_api_client,
listall=True,
resourceType='Template',
key='OS',
value='windows8')
self.assertEqual(isinstance(tags, list), True,
"List tags should not return empty response")
self.assertEqual(tags[0].value, 'windows8',
'The tag should have original value')
Template.list(
self.user_api_client,
templatefilter=self.services["template"]["templatefilter"],
listall=True,
key='OS',
value='windows8')
self.debug("Deleting the created tag..")
try:
tag.delete(self.user_api_client,
resourceIds=template.id,
resourceType='Template',
tags={'OS': 'windows8'})
except Exception as e:
self.fail("Failed to delete the tag - %s" % e)
self.debug("Verifying if tag is actually deleted!")
tags = Tag.list(self.user_api_client,
listall=True,
resourceType='Template',
key='OS',
value='windows8')
self.assertEqual(tags, None, "List tags should return empty response")
return
def setUpClass(cls):
cls.testClient = super(TestMulipleNicSupport, cls).getClsTestClient()
cls.apiclient = cls.testClient.getApiClient()
cls.testdata = cls.testClient.getParsedTestDataConfig()
cls.services = cls.testClient.getParsedTestDataConfig()
zone = get_zone(cls.apiclient, cls.testClient.getZoneForTests())
cls.zone = Zone(zone.__dict__)
cls._cleanup = []
cls.skip = False
if str(cls.zone.securitygroupsenabled) != "True":
cls.skip = True
return
cls.logger = logging.getLogger("TestMulipleNicSupport")
cls.stream_handler = logging.StreamHandler()
cls.logger.setLevel(logging.DEBUG)
cls.logger.addHandler(cls.stream_handler)
# Get Domain and templates
cls.domain = get_domain(cls.apiclient)
cls.services['mode'] = cls.zone.networktype
cls.template = get_template(cls.apiclient,
cls.zone.id,
hypervisor="KVM")
if cls.template == FAILED:
cls.skip = True
return
# Create new domain, account, network and VM
cls.user_domain = Domain.create(
cls.apiclient,
services=cls.testdata["acl"]["domain2"],
parentdomainid=cls.domain.id)
# Create account
cls.account1 = Account.create(cls.apiclient,
cls.testdata["acl"]["accountD2"],
admin=True,
domainid=cls.user_domain.id)
# Create small service offering
cls.service_offering = ServiceOffering.create(
cls.apiclient, cls.testdata["service_offerings"]["small"])
cls._cleanup.append(cls.service_offering)
cls.services["network"]["zoneid"] = cls.zone.id
cls.network_offering = NetworkOffering.create(
cls.apiclient,
cls.services["network_offering"],
)
# Enable Network offering
cls.network_offering.update(cls.apiclient, state='Enabled')
cls._cleanup.append(cls.network_offering)
cls.testdata["virtual_machine"]["zoneid"] = cls.zone.id
cls.testdata["virtual_machine"]["template"] = cls.template.id
if cls.zone.securitygroupsenabled:
# Enable networking for reaching to VM thorugh SSH
security_group = SecurityGroup.create(
cls.apiclient,
cls.testdata["security_group"],
account=cls.account1.name,
domainid=cls.account1.domainid)
# Authorize Security group to SSH to VM
ingress_rule = security_group.authorize(
cls.apiclient,
cls.testdata["ingress_rule"],
account=cls.account1.name,
domainid=cls.account1.domainid)
# Authorize Security group to SSH to VM
ingress_rule2 = security_group.authorize(
cls.apiclient,
cls.testdata["ingress_rule_ICMP"],
account=cls.account1.name,
domainid=cls.account1.domainid)
cls.testdata["shared_network_offering_sg"]["specifyVlan"] = 'True'
cls.testdata["shared_network_offering_sg"]["specifyIpRanges"] = 'True'
cls.shared_network_offering = NetworkOffering.create(
cls.apiclient,
cls.testdata["shared_network_offering_sg"],
conservemode=False)
NetworkOffering.update(cls.shared_network_offering,
cls.apiclient,
id=cls.shared_network_offering.id,
state="enabled")
physical_network, vlan = get_free_vlan(cls.apiclient, cls.zone.id)
cls.testdata["shared_network_sg"][
"physicalnetworkid"] = physical_network.id
random_subnet_number = random.randrange(90, 99)
cls.testdata["shared_network_sg"][
"name"] = "Shared-Network-SG-Test-vlan" + str(random_subnet_number)
cls.testdata["shared_network_sg"][
"displaytext"] = "Shared-Network-SG-Test-vlan" + str(
random_subnet_number)
cls.testdata["shared_network_sg"]["vlan"] = "vlan://" + str(
random_subnet_number)
cls.testdata["shared_network_sg"]["startip"] = "192.168." + str(
random_subnet_number) + ".240"
cls.testdata["shared_network_sg"]["endip"] = "192.168." + str(
random_subnet_number) + ".250"
cls.testdata["shared_network_sg"]["gateway"] = "192.168." + str(
random_subnet_number) + ".254"
cls.network1 = Network.create(
cls.apiclient,
cls.testdata["shared_network_sg"],
networkofferingid=cls.shared_network_offering.id,
zoneid=cls.zone.id,
accountid=cls.account1.name,
domainid=cls.account1.domainid)
random_subnet_number = random.randrange(100, 110)
cls.testdata["shared_network_sg"][
"name"] = "Shared-Network-SG-Test-vlan" + str(random_subnet_number)
cls.testdata["shared_network_sg"][
"displaytext"] = "Shared-Network-SG-Test-vlan" + str(
random_subnet_number)
cls.testdata["shared_network_sg"]["vlan"] = "vlan://" + str(
random_subnet_number)
cls.testdata["shared_network_sg"]["startip"] = "192.168." + str(
random_subnet_number) + ".240"
cls.testdata["shared_network_sg"]["endip"] = "192.168." + str(
random_subnet_number) + ".250"
cls.testdata["shared_network_sg"]["gateway"] = "192.168." + str(
random_subnet_number) + ".254"
cls.network2 = Network.create(
cls.apiclient,
cls.testdata["shared_network_sg"],
networkofferingid=cls.shared_network_offering.id,
zoneid=cls.zone.id,
accountid=cls.account1.name,
domainid=cls.account1.domainid)
random_subnet_number = random.randrange(111, 120)
cls.testdata["shared_network_sg"][
"name"] = "Shared-Network-SG-Test-vlan" + str(random_subnet_number)
cls.testdata["shared_network_sg"][
"displaytext"] = "Shared-Network-SG-Test-vlan" + str(
random_subnet_number)
cls.testdata["shared_network_sg"]["vlan"] = "vlan://" + str(
random_subnet_number)
cls.testdata["shared_network_sg"]["startip"] = "192.168." + str(
random_subnet_number) + ".240"
cls.testdata["shared_network_sg"]["endip"] = "192.168." + str(
random_subnet_number) + ".250"
cls.testdata["shared_network_sg"]["gateway"] = "192.168." + str(
random_subnet_number) + ".254"
cls.network3 = Network.create(
cls.apiclient,
cls.testdata["shared_network_sg"],
networkofferingid=cls.shared_network_offering.id,
zoneid=cls.zone.id,
accountid=cls.account1.name,
domainid=cls.account1.domainid)
try:
cls.virtual_machine1 = VirtualMachine.create(
cls.apiclient,
cls.testdata["virtual_machine"],
accountid=cls.account1.name,
domainid=cls.account1.domainid,
serviceofferingid=cls.service_offering.id,
templateid=cls.template.id,
securitygroupids=[security_group.id],
networkids=cls.network1.id)
for nic in cls.virtual_machine1.nic:
if nic.isdefault:
cls.virtual_machine1.ssh_ip = nic.ipaddress
cls.virtual_machine1.default_network_id = nic.networkid
break
except Exception as e:
cls.fail("Exception while deploying virtual machine: %s" % e)
try:
cls.virtual_machine2 = VirtualMachine.create(
cls.apiclient,
cls.testdata["virtual_machine"],
accountid=cls.account1.name,
domainid=cls.account1.domainid,
serviceofferingid=cls.service_offering.id,
templateid=cls.template.id,
securitygroupids=[security_group.id],
networkids=[str(cls.network1.id),
str(cls.network2.id)])
for nic in cls.virtual_machine2.nic:
if nic.isdefault:
cls.virtual_machine2.ssh_ip = nic.ipaddress
cls.virtual_machine2.default_network_id = nic.networkid
break
except Exception as e:
cls.fail("Exception while deploying virtual machine: %s" % e)
cls._cleanup.append(cls.virtual_machine1)
cls._cleanup.append(cls.virtual_machine2)
cls._cleanup.append(cls.network1)
cls._cleanup.append(cls.network2)
cls._cleanup.append(cls.network3)
cls._cleanup.append(cls.shared_network_offering)
if cls.zone.securitygroupsenabled:
cls._cleanup.append(security_group)
cls._cleanup.append(cls.account1)
cls._cleanup.append(cls.user_domain)
def test_03_RVR_Network_check_router_state(self):
""" Test redundant router internals """
self.logger.debug("Starting test_03_RVR_Network_check_router_state...")
network_offering_egress_false = get_default_redundant_isolated_network_offering(
self.apiclient)
self.logger.debug("Creating network with network offering: %s" %
network_offering_egress_false.id)
network = Network.create(
self.apiclient,
self.services["network"],
accountid=self.account.name,
domainid=self.account.domainid,
networkofferingid=network_offering_egress_false.id,
zoneid=self.zone.id)
self.logger.debug("Created network with ID: %s" % network.id)
networks = Network.list(self.apiclient, id=network.id, listall=True)
self.assertEqual(
isinstance(networks, list), True,
"List networks should return a valid response for created network")
self.logger.debug("Deploying VM in account: %s" % self.account.name)
virtual_machine = VirtualMachine.create(
self.apiclient,
self.services["virtual_machine"],
templateid=self.template.id,
accountid=self.account.name,
domainid=self.account.domainid,
serviceofferingid=self.service_offering.id,
networkids=[str(network.id)])
self.logger.debug("Deployed VM in network: %s" % network.id)
self.cleanup.insert(0, network)
self.cleanup.insert(0, virtual_machine)
vms = VirtualMachine.list(self.apiclient,
id=virtual_machine.id,
listall=True)
self.assertEqual(isinstance(vms, list), True,
"List Vms should return a valid list")
vm = vms[0]
self.assertEqual(vm.state, "Running",
"VM should be in running state after deployment")
self.logger.debug("Listing routers for network: %s" % network.name)
routers = Router.list(self.apiclient,
networkid=network.id,
listall=True)
self.assertEqual(
isinstance(routers, list), True,
"list router should return Master and backup routers")
self.assertEqual(
len(routers), 2,
"Length of the list router should be 2 (Backup & master)")
vals = ["MASTER", "BACKUP", "UNKNOWN"]
cnts = [0, 0, 0]
result = "UNKNOWN"
for router in routers:
if router.state == "Running":
hosts = list_hosts(self.apiclient,
zoneid=router.zoneid,
type='Routing',
state='Up',
id=router.hostid)
self.assertEqual(isinstance(hosts, list), True,
"Check list host returns a valid list")
host = hosts[0]
try:
host.user, host.passwd = get_host_credentials(
self.config, host.ipaddress)
result = str(
get_process_status(
host.ipaddress, 22, host.user, host.passwd,
router.linklocalip,
"sh /opt/cosmic/router/scripts/checkrouter.sh "))
except KeyError:
self.skipTest(
"Marvin configuration has no host credentials to\
check router services")
if result.count(vals[0]) == 1:
cnts[vals.index(vals[0])] += 1
if cnts[vals.index('MASTER')] != 1:
self.fail("No Master or too many master routers found %s" %
cnts[vals.index('MASTER')])
return
