apache/cloudstack
1
0
Fork 0
mirror of https://github.com/apache/cloudstack.git synced 2025-10-26 08:42:29 +01:00
Code Issues Packages Projects Releases Wiki Activity
cloudstack/test/integration/plugins/nuagevsp/test_nuage_network_migration.py
Raf Smeets 19d6578732 CLOUDSTACK-10303 : Refactor test data to nuage_test_data.py runnable against simulator (#2483) 
* Refactored nuage tests

Added simulator support for ConfigDrive
Allow all nuage tests to run against simulator
Refactored nuage tests to remove code duplication

* Move test data from test_data.py to nuage_test_data.py

Nuage test data is now contained in nuage_test_data.py instead of
test_data.py
Removed all nuage test data from nuage_test_data.py

* CLOUD-1252 fixed cleanup of vpc tier network

* Import libVSD into the codebase

* CLOUDSTACK-1253: Volumes are not expunged in simulator

* Fixed some merge issues in test_nuage_vsp_mngd_subnets test

* Implement GetVolumeStatsCommand in Simulator

* Add vspk as marvin nuagevsp dependency, after removing libVSD dependency

* correct libVSD files for license purposes

pep8 pyflakes compliant
2018-03-14 17:17:36 +05:30

2003 lines
87 KiB
Python
Raw Blame History

# Licensed to the Apache Software Foundation (ASF) under one
# or more contributor license agreements. See the NOTICE file
# distributed with this work for additional information
# regarding copyright ownership. The ASF licenses this file
# to you under the Apache License, Version 2.0 (the
# "License"); you may not use this file except in compliance
# with the License. You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing,
# software distributed under the License is distributed on an
# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
# KIND, either express or implied. See the License for the
# specific language governing permissions and limitations
# under the License.
""" Network migration test with Nuage VSP SDN plugin
"""
# Import Local Modules
from nuageTestCase import nuageTestCase
from marvin.lib.base import (Account, Host)
from marvin.lib.utils import is_server_ssh_ready
from marvin.cloudstackAPI import updateZone
# Import System Modules
from nose.plugins.attrib import attr
import time
import base64
import unittest
import re
class TestNuageMigration(nuageTestCase):
"""Test Native to Nuage Migration
"""
@classmethod
def setUpClass(cls):
super(TestNuageMigration, cls).setUpClass()
if not hasattr(cls.vsp_physical_network, "tags") \
or cls.vsp_physical_network.tags != 'nuage':
raise unittest.SkipTest("Require migrateACS configuration - skip")
# create a native vpc offering
cls.native_vpc_offering = cls.create_VpcOffering(cls.test_data
["vpc_offering"])
# create a nuage vpc offering
cls.nuage_vpc_offering = \
cls.create_VpcOffering(cls.test_data["nuagevsp"]["vpc_offering"])
# tier network offerings
cls.nuage_vpc_network_offering = \
cls.create_NetworkOffering(cls.test_data["nuagevsp"]
["vpc_network_offering"])
cls.native_vpc_network_offering = \
cls.create_NetworkOffering(cls.test_data
["nw_offering_isolated_vpc"])
# create a Nuage isolated network offering with vr
cls.nuage_isolated_network_offering = cls.create_NetworkOffering(
cls.test_data["nuagevsp"]["isolated_network_offering"], True)
# create a Nuage isolated network offering with vr and persistent
cls.nuage_isolated_network_offering_persistent = \
cls.create_NetworkOffering(
cls.test_data["nuagevsp"]
["isolated_network_offering_persistent"],
True)
# create a Nuage isolated network offering without vr
cls.nuage_isolated_network_offering_without_vr = \
cls.create_NetworkOffering(
cls.test_data["nuagevsp"]
["isolated_network_offering_without_vr"],
True)
# create a Nuage isolated network offering without vr but persistent
cls.nuage_isolated_network_offering_without_vr_persistent = \
cls.create_NetworkOffering(
cls.test_data["nuagevsp"]
["isolated_network_offering_without_vr_persistent"],
True)
# create a native isolated network offering
cls.native_isolated_network_offering = cls.create_NetworkOffering(
cls.test_data["isolated_network_offering"], True)
# create a native persistent isolated network offering
cls.native_isolated_network_offering_persistent = \
cls.create_NetworkOffering(
cls.test_data["nw_off_isolated_persistent"], True)
# create a native persistent staticNat isolated network offering
cls.native_isolated_network_staticnat_offering_persistent = \
cls.create_NetworkOffering(
cls.test_data["isolated_staticnat_network_offering"], True)
# create a Native shared network offering
cls.native_shared_network_offering = cls.create_NetworkOffering(
cls.services["shared_network_offering"], False)
# create a Nuage shared network offering
cls.nuage_shared_network_offering = cls.create_NetworkOffering(
cls.test_data["nuagevsp"]["shared_nuage_network_offering"],
False)
cls._cleanup = [
cls.nuage_isolated_network_offering,
cls.nuage_isolated_network_offering_persistent,
cls.nuage_isolated_network_offering_without_vr,
cls.nuage_isolated_network_offering_without_vr_persistent,
cls.native_isolated_network_offering,
cls.native_isolated_network_offering_persistent,
cls.native_vpc_offering,
cls.nuage_vpc_offering,
cls.nuage_vpc_network_offering,
cls.native_vpc_network_offering,
cls.native_shared_network_offering,
cls.nuage_shared_network_offering
]
return
def setUp(self):
# Create an account
self.account = Account.create(self.api_client,
self.test_data["account"],
admin=True,
domainid=self.domain.id
)
self.cleanup = [self.account]
return
def migrate_network(self, nw_off, network, resume=False):
return network.migrate(self.api_client, nw_off.id, resume)
def migrate_vpc(self, vpc, vpc_offering,
network_offering_map, resume=False):
return vpc.migrate(self.api_client,
vpc_offering.id,
network_offering_map, resume)
def verify_pingtovmipaddress(self, ssh, pingtovmipaddress):
"""verify ping to ipaddress of the vm and retry 3 times"""
successfull_ping = False
nbr_retries = 0
max_retries = 5
cmd = 'ping -c 2 ' + pingtovmipaddress
while not successfull_ping and nbr_retries < max_retries:
self.debug("ping vm by ipaddress with command: " + cmd)
outputlist = ssh.execute(cmd)
self.debug("command is executed properly " + cmd)
completeoutput = str(outputlist).strip('[]')
self.debug("complete output is " + completeoutput)
if '2 received' in completeoutput:
self.debug("PASS as vm is pingeable: " + completeoutput)
successfull_ping = True
else:
self.debug("FAIL as vm is not pingeable: " + completeoutput)
time.sleep(3)
nbr_retries = nbr_retries + 1
if not successfull_ping:
self.fail("FAILED TEST as excepted value not found in vm")
def verify_pingtovmhostname(self, ssh, pingtovmhostname):
"""verify ping to hostname of the vm and retry 3 times"""
successfull_ping = False
nbr_retries = 0
max_retries = 5
cmd = 'ping -c 2 ' + pingtovmhostname
while not successfull_ping and nbr_retries < max_retries:
self.debug("ping vm by hostname with command: " + cmd)
outputlist = ssh.execute(cmd)
self.debug("command is executed properly " + cmd)
completeoutput = str(outputlist).strip('[]')
self.debug("complete output is " + completeoutput)
if '2 received' in completeoutput:
self.debug("PASS as vm is pingeable: " + completeoutput)
successfull_ping = True
else:
self.debug("FAIL as vm is not pingeable: " + completeoutput)
time.sleep(3)
nbr_retries = nbr_retries + 1
if not successfull_ping:
self.fail("FAILED TEST as excepted value not found in vm")
def update_userdata(self, vm, expected_user_data):
updated_user_data = base64.b64encode(expected_user_data)
vm.update(self.api_client, userdata=updated_user_data)
return expected_user_data
def get_userdata_url(self, vm):
self.debug("Getting user data url")
nic = vm.nic[0]
gateway = str(nic.gateway)
self.debug("Gateway: " + gateway)
user_data_url = 'curl "http://' + gateway + ':80/latest/user-data"'
return user_data_url
def define_cloudstack_managementip(self):
# get cloudstack managementips from cfg file
config = self.getClsConfig()
return [config.mgtSvr[0].mgtSvrIp, config.mgtSvr[1].mgtSvrIp]
def cloudstack_connection_vsd(self, connection="up",
cscip=["csc-1", "csc-2"]):
self.debug("SSH into cloudstack management server(s), setting "
"connection to VSD as %s " % connection)
try:
for ip in cscip:
csc_ssh_client = is_server_ssh_ready(
ipaddress=ip,
port=22,
username="root",
password="tigris",
retries=2
)
self.debug("SSH is successful for cloudstack management "
"server with IP %s" % ip)
if connection == "down":
cmd = "iptables -A OUTPUT -p tcp --dport 8443 -j DROP"
else:
cmd = "iptables -D OUTPUT -p tcp --dport 8443 -j DROP"
self.execute_cmd(csc_ssh_client, cmd)
except Exception as e:
self.debug("Setting cloudstack management server(s) connection %s "
"to VSD fails with exception %s" % (connection, e))
def verify_cloudstack_host_state_up(self, state):
nbr_retries = 0
max_retries = 30
self.debug("Verify state by list hosts type=L2Networking")
result = Host.list(self.api_client, type="L2Networking")
while result[0].state != state and nbr_retries < max_retries:
time.sleep(5)
result = Host.list(self.api_client, type="L2Networking")
nbr_retries = nbr_retries + 1
if nbr_retries == max_retries:
self.debug("TIMEOUT - state of list hosts unchanged")
def verifymigrationerrortext(self, errortext, expectstr):
if expectstr in errortext:
self.debug("Migrate_network fails with expected errortext %s",
errortext)
else:
self.fail("Migrate_network fails but test expects "
"other errortext %s", expectstr)
@attr(tags=["migrateACS", "novms"],
required_hardware="false")
def test_01_native_to_nuage_network_migration_novms(self):
"""
Verify Migration for an isolated network without VMs
1. create multiple native non-persistent isolated network
2. move to nuage non-persistent isolated network
3. move to native persistent network, check VR state
4. move to nuage persistent network, check VR state
"""
isolated_network = self.create_Network(
self.native_isolated_network_offering, gateway="10.0.0.1",
netmask="255.255.255.0")
isolated_network2 = self.create_Network(
self.native_isolated_network_offering, gateway="10.1.0.1",
netmask="255.255.255.0")
shared_network = self.create_Network(
self.native_shared_network_offering, gateway="10.3.0.1",
netmask="255.255.255.0", vlan=1201)
try:
self.migrate_network(
self.nuage_shared_network_offering,
shared_network, resume=False)
except Exception as e:
errortext = \
re.search(".*errortext\s*:\s*u?(['\"])([^\\1]+)\\1.*",
e.message).group(2)
self.debug("Migration fails with %s" % errortext)
expectstr = "NetworkOfferingId can be upgraded only for the " \
"network of type Isolated"
self.verifymigrationerrortext(errortext, expectstr)
try:
self.migrate_network(
self.nuage_shared_network_offering,
isolated_network, resume=False)
except Exception as e:
errortext = \
re.search(".*errortext\s*:\s*u?(['\"])([^\\1]+)\\1.*",
e.message).group(2)
self.debug("Migration fails with %s" % errortext)
expectstr = "Can't upgrade from network offering"
self.verifymigrationerrortext(errortext, expectstr)
self.nuage_isolated_network_offering.update(self.api_client,
state="Disabled")
self.validate_NetworkOffering(
self.nuage_isolated_network_offering, state="Disabled")
try:
self.migrate_network(
self.nuage_isolated_network_offering,
isolated_network, resume=False)
except Exception as e:
errortext = \
re.search(".*errortext\s*:\s*u?(['\"])([^\\1]+)\\1.*",
e.message).group(2)
self.debug("Migration fails with %s" % errortext)
expectstr = "Failed to migrate network as the specified network " \
"offering is not enabled."
self.verifymigrationerrortext(errortext, expectstr)
self.nuage_isolated_network_offering.update(self.api_client,
state="Enabled")
self.validate_NetworkOffering(
self.nuage_isolated_network_offering, state="Enabled")
self.migrate_network(
self.nuage_isolated_network_offering, isolated_network,
resume=True)
self.verify_vsd_network_not_present(isolated_network, None)
self.migrate_network(
self.native_isolated_network_offering_persistent, isolated_network)
self.verify_vsd_network_not_present(isolated_network, None)
vr = self.get_Router(isolated_network)
self.check_Router_state(vr, "Running")
try:
self.migrate_network(
self.nuage_vpc_offering, isolated_network, resume=False)
except Exception as e:
self.debug("Migration fails with %s" % e)
try:
self.migrate_network(
self.nuage_vpc_network_offering, isolated_network,
resume=False)
except Exception as e:
errortext = \
re.search(".*errortext\s*:\s*u?(['\"])([^\\1]+)\\1.*",
e.message).group(2)
self.debug("Migration fails with %s" % errortext)
expectstr = "Failed to migrate network as the specified network " \
"offering is a VPC offering"
self.verifymigrationerrortext(errortext, expectstr)
self.migrate_network(
self.nuage_isolated_network_offering_persistent, isolated_network)
self.verify_vsd_network(self.domain.id, isolated_network, None)
vr = self.get_Router(isolated_network)
self.check_Router_state(vr, "Running")
self.verify_vsd_router(vr)
with self.assertRaises(Exception):
self.verify_vsd_network(self.domain.id, isolated_network2, None)
self.add_resource_tag(
self.native_isolated_network_offering_persistent.id,
"NetworkOffering", "RelatedNetworkOffering",
self.native_isolated_network_offering.id)
result = self.list_resource_tag(
self.native_isolated_network_offering_persistent.id,
"NetworkOffering", "RelatedNetworkOffering")
if result[0].value != self.native_isolated_network_offering.id:
self.fail("Listed resource value does not match with stored"
" resource value!")
self.delete_resource_tag(
self.native_isolated_network_offering_persistent.id,
"NetworkOffering")
empty = self.list_resource_tag(
self.native_isolated_network_offering_persistent.id,
"NetworkOffering", "RelatedNetworkOffering")
if empty:
self.fail("clean up of resource values did was not successful!")
@attr(tags=["migrateACS", "stoppedvms"],
required_hardware="false")
def test_02_native_to_nuage_network_migration_stoppedvms(self):
"""
Verify Migration for an isolated network with stopped VMs
1. create multiple native non-persistent isolated network
2. deploy vm and stop vm
3. move to nuage non-persistent isolated network
4. deploy vm and stop vm
5. move to native persistent network, check VR state
6. deploy vm and stop vm
7. move to nuage persistent network, check VR state
"""
isolated_network = self.create_Network(
self.native_isolated_network_offering, gateway="10.0.0.1",
netmask="255.255.255.0")
vm_1 = self.create_VM(isolated_network)
vm_1.stop(self.api_client)
self.migrate_network(
self.nuage_isolated_network_offering, isolated_network)
vm_1.delete(self.api_client, expunge=True)
vm_2 = self.create_VM(isolated_network)
vm_2.stop(self.api_client)
self.verify_vsd_network(self.domain.id, isolated_network, None)
self.migrate_network(
self.native_isolated_network_offering_persistent, isolated_network)
self.verify_vsd_network_not_present(isolated_network, None)
vr = self.get_Router(isolated_network)
self.check_Router_state(vr, "Running")
vm_2.delete(self.api_client, expunge=True)
vm_3 = self.create_VM(isolated_network)
vm_3.stop(self.api_client)
self.migrate_network(
self.nuage_isolated_network_offering_persistent, isolated_network)
self.verify_vsd_network(self.domain.id, isolated_network, None)
vr2 = self.get_Router(isolated_network)
self.check_Router_state(vr2, "Running")
self.verify_vsd_router(vr2)
self.verify_vsd_network(self.domain.id, isolated_network, None)
@attr(tags=["migrateACS", "nonpersist"],
required_hardware="false")
def test_03_migrate_native_nonpersistent_network_to_nuage_traffic(self):
"""
Verify traffic after Migration of a non-persistent isolated network
1. create native non-persistent isolated network
2. move to nuage non-persistent isolated network
3. Spin VM's and verify traffic provided by Nuage
"""
for i in range(1, 3):
isolated_network = self.create_Network(
self.native_isolated_network_offering, gateway="10.1.0.1",
netmask="255.255.255.0", account=self.account)
try:
self.migrate_network(
self.nuage_vpc_network_offering,
isolated_network, resume=False)
except Exception as e:
errortext = re.search(".*errortext\s*:\s*u?'([^']+)'.*",
e.message).group(1)
self.debug("Migration fails with %s" % errortext)
expectstr = "Failed to migrate network as the specified network " \
"offering is a VPC offering"
self.verifymigrationerrortext(errortext, expectstr)
self.migrate_network(
self.nuage_isolated_network_offering_without_vr,
isolated_network, resume=True)
self.migrate_network(
self.nuage_isolated_network_offering_without_vr,
isolated_network, resume=False)
self.verify_vsd_network_not_present(isolated_network, None)
self.debug("Deploying a VM in the created Isolated network...")
vm_1 = self.create_VM(isolated_network)
self.validate_Network(isolated_network, state="Implemented")
self.check_VM_state(vm_1, state="Running")
vm_2 = self.create_VM(isolated_network)
self.check_VM_state(vm_2, state="Running")
# VSD verification
self.verify_vsd_network(self.domain.id, isolated_network)
# self.verify_vsd_router(vr_1)
self.verify_vsd_vm(vm_1)
self.verify_vsd_vm(vm_2)
# Creating Static NAT rule
self.debug("Creating Static NAT rule for the deployed VM in the "
"created Isolated network...")
public_ip = self.acquire_PublicIPAddress(isolated_network)
self.validate_PublicIPAddress(public_ip, isolated_network)
self.create_StaticNatRule_For_VM(vm_1, public_ip, isolated_network)
self.validate_PublicIPAddress(
public_ip, isolated_network, static_nat=True, vm=vm_1)
fw_rule = self.create_FirewallRule(
public_ip, self.test_data["ingress_rule"])
# VSD verification for Static NAT functionality
self.verify_vsd_floating_ip(isolated_network, vm_1,
public_ip.ipaddress)
self.verify_vsd_firewall_rule(fw_rule)
# Ssh into the VM via floating ip
vm_public_ip = public_ip.ipaddress.ipaddress
try:
vm_1.ssh_ip = vm_public_ip
vm_1.ssh_port = self.test_data["virtual_machine"]["ssh_port"]
vm_1.username = self.test_data["virtual_machine"]["username"]
vm_1.password = self.test_data["virtual_machine"]["password"]
self.debug("SSHing into VM: %s with %s" %
(vm_1.ssh_ip, vm_1.password))
ssh = vm_1.get_ssh_client(ipaddress=vm_public_ip)
except Exception as e:
self.fail("SSH into VM failed with exception %s" % e)
self.verify_pingtovmipaddress(ssh, vm_2.ipaddress)
vm_1.delete(self.api_client, expunge=True)
vm_2.delete(self.api_client, expunge=True)
isolated_network.delete(self.api_client)
self.debug("Number of loops %s" % i)
@attr(tags=["migrateACS", "persist"],
required_hardware="false")
def test_04_migrate_native_persistentnetwork_to_nuage_traffic(self):
"""
Verify traffic after Migration of a persistent isolated network
1. create native persistent isolated network
2. move to nuage persistent isolated network without VR
3. Spin VM's and verify traffic provided by Nuage
"""
for i in range(1, 3):
isolated_network = self.create_Network(
self.native_isolated_network_offering_persistent,
gateway="10.2.0.1",
netmask="255.255.255.0", account=self.account)
self.verify_vsd_network_not_present(isolated_network, None)
vr = self.get_Router(isolated_network)
self.check_Router_state(vr, "Running")
csc_ips = self.define_cloudstack_managementip()
self.cloudstack_connection_vsd(connection="down", cscip=csc_ips)
self.debug("-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=")
self.debug("Migrate_network fails if connection ACS VSD is down")
self.debug("-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=")
self.verify_cloudstack_host_state_up("Alert")
try:
self.migrate_network(
self.nuage_isolated_network_offering_without_vr_persistent,
isolated_network, resume=False)
except Exception as e:
errortext = re.search(".*errortext\s*:\s*u?'([^']+)'.*",
e.message).group(1)
self.debug("Migration fails with %s" % errortext)
expectstr = "Failed to implement network (with specified id) " \
"elements and resources as a part of network update"
self.verifymigrationerrortext(errortext, expectstr)
self.cloudstack_connection_vsd(connection="up", cscip=csc_ips)
self.debug("-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=")
self.debug("Migrate_network resumes if connection ACS VSD is up")
self.debug("-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=")
self.verify_cloudstack_host_state_up("Up")
try:
self.migrate_network(
self.nuage_isolated_network_offering_without_vr_persistent,
isolated_network, resume=False)
except Exception as e:
errortext = \
re.search(".*errortext\s*:\s*u?(['\"])([^\\1]+)\\1.*",
e.message).group(2)
self.debug("Migration fails with %s" % errortext)
expectstr = "Failed to migrate network as previous migration " \
"left this network in transient condition. " \
"Specify resume as true."
self.verifymigrationerrortext(errortext, expectstr)
self.migrate_network(
self.nuage_isolated_network_offering_without_vr_persistent,
isolated_network, resume=True)
self.verify_vsd_network(self.domain.id, isolated_network, None)
with self.assertRaises(Exception):
self.get_Router(isolated_network)
self.debug("Deploying a VM in the created Isolated network...")
vm_1 = self.create_VM(isolated_network)
self.validate_Network(isolated_network, state="Implemented")
with self.assertRaises(Exception):
self.get_Router(isolated_network)
self.check_VM_state(vm_1, state="Running")
vm_2 = self.create_VM(isolated_network)
self.check_VM_state(vm_2, state="Running")
# VSD verification
self.verify_vsd_network(self.domain.id, isolated_network)
self.verify_vsd_vm(vm_1)
self.verify_vsd_vm(vm_2)
# Creating Static NAT rule
self.debug("Creating Static NAT rule for the deployed VM in the "
"created Isolated network...")
public_ip = self.acquire_PublicIPAddress(isolated_network)
self.validate_PublicIPAddress(public_ip, isolated_network)
self.create_StaticNatRule_For_VM(vm_1, public_ip, isolated_network)
self.validate_PublicIPAddress(
public_ip, isolated_network, static_nat=True, vm=vm_1)
fw_rule = self.create_FirewallRule(
public_ip, self.test_data["ingress_rule"])
# VSD verification for Static NAT functionality
self.verify_vsd_floating_ip(isolated_network, vm_1,
public_ip.ipaddress)
self.verify_vsd_firewall_rule(fw_rule)
# Ssh into the VM via floating ip
vm_public_ip = public_ip.ipaddress.ipaddress
try:
vm_1.ssh_ip = vm_public_ip
vm_1.ssh_port = self.test_data["virtual_machine"]["ssh_port"]
vm_1.username = self.test_data["virtual_machine"]["username"]
vm_1.password = self.test_data["virtual_machine"]["password"]
self.debug("SSHing into VM: %s with %s" %
(vm_1.ssh_ip, vm_1.password))
ssh = vm_1.get_ssh_client(ipaddress=vm_public_ip)
except Exception as e:
self.fail("SSH into VM failed with exception %s" % e)
self.verify_pingtovmipaddress(ssh, vm_2.ipaddress)
vm_1.delete(self.api_client, expunge=True)
vm_2.delete(self.api_client, expunge=True)
isolated_network.delete(self.api_client)
self.debug("Number of loops %s" % i)
@attr(tags=["migrateACS", "nicmigration"],
required_hardware="false")
def test_05_native_to_nuage_nic_migration(self):
"""
Verify Nic migration of GuestVm in an isolated network
1. create multiple native non-persistent isolated network
2. populate network with 2 vm's
3. enable static nat + create FW rule
4. move to nuage non-persistent isolated network, check:
- public ip
- FW rules
- VR
- VM's
"""
isolated_network = self.create_Network(
self.native_isolated_network_offering, gateway="10.0.0.1",
netmask="255.255.255.0")
isolated_network2 = self.create_Network(
self.native_isolated_network_offering, gateway="10.1.0.1",
netmask="255.255.255.0")
vm1 = self.create_VM(isolated_network)
public_ip = self.acquire_PublicIPAddress(isolated_network)
self.create_StaticNatRule_For_VM(vm1, public_ip, isolated_network)
firewall_rule = self.create_FirewallRule(public_ip)
vm2 = self.create_VM(isolated_network)
vr = self.get_Router(isolated_network)
self.check_Router_state(vr, "Running")
self.migrate_network(
self.nuage_isolated_network_offering, isolated_network)
self.verify_vsd_network(self.domain.id, isolated_network, None)
self.verify_vsd_vm(vm1)
self.verify_vsd_floating_ip(isolated_network, vm1, public_ip.ipaddress)
self.verify_vsd_firewall_rule(firewall_rule)
self.verify_vsd_vm(vm2)
vr = self.get_Router(isolated_network)
self.check_Router_state(vr, "Running")
self.verify_vsd_router(vr)
with self.assertRaises(Exception):
self.verify_vsd_network(self.domain.id, isolated_network2, None)
@attr(tags=["migrateACS", "nonpersistnic"],
required_hardware="false")
def test_06_migrate_native_nonpersistent_nic_to_nuage_traffic(self):
"""
Verify Nic migration of GuestVm in a non-persistent isolated network
1. create two native non-persistent isolated networks
2. Deploy 2 vm's in first network
3. enable static nat + create FW rule
4. move first network to nuage non-persistent isolated network,
check:
- public ip
- FW rules
- VR
- VM's
5. Destroy and expunge 1 VM in first network
6. Deploy a new VM in first network and check traffic
7. Move second network to nuage non-persistent isolated network,
check:
- public ip
- FW rules
- VR
- VM's
8. Deploy 2 vm in second network , move it and check
9. Cleanup
"""
isolated_network = self.create_Network(
self.native_isolated_network_offering, gateway="10.3.0.1",
netmask="255.255.255.0")
isolated_network2 = self.create_Network(
self.native_isolated_network_offering, gateway="10.4.0.1",
netmask="255.255.255.0")
vm_1 = self.create_VM(isolated_network)
public_ip = self.acquire_PublicIPAddress(isolated_network)
self.create_StaticNatRule_For_VM(vm_1, public_ip, isolated_network)
firewall_rule = self.create_FirewallRule(public_ip)
vm_2 = self.create_VM(isolated_network)
vr = self.get_Router(isolated_network)
self.check_Router_state(vr, "Running")
self.migrate_network(
self.nuage_isolated_network_offering, isolated_network)
self.verify_vsd_network(self.domain.id, isolated_network, None)
self.verify_vsd_vm(vm_1)
self.verify_vsd_floating_ip(isolated_network, vm_1,
public_ip.ipaddress)
self.verify_vsd_firewall_rule(firewall_rule)
self.verify_vsd_vm(vm_2)
vr_3 = self.get_Router(isolated_network)
self.check_Router_state(vr_3, "Running")
self.verify_vsd_router(vr_3)
# VSD verification for Static NAT functionality
self.verify_vsd_floating_ip(isolated_network, vm_1,
public_ip.ipaddress)
self.verify_vsd_firewall_rule(firewall_rule)
# Ssh into the VM via floating ip
vm_public_ip = public_ip.ipaddress.ipaddress
try:
vm_1.ssh_ip = vm_public_ip
vm_1.ssh_port = self.test_data["virtual_machine"]["ssh_port"]
vm_1.username = self.test_data["virtual_machine"]["username"]
vm_1.password = self.test_data["virtual_machine"]["password"]
self.debug("SSHing into VM: %s with %s" %
(vm_1.ssh_ip, vm_1.password))
ssh = vm_1.get_ssh_client(ipaddress=vm_public_ip)
except Exception as e:
self.fail("SSH into VM failed with exception %s" % e)
self.verify_pingtovmipaddress(ssh, vm_2.ipaddress)
vm_2.delete(self.api_client, expunge=True)
with self.assertRaises(Exception):
self.verify_vsd_vm(vm_2)
vm_4 = self.create_VM(isolated_network)
self.verify_vsd_vm(vm_4)
with self.assertRaises(Exception):
self.verify_vsd_network(self.domain.id, isolated_network2, None)
vm_3 = self.create_VM(isolated_network2)
vr_2 = self.get_Router(isolated_network2)
self.check_Router_state(vr_2, "Running")
# Ssh into the VM via floating ip
vm_public_ip = public_ip.ipaddress.ipaddress
try:
vm_1.ssh_ip = vm_public_ip
vm_1.ssh_port = self.test_data["virtual_machine"]["ssh_port"]
vm_1.username = self.test_data["virtual_machine"]["username"]
vm_1.password = self.test_data["virtual_machine"]["password"]
self.debug("SSHing into VM: %s with %s" %
(vm_1.ssh_ip, vm_1.password))
ssh = vm_1.get_ssh_client(ipaddress=vm_public_ip)
except Exception as e:
self.fail("SSH into VM failed with exception %s" % e)
self.verify_pingtovmipaddress(ssh, vm_4.ipaddress)
vm_1.delete(self.api_client, expunge=True)
vm_4.delete(self.api_client, expunge=True)
isolated_network.delete(self.api_client)
self.migrate_network(
self.nuage_isolated_network_offering_without_vr,
isolated_network2)
public_ip_2 = self.acquire_PublicIPAddress(isolated_network2)
self.create_StaticNatRule_For_VM(vm_3, public_ip_2, isolated_network2)
firewall_rule_2 = self.create_FirewallRule(public_ip_2)
self.verify_vsd_floating_ip(isolated_network2, vm_3,
public_ip_2.ipaddress)
self.verify_vsd_firewall_rule(firewall_rule_2)
self.verify_vsd_network(self.domain.id, isolated_network2, None)
self.verify_vsd_vm(vm_3)
self.verify_vsd_floating_ip(isolated_network2, vm_3,
public_ip_2.ipaddress)
self.verify_vsd_firewall_rule(firewall_rule_2)
with self.assertRaises(Exception):
self.get_Router(isolated_network2)
vm_5 = self.create_VM(isolated_network2)
self.verify_vsd_vm(vm_5)
# Ssh into the VM via floating ip
vm_public_ip_2 = public_ip_2.ipaddress.ipaddress
try:
vm_3.ssh_ip = vm_public_ip_2
vm_3.ssh_port = self.test_data["virtual_machine"]["ssh_port"]
vm_3.username = self.test_data["virtual_machine"]["username"]
vm_3.password = self.test_data["virtual_machine"]["password"]
self.debug("SSHing into VM: %s with %s" %
(vm_3.ssh_ip, vm_3.password))
ssh = vm_3.get_ssh_client(ipaddress=vm_public_ip_2)
except Exception as e:
self.fail("SSH into VM failed with exception %s" % e)
self.verify_pingtovmipaddress(ssh, vm_5.ipaddress)
@attr(tags=["migrateACS", "persistnic"],
required_hardware="false")
def test_07_migrate_native_persistent_nic_to_nuage_traffic(self):
"""
Verify Nic migration of GuestVm in a persistent isolated network
1. create two native persistent isolated networks
2. deploy 2 vm's in this network
3. move to nuage non-persistent isolated network,
4. enable static nat + create FW rule
check:
- public ip
- FW rules
- VR
- VM's
"""
isolated_network = self.create_Network(
self.native_isolated_network_offering_persistent,
gateway="10.5.0.1",
netmask="255.255.255.0")
isolated_network2 = self.create_Network(
self.native_isolated_network_offering_persistent,
gateway="10.6.0.1",
netmask="255.255.255.0")
vm_1 = self.create_VM(isolated_network)
vm_2 = self.create_VM(isolated_network)
vr = self.get_Router(isolated_network)
self.check_Router_state(vr, "Running")
vm_3 = self.create_VM(isolated_network2)
self.migrate_network(
self.nuage_isolated_network_offering_without_vr_persistent,
isolated_network)
public_ip = self.acquire_PublicIPAddress(isolated_network)
self.create_StaticNatRule_For_VM(vm_1, public_ip, isolated_network)
firewall_rule = self.create_FirewallRule(public_ip)
self.verify_vsd_network(self.domain.id, isolated_network, None)
self.verify_vsd_vm(vm_1)
self.verify_vsd_floating_ip(isolated_network, vm_1,
public_ip.ipaddress)
self.verify_vsd_firewall_rule(firewall_rule)
self.verify_vsd_vm(vm_2)
with self.assertRaises(Exception):
self.get_Router(isolated_network)
# Ssh into the VM via floating ip
vm_public_ip = public_ip.ipaddress.ipaddress
try:
vm_1.ssh_ip = vm_public_ip
vm_1.ssh_port = self.test_data["virtual_machine"]["ssh_port"]
vm_1.username = self.test_data["virtual_machine"]["username"]
vm_1.password = self.test_data["virtual_machine"]["password"]
self.debug("SSHing into VM: %s with %s" %
(vm_1.ssh_ip, vm_1.password))
ssh = vm_1.get_ssh_client(ipaddress=vm_public_ip)
except Exception as e:
self.fail("SSH into VM failed with exception %s" % e)
self.verify_pingtovmipaddress(ssh, vm_2.ipaddress)
vm_1.delete(self.api_client, expunge=True)
self.migrate_network(
self.nuage_isolated_network_offering_without_vr_persistent,
isolated_network2)
vm_2.delete(self.api_client, expunge=True)
isolated_network.delete(self.api_client)
self.verify_vsd_network(self.domain.id, isolated_network2, None)
self.verify_vsd_vm(vm_3)
public_ip_2 = self.acquire_PublicIPAddress(isolated_network2)
self.create_StaticNatRule_For_VM(vm_3, public_ip_2, isolated_network2)
firewall_rule_2 = self.create_FirewallRule(public_ip_2)
vm_4 = self.create_VM(isolated_network2)
self.verify_vsd_floating_ip(isolated_network2, vm_3,
public_ip_2.ipaddress)
self.verify_vsd_firewall_rule(firewall_rule_2)
self.verify_vsd_vm(vm_4)
# Ssh into the VM via floating ip
vm_public_ip_2 = public_ip_2.ipaddress.ipaddress
try:
vm_3.ssh_ip = vm_public_ip_2
vm_3.ssh_port = self.test_data["virtual_machine"]["ssh_port"]
vm_3.username = self.test_data["virtual_machine"]["username"]
vm_3.password = self.test_data["virtual_machine"]["password"]
self.debug("SSHing into VM: %s with %s" %
(vm_3.ssh_ip, vm_3.password))
ssh = vm_3.get_ssh_client(ipaddress=vm_public_ip_2)
except Exception as e:
self.fail("SSH into VM failed with exception %s" % e)
self.verify_pingtovmipaddress(ssh, vm_4.ipaddress)
@attr(tags=["migrateACS", "isomultinic"],
required_hardware="false")
def test_08_migrate_native_multinic_to_nuage_traffic(self):
"""
Verify MultiNic migration of GuestVm with multiple isolated networks
1. create one native non-persistent isolated network
2. create one native persistent isolated network
3. deploy 2 vm's in both these network
4. move non-persist to nuage non-persistent isolated network,
5. move persist to nuage persistent isolated network
6. enable static nat + create FW rule
check:
- public ip
- FW rules
- VR
- VM's
"""
isolated_network = self.create_Network(
self.native_isolated_network_offering,
gateway="10.7.0.1",
netmask="255.255.255.0")
isolated_network2 = self.create_Network(
self.native_isolated_network_offering_persistent,
gateway="10.8.0.1",
netmask="255.255.255.0")
vm_1 = self.create_VM([isolated_network, isolated_network2])
vm_2 = self.create_VM([isolated_network2, isolated_network])
vr = self.get_Router(isolated_network2)
self.check_Router_state(vr, "Running")
self.migrate_network(
self.nuage_isolated_network_offering_without_vr,
isolated_network)
vm_3 = self.create_VM(isolated_network)
public_ip = self.acquire_PublicIPAddress(isolated_network)
self.create_StaticNatRule_For_VM(vm_3, public_ip, isolated_network)
firewall_rule = self.create_FirewallRule(public_ip)
self.verify_vsd_network(self.domain.id, isolated_network, None)
self.verify_vsd_vm(vm_3)
self.verify_vsd_floating_ip(isolated_network, vm_3,
public_ip.ipaddress)
self.verify_vsd_firewall_rule(firewall_rule)
# Ssh into the VM via floating ip
vm_public_ip = public_ip.ipaddress.ipaddress
try:
vm_3.ssh_ip = vm_public_ip
vm_3.ssh_port = self.test_data["virtual_machine"]["ssh_port"]
vm_3.username = self.test_data["virtual_machine"]["username"]
vm_3.password = self.test_data["virtual_machine"]["password"]
self.debug("SSHing into VM: %s with %s" %
(vm_3.ssh_ip, vm_3.password))
ssh = vm_3.get_ssh_client(ipaddress=vm_public_ip)
except Exception as e:
self.fail("SSH into VM failed with exception %s" % e)
defaultipaddress = \
[nic.ipaddress for nic in vm_1.nic if nic.isdefault][0]
self.verify_pingtovmipaddress(ssh, defaultipaddress)
self.migrate_network(
self.nuage_isolated_network_offering_without_vr_persistent,
isolated_network2)
vm_3.delete(self.api_client, expunge=True)
public_ip.delete(self.api_client)
vm_4 = self.create_VM(isolated_network2)
public_ip_2 = self.acquire_PublicIPAddress(isolated_network2)
self.create_StaticNatRule_For_VM(vm_4, public_ip_2, isolated_network2)
firewall_rule_2 = self.create_FirewallRule(public_ip_2)
self.verify_vsd_floating_ip(isolated_network2, vm_4,
public_ip_2.ipaddress)
self.verify_vsd_firewall_rule(firewall_rule_2)
self.verify_vsd_vm(vm_4)
# Ssh into the VM via floating ip
vm_public_ip_2 = public_ip_2.ipaddress.ipaddress
try:
vm_4.ssh_ip = vm_public_ip_2
vm_4.ssh_port = self.test_data["virtual_machine"]["ssh_port"]
vm_4.username = self.test_data["virtual_machine"]["username"]
vm_4.password = self.test_data["virtual_machine"]["password"]
self.debug("SSHing into VM: %s with %s" %
(vm_4.ssh_ip, vm_4.password))
ssh = vm_4.get_ssh_client(ipaddress=vm_public_ip_2)
except Exception as e:
self.fail("SSH into VM failed with exception %s" % e)
defaultipaddress2 = \
[nic.ipaddress for nic in vm_2.nic if nic.isdefault][0]
self.verify_pingtovmipaddress(ssh, defaultipaddress2)
@attr(tags=["migrateACS", "persiststaticnat"],
required_hardware="false")
def test_09_migrate_native_persist_staticnat_to_nuage_traffic(self):
"""
Verify StaticNat migration of GuestVm in a persistent isolated network
1. create one native persistent isolated network offering
2. with Dhcp,SourceNat,StaticNat,Dns,Userdata and Firewall
3. create one native persistent isolated network with above
4. deploy 2 vm's in this network
5. In a loop
enable staticnat on first vm and open port 22 for ssh
login to vm1 and ping vm2
verify userdata in Native
move to nuage persistent isolated network,
deploy 2 new vm's in this network
enable staticnat on new vm and open port 22 for ssh
check:
- public ips
- FW rules
- VR
- VM's ping old and new VM's
- verify userdata in Nuage
- Release public ips
move back to native persistent isolated network,
"""
isolated_network = self.create_Network(
self.native_isolated_network_staticnat_offering_persistent,
gateway="10.9.0.1",
netmask="255.255.255.0", account=self.account)
vm_1 = self.create_VM(isolated_network)
vm_2 = self.create_VM(isolated_network)
vr = self.get_Router(isolated_network)
self.check_Router_state(vr, "Running")
for i in range(1, 3):
self.debug("+++++Starting again as Native in Loop+++++")
public_ip = self.acquire_PublicIPAddress(isolated_network)
self.create_StaticNatRule_For_VM(vm_1, public_ip, isolated_network)
firewall_rule = self.create_FirewallRule(public_ip)
self.migrate_network(
self.nuage_isolated_network_offering_persistent,
isolated_network)
self.verify_vsd_network(self.domain.id, isolated_network, None)
self.verify_vsd_vm(vm_1)
self.verify_vsd_floating_ip(isolated_network, vm_1,
public_ip.ipaddress)
self.verify_vsd_firewall_rule(firewall_rule)
self.verify_vsd_vm(vm_2)
vm_3 = self.create_VM(isolated_network)
public_ip_2 = self.acquire_PublicIPAddress(isolated_network)
self.create_StaticNatRule_For_VM(vm_3,
public_ip_2,
isolated_network)
firewall_rule_2 = self.create_FirewallRule(public_ip_2)
vm_4 = self.create_VM(isolated_network)
self.verify_vsd_floating_ip(isolated_network, vm_3,
public_ip_2.ipaddress)
self.verify_vsd_firewall_rule(firewall_rule_2)
self.verify_vsd_vm(vm_3)
self.verify_vsd_vm(vm_4)
# Ssh into the VM via floating ip
vm_public_ip_2 = public_ip_2.ipaddress.ipaddress
try:
vm_3.ssh_ip = vm_public_ip_2
vm_3.ssh_port = self.test_data["virtual_machine"]["ssh_port"]
vm_3.username = self.test_data["virtual_machine"]["username"]
vm_3.password = self.test_data["virtual_machine"]["password"]
self.debug("SSHing into VM: %s with %s" %
(vm_3.ssh_ip, vm_3.password))
ssh2 = vm_3.get_ssh_client(ipaddress=vm_public_ip_2)
except Exception as e:
self.fail("SSH into VM failed with exception %s" % e)
self.verify_pingtovmipaddress(ssh2, vm_1.ipaddress)
self.verify_pingtovmipaddress(ssh2, vm_4.ipaddress)
self.verify_pingtovmipaddress(ssh2, vm_2.ipaddress)
self.debug("Updating the running vm_3 with new user data...")
expected_user_data2 = self.update_userdata(vm_3, "hellonuage vm3")
self.debug("SSHing into the vm_3 for verifying its user data...")
user_data_cmd = self.get_userdata_url(vm_3)
self.debug("Getting user data with command: " + user_data_cmd)
actual_user_data2 = self.execute_cmd(ssh2, user_data_cmd)
self.debug("Actual user data - " + actual_user_data2 +
", Expected user data - " + expected_user_data2)
self.assertEqual(actual_user_data2, expected_user_data2,
"Un-expected VM (VM_3) user data")
vm_3.delete(self.api_client, expunge=True)
vm_4.delete(self.api_client, expunge=True)
public_ip_2.delete(self.api_client)
# ReleaseIP as get_ssh_client fails when migrating back to native
public_ip.delete(self.api_client)
self.debug("++++++++Migrating network back to native+++++++")
self.migrate_network(
self.native_isolated_network_staticnat_offering_persistent,
isolated_network)
@attr(tags=["migrateACS", "vpcnovms"],
required_hardware="false")
def test_10_migrate_native_vpc(self):
vpc = self.create_Vpc(self.native_vpc_offering)
network = self.create_Network(self.native_vpc_network_offering,
vpc=vpc)
self.create_VM(network)
network_offering_map = \
[{"networkid": network.id,
"networkofferingid":
self.nuage_isolated_network_offering_without_vr.id}]
try:
self.migrate_vpc(vpc, self.nuage_vpc_offering,
network_offering_map, resume=False)
except Exception as e:
errortext = re.search(".*errortext\s*:\s*u?(['\"])([^\\1]+)\\1.*",
e.message).group(2)
self.debug("Migration fails with %s" % errortext)
expectstr = "can't be used for VPC networks"
self.verifymigrationerrortext(errortext, expectstr)
network_offering_map = \
[{"networkid": network.id,
"networkofferingid": self.nuage_vpc_network_offering.id}]
self.migrate_vpc(vpc, self.nuage_vpc_offering,
network_offering_map)
self.verify_vsd_network(self.domain.id, network, vpc)
@attr(tags=["migrateACS", "vpcstaticnat"],
required_hardware="false")
def test_11_migrate_native_vpc_staticnat_to_nuage_traffic(self):
"""
Verify StaticNat migration of GuestVm in a vpc network
1. create one native vpc network offering
2. create one native vpc tier network offering
3. with Dhcp,SourceNat,StaticNat,Dns,Userdata and NetworkACL
4. create one vpc with above native vpc network offering
5. create one native vpc tier network in above vpc
6. deploy 2 vm's in this tier network
7. In a loop
enable staticnat on first vm and ssh into vm
login to vm1 and ping vm2
verify userdata in Native
move to nuage vpc tier networkoffering,
deploy 2 new vm's in this network
enable staticnat on new vm and ssh into vm
check:
- public ips
- NetworkACL rules
- VR
- VM's ping old and new VM's
- verify userdata in Nuage
- Release public ips
move back to native vpc tier network offering,
"""
cmd = updateZone.updateZoneCmd()
cmd.id = self.zone.id
cmd.domain = "vpc.com"
self.api_client.updateZone(cmd)
self.debug("Creating Native VSP VPC offering with Static NAT service "
"provider as VPCVR...")
native_vpc_off = self.create_VpcOffering(
self.test_data["vpc_offering_reduced"])
self.validate_VpcOffering(native_vpc_off, state="Enabled")
self.debug("Creating a VPC with Static NAT service provider as "
"VpcVirtualRouter")
vpc = self.create_Vpc(native_vpc_off, cidr='10.1.0.0/16')
self.validate_Vpc(vpc, state="Enabled")
self.debug("Creating native VPC Network Tier offering "
"with Static NAT service provider as VPCVR")
native_tiernet_off = self.create_NetworkOffering(
self.test_data["nw_offering_reduced_vpc"])
self.validate_NetworkOffering(native_tiernet_off, state="Enabled")
acl_list = self.create_NetworkAclList(
name="acl", description="acl", vpc=vpc)
acl_item = self.create_NetworkAclRule(
self.test_data["ingress_rule"], acl_list=acl_list)
self.create_NetworkAclRule(
self.test_data["icmprule"], acl_list=acl_list)
self.debug("Creating a VPC tier network with Static NAT service")
vpc_tier = self.create_Network(native_tiernet_off,
gateway='10.1.0.1',
vpc=vpc,
acl_list=acl_list)
self.validate_Network(vpc_tier, state="Implemented")
self.debug("Creating 2nd VPC tier network with Static NAT service")
vpc_2ndtier = self.create_Network(native_tiernet_off,
gateway='10.1.128.1',
vpc=vpc,
acl_list=acl_list)
self.validate_Network(vpc_2ndtier, state="Implemented")
vpc_vr = self.get_Router(vpc_tier)
self.check_Router_state(vpc_vr, state="Running")
self.debug("Deploying a VM in the created VPC tier network")
self.test_data["virtual_machine"]["displayname"] = "vpcvm1"
self.test_data["virtual_machine"]["name"] = "vpcvm1"
vpc_vm_1 = self.create_VM(vpc_tier)
self.check_VM_state(vpc_vm_1, state="Running")
self.debug("Deploying another VM in the created VPC tier network")
self.test_data["virtual_machine"]["displayname"] = "vpcvm2"
self.test_data["virtual_machine"]["name"] = "vpcvm2"
vpc_vm_2 = self.create_VM(vpc_tier)
self.check_VM_state(vpc_vm_2, state="Running")
self.debug("Deploying a VM in the 2nd VPC tier network")
self.test_data["virtual_machine"]["displayname"] = "vpcvm12"
self.test_data["virtual_machine"]["name"] = "vpcvm12"
vpc_vm_12 = self.create_VM(vpc_2ndtier)
self.check_VM_state(vpc_vm_2, state="Running")
self.test_data["virtual_machine"]["displayname"] = None
self.test_data["virtual_machine"]["name"] = None
for i in range(1, 3):
self.debug("+++++Starting again as Native in Loop+++++")
self.debug("Creating Static NAT rule for the deployed VM "
"in the created VPC network...")
public_ip_1 = self.acquire_PublicIPAddress(vpc_tier, vpc=vpc)
self.validate_PublicIPAddress(public_ip_1, vpc_tier)
self.create_StaticNatRule_For_VM(vpc_vm_1, public_ip_1, vpc_tier)
self.validate_PublicIPAddress(
public_ip_1, vpc_tier, static_nat=True, vm=vpc_vm_1)
network_offering_map = \
[{"networkid": vpc_tier.id,
"networkofferingid": self.nuage_vpc_network_offering.id},
{"networkid": vpc_2ndtier.id,
"networkofferingid": self.nuage_vpc_network_offering.id}]
csc_ips = self.define_cloudstack_managementip()
self.cloudstack_connection_vsd(connection="down",
cscip=csc_ips)
self.debug("-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=")
self.debug("Migrate_vpc fails when connection ACS VSD is down")
self.debug("-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=")
self.verify_cloudstack_host_state_up("Alert")
try:
self.migrate_vpc(vpc, self.nuage_vpc_offering,
network_offering_map, resume=False)
except Exception as e:
errortext = \
re.search(".*errortext\s*:\s*u?(['\"])([^\\1]+)\\1.*",
e.message).group(2)
self.debug("Migration fails with %s" % errortext)
expectstr = "Failed to implement network (with specified id) " \
"elements and resources as a part of network update"
self.verifymigrationerrortext(errortext, expectstr)
self.cloudstack_connection_vsd(connection="up",
cscip=csc_ips)
self.debug("-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=")
self.debug("Migrate_vpc resumes when connection ACS VSD is up")
self.debug("-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=")
self.verify_cloudstack_host_state_up("Up")
try:
self.migrate_vpc(vpc, self.nuage_vpc_offering,
network_offering_map, resume=False)
except Exception as e:
errortext = \
re.search(".*errortext\s*:\s*u?(['\"])([^\\1]+)\\1.*",
e.message).group(2)
self.debug("Migration fails with %s" % errortext)
expectstr = "Failed to migrate VPC as previous migration " \
"left this VPC in transient condition. " \
"Specify resume as true."
self.verifymigrationerrortext(errortext, expectstr)
network_offering_map = \
[{"networkid": vpc_tier.id,
"networkofferingid": self.nuage_vpc_network_offering.id},
{"networkid": vpc_2ndtier.id,
"networkofferingid":
self.nuage_isolated_network_offering.id}]
try:
self.migrate_vpc(vpc, self.nuage_vpc_offering,
network_offering_map, resume=True)
except Exception as e:
errortext = \
re.search(".*errortext\s*:\s*u?(['\"])([^\\1]+)\\1.*",
e.message).group(2)
self.debug("Migration fails with %s" % errortext)
expectstr = "can't be used for VPC networks for network"
self.verifymigrationerrortext(errortext, expectstr)
network_offering_map = \
[{"networkid": vpc_tier.id,
"networkofferingid": self.nuage_vpc_network_offering.id},
{"networkid": vpc_2ndtier.id,
"networkofferingid": self.nuage_vpc_network_offering.id}]
self.migrate_vpc(vpc, self.nuage_vpc_offering,
network_offering_map, resume=True)
# checking after successful migrate vpc, migrate still succeeds
self.migrate_vpc(vpc, self.nuage_vpc_offering,
network_offering_map, resume=True)
self.migrate_vpc(vpc, self.nuage_vpc_offering,
network_offering_map, resume=False)
# VSD verification after VPC migration functionality
self.verify_vsd_network(self.domain.id, vpc_tier, vpc)
self.verify_vsd_vm(vpc_vm_1)
self.verify_vsd_vm(vpc_vm_2)
self.verify_vsd_floating_ip(
vpc_tier, vpc_vm_1, public_ip_1.ipaddress, vpc=vpc)
self.verify_vsd_firewall_rule(acl_item)
# self.verify_vsd_firewall_rule(acl_item2)
self.verify_vsd_vm(vpc_vm_12)
self.test_data["virtual_machine"]["displayname"] = "vpcvm3"
self.test_data["virtual_machine"]["name"] = "vpcvm3"
vpc_vm_3 = self.create_VM(vpc_tier)
public_ip_2 = self.acquire_PublicIPAddress(vpc_tier, vpc=vpc)
self.create_StaticNatRule_For_VM(vpc_vm_3,
public_ip_2,
vpc_tier)
self.test_data["virtual_machine"]["displayname"] = "vpcvm4"
self.test_data["virtual_machine"]["name"] = "vpcvm4"
vpc_vm_4 = self.create_VM(vpc_tier)
self.verify_vsd_floating_ip(vpc_tier, vpc_vm_3,
public_ip_2.ipaddress, vpc=vpc)
self.verify_vsd_vm(vpc_vm_3)
self.verify_vsd_vm(vpc_vm_4)
self.test_data["virtual_machine"]["displayname"] = None
self.test_data["virtual_machine"]["name"] = None
vm_public_ip_2 = public_ip_2.ipaddress.ipaddress
try:
vpc_vm_3.ssh_ip = vm_public_ip_2
vpc_vm_3.ssh_port = \
self.test_data["virtual_machine"]["ssh_port"]
vpc_vm_3.username = \
self.test_data["virtual_machine"]["username"]
vpc_vm_3.password = \
self.test_data["virtual_machine"]["password"]
self.debug("SSHing into VM: %s with %s" %
(vpc_vm_3.ssh_ip, vpc_vm_3.password))
ssh2 = vpc_vm_3.get_ssh_client(ipaddress=vm_public_ip_2)
except Exception as e:
self.fail("SSH into VM failed with exception %s" % e)
self.verify_pingtovmipaddress(ssh2, vpc_vm_1.ipaddress)
self.verify_pingtovmhostname(ssh2, "vpcvm1")
self.verify_pingtovmipaddress(ssh2, vpc_vm_4.ipaddress)
self.verify_pingtovmhostname(ssh2, "vpcvm4")
self.verify_pingtovmipaddress(ssh2, vpc_vm_2.ipaddress)
self.verify_pingtovmhostname(ssh2, "vpcvm2")
self.debug("Updating the running vm_3 with new user data...")
expected_user_data2 = self.update_userdata(vpc_vm_3,
"hellonuage vm3")
self.debug("SSHing into the vm_3 for verifying its user data...")
user_data_cmd = self.get_userdata_url(vpc_vm_3)
self.debug("Getting user data with command: " + user_data_cmd)
actual_user_data2 = self.execute_cmd(ssh2, user_data_cmd)
self.debug("Actual user data - " + actual_user_data2 +
", Expected user data - " + expected_user_data2)
self.assertEqual(actual_user_data2, expected_user_data2,
"Un-expected VM (VM_3) user data")
self.verify_pingtovmipaddress(ssh2, vpc_vm_12.ipaddress)
self.verify_pingtovmhostname(ssh2, "vpcvm12")
vpc_vm_3.delete(self.api_client, expunge=True)
vpc_vm_4.delete(self.api_client, expunge=True)
public_ip_2.delete(self.api_client)
# ReleaseIP as get_ssh_client fails when migrating back to native
public_ip_1.delete(self.api_client)
self.debug("++++++++Migrating network back to native+++++++")
network_offering_map = \
[{"networkid": vpc_tier.id,
"networkofferingid": native_tiernet_off.id},
{"networkid": vpc_2ndtier.id,
"networkofferingid": native_tiernet_off.id}]
self.migrate_vpc(vpc, native_vpc_off,
network_offering_map)
@attr(tags=["migrateACS", "vpcmultinic"],
required_hardware="false")
def test_12_migrate_native_vpc_multinic_to_nuage_traffic(self):
"""
Verify MultiNic migration of GuestVm in multiple networks
1. create one native vpc network offering
2. create one native vpc tier network offering
3. with Dhcp,SourceNat,StaticNat,Dns,Userdata and NetworkACL
4. create one vpc with above native vpc network offering
5. create one native vpc tier network in above vpc
6. create 2nd isolated network
7. deploy 2 vm's in both networks
8. move to nuage vpc tier networkoffering,
9. deploy vm3 in vpc tier network
10. enable staticnat on first vm and ssh into vm
11. login to vm3 and ping vm1 nic1
12. move isolated network to nuage networkoffering,
13. deploy vm4 in 2nd vpc tier network
14. enable staticnat on new vm4 and ssh into vm
15. login to vm4 and ping vm2 nic1
"""
cmd = updateZone.updateZoneCmd()
cmd.id = self.zone.id
cmd.domain = "vpc.com"
self.api_client.updateZone(cmd)
self.debug("Creating Native VSP VPC offering with Static NAT service "
"provider as VPCVR...")
native_vpc_off = self.create_VpcOffering(
self.test_data["vpc_offering_reduced"])
self.validate_VpcOffering(native_vpc_off, state="Enabled")
self.debug("Creating a VPC with Static NAT service provider as "
"VpcVirtualRouter")
vpc = self.create_Vpc(native_vpc_off, cidr='10.1.0.0/16')
self.validate_Vpc(vpc, state="Enabled")
self.debug("Creating native VPC Network Tier offering "
"with Static NAT service provider as VPCVR")
native_tiernet_off = self.create_NetworkOffering(
self.test_data["nw_offering_reduced_vpc"])
self.validate_NetworkOffering(native_tiernet_off, state="Enabled")
acl_list = self.create_NetworkAclList(
name="acl", description="acl", vpc=vpc)
acl_item = self.create_NetworkAclRule(
self.test_data["ingress_rule"], acl_list=acl_list)
self.create_NetworkAclRule(
self.test_data["icmprule"], acl_list=acl_list)
self.debug("Creating a VPC tier network with Static NAT service")
vpc_tier = self.create_Network(native_tiernet_off,
gateway='10.1.0.1',
vpc=vpc,
acl_list=acl_list)
self.validate_Network(vpc_tier, state="Implemented")
self.debug("Creating 2nd VPC tier network with Static NAT service")
vpc_2ndtier = self.create_Network(native_tiernet_off,
gateway='10.1.128.1',
vpc=vpc,
acl_list=acl_list)
self.validate_Network(vpc_2ndtier, state="Implemented")
vpc_vr = self.get_Router(vpc_tier)
self.check_Router_state(vpc_vr, state="Running")
isolated_network = self.create_Network(
self.native_isolated_network_staticnat_offering_persistent,
gateway="10.10.0.1",
netmask="255.255.255.0", account=self.account)
self.debug("Creating isolated network with Static NAT service")
self.debug("Deploying a multinic VM in both networks")
self.test_data["virtual_machine"]["displayname"] = "vpcvm1"
self.test_data["virtual_machine"]["name"] = "vpcvm1"
vpc_vm_1 = self.create_VM([vpc_tier, isolated_network])
self.check_VM_state(vpc_vm_1, state="Running")
self.debug("Deploying another VM in both networks other defaultnic")
self.test_data["virtual_machine"]["displayname"] = "vpcvm2"
self.test_data["virtual_machine"]["name"] = "vpcvm2"
vpc_vm_2 = self.create_VM([isolated_network, vpc_tier])
self.check_VM_state(vpc_vm_2, state="Running")
self.test_data["virtual_machine"]["displayname"] = None
self.test_data["virtual_machine"]["name"] = None
network_offering_map_fault = \
[{"networkid": vpc_tier.id,
"networkofferingid": self.nuage_vpc_network_offering.id}]
try:
self.migrate_vpc(vpc, self.nuage_vpc_offering,
network_offering_map_fault, resume=False)
except Exception as e:
errortext = re.search(".*errortext\s*:\s*u?'([^']+)'.*",
e.message).group(1)
self.debug("Migration fails with %s" % errortext)
expectstr = "Failed to migrate VPC as the specified " \
"tierNetworkOfferings is not complete"
self.verifymigrationerrortext(errortext, expectstr)
try:
self.migrate_network(self.nuage_isolated_network_offering,
vpc_tier, resume=False)
except Exception as e:
errortext = re.search(".*errortext\s*:\s*u?'([^']+)'.*",
e.message).group(1)
self.debug("Migration fails with %s" % errortext)
expectstr = "Failed to migrate network as the specified " \
"network is a vpc tier. Use migrateVpc."
self.verifymigrationerrortext(errortext, expectstr)
network_offering_map_fault2 = \
[{"networkid": vpc_tier.id,
"networkofferingid": self.nuage_vpc_network_offering.id},
{"networkid": vpc_2ndtier.id,
"networkofferingid": self.nuage_isolated_network_offering.id}]
try:
self.migrate_vpc(vpc, self.nuage_vpc_offering,
network_offering_map_fault2, resume=True)
except Exception as e:
errortext = \
re.search(".*errortext\s*:\s*u?(['\"])([^\\1]+)\\1.*",
e.message).group(2)
self.debug("Migration fails with %s" % errortext)
expectstr = "can't be used for VPC networks for network"
self.verifymigrationerrortext(errortext, expectstr)
network_offering_map = \
[{"networkid": vpc_tier.id,
"networkofferingid": self.nuage_vpc_network_offering.id},
{"networkid": vpc_2ndtier.id,
"networkofferingid": self.nuage_vpc_network_offering.id}]
self.migrate_vpc(vpc, self.nuage_vpc_offering,
network_offering_map, resume=True)
self.debug("Deploying another VM in the created VPC tier network")
self.test_data["virtual_machine"]["displayname"] = "vpcvm3"
self.test_data["virtual_machine"]["name"] = "vpcvm3"
vpc_vm_3 = self.create_VM(vpc_tier)
self.check_VM_state(vpc_vm_3, state="Running")
self.test_data["virtual_machine"]["displayname"] = None
self.test_data["virtual_machine"]["name"] = None
self.debug("Creating Static NAT rule for the deployed VM "
"in the created VPC network...")
public_ip_1 = self.acquire_PublicIPAddress(vpc_tier, vpc=vpc)
self.validate_PublicIPAddress(public_ip_1, vpc_tier)
self.create_StaticNatRule_For_VM(vpc_vm_3, public_ip_1, vpc_tier)
self.validate_PublicIPAddress(
public_ip_1, vpc_tier, static_nat=True, vm=vpc_vm_3)
# VSD verification after VPC migration functionality
self.verify_vsd_network(self.domain.id, vpc_tier, vpc)
self.verify_vsd_vm(vpc_vm_3)
self.verify_vsd_floating_ip(
vpc_tier, vpc_vm_3, public_ip_1.ipaddress, vpc=vpc)
self.verify_vsd_firewall_rule(acl_item)
# self.verify_vsd_vm(vpc_vm_1)
vm_public_ip_1 = public_ip_1.ipaddress.ipaddress
try:
vpc_vm_3.ssh_ip = vm_public_ip_1
vpc_vm_3.ssh_port = \
self.test_data["virtual_machine"]["ssh_port"]
vpc_vm_3.username = \
self.test_data["virtual_machine"]["username"]
vpc_vm_3.password = \
self.test_data["virtual_machine"]["password"]
self.debug("SSHing into VM: %s with %s" %
(vpc_vm_3.ssh_ip, vpc_vm_1.password))
ssh = vpc_vm_3.get_ssh_client(ipaddress=vm_public_ip_1)
except Exception as e:
self.fail("SSH into VM failed with exception %s" % e)
defaultipaddress = \
[nic.ipaddress for nic in vpc_vm_1.nic if nic.isdefault][0]
self.verify_pingtovmipaddress(ssh, defaultipaddress)
vpc_vm_3.delete(self.api_client, expunge=True)
public_ip_1.delete(self.api_client)
self.migrate_network(
self.nuage_isolated_network_offering_without_vr,
isolated_network)
self.test_data["virtual_machine"]["displayname"] = "vm4"
self.test_data["virtual_machine"]["name"] = "vm4"
vm_4 = self.create_VM(isolated_network)
self.test_data["virtual_machine"]["displayname"] = None
self.test_data["virtual_machine"]["name"] = None
self.debug("Creating Static NAT rule for the deployed VM "
"in the created VPC network...")
public_ip_2 = self.acquire_PublicIPAddress(isolated_network)
self.validate_PublicIPAddress(public_ip_1, isolated_network)
self.create_StaticNatRule_For_VM(vm_4, public_ip_2, isolated_network)
self.validate_PublicIPAddress(
public_ip_2, isolated_network, static_nat=True, vm=vm_4)
firewall_rule_2 = self.create_FirewallRule(public_ip_2)
self.verify_vsd_network(self.domain.id, isolated_network)
self.verify_vsd_floating_ip(isolated_network, vm_4,
public_ip_2.ipaddress)
self.verify_vsd_vm(vm_4)
self.verify_vsd_firewall_rule(firewall_rule_2)
# self.verify_vsd_vm(vpc_vm_2)
vm_public_ip_2 = public_ip_2.ipaddress.ipaddress
try:
vm_4.ssh_ip = vm_public_ip_2
vm_4.ssh_port = self.test_data["virtual_machine"]["ssh_port"]
vm_4.username = self.test_data["virtual_machine"]["username"]
vm_4.password = self.test_data["virtual_machine"]["password"]
self.debug("SSHing into VM: %s with %s" %
(vm_4.ssh_ip, vm_4.password))
ssh2 = vm_4.get_ssh_client(ipaddress=vm_public_ip_2)
except Exception as e:
self.fail("SSH into VM failed with exception %s" % e)
defaultipaddress2 = \
[nic.ipaddress for nic in vpc_vm_2.nic if nic.isdefault][0]
self.verify_pingtovmipaddress(ssh2, defaultipaddress2)
@attr(tags=["migrateACS", "guestvmip2"],
required_hardware="false")
def test_13_verify_guestvmip2_when_migrating_to_nuage(self):
"""
Verify migration of GuestVm with ip .2 still works
when migrating isolated or vpc tier networks
"""
isolated_network = self.create_Network(
self.native_isolated_network_offering,
gateway="10.13.0.1",
netmask="255.255.255.248", account=self.account)
self.test_data["virtual_machine"]["ipaddress"] = "10.13.0.2"
vm_11 = self.create_VM(isolated_network)
self.test_data["virtual_machine"]["ipaddress"] = "10.13.0.3"
vm_12 = self.create_VM(isolated_network)
self.test_data["virtual_machine"]["ipaddress"] = "10.13.0.4"
vm_13 = self.create_VM(isolated_network)
self.test_data["virtual_machine"]["ipaddress"] = "10.13.0.5"
vm_14 = self.create_VM(isolated_network)
self.test_data["virtual_machine"]["ipaddress"] = None
vm_15 = self.create_VM(isolated_network)
try:
self.migrate_network(
self.nuage_isolated_network_offering_persistent,
isolated_network, resume=False)
except Exception as e:
errortext = re.search(".*errortext\s*:\s*u?'([^']+)'.*",
e.message).group(1)
self.debug("Migration fails with %s" % errortext)
expectstr = "Failed to implement network (with specified id) " \
"elements and resources as a part of network update"
self.verifymigrationerrortext(errortext, expectstr)
try:
self.migrate_network(
self.nuage_isolated_network_offering_without_vr,
isolated_network, resume=False)
except Exception as e:
errortext = \
re.search(".*errortext\s*:\s*u?(['\"])([^\\1]+)\\1.*",
e.message).group(2)
self.debug("Migration fails with %s" % errortext)
expectstr = "Failed to migrate network as previous migration " \
"left this network in transient condition. " \
"Specify resume as true."
self.verifymigrationerrortext(errortext, expectstr)
try:
self.migrate_network(
self.nuage_isolated_network_offering_without_vr,
isolated_network, resume=True)
except Exception as e:
errortext = \
re.search(".*errortext\s*:\s*u?(['\"])([^\\1]+)\\1.*",
e.message).group(2)
self.debug("Migration fails with %s" % errortext)
expectstr = "Failed to resume migrating network as network offering " \
"does not match previously specified network offering"
self.verifymigrationerrortext(errortext, expectstr)
vm_13.delete(self.api_client, expunge=True)
try:
self.migrate_network(
self.nuage_isolated_network_offering_without_vr,
isolated_network, resume=True)
except Exception as e:
errortext = \
re.search(".*errortext\s*:\s*u?(['\"])([^\\1]+)\\1.*",
e.message).group(2)
self.debug("Migration fails with %s" % errortext)
expectstr = "Failed to resume migrating network as network offering " \
"does not match previously specified network offering"
self.verifymigrationerrortext(errortext, expectstr)
try:
self.migrate_network(
self.nuage_isolated_network_offering_persistent,
isolated_network, resume=False)
except Exception as e:
errortext = \
re.search(".*errortext\s*:\s*u?(['\"])([^\\1]+)\\1.*",
e.message).group(2)
self.debug("Migration fails with %s" % errortext)
expectstr = "Failed to migrate network as previous migration " \
"left this network in transient condition. " \
"Specify resume as true."
self.verifymigrationerrortext(errortext, expectstr)
self.migrate_network(
self.nuage_isolated_network_offering_persistent,
isolated_network, resume=True)
self.verify_vsd_network(self.domain.id, isolated_network, None)
self.verify_vsd_vm(vm_11)
self.verify_vsd_vm(vm_12)
self.verify_vsd_vm(vm_14)
self.verify_vsd_vm(vm_15)
cmd = updateZone.updateZoneCmd()
cmd.id = self.zone.id
cmd.domain = "vpc.com"
self.api_client.updateZone(cmd)
self.debug("Creating Native VSP VPC offering with Static NAT service "
"provider as VPCVR...")
native_vpc_off = self.create_VpcOffering(
self.test_data["vpc_offering_reduced"])
self.validate_VpcOffering(native_vpc_off, state="Enabled")
self.debug("Creating a VPC with Static NAT service provider as "
"VpcVirtualRouter")
vpc = self.create_Vpc(native_vpc_off, cidr='10.1.0.0/16')
self.validate_Vpc(vpc, state="Enabled")
self.debug("Creating native VPC Network Tier offering "
"with Static NAT service provider as VPCVR")
native_tiernet_off = self.create_NetworkOffering(
self.test_data["nw_offering_reduced_vpc"])
self.validate_NetworkOffering(native_tiernet_off, state="Enabled")
acl_list = self.create_NetworkAclList(
name="acl", description="acl", vpc=vpc)
self.create_NetworkAclRule(
self.test_data["ingress_rule"], acl_list=acl_list)
self.create_NetworkAclRule(
self.test_data["icmprule"], acl_list=acl_list)
self.debug("Creating a VPC tier network with Static NAT service")
vpc_tier = self.create_Network(native_tiernet_off,
gateway='10.1.1.1',
vpc=vpc,
acl_list=acl_list)
self.validate_Network(vpc_tier, state="Implemented")
vpc_vr = self.get_Router(vpc_tier)
self.check_Router_state(vpc_vr, state="Running")
self.debug("Deploying a VM in a vpc tier network")
self.test_data["virtual_machine"]["displayname"] = "vpcvm1"
self.test_data["virtual_machine"]["name"] = "vpcvm1"
self.test_data["virtual_machine"]["ipaddress"] = "10.1.1.2"
vpc_vm_1 = self.create_VM(vpc_tier)
self.test_data["virtual_machine"]["ipaddress"] = None
self.check_VM_state(vpc_vm_1, state="Running")
self.debug("Deploying another VM in vpc tier")
self.test_data["virtual_machine"]["displayname"] = "vpcvm2"
self.test_data["virtual_machine"]["name"] = "vpcvm2"
vpc_vm_2 = self.create_VM(vpc_tier)
self.check_VM_state(vpc_vm_2, state="Running")
network_offering_map = \
[{"networkid": vpc_tier.id,
"networkofferingid": self.nuage_vpc_network_offering.id}]
self.migrate_vpc(vpc, self.nuage_vpc_offering,
network_offering_map, resume=False)
self.verify_vsd_network(self.domain.id, vpc_tier, vpc)
self.verify_vsd_vm(vpc_vm_1)
self.verify_vsd_vm(vpc_vm_2)
@attr(tags=["migrateACS", "nativeisoonly"],
required_hardware="false")
def test_14_native_to_native_network_migration(self):
"""
Verify Migration for an isolated network nativeOnly
1. create native non-persistent isolated network
2. migrate to native persistent isolated network, check VR state
3. migrate back to native non-persistent network
4. deploy VM in non-persistent isolated network
5. acquire ip and enable staticnat
6. migrate to native persistent isolated network
7. migrate back to native non-persistent network
"""
isolated_network = self.create_Network(
self.native_isolated_network_offering, gateway="10.0.0.1",
netmask="255.255.255.0")
self.migrate_network(
self.native_isolated_network_offering_persistent,
isolated_network, resume=False)
vr = self.get_Router(isolated_network)
self.check_Router_state(vr, "Running")
self.migrate_network(
self.native_isolated_network_offering,
isolated_network, resume=False)
vm_1 = self.create_VM(isolated_network)
vr = self.get_Router(isolated_network)
self.check_Router_state(vr, "Running")
public_ip = self.acquire_PublicIPAddress(isolated_network)
self.create_StaticNatRule_For_VM(vm_1, public_ip, isolated_network)
self.create_FirewallRule(public_ip)
self.migrate_network(
self.native_isolated_network_offering_persistent,
isolated_network, resume=False)
self.migrate_network(
self.native_isolated_network_offering,
isolated_network, resume=False)
@attr(tags=["migrateACS", "nativevpconly"],
required_hardware="false")
def test_15_native_to_native_vpc_migration(self):
"""
Verify Migration for a vpc network nativeOnly
1. create native vpc with 2 tier networks
2. migrate to native vpc, check VR state
3. deploy VM in vpc tier network
4. acquire ip and enable staticnat
5. migrate to native vpc network
"""
cmd = updateZone.updateZoneCmd()
cmd.id = self.zone.id
cmd.domain = "vpc.com"
self.api_client.updateZone(cmd)
self.debug("Creating Native VSP VPC offering with Static NAT service "
"provider as VPCVR...")
native_vpc_off = self.create_VpcOffering(
self.test_data["vpc_offering_reduced"])
self.validate_VpcOffering(native_vpc_off, state="Enabled")
self.debug("Creating a VPC with Static NAT service provider as "
"VpcVirtualRouter")
vpc = self.create_Vpc(native_vpc_off, cidr='10.1.0.0/16')
self.validate_Vpc(vpc, state="Enabled")
self.debug("Creating native VPC Network Tier offering "
"with Static NAT service provider as VPCVR")
native_tiernet_off = self.create_NetworkOffering(
self.test_data["nw_offering_reduced_vpc"])
self.validate_NetworkOffering(native_tiernet_off, state="Enabled")
acl_list = self.create_NetworkAclList(
name="acl", description="acl", vpc=vpc)
self.create_NetworkAclRule(
self.test_data["ingress_rule"], acl_list=acl_list)
self.create_NetworkAclRule(
self.test_data["icmprule"], acl_list=acl_list)
self.debug("Creating a VPC tier network with Static NAT service")
vpc_tier = self.create_Network(native_tiernet_off,
gateway='10.1.0.1',
vpc=vpc,
acl_list=acl_list)
self.validate_Network(vpc_tier, state="Implemented")
self.debug("Creating 2nd VPC tier network with Static NAT service")
vpc_2ndtier = self.create_Network(native_tiernet_off,
gateway='10.1.128.1',
vpc=vpc,
acl_list=acl_list)
self.validate_Network(vpc_2ndtier, state="Implemented")
vpc_vr = self.get_Router(vpc_tier)
self.check_Router_state(vpc_vr, state="Running")
network_offering_map = \
[{"networkid": vpc_tier.id,
"networkofferingid": self.native_vpc_network_offering.id},
{"networkid": vpc_2ndtier.id,
"networkofferingid": self.native_vpc_network_offering.id}]
self.migrate_vpc(vpc, self.native_vpc_offering,
network_offering_map, resume=False)
self.debug("Deploying a VM in the created VPC tier network")
self.test_data["virtual_machine"]["displayname"] = "vpcvm1"
self.test_data["virtual_machine"]["name"] = "vpcvm1"
vpc_vm_1 = self.create_VM(vpc_tier)
self.check_VM_state(vpc_vm_1, state="Running")
self.debug("Deploying another VM in the created VPC tier network")
self.test_data["virtual_machine"]["displayname"] = "vpcvm2"
self.test_data["virtual_machine"]["name"] = "vpcvm2"
vpc_vm_2 = self.create_VM(vpc_tier)
self.check_VM_state(vpc_vm_2, state="Running")
self.debug("Deploying a VM in the 2nd VPC tier network")
self.test_data["virtual_machine"]["displayname"] = "vpcvm12"
self.test_data["virtual_machine"]["name"] = "vpcvm12"
self.create_VM(vpc_2ndtier)
self.check_VM_state(vpc_vm_2, state="Running")
self.test_data["virtual_machine"]["displayname"] = None
self.test_data["virtual_machine"]["name"] = None
self.debug("Creating Static NAT rule for the deployed VM "
"in the created VPC network...")
public_ip_1 = self.acquire_PublicIPAddress(vpc_tier, vpc=vpc)
self.validate_PublicIPAddress(public_ip_1, vpc_tier)
self.create_StaticNatRule_For_VM(vpc_vm_1, public_ip_1, vpc_tier)
self.validate_PublicIPAddress(
public_ip_1, vpc_tier, static_nat=True, vm=vpc_vm_1)
network_offering_map = \
[{"networkid": vpc_tier.id,
"networkofferingid": self.native_vpc_network_offering.id},
{"networkid": vpc_2ndtier.id,
"networkofferingid": self.native_vpc_network_offering.id}]
self.migrate_vpc(vpc, self.native_vpc_offering,
network_offering_map, resume=False)
Reference in New Issue View Git Blame Copy Permalink