From 588c039b95377a44cf3cd89a478085a55fb1252a Mon Sep 17 00:00:00 2001 From: Rishi Verma Date: Fri, 25 Jul 2014 19:02:15 +0530 Subject: [PATCH 01/15] test server manager --- scripts/smgr/__init__.py | 1 + scripts/smgr/config.py | 33 ++ scripts/smgr/regression.py | 282 ++++++++++++++++ scripts/smgr/sanity.py | 15 + scripts/smgr/sanity_base.py | 125 ++++++++ scripts/smgr/setup.py | 179 +++++++++++ scripts/smgr/smgr_regression.py | 60 ++++ scripts/smgr/smgr_sanity.py | 282 ++++++++++++++++ scripts/smgr/smgr_setup.py | 70 ++++ scripts/smgr/smgr_tests.py | 55 ++++ scripts/smgr/tests_with_setup_base_webui.py | 236 ++++++++++++++ scripts/smgr/upgrade_test.py | 55 ++++ scripts/smgr/verify.py | 338 ++++++++++++++++++++ scripts/smgr/webui_sanity_resource.py | 70 ++++ scripts/smgr/webui_topology.py | 94 ++++++ 15 files changed, 1895 insertions(+) create mode 100644 scripts/smgr/__init__.py create mode 100644 scripts/smgr/config.py create mode 100644 scripts/smgr/regression.py create mode 100644 scripts/smgr/sanity.py create mode 100644 scripts/smgr/sanity_base.py create mode 100644 scripts/smgr/setup.py create mode 100644 scripts/smgr/smgr_regression.py create mode 100644 scripts/smgr/smgr_sanity.py create mode 100644 scripts/smgr/smgr_setup.py create mode 100644 scripts/smgr/smgr_tests.py create mode 100644 scripts/smgr/tests_with_setup_base_webui.py create mode 100755 scripts/smgr/upgrade_test.py create mode 100644 scripts/smgr/verify.py create mode 100644 scripts/smgr/webui_sanity_resource.py create mode 100644 scripts/smgr/webui_topology.py diff --git a/scripts/smgr/__init__.py b/scripts/smgr/__init__.py new file mode 100644 index 000000000..a82e9e238 --- /dev/null +++ b/scripts/smgr/__init__.py @@ -0,0 +1 @@ +"""Security group tests.""" diff --git a/scripts/smgr/config.py b/scripts/smgr/config.py new file mode 100644 index 000000000..149ce579f --- /dev/null +++ b/scripts/smgr/config.py @@ -0,0 +1,33 @@ +import time + +import paramiko +import fixtures +from fabric.api import run, hide, settings + +from vn_test import VNFixture +from vm_test import VMFixture +from policy_test import PolicyFixture +from policy.config import ConfigPolicy +from connections import ContrailConnections +from security_group import SecurityGroupFixture + + +class ConfigSecGroup(ConfigPolicy): + + def config_sec_group(self, name, secgrpid=None, entries=None): + secgrp_fixture = self.useFixture(SecurityGroupFixture(self.inputs, + self.connections, self.inputs.domain_name, self.inputs.project_name, + secgrp_name=name, secgrp_id=secgrpid, secgrp_entries=entries)) + result, msg = secgrp_fixture.verify_on_setup() + assert result, msg + return secgrp_fixture + + def delete_sec_group(self, secgrp_fix): + secgrp_fix.cleanUp() + self.remove_from_cleanups(secgrp_fix) + + def remove_from_cleanups(self, fix): + for cleanup in self._cleanups: + if fix.cleanUp in cleanup: + self._cleanups.remove(cleanup) + break diff --git a/scripts/smgr/regression.py b/scripts/smgr/regression.py new file mode 100644 index 000000000..7ecb1f038 --- /dev/null +++ b/scripts/smgr/regression.py @@ -0,0 +1,282 @@ +import os +import fixtures +import testtools +import unittest + +from testresources import ResourcedTestCase + +from connections import ContrailConnections +from securitygroup.config import ConfigSecGroup +from tcutils.wrappers import preposttest_wrapper +from securitygroup.setup import SecurityGroupSetupResource +from verify import VerifySecGroup + + +class SecurityGroupRegressionTests(testtools.TestCase, ResourcedTestCase, + fixtures.TestWithFixtures, + ConfigSecGroup, VerifySecGroup): + + resources = [('base_setup', SecurityGroupSetupResource)] + + def __init__(self, *args, **kwargs): + testtools.TestCase.__init__(self, *args, **kwargs) + self.res = SecurityGroupSetupResource.getResource() + self.inputs = self.res.inputs + self.connections = self.res.connections + self.logger = self.inputs.logger + self.nova_fixture = self.res.nova_fixture + self.analytics_obj = self.connections.analytics_obj + self.vnc_lib = self.connections.vnc_lib + self.quantum_fixture = self.connections.quantum_fixture + + def __del__(self): + self.logger.debug("Unconfig the common resurces.") + SecurityGroupSetupResource.finishedWith(self.res) + + def setUp(self): + super(SecurityGroupRegressionTests, self).setUp() + if 'PARAMS_FILE' in os.environ: + self.ini_file = os.environ.get('PARAMS_FILE') + else: + self.ini_file = 'params.ini' + + def tearDown(self): + self.logger.debug("Tearing down SecurityGroupRegressionTests.") + super(SecurityGroupRegressionTests, self).tearDown() + SecurityGroupSetupResource.finishedWith(self.res) + + def runTest(self): + pass + + def config_policy_and_attach_to_vn(self, rules): + policy_name = "sec_grp_policy" + policy_fix = self.config_policy(policy_name, rules) + assert policy_fix.verify_on_setup() + policy_vn1_attach_fix = self.attach_policy_to_vn( + policy_fix, self.res.vn1_fix) + policy_vn2_attach_fix = self.attach_policy_to_vn( + policy_fix, self.res.vn2_fix) + + @preposttest_wrapper + def test_sec_group_with_proto(self): + """Verify security group with allow specific protocol on all ports and policy with allow all between VN's""" + self.logger.info("Configure the policy with allow any") + rules = [ + { + 'direction': '<>', + 'protocol': 'any', + 'source_network': self.res.vn1_name, + 'src_ports': [0, -1], + 'dest_network': self.res.vn2_name, + 'dst_ports': [0, -1], + 'simple_action': 'pass', + }, + ] + self.config_policy_and_attach_to_vn(rules) + rule = [{'direction': '<>', + 'protocol': 'tcp', + 'dst_addresses': [{'subnet': {'ip_prefix': '10.1.1.0', 'ip_prefix_len': 24}}, + {'subnet': {'ip_prefix': '20.1.1.0', 'ip_prefix_len': 24}}], + 'dst_ports': [{'start_port': 0, 'end_port': -1}], + 'src_ports': [{'start_port': 0, 'end_port': -1}], + 'src_addresses': [{'security_group': 'local'}], + }, + {'direction': '<>', + 'protocol': 'tcp', + 'src_addresses': [{'subnet': {'ip_prefix': '10.1.1.0', 'ip_prefix_len': 24}}, + {'subnet': {'ip_prefix': '20.1.1.0', 'ip_prefix_len': 24}}], + 'src_ports': [{'start_port': 0, 'end_port': -1}], + 'dst_ports': [{'start_port': 0, 'end_port': -1}], + 'dst_addresses': [{'security_group': 'local'}], + }] + self.res.sg1_fix.replace_rules(rule) + + rule = [{'direction': '<>', + 'protocol': 'udp', + 'dst_addresses': [{'subnet': {'ip_prefix': '10.1.1.0', 'ip_prefix_len': 24}}, + {'subnet': {'ip_prefix': '20.1.1.0', 'ip_prefix_len': 24}}], + 'dst_ports': [{'start_port': 0, 'end_port': -1}], + 'src_ports': [{'start_port': 0, 'end_port': -1}], + 'src_addresses': [{'security_group': 'local'}], + }, + {'direction': '<>', + 'protocol': 'udp', + 'src_addresses': [{'subnet': {'ip_prefix': '10.1.1.0', 'ip_prefix_len': 24}}, + {'subnet': {'ip_prefix': '20.1.1.0', 'ip_prefix_len': 24}}], + 'src_ports': [{'start_port': 0, 'end_port': -1}], + 'dst_ports': [{'start_port': 0, 'end_port': -1}], + 'dst_addresses': [{'security_group': 'local'}], + }] + self.res.sg2_fix.replace_rules(rule) + + self.verify_sec_group_port_proto() + return True + + @preposttest_wrapper + def test_sec_group_with_port(self): + """Verify security group with allow specific protocol/port and policy with allow all between VN's""" + self.logger.info("Configure the policy with allow any") + rules = [ + { + 'direction': '<>', + 'protocol': 'any', + 'source_network': self.res.vn1_name, + 'src_ports': [0, -1], + 'dest_network': self.res.vn2_name, + 'dst_ports': [0, -1], + 'simple_action': 'pass', + }, + ] + self.config_policy_and_attach_to_vn(rules) + + rule = [{'direction': '<>', + 'protocol': 'tcp', + 'dst_addresses': [{'subnet': {'ip_prefix': '10.1.1.0', 'ip_prefix_len': 24}}, + {'subnet': {'ip_prefix': '20.1.1.0', 'ip_prefix_len': 24}}], + 'dst_ports': [{'start_port': 8000, 'end_port': 9000}], + 'src_ports': [{'start_port': 8000, 'end_port': 9000}], + 'src_addresses': [{'security_group': 'local'}], + }, + {'direction': '<>', + 'protocol': 'tcp', + 'src_addresses': [{'subnet': {'ip_prefix': '10.1.1.0', 'ip_prefix_len': 24}}, + {'subnet': {'ip_prefix': '20.1.1.0', 'ip_prefix_len': 24}}], + 'src_ports': [{'start_port': 8000, 'end_port': 9000}], + 'dst_ports': [{'start_port': 8000, 'end_port': 9000}], + 'dst_addresses': [{'security_group': 'local'}], + }] + self.res.sg1_fix.replace_rules(rule) + + rule = [{'direction': '<>', + 'protocol': 'udp', + 'dst_addresses': [{'subnet': {'ip_prefix': '10.1.1.0', 'ip_prefix_len': 24}}, + {'subnet': {'ip_prefix': '20.1.1.0', 'ip_prefix_len': 24}}], + 'dst_ports': [{'start_port': 8000, 'end_port': 9000}], + 'src_ports': [{'start_port': 8000, 'end_port': 9000}], + 'src_addresses': [{'security_group': 'local'}], + }, + {'direction': '<>', + 'protocol': 'udp', + 'src_addresses': [{'subnet': {'ip_prefix': '10.1.1.0', 'ip_prefix_len': 24}}, + {'subnet': {'ip_prefix': '20.1.1.0', 'ip_prefix_len': 24}}], + 'src_ports': [{'start_port': 8000, 'end_port': 9000}], + 'dst_ports': [{'start_port': 8000, 'end_port': 9000}], + 'dst_addresses': [{'security_group': 'local'}], + }] + self.res.sg2_fix.replace_rules(rule) + + self.verify_sec_group_port_proto(port_test=True) + return True + + @preposttest_wrapper + def test_sec_group_with_proto_and_policy_to_allow_only_tcp(self): + """Verify security group with allow specific protocol on all ports and policy with allow only TCP between VN's""" + self.logger.info("Configure the policy with allow TCP only rule.") + rules = [ + { + 'direction': '<>', + 'protocol': 'tcp', + 'source_network': self.res.vn1_name, + 'src_ports': [0, -1], + 'dest_network': self.res.vn2_name, + 'dst_ports': [0, -1], + 'simple_action': 'pass', + }, + ] + self.config_policy_and_attach_to_vn(rules) + + rule = [{'direction': '<>', + 'protocol': 'tcp', + 'dst_addresses': [{'subnet': {'ip_prefix': '10.1.1.0', 'ip_prefix_len': 24}}, + {'subnet': {'ip_prefix': '20.1.1.0', 'ip_prefix_len': 24}}], + 'dst_ports': [{'start_port': 0, 'end_port': -1}], + 'src_ports': [{'start_port': 0, 'end_port': -1}], + 'src_addresses': [{'security_group': 'local'}], + }, + {'direction': '<>', + 'protocol': 'tcp', + 'src_addresses': [{'subnet': {'ip_prefix': '10.1.1.0', 'ip_prefix_len': 24}}, + {'subnet': {'ip_prefix': '20.1.1.0', 'ip_prefix_len': 24}}], + 'src_ports': [{'start_port': 0, 'end_port': -1}], + 'dst_ports': [{'start_port': 0, 'end_port': -1}], + 'dst_addresses': [{'security_group': 'local'}], + }] + self.res.sg1_fix.replace_rules(rule) + + rule = [{'direction': '<>', + 'protocol': 'udp', + 'dst_addresses': [{'subnet': {'ip_prefix': '10.1.1.0', 'ip_prefix_len': 24}}, + {'subnet': {'ip_prefix': '20.1.1.0', 'ip_prefix_len': 24}}], + 'dst_ports': [{'start_port': 0, 'end_port': -1}], + 'src_ports': [{'start_port': 0, 'end_port': -1}], + 'src_addresses': [{'security_group': 'local'}], + }, + {'direction': '<>', + 'protocol': 'udp', + 'src_addresses': [{'subnet': {'ip_prefix': '10.1.1.0', 'ip_prefix_len': 24}}, + {'subnet': {'ip_prefix': '20.1.1.0', 'ip_prefix_len': 24}}], + 'src_ports': [{'start_port': 0, 'end_port': -1}], + 'dst_ports': [{'start_port': 0, 'end_port': -1}], + 'dst_addresses': [{'security_group': 'local'}], + }] + self.res.sg2_fix.replace_rules(rule) + + self.verify_sec_group_with_udp_and_policy_with_tcp() + return True + + @preposttest_wrapper + def test_sec_group_with_proto_and_policy_to_allow_only_tcp_ports(self): + """Verify security group with allow specific protocol on all ports and policy with allow only TCP on specifif ports between VN's""" + self.logger.info( + "Configure the policy with allow TCP port 8000/9000 only rule.") + rules = [ + { + 'direction': '<>', + 'protocol': 'tcp', + 'source_network': self.res.vn1_name, + 'src_ports': [8000, 8000], + 'dest_network': self.res.vn2_name, + 'dst_ports': [9000, 9000], + 'simple_action': 'pass', + }, + ] + self.config_policy_and_attach_to_vn(rules) + + rule = [{'direction': '<>', + 'protocol': 'tcp', + 'dst_addresses': [{'subnet': {'ip_prefix': '10.1.1.0', 'ip_prefix_len': 24}}, + {'subnet': {'ip_prefix': '20.1.1.0', 'ip_prefix_len': 24}}], + 'dst_ports': [{'start_port': 0, 'end_port': -1}], + 'src_ports': [{'start_port': 0, 'end_port': -1}], + 'src_addresses': [{'security_group': 'local'}], + }, + {'direction': '<>', + 'protocol': 'tcp', + 'src_addresses': [{'subnet': {'ip_prefix': '10.1.1.0', 'ip_prefix_len': 24}}, + {'subnet': {'ip_prefix': '20.1.1.0', 'ip_prefix_len': 24}}], + 'src_ports': [{'start_port': 0, 'end_port': -1}], + 'dst_ports': [{'start_port': 0, 'end_port': -1}], + 'dst_addresses': [{'security_group': 'local'}], + }] + self.res.sg1_fix.replace_rules(rule) + + rule = [{'direction': '<>', + 'protocol': 'udp', + 'dst_addresses': [{'subnet': {'ip_prefix': '10.1.1.0', 'ip_prefix_len': 24}}, + {'subnet': {'ip_prefix': '20.1.1.0', 'ip_prefix_len': 24}}], + 'dst_ports': [{'start_port': 0, 'end_port': -1}], + 'src_ports': [{'start_port': 0, 'end_port': -1}], + 'src_addresses': [{'security_group': 'local'}], + }, + {'direction': '<>', + 'protocol': 'udp', + 'src_addresses': [{'subnet': {'ip_prefix': '10.1.1.0', 'ip_prefix_len': 24}}, + {'subnet': {'ip_prefix': '20.1.1.0', 'ip_prefix_len': 24}}], + 'src_ports': [{'start_port': 0, 'end_port': -1}], + 'dst_ports': [{'start_port': 0, 'end_port': -1}], + 'dst_addresses': [{'security_group': 'local'}], + }] + self.res.sg2_fix.replace_rules(rule) + + self.verify_sec_group_with_udp_and_policy_with_tcp_port() + return True diff --git a/scripts/smgr/sanity.py b/scripts/smgr/sanity.py new file mode 100644 index 000000000..5f057287b --- /dev/null +++ b/scripts/smgr/sanity.py @@ -0,0 +1,15 @@ +from securitygroup.sanity_base import SecurityGroupSanityTestsBase + + +class SecurityGroupSanityTests(SecurityGroupSanityTestsBase): + + def setUp(self): + super(SecurityGroupSanityTests, self).setUp() + + def cleanUp(self): + super(SecurityGroupSanityTests, self).cleanUp() + + # Any new testcases outside of SecurityGroupSanityTestsBase tests go here + +if __name__ == '__main__': + unittest.main() diff --git a/scripts/smgr/sanity_base.py b/scripts/smgr/sanity_base.py new file mode 100644 index 000000000..88b578f1b --- /dev/null +++ b/scripts/smgr/sanity_base.py @@ -0,0 +1,125 @@ +import os +import unittest +import testtools + +from vnc_api.vnc_api import NoIdError + +from connections import ContrailConnections +from contrail_test_init import ContrailTestInit +from tcutils.wrappers import preposttest_wrapper + +from vn_test import VNFixture +from vm_test import VMFixture +from securitygroup.config import ConfigSecGroup + + +class SecurityGroupSanityTestsBase(testtools.TestCase, ConfigSecGroup): + + def setUp(self): + super(SecurityGroupSanityTestsBase, self).setUp() + if 'PARAMS_FILE' in os.environ: + self.ini_file = os.environ.get('PARAMS_FILE') + else: + self.ini_file = 'params.ini' + self.inputs = self.useFixture(ContrailTestInit(self.ini_file)) + self.connections = ContrailConnections(self.inputs) + self.quantum_fixture = self.connections.quantum_fixture + self.nova_fixture = self.connections.nova_fixture + self.vnc_lib = self.connections.vnc_lib + self.logger = self.inputs.logger + self.analytics_obj = self.connections.analytics_obj + + def cleanUp(self): + self.logger.info("Cleaning up Security group tests.") + super(SecurityGroupSanityTestsBase, self).cleanUp() + + @preposttest_wrapper + def test_sec_group_add_delete(self): + """Verify security group add delete + 1. Create custom security group with rule in it + 2. Delete custom security group + Pass criteria: Step 1 and 2 should pass + """ + rule = [{'direction': '>', + 'protocol': 'tcp', + 'dst_addresses': [{'subnet': {'ip_prefix': '10.1.1.0', 'ip_prefix_len': 24}}], + 'dst_ports': [{'start_port': 8000, 'end_port': 8000}], + 'src_ports': [{'start_port': 9000, 'end_port': 9000}], + 'src_addresses': [{'security_group': 'local'}], + }] + secgrp_fix = self.config_sec_group(name='test_sec_group', entries=rule) + self.delete_sec_group(secgrp_fix) + return True + + @preposttest_wrapper + def test_vm_with_sec_group(self): + """Verify attach dettach security group in VM + 1. Create VN with subnet + 2. Create security group with custom rules + 3. Launch VM in custom created security group and verify + 4. Remove secuity group association with VM + 5. Add back custom security group to VM and verify + 6. Try to delete security group with association to VM. It should fail. + Pass criteria: Step 2,3,4,5 and 6 should pass + """ + vn_name = "test_sec_vn" + vn_net = ['11.1.1.0/24'] + vn = self.useFixture(VNFixture( + project_name=self.inputs.project_name, connections=self.connections, + vn_name=vn_name, inputs=self.inputs, subnets=vn_net)) + assert vn.verify_on_setup() + + secgrp_name = 'test_sec_group' + rule = [{'direction': '>', + 'protocol': 'tcp', + 'dst_addresses': [{'subnet': {'ip_prefix': '10.1.1.0', 'ip_prefix_len': 24}}], + 'dst_ports': [{'start_port': 8000, 'end_port': 8000}], + 'src_ports': [{'start_port': 9000, 'end_port': 9000}], + 'src_addresses': [{'security_group': 'local'}], + }] + secgrp = self.config_sec_group(name=secgrp_name, entries=rule) + secgrp_id = secgrp.secgrp_fix._obj.uuid + vm_name = "test_sec_vm" + vm = self.useFixture(VMFixture( + project_name=self.inputs.project_name, connections=self.connections, + vn_obj=vn.obj, vm_name=vm_name, image_name='ubuntu-traffic', flavor='contrail_flavor_small', + sg_ids=[secgrp_id])) + assert vm.verify_on_setup() + assert vm.wait_till_vm_is_up() + result, msg = vm.verify_security_group(secgrp_name) + assert result, msg + + self.logger.info("Remove security group %s from VM %s", + secgrp_name, vm_name) + vm.remove_security_group(secgrp=secgrp_name) + result, msg = vm.verify_security_group(secgrp_name) + if result: + assert False, "Security group %s is not removed from VM %s" % (secgrp_name, + vm_name) + + import time + time.sleep(4) + vm.add_security_group(secgrp=secgrp_name) + result, msg = vm.verify_security_group(secgrp_name) + assert result, msg + + self.logger.info( + "Try deleting the security group %s with back ref.", secgrp_name) + try: + secgrp.secgrp_fix.cleanUp() + except Exception, msg: + self.logger.info(msg) + self.logger.info( + "Not able to delete the security group with back ref as expected") + else: + try: + secgroup = self.vnc_lib.security_group_read( + fq_name=secgrp.secgrp_fq_name) + self.logger.info( + "Not able to delete the security group with back ref as expected") + except NoIdError: + errmsg = "Security group deleted, when it is attached to a VM." + self.logger.error(errmsg) + assert False, errmsg + + return True diff --git a/scripts/smgr/setup.py b/scripts/smgr/setup.py new file mode 100644 index 000000000..afff6fe01 --- /dev/null +++ b/scripts/smgr/setup.py @@ -0,0 +1,179 @@ +import os + +import fixtures +from testresources import TestResource + +from policy_test import PolicyFixture +from vn_test import MultipleVNFixture +from vm_test import MultipleVMFixture +from connections import ContrailConnections +from securitygroup.config import ConfigSecGroup +from contrail_test_init import ContrailTestInit + + +class SecurityGroupSetup(fixtures.Fixture, ConfigSecGroup): + + """Common resources required for the security group regression test suite. + """ + + def __init__(self, common_resource): + super(SecurityGroupSetup, self).__init__() + self.common_resource = common_resource + + def setUp(self): + super(SecurityGroupSetup, self).setUp() + if 'PARAMS_FILE' in os.environ: + self.ini_file = os.environ.get('PARAMS_FILE') + else: + self.ini_file = 'params.ini' + self.inputs = self.useFixture(ContrailTestInit(self.ini_file)) + self.connections = ContrailConnections(self.inputs) + self.quantum_fixture = self.connections.quantum_fixture + self.nova_fixture = self.connections.nova_fixture + self.vnc_lib = self.connections.vnc_lib + self.logger = self.inputs.logger + + self.logger.info("Configuring setup for security group tests.") + self.setup() + self.logger.info("Verifying setup of security group tests.") + self.verify() + self.logger.info( + "Finished configuring setup for security group tests.") + return self + + def setup(self): + """Config common resources.""" + vn_s = {'vn1': '20.1.1.0/24', 'vn2': ['10.1.1.0/24']} + self.multi_vn_fixture = self.useFixture(MultipleVNFixture( + connections=self.connections, inputs=self.inputs, subnet_count=2, + vn_name_net=vn_s, project_name=self.inputs.project_name)) + vns = self.multi_vn_fixture.get_all_fixture_obj() + (self.vn1_name, self.vn1_fix) = self.multi_vn_fixture._vn_fixtures[0] + (self.vn2_name, self.vn2_fix) = self.multi_vn_fixture._vn_fixtures[1] + + self.logger.info("Configure security groups required for test.") + self.config_sec_groups() + + self.multi_vm_fixture = self.useFixture(MultipleVMFixture( + project_name=self.inputs.project_name, connections=self.connections, + vm_count_per_vn=3, vn_objs=vns, image_name='ubuntu-traffic', + flavor='contrail_flavor_small')) + vms = self.multi_vm_fixture.get_all_fixture() + (self.vm1_name, self.vm1_fix) = vms[0] + (self.vm2_name, self.vm2_fix) = vms[1] + (self.vm3_name, self.vm3_fix) = vms[2] + (self.vm4_name, self.vm4_fix) = vms[3] + (self.vm5_name, self.vm5_fix) = vms[4] + (self.vm6_name, self.vm6_fix) = vms[5] + + self.logger.info("Adding the sec groups to the VM's") + self.vm1_fix.add_security_group(secgrp=self.sg1_name) + self.vm1_fix.add_security_group(secgrp=self.sg2_name) + self.vm2_fix.add_security_group(secgrp=self.sg2_name) + self.vm4_fix.add_security_group(secgrp=self.sg1_name) + self.vm4_fix.add_security_group(secgrp=self.sg2_name) + self.vm5_fix.add_security_group(secgrp=self.sg1_name) + + self.logger.info("Remove the default sec group form the VM's") + self.vm1_fix.remove_security_group(secgrp='default') + self.vm2_fix.remove_security_group(secgrp='default') + self.vm4_fix.remove_security_group(secgrp='default') + self.vm5_fix.remove_security_group(secgrp='default') + + def config_sec_groups(self): + self.sg1_name = 'test_tcp_sec_group' + rule = [{'direction': '<>', + 'protocol': 'tcp', + 'dst_addresses': [{'subnet': {'ip_prefix': '10.1.1.0', 'ip_prefix_len': 24}}, + {'subnet': {'ip_prefix': '20.1.1.0', 'ip_prefix_len': 24}}], + 'dst_ports': [{'start_port': 0, 'end_port': -1}], + 'src_ports': [{'start_port': 0, 'end_port': -1}], + 'src_addresses': [{'security_group': 'local'}], + }, + {'direction': '<>', + 'protocol': 'tcp', + 'src_addresses': [{'subnet': {'ip_prefix': '10.1.1.0', 'ip_prefix_len': 24}}, + {'subnet': {'ip_prefix': '20.1.1.0', 'ip_prefix_len': 24}}], + 'src_ports': [{'start_port': 0, 'end_port': -1}], + 'dst_ports': [{'start_port': 0, 'end_port': -1}], + 'dst_addresses': [{'security_group': 'local'}], + }] + + self.sg1_fix = self.config_sec_group(name=self.sg1_name, entries=rule) + + self.sg2_name = 'test_udp_sec_group' + rule = [{'direction': '<>', + 'protocol': 'udp', + 'dst_addresses': [{'subnet': {'ip_prefix': '10.1.1.0', 'ip_prefix_len': 24}}, + {'subnet': {'ip_prefix': '20.1.1.0', 'ip_prefix_len': 24}}], + 'dst_ports': [{'start_port': 0, 'end_port': -1}], + 'src_ports': [{'start_port': 0, 'end_port': -1}], + 'src_addresses': [{'security_group': 'local'}], + }, + {'direction': '<>', + 'protocol': 'udp', + 'src_addresses': [{'subnet': {'ip_prefix': '10.1.1.0', 'ip_prefix_len': 24}}, + {'subnet': {'ip_prefix': '20.1.1.0', 'ip_prefix_len': 24}}], + 'src_ports': [{'start_port': 0, 'end_port': -1}], + 'dst_ports': [{'start_port': 0, 'end_port': -1}], + 'dst_addresses': [{'security_group': 'local'}], + }] + self.sg2_fix = self.config_sec_group(name=self.sg2_name, entries=rule) + + def verify(self): + """verfiy common resources.""" + self.logger.debug("Verify the configured VN's.") + assert self.multi_vn_fixture.verify_on_setup() + + self.logger.debug("Verify the configured VM's.") + assert self.multi_vm_fixture.verify_on_setup() + + self.logger.info("Installing traffic package in VM.") + self.vm1_fix.install_pkg("Traffic") + self.vm2_fix.install_pkg("Traffic") + self.vm3_fix.install_pkg("Traffic") + self.vm4_fix.install_pkg("Traffic") + self.vm5_fix.install_pkg("Traffic") + self.vm6_fix.install_pkg("Traffic") + + self.logger.debug("Verify the configured security groups.") + result, msg = self.sg1_fix.verify_on_setup() + assert result, msg + result, msg = self.sg2_fix.verify_on_setup() + assert result, msg + + self.logger.debug("Verify the attached security groups in the VM.") + result, msg = self.vm1_fix.verify_security_group(self.sg1_name) + assert result, msg + result, msg = self.vm1_fix.verify_security_group(self.sg2_name) + assert result, msg + result, msg = self.vm2_fix.verify_security_group(self.sg2_name) + assert result, msg + result, msg = self.vm4_fix.verify_security_group(self.sg1_name) + assert result, msg + result, msg = self.vm4_fix.verify_security_group(self.sg2_name) + assert result, msg + result, msg = self.vm5_fix.verify_security_group(self.sg2_name) + assert result, msg + + def tearDown(self): + self.logger.info("Tearing down resources of security group tests") + super(SecurityGroupSetup, self).cleanUp() + + def dirtied(self): + self.common_resource.dirtied(self) + + +class _SecurityGroupSetupResource(TestResource): + + def make(self, dependencyresource): + base_setup = SecurityGroupSetup(self) + base_setup.setUp() + return base_setup + + def clean(self, base_setup): + base_setup.logger.info( + "Cleaning up security group test resources here") + base_setup.tearDown() + +SecurityGroupSetupResource = _SecurityGroupSetupResource() diff --git a/scripts/smgr/smgr_regression.py b/scripts/smgr/smgr_regression.py new file mode 100644 index 000000000..742cbaee4 --- /dev/null +++ b/scripts/smgr/smgr_regression.py @@ -0,0 +1,60 @@ +import os +import fixtures +import testtools +import unittest + +from testresources import ResourcedTestCase + +from connections import ContrailConnections +from tcutils.wrappers import preposttest_wrapper +from smgr.smgr_setup import SmgrSetupResource + + +class SmgrRegressionTests(testtools.TestCase, ResourcedTestCase, + fixtures.TestWithFixtures): + + resources = [('base_setup', SmgrSetupResource)] + + def __init__(self, *args, **kwargs): + testtools.TestCase.__init__(self, *args, **kwargs) + self.res = SmgrSetupResource.getResource() + self.inputs = self.res.inputs + self.connections = self.res.connections + self.logger = self.inputs.logger + + def __del__(self): + self.logger.debug("Unconfig the common resurces.") + SmgrSetupResource.finishedWith(self.res) + + def setUp(self): + super(SmgrRegressionTests, self).setUp() + if 'PARAMS_FILE' in os.environ: + self.ini_file = os.environ.get('PARAMS_FILE') + else: + self.ini_file = 'params.ini' + + def tearDown(self): + self.logger.debug("Tearing down SmgrRegressionTests.") + super(SmgrRegressionTests, self).tearDown() + SmgrSetupResource.finishedWith(self.res) + + def runTest(self): + pass + + + @preposttest_wrapper + def test_reimage(self): + """Verify reimage using server manager in a multinode setup""" + self.logger.info("Verify reimage using server manager in a multinode setup") + self.res.smgr_fix.reimage() + + return True + + @preposttest_wrapper + def test_provision(self): + """Verify provision using server manager in a multinode setup""" + self.logger.info("Verify provision using server manager in a multinode setup") + self.res.smgr_fix.provision() + + return True + diff --git a/scripts/smgr/smgr_sanity.py b/scripts/smgr/smgr_sanity.py new file mode 100644 index 000000000..37afb2000 --- /dev/null +++ b/scripts/smgr/smgr_sanity.py @@ -0,0 +1,282 @@ +import os +import fixtures +import testtools +import unittest + +from testresources import ResourcedTestCase + +from connections import ContrailConnections +from securitygroup.config import ConfigSecGroup +from tcutils.wrappers import preposttest_wrapper +from securitygroup.setup import SecurityGroupSetupResource +from verify import VerifySecGroup + + +class SmgrRegressionTests(testtools.TestCase, ResourcedTestCase, + fixtures.TestWithFixtures, + ConfigSecGroup, VerifySecGroup): + + resources = [('base_setup', SecurityGroupSetupResource)] + + def __init__(self, *args, **kwargs): + testtools.TestCase.__init__(self, *args, **kwargs) + self.res = SecurityGroupSetupResource.getResource() + self.inputs = self.res.inputs + self.connections = self.res.connections + self.logger = self.inputs.logger + self.nova_fixture = self.res.nova_fixture + self.analytics_obj = self.connections.analytics_obj + self.vnc_lib = self.connections.vnc_lib + self.quantum_fixture = self.connections.quantum_fixture + + def __del__(self): + self.logger.debug("Unconfig the common resurces.") + SecurityGroupSetupResource.finishedWith(self.res) + + def setUp(self): + super(SecurityGroupRegressionTests, self).setUp() + if 'PARAMS_FILE' in os.environ: + self.ini_file = os.environ.get('PARAMS_FILE') + else: + self.ini_file = 'params.ini' + + def tearDown(self): + self.logger.debug("Tearing down SecurityGroupRegressionTests.") + super(SecurityGroupRegressionTests, self).tearDown() + SecurityGroupSetupResource.finishedWith(self.res) + + def runTest(self): + pass + + def config_policy_and_attach_to_vn(self, rules): + policy_name = "sec_grp_policy" + policy_fix = self.config_policy(policy_name, rules) + assert policy_fix.verify_on_setup() + policy_vn1_attach_fix = self.attach_policy_to_vn( + policy_fix, self.res.vn1_fix) + policy_vn2_attach_fix = self.attach_policy_to_vn( + policy_fix, self.res.vn2_fix) + + @preposttest_wrapper + def test_sec_group_with_proto(self): + """Verify security group with allow specific protocol on all ports and policy with allow all between VN's""" + self.logger.info("Configure the policy with allow any") + rules = [ + { + 'direction': '<>', + 'protocol': 'any', + 'source_network': self.res.vn1_name, + 'src_ports': [0, -1], + 'dest_network': self.res.vn2_name, + 'dst_ports': [0, -1], + 'simple_action': 'pass', + }, + ] + self.config_policy_and_attach_to_vn(rules) + rule = [{'direction': '<>', + 'protocol': 'tcp', + 'dst_addresses': [{'subnet': {'ip_prefix': '10.1.1.0', 'ip_prefix_len': 24}}, + {'subnet': {'ip_prefix': '20.1.1.0', 'ip_prefix_len': 24}}], + 'dst_ports': [{'start_port': 0, 'end_port': -1}], + 'src_ports': [{'start_port': 0, 'end_port': -1}], + 'src_addresses': [{'security_group': 'local'}], + }, + {'direction': '<>', + 'protocol': 'tcp', + 'src_addresses': [{'subnet': {'ip_prefix': '10.1.1.0', 'ip_prefix_len': 24}}, + {'subnet': {'ip_prefix': '20.1.1.0', 'ip_prefix_len': 24}}], + 'src_ports': [{'start_port': 0, 'end_port': -1}], + 'dst_ports': [{'start_port': 0, 'end_port': -1}], + 'dst_addresses': [{'security_group': 'local'}], + }] + self.res.sg1_fix.replace_rules(rule) + + rule = [{'direction': '<>', + 'protocol': 'udp', + 'dst_addresses': [{'subnet': {'ip_prefix': '10.1.1.0', 'ip_prefix_len': 24}}, + {'subnet': {'ip_prefix': '20.1.1.0', 'ip_prefix_len': 24}}], + 'dst_ports': [{'start_port': 0, 'end_port': -1}], + 'src_ports': [{'start_port': 0, 'end_port': -1}], + 'src_addresses': [{'security_group': 'local'}], + }, + {'direction': '<>', + 'protocol': 'udp', + 'src_addresses': [{'subnet': {'ip_prefix': '10.1.1.0', 'ip_prefix_len': 24}}, + {'subnet': {'ip_prefix': '20.1.1.0', 'ip_prefix_len': 24}}], + 'src_ports': [{'start_port': 0, 'end_port': -1}], + 'dst_ports': [{'start_port': 0, 'end_port': -1}], + 'dst_addresses': [{'security_group': 'local'}], + }] + self.res.sg2_fix.replace_rules(rule) + + self.verify_sec_group_port_proto() + return True + + @preposttest_wrapper + def test_sec_group_with_port(self): + """Verify security group with allow specific protocol/port and policy with allow all between VN's""" + self.logger.info("Configure the policy with allow any") + rules = [ + { + 'direction': '<>', + 'protocol': 'any', + 'source_network': self.res.vn1_name, + 'src_ports': [0, -1], + 'dest_network': self.res.vn2_name, + 'dst_ports': [0, -1], + 'simple_action': 'pass', + }, + ] + self.config_policy_and_attach_to_vn(rules) + + rule = [{'direction': '<>', + 'protocol': 'tcp', + 'dst_addresses': [{'subnet': {'ip_prefix': '10.1.1.0', 'ip_prefix_len': 24}}, + {'subnet': {'ip_prefix': '20.1.1.0', 'ip_prefix_len': 24}}], + 'dst_ports': [{'start_port': 8000, 'end_port': 9000}], + 'src_ports': [{'start_port': 8000, 'end_port': 9000}], + 'src_addresses': [{'security_group': 'local'}], + }, + {'direction': '<>', + 'protocol': 'tcp', + 'src_addresses': [{'subnet': {'ip_prefix': '10.1.1.0', 'ip_prefix_len': 24}}, + {'subnet': {'ip_prefix': '20.1.1.0', 'ip_prefix_len': 24}}], + 'src_ports': [{'start_port': 8000, 'end_port': 9000}], + 'dst_ports': [{'start_port': 8000, 'end_port': 9000}], + 'dst_addresses': [{'security_group': 'local'}], + }] + self.res.sg1_fix.replace_rules(rule) + + rule = [{'direction': '<>', + 'protocol': 'udp', + 'dst_addresses': [{'subnet': {'ip_prefix': '10.1.1.0', 'ip_prefix_len': 24}}, + {'subnet': {'ip_prefix': '20.1.1.0', 'ip_prefix_len': 24}}], + 'dst_ports': [{'start_port': 8000, 'end_port': 9000}], + 'src_ports': [{'start_port': 8000, 'end_port': 9000}], + 'src_addresses': [{'security_group': 'local'}], + }, + {'direction': '<>', + 'protocol': 'udp', + 'src_addresses': [{'subnet': {'ip_prefix': '10.1.1.0', 'ip_prefix_len': 24}}, + {'subnet': {'ip_prefix': '20.1.1.0', 'ip_prefix_len': 24}}], + 'src_ports': [{'start_port': 8000, 'end_port': 9000}], + 'dst_ports': [{'start_port': 8000, 'end_port': 9000}], + 'dst_addresses': [{'security_group': 'local'}], + }] + self.res.sg2_fix.replace_rules(rule) + + self.verify_sec_group_port_proto(port_test=True) + return True + + @preposttest_wrapper + def test_sec_group_with_proto_and_policy_to_allow_only_tcp(self): + """Verify security group with allow specific protocol on all ports and policy with allow only TCP between VN's""" + self.logger.info("Configure the policy with allow TCP only rule.") + rules = [ + { + 'direction': '<>', + 'protocol': 'tcp', + 'source_network': self.res.vn1_name, + 'src_ports': [0, -1], + 'dest_network': self.res.vn2_name, + 'dst_ports': [0, -1], + 'simple_action': 'pass', + }, + ] + self.config_policy_and_attach_to_vn(rules) + + rule = [{'direction': '<>', + 'protocol': 'tcp', + 'dst_addresses': [{'subnet': {'ip_prefix': '10.1.1.0', 'ip_prefix_len': 24}}, + {'subnet': {'ip_prefix': '20.1.1.0', 'ip_prefix_len': 24}}], + 'dst_ports': [{'start_port': 0, 'end_port': -1}], + 'src_ports': [{'start_port': 0, 'end_port': -1}], + 'src_addresses': [{'security_group': 'local'}], + }, + {'direction': '<>', + 'protocol': 'tcp', + 'src_addresses': [{'subnet': {'ip_prefix': '10.1.1.0', 'ip_prefix_len': 24}}, + {'subnet': {'ip_prefix': '20.1.1.0', 'ip_prefix_len': 24}}], + 'src_ports': [{'start_port': 0, 'end_port': -1}], + 'dst_ports': [{'start_port': 0, 'end_port': -1}], + 'dst_addresses': [{'security_group': 'local'}], + }] + self.res.sg1_fix.replace_rules(rule) + + rule = [{'direction': '<>', + 'protocol': 'udp', + 'dst_addresses': [{'subnet': {'ip_prefix': '10.1.1.0', 'ip_prefix_len': 24}}, + {'subnet': {'ip_prefix': '20.1.1.0', 'ip_prefix_len': 24}}], + 'dst_ports': [{'start_port': 0, 'end_port': -1}], + 'src_ports': [{'start_port': 0, 'end_port': -1}], + 'src_addresses': [{'security_group': 'local'}], + }, + {'direction': '<>', + 'protocol': 'udp', + 'src_addresses': [{'subnet': {'ip_prefix': '10.1.1.0', 'ip_prefix_len': 24}}, + {'subnet': {'ip_prefix': '20.1.1.0', 'ip_prefix_len': 24}}], + 'src_ports': [{'start_port': 0, 'end_port': -1}], + 'dst_ports': [{'start_port': 0, 'end_port': -1}], + 'dst_addresses': [{'security_group': 'local'}], + }] + self.res.sg2_fix.replace_rules(rule) + + self.verify_sec_group_with_udp_and_policy_with_tcp() + return True + + @preposttest_wrapper + def test_sec_group_with_proto_and_policy_to_allow_only_tcp_ports(self): + """Verify security group with allow specific protocol on all ports and policy with allow only TCP on specifif ports between VN's""" + self.logger.info( + "Configure the policy with allow TCP port 8000/9000 only rule.") + rules = [ + { + 'direction': '<>', + 'protocol': 'tcp', + 'source_network': self.res.vn1_name, + 'src_ports': [8000, 8000], + 'dest_network': self.res.vn2_name, + 'dst_ports': [9000, 9000], + 'simple_action': 'pass', + }, + ] + self.config_policy_and_attach_to_vn(rules) + + rule = [{'direction': '<>', + 'protocol': 'tcp', + 'dst_addresses': [{'subnet': {'ip_prefix': '10.1.1.0', 'ip_prefix_len': 24}}, + {'subnet': {'ip_prefix': '20.1.1.0', 'ip_prefix_len': 24}}], + 'dst_ports': [{'start_port': 0, 'end_port': -1}], + 'src_ports': [{'start_port': 0, 'end_port': -1}], + 'src_addresses': [{'security_group': 'local'}], + }, + {'direction': '<>', + 'protocol': 'tcp', + 'src_addresses': [{'subnet': {'ip_prefix': '10.1.1.0', 'ip_prefix_len': 24}}, + {'subnet': {'ip_prefix': '20.1.1.0', 'ip_prefix_len': 24}}], + 'src_ports': [{'start_port': 0, 'end_port': -1}], + 'dst_ports': [{'start_port': 0, 'end_port': -1}], + 'dst_addresses': [{'security_group': 'local'}], + }] + self.res.sg1_fix.replace_rules(rule) + + rule = [{'direction': '<>', + 'protocol': 'udp', + 'dst_addresses': [{'subnet': {'ip_prefix': '10.1.1.0', 'ip_prefix_len': 24}}, + {'subnet': {'ip_prefix': '20.1.1.0', 'ip_prefix_len': 24}}], + 'dst_ports': [{'start_port': 0, 'end_port': -1}], + 'src_ports': [{'start_port': 0, 'end_port': -1}], + 'src_addresses': [{'security_group': 'local'}], + }, + {'direction': '<>', + 'protocol': 'udp', + 'src_addresses': [{'subnet': {'ip_prefix': '10.1.1.0', 'ip_prefix_len': 24}}, + {'subnet': {'ip_prefix': '20.1.1.0', 'ip_prefix_len': 24}}], + 'src_ports': [{'start_port': 0, 'end_port': -1}], + 'dst_ports': [{'start_port': 0, 'end_port': -1}], + 'dst_addresses': [{'security_group': 'local'}], + }] + self.res.sg2_fix.replace_rules(rule) + + self.verify_sec_group_with_udp_and_policy_with_tcp_port() + return True diff --git a/scripts/smgr/smgr_setup.py b/scripts/smgr/smgr_setup.py new file mode 100644 index 000000000..95a7cf8b3 --- /dev/null +++ b/scripts/smgr/smgr_setup.py @@ -0,0 +1,70 @@ +import os + +import fixtures +from testresources import TestResource + +from smgr_test import CreateSmgrDbFixture +from connections import ContrailConnections +from contrail_test_init import ContrailTestInit + + +class SmgrSetup(fixtures.Fixture): + + """Common resources required for the smgr test suite. + """ + + def __init__(self, common_resource): + super(SmgrSetup, self).__init__() + self.common_resource = common_resource + + def setUp(self): + super(SmgrSetup, self).setUp() + if 'PARAMS_FILE' in os.environ: + self.ini_file = os.environ.get('PARAMS_FILE') + else: + self.ini_file = 'params.ini' + self.inputs = self.useFixture(ContrailTestInit(self.ini_file)) + self.connections = ContrailConnections(self.inputs) + self.logger = self.inputs.logger + + self.logger.info("Configuring setup for smgr tests.") + self.setup() + self.logger.info("Verifying setup of smgr tests.") + self.verify() + self.logger.info( + "Finished configuring setup for smgr tests.") + return self + + def setup(self): + """Config common resources.""" + self.smgr_fixture = self.useFixture(SmgrFixture( + connections=self.connections, inputs=self.inputs, + smgr_config_ini="smgr_config.ini")) + + self.logger.info("Adding Server to smgr DB") + self.smgr_fixture.svrmgr_add_all() + + def verify(self): + """verfiy common resources.""" + self.logger.debug("Verify the configured roles") + assert self.smgr_fixture.verify_roles() + + def tearDown(self): + self.logger.info("Tearing down resources of smgr tests") + super(SmgrSetup, self).cleanUp() + + + +class _SmgrSetupResource(TestResource): + + def make(self, dependencyresource): + base_setup = SmgrSetup(self) + base_setup.setUp() + return base_setup + + def clean(self, base_setup): + base_setup.logger.info( + "Cleaning up smgr test resources here") + base_setup.tearDown() + +SmgrSetupResource = _SmgrSetupResource() diff --git a/scripts/smgr/smgr_tests.py b/scripts/smgr/smgr_tests.py new file mode 100644 index 000000000..786ff79af --- /dev/null +++ b/scripts/smgr/smgr_tests.py @@ -0,0 +1,55 @@ +# Need to import path to test/fixtures and test/scripts/ +# Ex : export PYTHONPATH='$PATH:/root/test/fixtures/:/root/test/scripts/' +# +# To run tests, you can do 'python sanity_tests.py'. To run specific tests, +# You can do 'python -m testtools.run -l tests' +# Set the env variable PARAMS_FILE to point to your ini file. Else it will try to pick params.ini in PWD +# Set the env variable SINGLE_NODE_IP if you are running a single node(No +# need to populate the json file) + +import os +import unittest +from upgrade import * +from util import get_os_env +from tcutils.contrailtestrunner import ContrailHTMLTestRunner + + +if __name__ == "__main__": + + if not get_os_env('SCRIPT_TS'): + os.environ['SCRIPT_TS'] = time.strftime("%Y_%m_%d_%H_%M_%S") + if 'PARAMS_FILE' in os.environ: + ini_file = os.environ.get('PARAMS_FILE') + else: + ini_file = 'params.ini' + inputs = ContrailTestInit(ini_file) + inputs.setUp() + print "\nTest Log File : %s" % (inputs.log_file) + suite = unittest.TestSuite() + test_result = unittest.TestResult() + suite.addTest(Upgrade('test_fiptraffic_before_upgrade')) + suite.addTest(Smgr('test_smgr')) + suite.addTest(Upgrade('test_traffic_after_upgrade')) + descr = inputs.get_html_description() + + if inputs.generate_html_report: + buf = open(inputs.html_report, 'w') + + runner = ContrailHTMLTestRunner( + stream=buf, + title='%s Result %s' % ( + inputs.log_scenario, inputs.build_id), + description=descr + ) + test_result = runner.run(suite) + buf.close() + print "Test HTML Result : %s " % (inputs.html_report) + inputs.upload_results() + file_to_send = inputs.html_report + else: + test_result = unittest.TextTestRunner(verbosity=2).run(suite) + file_to_send = inputs.log_file + + inputs.log_any_issues(test_result) + inputs.send_mail(file_to_send) + print "\nTest Log File : %s" % (inputs.log_file) diff --git a/scripts/smgr/tests_with_setup_base_webui.py b/scripts/smgr/tests_with_setup_base_webui.py new file mode 100644 index 000000000..7fa3af67e --- /dev/null +++ b/scripts/smgr/tests_with_setup_base_webui.py @@ -0,0 +1,236 @@ +# Need to import path to test/fixtures and test/scripts/ +# Ex : export PYTHONPATH='$PATH:/root/test/fixtures/:/root/test/scripts/' +# +# To run tests, you can do 'python -m testtools.run tests'. To run specific tests, +# You can do 'python -m testtools.run -l tests' +# Set the env variable PARAMS_FILE to point to your ini file. Else it will try to pick params.ini in PWD +# +import os +import fixtures +import testtools + +from contrail_test_init import * +from vn_test import * +from vm_test import * +from connections import ContrailConnections +from floating_ip import * +from policy_test import * +from contrail_fixtures import * +from tcutils.wrappers import preposttest_wrapper +from testresources import ResourcedTestCase +from webui_sanity_resource import SolnSetupResource +from selenium import webdriver +from pyvirtualdisplay import Display +from selenium.webdriver.common.keys import Keys +import time +import random +from webui_test import * +from selenium.webdriver.support.ui import WebDriverWait + + +class WebuiTestSanity(testtools.TestCase, ResourcedTestCase, fixtures.TestWithFixtures): + + resources = [('base_setup', SolnSetupResource)] + + def __init__(self, *args, **kwargs): + testtools.TestCase.__init__(self, *args, **kwargs) + self.res = SolnSetupResource.getResource() + self.inputs = self.res.inputs + self.connections = self.res.connections + self.logger = self.res.logger + self.nova_fixture = self.res.nova_fixture + self.analytics_obj = self.connections.analytics_obj + self.vnc_lib = self.connections.vnc_lib + self.quantum_fixture = self.connections.quantum_fixture + self.cn_inspect = self.connections.cn_inspect + if self.inputs.webui_verification_flag: + self.browser = self.connections.browser + self.browser_openstack = self.connections.browser_openstack + self.delay = 10 + self.webui = WebuiTest(self.connections, self.inputs) + self.webui_common = WebuiCommon(self.webui) + + def __del__(self): + print "Deleting test_with_setup now" + SolnSetupResource.finishedWith(self.res) + + def setUp(self): + super(WebuiTestSanity, self).setUp() + if 'PARAMS_FILE' in os.environ: + self.ini_file = os.environ.get('PARAMS_FILE') + else: + self.ini_file = 'params.ini' + + def tearDown(self): + print "Tearing down test" + super(WebuiTestSanity, self).tearDown() + SolnSetupResource.finishedWith(self.res) + + def runTest(self): + pass + # end runTest + + @preposttest_wrapper + def test_control_node_basic_details_in_webui_monitor_infra_control_nodes(self): + '''Test to validate control node basic view details in webui monitor tab + ''' + assert self.webui.verify_bgp_routers_ops_basic_data() + return True + # end + # test_verify_control_node_basic_details_in_webui_monitor_infra_control_nodes + + @preposttest_wrapper + def test_control_node_advance_details_in_webui_monitor_infra_control_nodes(self): + '''Test to validate control node basic view details in webui monitor tab + ''' + assert self.webui.verify_bgp_routers_ops_advance_data() + return True + # end + # test_verify_control_node_advance_details_in_webui_monitor_infra_control_nodes + + @preposttest_wrapper + def test_vrouter_basic_details_in_webui_monitor_infra_virtual_routers(self): + '''Test to validate vrouter basic view details in webui monitor tab + ''' + assert self.webui.verify_vrouter_ops_basic_data() + return True + # end + # test_verify_vrouter_basic_details_in_webui_monitor_infra_virtual_routers + + @preposttest_wrapper + def test_vrouter_advance_details_in_webui_monitor_infra_virtual_routers(self): + '''Test to validate vrouter advance view details in webui monitor tab + ''' + assert self.webui.verify_vrouter_ops_advance_data() + return True + # end + # test_verify_vrouter_node_advance_details_in_webui_monitor_infra_virtual_nodes + + @preposttest_wrapper + def test_analytics_node_basic_details_in_webui_monitor_infra_analytics_nodes(self): + '''Test to validate analytics node basic view details in webui monitor tab + ''' + assert self.webui.verify_analytics_nodes_ops_basic_data() + return True + # end + # test_verify_analytics_basic_details_in_webui_monitor_infra_analytics_nodes + + @preposttest_wrapper + def test_analytics_node_advance_details_in_webui_monitor_infra_analytics_nodes(self): + '''Test to validate analytics node advance view details in webui monitor tab + ''' + assert self.webui.verify_analytics_nodes_ops_advance_data() + return True + # end + # test_verify_analytics_node_advance_details_in_webui_monitor_infra_analytics_nodes + + @preposttest_wrapper + def test_config_node_basic_details_in_webui_monitor_infra_config_nodes(self): + '''Test to validate config node advance view details in webui monitor + ''' + assert self.webui.verify_config_nodes_ops_basic_data() + return True + # end + # test_verify_config_node_basic_details_in_webui_monitor_infra_config_nodes + + @preposttest_wrapper + def test_config_node_advance_details_in_webui_monitor_infra_config_nodes(self): + '''Test to validate config node advance view details in webui monitor tab + ''' + assert self.webui.verify_config_nodes_ops_advance_data() + return True + # end + # test_verify_config_node_advance_details_in_webui_monitor_infra_config_nodes + + @preposttest_wrapper + def test_network_basic_details_in_webui_monitor_networking_networks(self): + '''Test to validate network basic view details in webui monitor + ''' + assert self.webui.verify_vn_ops_basic_data() + return True + # end + # test_verify_networks_basic_details_in_webui_monitor_networking_networks + + @preposttest_wrapper + def test_network_advance_details_in_webui_monitor_networking_networks(self): + '''Test to validate network advance view details in webui monitor tab + ''' + assert self.webui.verify_vn_ops_advance_data() + return True + # end + # test_verify_networks_advance_details_in_webui_monitor_networking_networks + + @preposttest_wrapper + def test_dashboard_details_in_webui_monitor_infra_dashborad(self): + '''Test to validate dashboard details details in webui monitor tab + ''' + assert self.webui.verify_dashboard_details() + return True + # end test_dashboard_details_in_webui_monitor_infra_dashborad + + @preposttest_wrapper + def test_instance_basic_details_in_webui_monitor_networking_networks(self): + '''Test to validate instace basic view details in webui monitor tab + ''' + assert self.webui.verify_vm_ops_basic_data() + return True + # end + # test_verify_instance_basic_details_in_webui_monitor_networking_networks + + @preposttest_wrapper + def test_instance_advance_details_in_webui_monitor_networking_networks(self): + '''Test to validate instance advance view details in webui monitor tab + ''' + assert self.webui.verify_vm_ops_advance_data() + return True + # end + # test_verify_instance_advance_details_in_webui_monitor_networking_networks + + @preposttest_wrapper + def test_floating_ips_in_webui_config_networking_manage_floating_ips(self): + '''Test to validate networks in webui config tab + ''' + assert self.webui.verify_floating_ip_api_data() + return True + # end test_floating_ips_in_webui_config_networking_manage_floating_ips + + @preposttest_wrapper + def test_networks_in_webui_config_networking_networks(self): + '''Test to validate networks in webui config tab + ''' + assert self.webui.verify_vn_api_data() + return True + # end test_verify_networks_in_webui_config_networking_networks + + @preposttest_wrapper + def test_ipam_in_webui_config_networking_ip_address_management(self): + '''Test to validate ipam in webui config networking ip address management + ''' + assert self.webui.verify_ipam_api_data() + return True + # end verify_ipam_api_basic_data_in_webui + + @preposttest_wrapper + def test_policy_in_webui_config_networking_policies(self): + '''Test to validate policies in webui config networking policies + ''' + assert self.webui.verify_policy_api_data() + return True + # end verify_policies_api_basic_data_in_webui + + @preposttest_wrapper + def test_service_templates_in_webui_config_services_service_templates(self): + '''Test to validate service templates in webui config services service templates + ''' + assert self.webui.verify_service_template_api_basic_data() + return True + # end test_service_templates_in_webui_config_services_service_templates + + @preposttest_wrapper + def test_service_instance_in_webui_config_services_service_instance(self): + '''Test to validate service instance in webui config services service instance + ''' + assert self.webui.verify_service_instance_api_basic_data() + return True + # end test_service_instance_in_webui_config_services_service_instance +# end WebuiTestSanity diff --git a/scripts/smgr/upgrade_test.py b/scripts/smgr/upgrade_test.py new file mode 100755 index 000000000..73d4c5555 --- /dev/null +++ b/scripts/smgr/upgrade_test.py @@ -0,0 +1,55 @@ +# Need to import path to test/fixtures and test/scripts/ +# Ex : export PYTHONPATH='$PATH:/root/test/fixtures/:/root/test/scripts/' +# +# To run tests, you can do 'python sanity_tests.py'. To run specific tests, +# You can do 'python -m testtools.run -l tests' +# Set the env variable PARAMS_FILE to point to your ini file. Else it will try to pick params.ini in PWD +# Set the env variable SINGLE_NODE_IP if you are running a single node(No +# need to populate the json file) + +import os +import unittest +from upgrade import * +from util import get_os_env +from tcutils.contrailtestrunner import ContrailHTMLTestRunner + + +if __name__ == "__main__": + + if not get_os_env('SCRIPT_TS'): + os.environ['SCRIPT_TS'] = time.strftime("%Y_%m_%d_%H_%M_%S") + if 'PARAMS_FILE' in os.environ: + ini_file = os.environ.get('PARAMS_FILE') + else: + ini_file = 'params.ini' + inputs = ContrailTestInit(ini_file) + inputs.setUp() + print "\nTest Log File : %s" % (inputs.log_file) + suite = unittest.TestSuite() + test_result = unittest.TestResult() + suite.addTest(Upgrade('test_fiptraffic_before_upgrade')) + suite.addTest(Upgrade('test_upgrade')) + suite.addTest(Upgrade('test_traffic_after_upgrade')) + descr = inputs.get_html_description() + + if inputs.generate_html_report: + buf = open(inputs.html_report, 'w') + + runner = ContrailHTMLTestRunner( + stream=buf, + title='%s Result %s' % ( + inputs.log_scenario, inputs.build_id), + description=descr + ) + test_result = runner.run(suite) + buf.close() + print "Test HTML Result : %s " % (inputs.html_report) + inputs.upload_results() + file_to_send = inputs.html_report + else: + test_result = unittest.TextTestRunner(verbosity=2).run(suite) + file_to_send = inputs.log_file + + inputs.log_any_issues(test_result) + inputs.send_mail(file_to_send) + print "\nTest Log File : %s" % (inputs.log_file) diff --git a/scripts/smgr/verify.py b/scripts/smgr/verify.py new file mode 100644 index 000000000..4488f0945 --- /dev/null +++ b/scripts/smgr/verify.py @@ -0,0 +1,338 @@ +import os +import sys +from time import sleep + +from util import retry +sys.path.append(os.path.realpath('tcutils/pkgs/Traffic')) +from traffic.core.stream import Stream +from traffic.core.helpers import Host, Sender, Receiver +from traffic.core.profile import StandardProfile, ContinuousProfile + + +class VerifySecGroup(): + + def verify_traffic(self, sender_vm, receiver_vm, proto, sport, dport, count=None, fip=None): + # Create stream and profile + if fip: + stream = Stream( + protocol="ip", sport=sport, dport=dport, proto=proto, src=sender_vm.vm_ip, + dst=fip) + else: + stream = Stream( + protocol="ip", sport=sport, dport=dport, proto=proto, src=sender_vm.vm_ip, + dst=receiver_vm.vm_ip) + profile_kwargs = {'stream': stream} + if fip: + profile_kwargs.update({'listener': receiver_vm.vm_ip}) + if count: + profile_kwargs.update({'count': count}) + profile = StandardProfile(**profile_kwargs) + else: + profile = ContinuousProfile(**profile_kwargs) + + # Set VM credentials + send_node = Host(sender_vm.vm_node_ip, + self.inputs.username, self.inputs.password) + recv_node = Host(receiver_vm.vm_node_ip, + self.inputs.username, self.inputs.password) + send_host = Host(sender_vm.local_ip, + sender_vm.vm_username, sender_vm.vm_password) + recv_host = Host(receiver_vm.local_ip, + receiver_vm.vm_username, receiver_vm.vm_password) + + # Create send, receive helpers + sender = Sender("send%s" % + proto, profile, send_node, send_host, self.inputs.logger) + receiver = Receiver("recv%s" % + proto, profile, recv_node, recv_host, self.inputs.logger) + + # start traffic + receiver.start() + sender.start() + sleep(5) + + # stop traffic + sender.stop() + receiver.stop() + self.logger.info("Sent: %s; Received: %s", sender.sent, receiver.recv) + return (sender.sent, receiver.recv) + + def assert_traffic(self, sender, receiver, proto, sport, dport, + expectation='pass'): + self.logger.info("Sending %s traffic from %s with %s to %s with %s" % + (proto, sender[0].vm_name, sender[1], receiver[0].vm_name, receiver[1])) + sent, recv = self.verify_traffic(sender[0], receiver[0], + proto, sport, dport) + if expectation == 'pass': + msg = "%s traffic from %s with %s to %s with %s passed " % (proto, + sender[0].vm_name, sender[1], receiver[0].vm_name, receiver[1]) + errmsg = "%s traffic from %s with %s to %s with %s Failed " % (proto, + sender[0].vm_name, sender[1], receiver[0].vm_name, receiver[1]) + if (sent and recv == sent): + self.logger.info(msg) + return (True, msg) + else: + self.logger.error(errmsg) + if self.inputs.stop_on_fail: + self.logger.info( + "Sub test failed; Stopping test for debugging.") + import pdb + pdb.set_trace() + return (False, errmsg) + + elif expectation == 'fail': + msg = "%s traffic from %s with %s to %s with %s "\ + "failed as expected" % (proto, sender[0].vm_name, sender[1], + receiver[0].vm_name, receiver[1]) + errmsg = "%s traffic from %s with %s to %s with %s "\ + "passed; Expcted to fail " % (proto, sender[0].vm_name, sender[1], + receiver[0].vm_name, receiver[1]) + if (recv == 0): + self.logger.info(msg) + return (True, msg) + else: + self.logger.error(errmsg) + if self.inputs.stop_on_fail: + self.logger.info( + "Sub test failed; Stopping test for debugging.") + import pdb + pdb.set_trace() + return (False, errmsg) + + def verify_sec_group_port_proto(self, port_test=False): + results = [] + self.logger.info("Verifcations with UDP traffic") + sender = (self.res.vm1_fix, self.res.sg2_fix.secgrp_name) + receiver = (self.res.vm2_fix, self.res.sg2_fix.secgrp_name) + results.append( + self.assert_traffic(sender, receiver, 'udp', 8000, 9000, 'pass')) + if port_test: + results.append( + self.assert_traffic(sender, receiver, 'udp', 8010, 9010, 'fail')) + + sender = (self.res.vm1_fix, self.res.sg2_fix.secgrp_name) + receiver = (self.res.vm3_fix, 'default') + results.append( + self.assert_traffic(sender, receiver, 'udp', 8000, 9000, 'fail')) + if port_test: + results.append( + self.assert_traffic(sender, receiver, 'udp', 8010, 9010, 'fail')) + + sender = (self.res.vm1_fix, self.res.sg2_fix.secgrp_name) + receiver = (self.res.vm4_fix, self.res.sg2_fix.secgrp_name) + results.append( + self.assert_traffic(sender, receiver, 'udp', 8000, 9000, 'pass')) + if port_test: + results.append( + self.assert_traffic(sender, receiver, 'udp', 8010, 9010, 'fail')) + + sender = (self.res.vm1_fix, self.res.sg2_fix.secgrp_name) + receiver = (self.res.vm5_fix, self.res.sg1_fix.secgrp_name) + results.append( + self.assert_traffic(sender, receiver, 'udp', 8000, 9000, 'fail')) + if port_test: + results.append( + self.assert_traffic(sender, receiver, 'udp', 8010, 9010, 'fail')) + + sender = (self.res.vm1_fix, self.res.sg2_fix.secgrp_name) + receiver = (self.res.vm6_fix, 'default') + results.append( + self.assert_traffic(sender, receiver, 'udp', 8000, 9000, 'fail')) + if port_test: + results.append( + self.assert_traffic(sender, receiver, 'udp', 8010, 9010, 'fail')) + + self.logger.info("Verifcations with TCP traffic") + sender = (self.res.vm1_fix, self.res.sg1_fix.secgrp_name) + receiver = (self.res.vm2_fix, self.res.sg2_fix.secgrp_name) + results.append( + self.assert_traffic(sender, receiver, 'tcp', 8000, 9000, 'fail')) + if port_test: + results.append( + self.assert_traffic(sender, receiver, 'tcp', 8010, 9010, 'fail')) + + sender = (self.res.vm1_fix, self.res.sg1_fix.secgrp_name) + receiver = (self.res.vm3_fix, 'default') + results.append( + self.assert_traffic(sender, receiver, 'tcp', 8000, 9000, 'fail')) + if port_test: + results.append( + self.assert_traffic(sender, receiver, 'tcp', 8010, 9010, 'fail')) + + sender = (self.res.vm1_fix, self.res.sg1_fix.secgrp_name) + receiver = (self.res.vm4_fix, self.res.sg1_fix.secgrp_name) + results.append( + self.assert_traffic(sender, receiver, 'tcp', 8000, 9000, 'pass')) + if port_test: + results.append( + self.assert_traffic(sender, receiver, 'tcp', 8010, 9010, 'fail')) + + sender = (self.res.vm1_fix, self.res.sg1_fix.secgrp_name) + receiver = (self.res.vm5_fix, self.res.sg1_fix.secgrp_name) + results.append( + self.assert_traffic(sender, receiver, 'tcp', 8000, 9000, 'pass')) + if port_test: + results.append( + self.assert_traffic(sender, receiver, 'tcp', 8010, 9010, 'fail')) + + sender = (self.res.vm1_fix, self.res.sg1_fix.secgrp_name) + receiver = (self.res.vm6_fix, 'default') + results.append( + self.assert_traffic(sender, receiver, 'tcp', 8000, 9000, 'fail')) + if port_test: + results.append( + self.assert_traffic(sender, receiver, 'tcp', 8010, 9010, 'fail')) + + errmsg = '' + for (rc, msg) in results: + if rc: + self.logger.debug(msg) + else: + errmsg += msg + '\n' + if errmsg: + assert False, errmsg + + def verify_sec_group_with_udp_and_policy_with_tcp(self): + results = [] + self.logger.info("Verifcations with TCP traffic") + sender = (self.res.vm1_fix, self.res.sg1_fix.secgrp_name) + receiver = (self.res.vm2_fix, self.res.sg2_fix.secgrp_name) + results.append( + self.assert_traffic(sender, receiver, 'tcp', 8000, 9000, 'fail')) + + sender = (self.res.vm1_fix, self.res.sg1_fix.secgrp_name) + receiver = (self.res.vm3_fix, 'default') + results.append( + self.assert_traffic(sender, receiver, 'tcp', 8000, 9000, 'fail')) + + sender = (self.res.vm1_fix, self.res.sg1_fix.secgrp_name) + receiver = (self.res.vm4_fix, self.res.sg1_fix.secgrp_name) + results.append( + self.assert_traffic(sender, receiver, 'tcp', 8000, 9000, 'pass')) + + sender = (self.res.vm1_fix, self.res.sg1_fix.secgrp_name) + receiver = (self.res.vm5_fix, self.res.sg1_fix.secgrp_name) + results.append( + self.assert_traffic(sender, receiver, 'tcp', 8000, 9000, 'pass')) + + sender = (self.res.vm1_fix, self.res.sg1_fix.secgrp_name) + receiver = (self.res.vm6_fix, 'default') + results.append( + self.assert_traffic(sender, receiver, 'tcp', 8000, 9000, 'fail')) + + self.logger.info("Verifcations with UDP traffic") + sender = (self.res.vm1_fix, self.res.sg2_fix.secgrp_name) + receiver = (self.res.vm2_fix, self.res.sg2_fix.secgrp_name) + results.append( + self.assert_traffic(sender, receiver, 'udp', 8000, 9000, 'pass')) + + sender = (self.res.vm1_fix, self.res.sg2_fix.secgrp_name) + receiver = (self.res.vm3_fix, 'default') + results.append( + self.assert_traffic(sender, receiver, 'udp', 8000, 9000, 'fail')) + + sender = (self.res.vm1_fix, self.res.sg2_fix.secgrp_name) + receiver = (self.res.vm4_fix, self.res.sg2_fix.secgrp_name) + results.append( + self.assert_traffic(sender, receiver, 'udp', 8000, 9000, 'fail')) + + sender = (self.res.vm1_fix, self.res.sg2_fix.secgrp_name) + receiver = (self.res.vm5_fix, self.res.sg1_fix.secgrp_name) + results.append( + self.assert_traffic(sender, receiver, 'udp', 8000, 9000, 'fail')) + + sender = (self.res.vm1_fix, self.res.sg2_fix.secgrp_name) + receiver = (self.res.vm6_fix, 'default') + results.append( + self.assert_traffic(sender, receiver, 'udp', 8000, 9000, 'fail')) + + errmsg = '' + for (rc, msg) in results: + if rc: + self.logger.debug(msg) + else: + errmsg += msg + '\n' + if errmsg: + assert False, errmsg + + def verify_sec_group_with_udp_and_policy_with_tcp_port(self): + results = [] + self.logger.info("Verifcations with TCP traffic") + sender = (self.res.vm1_fix, self.res.sg1_fix.secgrp_name) + receiver = (self.res.vm2_fix, self.res.sg2_fix.secgrp_name) + results.append( + self.assert_traffic(sender, receiver, 'tcp', 8000, 9000, 'fail')) + results.append( + self.assert_traffic(sender, receiver, 'tcp', 8010, 9000, 'fail')) + + sender = (self.res.vm1_fix, self.res.sg1_fix.secgrp_name) + receiver = (self.res.vm3_fix, 'default') + results.append( + self.assert_traffic(sender, receiver, 'tcp', 8000, 9000, 'fail')) + results.append( + self.assert_traffic(sender, receiver, 'tcp', 8010, 9010, 'fail')) + + sender = (self.res.vm1_fix, self.res.sg1_fix.secgrp_name) + receiver = (self.res.vm4_fix, self.res.sg1_fix.secgrp_name) + results.append( + self.assert_traffic(sender, receiver, 'tcp', 8000, 9000, 'pass')) + results.append( + self.assert_traffic(sender, receiver, 'tcp', 8000, 9010, 'fail')) + + sender = (self.res.vm1_fix, self.res.sg1_fix.secgrp_name) + receiver = (self.res.vm5_fix, self.res.sg1_fix.secgrp_name) + results.append( + self.assert_traffic(sender, receiver, 'tcp', 8000, 9000, 'pass')) + results.append( + self.assert_traffic(sender, receiver, 'tcp', 8010, 9000, 'fail')) + sender = (self.res.vm1_fix, self.res.sg1_fix.secgrp_name) + receiver = (self.res.vm6_fix, 'default') + results.append( + self.assert_traffic(sender, receiver, 'tcp', 8000, 9000, 'fail')) + results.append( + self.assert_traffic(sender, receiver, 'tcp', 8010, 9000, 'fail')) + + self.logger.info("Verifcations with UDP traffic") + sender = (self.res.vm1_fix, self.res.sg2_fix.secgrp_name) + receiver = (self.res.vm2_fix, self.res.sg2_fix.secgrp_name) + results.append( + self.assert_traffic(sender, receiver, 'udp', 8000, 9000, 'pass')) + results.append( + self.assert_traffic(sender, receiver, 'udp', 8010, 9000, 'pass')) + + sender = (self.res.vm1_fix, self.res.sg2_fix.secgrp_name) + receiver = (self.res.vm3_fix, 'default') + results.append( + self.assert_traffic(sender, receiver, 'udp', 8000, 9000, 'fail')) + results.append( + self.assert_traffic(sender, receiver, 'udp', 8010, 9000, 'fail')) + + sender = (self.res.vm1_fix, self.res.sg2_fix.secgrp_name) + receiver = (self.res.vm4_fix, self.res.sg2_fix.secgrp_name) + results.append( + self.assert_traffic(sender, receiver, 'udp', 8000, 9000, 'fail')) + results.append( + self.assert_traffic(sender, receiver, 'udp', 8010, 9000, 'fail')) + + sender = (self.res.vm1_fix, self.res.sg2_fix.secgrp_name) + receiver = (self.res.vm5_fix, self.res.sg1_fix.secgrp_name) + results.append( + self.assert_traffic(sender, receiver, 'udp', 8000, 9000, 'fail')) + results.append( + self.assert_traffic(sender, receiver, 'udp', 8010, 9000, 'fail')) + + sender = (self.res.vm1_fix, self.res.sg2_fix.secgrp_name) + receiver = (self.res.vm6_fix, 'default') + results.append( + self.assert_traffic(sender, receiver, 'udp', 8000, 9000, 'fail')) + results.append( + self.assert_traffic(sender, receiver, 'udp', 8010, 9000, 'fail')) + + errmsg = '' + for (rc, msg) in results: + if rc: + self.logger.debug(msg) + else: + errmsg += msg + '\n' + if errmsg: + assert False, errmsg diff --git a/scripts/smgr/webui_sanity_resource.py b/scripts/smgr/webui_sanity_resource.py new file mode 100644 index 000000000..d88bdc709 --- /dev/null +++ b/scripts/smgr/webui_sanity_resource.py @@ -0,0 +1,70 @@ +import fixtures +import testtools +import os +import uuid +from connections import ContrailConnections +from contrail_test_init import * +from vn_test import * +from vm_test import * +from quantum_test import * +from vnc_api_test import * +from nova_test import * +from testresources import OptimisingTestSuite, TestResource +import time +from sdn_topo_setup import * +from webui_topology import * + + +class SolnSetup(fixtures.Fixture): + + def __init__(self, test_resource): + super(SolnSetup, self).__init__() + self.test_resource = test_resource + + def setUp(self): + super(SolnSetup, self).setUp() + if 'PARAMS_FILE' in os.environ: + self.ini_file = os.environ.get('PARAMS_FILE') + else: + self.ini_file = 'params.ini' + self.inputs = self.useFixture(ContrailTestInit(self.ini_file)) + self.connections = ContrailConnections(self.inputs) + self.quantum_fixture = self.connections.quantum_fixture + self.nova_fixture = self.connections.nova_fixture + self.vnc_lib = self.connections.vnc_lib + self.logger = self.inputs.logger + self.setup_common_objects() + return self + # end setUp + + def setup_common_objects(self): + time.sleep(5) + topo_obj = sdn_webui_config() + setup_obj = self.useFixture( + sdnTopoSetupFixture(self.connections, topo_obj)) + out = setup_obj.topo_setup(skip_verify='yes') + # end setup_webui_objects + + def tearDown(self): + print "Tearing down resources" + super(SolnSetup, self).cleanUp() + + def dirtied(self): + self.test_resource.dirtied(self) + + +class _SolnSetupResource(TestResource): + + def make(self, dependencyresource): + base_setup = SolnSetup(self) + base_setup.setUp() + return base_setup + # end make + + def clean(self, base_setup): + print "Am cleaning up here" +# super(_SolnSetupResource,self).clean() + base_setup.tearDown() + # end + +SolnSetupResource = _SolnSetupResource() diff --git a/scripts/smgr/webui_topology.py b/scripts/smgr/webui_topology.py new file mode 100644 index 000000000..5a842f5be --- /dev/null +++ b/scripts/smgr/webui_topology.py @@ -0,0 +1,94 @@ +'''*******AUTO-GENERATED TOPOLOGY*********''' + + +class sdn_webui_config (): + + def __init__(self, domain='default-domain', project='admin', username=None, password=None): + # + # Domain and project defaults: Do not change until support for + # non-default is tested! + self.domain = domain + self.project = project + self.username = username + self.password = password + # + # Define VN's in the project: + self.vnet_list = ['vnet0', 'vnet1', + 'vnet2', 'vnet3', 'left_vn', 'right_vn'] + # + # Define network info for each VN: + self.vn_nets = { + 'left_vn': ['31.1.1.0/24'], 'right_vn': ['41.2.2.0/24'], 'vnet0': ['10.1.1.0/30', '11.1.1.0/30'], + 'vnet1': ['12.1.1.0/30', '13.1.1.0/30'], 'vnet2': ['14.1.1.0/30', '15.1.1.0/30'], 'vnet3': ['16.1.1.0/30', '17.1.1.0/30']} + # + # Define network policies + self.policy_list = ['allow_tcp', 'policy0', + 'policy1', 'policy2', 'policy3'] + self.vn_policy = {'left_vn': ['allow_tcp'], 'right_vn': ['allow_tcp'], 'vnet0': ['policy0', 'policy1'], 'vnet1': [ + 'policy2', 'policy3'], 'vnet2': ['policy2', 'policy3'], 'vnet3': ['policy2', 'policy3']} + # + # Define ipams ## + self.vn_ipams = {'vnet1': 'ipam1', 'vnet2': 'ipam2', 'vnet3': 'ipam3'} + # + # define service templates ## + self.st_list = ['tcp_svc_template'] + self.st_params = {'tcp_svc_template': {'svc_img_name': 'vsrx-bridge', 'svc_type': 'firewall', 'if_list': + [['management', False, False], ['left', False, False], ['right', False, False]], 'svc_mode': 'transparent', 'svc_scaling': False, 'flavor': 'm1.medium', 'ordered_interfaces': True}} + + # define service instance + self.si_list = ['svcinst1'] + self.si_params = { + 'svcinst1': {'if_list': [['management', False, False], ['left', False, False], + ['right', False, False]], 'svc_template': 'tcp_svc_template', 'left_vn': None, 'right_vn': None}} + # Define VM's + # VM distribution on available compute nodes is handled by nova + # scheduler or contrail vm naming scheme + self.vn_of_vm = {'left_vm': 'left_vn', + 'right_vm': 'right_vn', 'vmc0': 'vnet0'} + # + # Define VN to VM mappings for each of the floating ip pools to be + # created. + self.fvn_vm_map = {'vnet3': ['vmc0']} + # Define network policy rules + self.rules = {} + + self.rules[ + 'allow_tcp'] = [{'direction': '<>', 'protocol': 'tcp', 'dest_network': 'right_vn', + 'source_network': 'left_vn', 'dst_ports': [9000, 9001], 'simple_action': 'pass', 'src_ports': [8000, 8001]}] + + self.rules['policy0'] = [{'direction': '>', 'protocol': 'any', 'dest_network': 'vnet0', 'source_network': 'vnet0', 'dst_ports': 'any', 'simple_action': 'deny', 'src_ports': [4, 5]}, {'direction': '>', 'protocol': 'any', 'dest_network': 'vnet0', 'source_network': 'vnet0', 'dst_ports': 'any', 'simple_action': 'deny', 'src_ports': [ + 1, 2]}, {'direction': '>', 'protocol': 'any', 'dest_network': 'vnet0', 'source_network': 'vnet0', 'dst_ports': 'any', 'simple_action': 'deny', 'src_ports': [2, 3]}, {'direction': '>', 'protocol': 'any', 'dest_network': 'vnet0', 'source_network': 'vnet0', 'dst_ports': 'any', 'simple_action': 'deny', 'src_ports': [3, 4]}] + + self.rules['policy1'] = [{'direction': '>', 'protocol': 'any', 'dest_network': 'vnet0', 'source_network': 'vnet0', 'dst_ports': 'any', 'simple_action': 'deny', 'src_ports': [4, 5]}, {'direction': '>', 'protocol': 'any', 'dest_network': 'vnet0', 'source_network': 'vnet0', 'dst_ports': 'any', 'simple_action': 'deny', 'src_ports': [ + 1, 2]}, {'direction': '>', 'protocol': 'any', 'dest_network': 'vnet0', 'source_network': 'vnet0', 'dst_ports': 'any', 'simple_action': 'deny', 'src_ports': [2, 3]}, {'direction': '>', 'protocol': 'any', 'dest_network': 'vnet0', 'source_network': 'vnet0', 'dst_ports': 'any', 'simple_action': 'deny', 'src_ports': [3, 4]}] + + self.rules['policy2'] = [{'direction': '>', 'protocol': 'udp', 'dest_network': 'vnet1', 'source_network': 'vnet1', 'dst_ports': 'any', 'simple_action': 'deny', 'src_ports': [4, 5]}, {'direction': '>', 'protocol': 'udp', 'dest_network': 'vnet1', 'source_network': 'vnet1', 'dst_ports': 'any', 'simple_action': 'deny', 'src_ports': [ + 1, 2]}, {'direction': '>', 'protocol': 'udp', 'dest_network': 'vnet1', 'source_network': 'vnet1', 'dst_ports': 'any', 'simple_action': 'deny', 'src_ports': [2, 3]}, {'direction': '>', 'protocol': 'udp', 'dest_network': 'vnet1', 'source_network': 'vnet1', 'dst_ports': 'any', 'simple_action': 'deny', 'src_ports': [3, 4]}] + + self.rules['policy3'] = [{'direction': '>', 'protocol': 'icmp', 'dest_network': 'vnet1', 'source_network': 'vnet1', 'dst_ports': 'any', 'simple_action': 'deny', 'src_ports': [4, 5]}, {'direction': '>', 'protocol': 'icmp', 'dest_network': 'vnet1', 'source_network': 'vnet1', 'dst_ports': 'any', 'simple_action': 'deny', 'src_ports': [ + 1, 2]}, {'direction': '>', 'protocol': 'icmp', 'dest_network': 'vnet1', 'source_network': 'vnet1', 'dst_ports': 'any', 'simple_action': 'deny', 'src_ports': [2, 3]}, {'direction': '>', 'protocol': 'icmp', 'dest_network': 'vnet1', 'source_network': 'vnet1', 'dst_ports': 'any', 'simple_action': 'deny', 'src_ports': [3, 4]}] + + + # end __init__ + +if __name__ == '__main__': + print "Currently topology limited to one domain/project.." + print "Based on need, can be extended to cover config for multiple domain/projects" + print "Running unit test for this module ..." + my_topo = sdn_webui_config(domain='default-domain', project='admin') + x = my_topo.__dict__ + print "\nprinting keys of topology dict:" + for key, value in x.iteritems(): + print key + print + # print "keys & values:" + # for key, value in x.iteritems(): print key, "-->", value + # Use topology_helper to extend/derive data from user-defined topology to help verifications. + # ex. get list of all vm's from topology; get list of vn's associated to a + # policy + import topo_helper + topo_h = topo_helper.topology_helper(my_topo) + #vmc_list= topo_h.get_vmc_list() + policy_vn = topo_h.get_policy_vn() + print "printing derived topo data - vn's associated to a policy: \n", policy_vn +# From 329c33f34c8a429a70767b136c5eb1c88cfd01bc Mon Sep 17 00:00:00 2001 From: Rishi Verma Date: Fri, 25 Jul 2014 19:08:46 +0530 Subject: [PATCH 02/15] remove unwanted files --- scripts/smgr/config.py | 33 -- scripts/smgr/regression.py | 282 ---------------- scripts/smgr/sanity.py | 15 - scripts/smgr/sanity_base.py | 125 -------- scripts/smgr/setup.py | 179 ----------- scripts/smgr/smgr_sanity.py | 282 ---------------- scripts/smgr/smgr_tests.py | 55 ---- scripts/smgr/tests_with_setup_base_webui.py | 236 -------------- scripts/smgr/upgrade_test.py | 55 ---- scripts/smgr/verify.py | 338 -------------------- scripts/smgr/webui_sanity_resource.py | 70 ---- scripts/smgr/webui_topology.py | 94 ------ 12 files changed, 1764 deletions(-) delete mode 100644 scripts/smgr/config.py delete mode 100644 scripts/smgr/regression.py delete mode 100644 scripts/smgr/sanity.py delete mode 100644 scripts/smgr/sanity_base.py delete mode 100644 scripts/smgr/setup.py delete mode 100644 scripts/smgr/smgr_sanity.py delete mode 100644 scripts/smgr/smgr_tests.py delete mode 100644 scripts/smgr/tests_with_setup_base_webui.py delete mode 100755 scripts/smgr/upgrade_test.py delete mode 100644 scripts/smgr/verify.py delete mode 100644 scripts/smgr/webui_sanity_resource.py delete mode 100644 scripts/smgr/webui_topology.py diff --git a/scripts/smgr/config.py b/scripts/smgr/config.py deleted file mode 100644 index 149ce579f..000000000 --- a/scripts/smgr/config.py +++ /dev/null @@ -1,33 +0,0 @@ -import time - -import paramiko -import fixtures -from fabric.api import run, hide, settings - -from vn_test import VNFixture -from vm_test import VMFixture -from policy_test import PolicyFixture -from policy.config import ConfigPolicy -from connections import ContrailConnections -from security_group import SecurityGroupFixture - - -class ConfigSecGroup(ConfigPolicy): - - def config_sec_group(self, name, secgrpid=None, entries=None): - secgrp_fixture = self.useFixture(SecurityGroupFixture(self.inputs, - self.connections, self.inputs.domain_name, self.inputs.project_name, - secgrp_name=name, secgrp_id=secgrpid, secgrp_entries=entries)) - result, msg = secgrp_fixture.verify_on_setup() - assert result, msg - return secgrp_fixture - - def delete_sec_group(self, secgrp_fix): - secgrp_fix.cleanUp() - self.remove_from_cleanups(secgrp_fix) - - def remove_from_cleanups(self, fix): - for cleanup in self._cleanups: - if fix.cleanUp in cleanup: - self._cleanups.remove(cleanup) - break diff --git a/scripts/smgr/regression.py b/scripts/smgr/regression.py deleted file mode 100644 index 7ecb1f038..000000000 --- a/scripts/smgr/regression.py +++ /dev/null @@ -1,282 +0,0 @@ -import os -import fixtures -import testtools -import unittest - -from testresources import ResourcedTestCase - -from connections import ContrailConnections -from securitygroup.config import ConfigSecGroup -from tcutils.wrappers import preposttest_wrapper -from securitygroup.setup import SecurityGroupSetupResource -from verify import VerifySecGroup - - -class SecurityGroupRegressionTests(testtools.TestCase, ResourcedTestCase, - fixtures.TestWithFixtures, - ConfigSecGroup, VerifySecGroup): - - resources = [('base_setup', SecurityGroupSetupResource)] - - def __init__(self, *args, **kwargs): - testtools.TestCase.__init__(self, *args, **kwargs) - self.res = SecurityGroupSetupResource.getResource() - self.inputs = self.res.inputs - self.connections = self.res.connections - self.logger = self.inputs.logger - self.nova_fixture = self.res.nova_fixture - self.analytics_obj = self.connections.analytics_obj - self.vnc_lib = self.connections.vnc_lib - self.quantum_fixture = self.connections.quantum_fixture - - def __del__(self): - self.logger.debug("Unconfig the common resurces.") - SecurityGroupSetupResource.finishedWith(self.res) - - def setUp(self): - super(SecurityGroupRegressionTests, self).setUp() - if 'PARAMS_FILE' in os.environ: - self.ini_file = os.environ.get('PARAMS_FILE') - else: - self.ini_file = 'params.ini' - - def tearDown(self): - self.logger.debug("Tearing down SecurityGroupRegressionTests.") - super(SecurityGroupRegressionTests, self).tearDown() - SecurityGroupSetupResource.finishedWith(self.res) - - def runTest(self): - pass - - def config_policy_and_attach_to_vn(self, rules): - policy_name = "sec_grp_policy" - policy_fix = self.config_policy(policy_name, rules) - assert policy_fix.verify_on_setup() - policy_vn1_attach_fix = self.attach_policy_to_vn( - policy_fix, self.res.vn1_fix) - policy_vn2_attach_fix = self.attach_policy_to_vn( - policy_fix, self.res.vn2_fix) - - @preposttest_wrapper - def test_sec_group_with_proto(self): - """Verify security group with allow specific protocol on all ports and policy with allow all between VN's""" - self.logger.info("Configure the policy with allow any") - rules = [ - { - 'direction': '<>', - 'protocol': 'any', - 'source_network': self.res.vn1_name, - 'src_ports': [0, -1], - 'dest_network': self.res.vn2_name, - 'dst_ports': [0, -1], - 'simple_action': 'pass', - }, - ] - self.config_policy_and_attach_to_vn(rules) - rule = [{'direction': '<>', - 'protocol': 'tcp', - 'dst_addresses': [{'subnet': {'ip_prefix': '10.1.1.0', 'ip_prefix_len': 24}}, - {'subnet': {'ip_prefix': '20.1.1.0', 'ip_prefix_len': 24}}], - 'dst_ports': [{'start_port': 0, 'end_port': -1}], - 'src_ports': [{'start_port': 0, 'end_port': -1}], - 'src_addresses': [{'security_group': 'local'}], - }, - {'direction': '<>', - 'protocol': 'tcp', - 'src_addresses': [{'subnet': {'ip_prefix': '10.1.1.0', 'ip_prefix_len': 24}}, - {'subnet': {'ip_prefix': '20.1.1.0', 'ip_prefix_len': 24}}], - 'src_ports': [{'start_port': 0, 'end_port': -1}], - 'dst_ports': [{'start_port': 0, 'end_port': -1}], - 'dst_addresses': [{'security_group': 'local'}], - }] - self.res.sg1_fix.replace_rules(rule) - - rule = [{'direction': '<>', - 'protocol': 'udp', - 'dst_addresses': [{'subnet': {'ip_prefix': '10.1.1.0', 'ip_prefix_len': 24}}, - {'subnet': {'ip_prefix': '20.1.1.0', 'ip_prefix_len': 24}}], - 'dst_ports': [{'start_port': 0, 'end_port': -1}], - 'src_ports': [{'start_port': 0, 'end_port': -1}], - 'src_addresses': [{'security_group': 'local'}], - }, - {'direction': '<>', - 'protocol': 'udp', - 'src_addresses': [{'subnet': {'ip_prefix': '10.1.1.0', 'ip_prefix_len': 24}}, - {'subnet': {'ip_prefix': '20.1.1.0', 'ip_prefix_len': 24}}], - 'src_ports': [{'start_port': 0, 'end_port': -1}], - 'dst_ports': [{'start_port': 0, 'end_port': -1}], - 'dst_addresses': [{'security_group': 'local'}], - }] - self.res.sg2_fix.replace_rules(rule) - - self.verify_sec_group_port_proto() - return True - - @preposttest_wrapper - def test_sec_group_with_port(self): - """Verify security group with allow specific protocol/port and policy with allow all between VN's""" - self.logger.info("Configure the policy with allow any") - rules = [ - { - 'direction': '<>', - 'protocol': 'any', - 'source_network': self.res.vn1_name, - 'src_ports': [0, -1], - 'dest_network': self.res.vn2_name, - 'dst_ports': [0, -1], - 'simple_action': 'pass', - }, - ] - self.config_policy_and_attach_to_vn(rules) - - rule = [{'direction': '<>', - 'protocol': 'tcp', - 'dst_addresses': [{'subnet': {'ip_prefix': '10.1.1.0', 'ip_prefix_len': 24}}, - {'subnet': {'ip_prefix': '20.1.1.0', 'ip_prefix_len': 24}}], - 'dst_ports': [{'start_port': 8000, 'end_port': 9000}], - 'src_ports': [{'start_port': 8000, 'end_port': 9000}], - 'src_addresses': [{'security_group': 'local'}], - }, - {'direction': '<>', - 'protocol': 'tcp', - 'src_addresses': [{'subnet': {'ip_prefix': '10.1.1.0', 'ip_prefix_len': 24}}, - {'subnet': {'ip_prefix': '20.1.1.0', 'ip_prefix_len': 24}}], - 'src_ports': [{'start_port': 8000, 'end_port': 9000}], - 'dst_ports': [{'start_port': 8000, 'end_port': 9000}], - 'dst_addresses': [{'security_group': 'local'}], - }] - self.res.sg1_fix.replace_rules(rule) - - rule = [{'direction': '<>', - 'protocol': 'udp', - 'dst_addresses': [{'subnet': {'ip_prefix': '10.1.1.0', 'ip_prefix_len': 24}}, - {'subnet': {'ip_prefix': '20.1.1.0', 'ip_prefix_len': 24}}], - 'dst_ports': [{'start_port': 8000, 'end_port': 9000}], - 'src_ports': [{'start_port': 8000, 'end_port': 9000}], - 'src_addresses': [{'security_group': 'local'}], - }, - {'direction': '<>', - 'protocol': 'udp', - 'src_addresses': [{'subnet': {'ip_prefix': '10.1.1.0', 'ip_prefix_len': 24}}, - {'subnet': {'ip_prefix': '20.1.1.0', 'ip_prefix_len': 24}}], - 'src_ports': [{'start_port': 8000, 'end_port': 9000}], - 'dst_ports': [{'start_port': 8000, 'end_port': 9000}], - 'dst_addresses': [{'security_group': 'local'}], - }] - self.res.sg2_fix.replace_rules(rule) - - self.verify_sec_group_port_proto(port_test=True) - return True - - @preposttest_wrapper - def test_sec_group_with_proto_and_policy_to_allow_only_tcp(self): - """Verify security group with allow specific protocol on all ports and policy with allow only TCP between VN's""" - self.logger.info("Configure the policy with allow TCP only rule.") - rules = [ - { - 'direction': '<>', - 'protocol': 'tcp', - 'source_network': self.res.vn1_name, - 'src_ports': [0, -1], - 'dest_network': self.res.vn2_name, - 'dst_ports': [0, -1], - 'simple_action': 'pass', - }, - ] - self.config_policy_and_attach_to_vn(rules) - - rule = [{'direction': '<>', - 'protocol': 'tcp', - 'dst_addresses': [{'subnet': {'ip_prefix': '10.1.1.0', 'ip_prefix_len': 24}}, - {'subnet': {'ip_prefix': '20.1.1.0', 'ip_prefix_len': 24}}], - 'dst_ports': [{'start_port': 0, 'end_port': -1}], - 'src_ports': [{'start_port': 0, 'end_port': -1}], - 'src_addresses': [{'security_group': 'local'}], - }, - {'direction': '<>', - 'protocol': 'tcp', - 'src_addresses': [{'subnet': {'ip_prefix': '10.1.1.0', 'ip_prefix_len': 24}}, - {'subnet': {'ip_prefix': '20.1.1.0', 'ip_prefix_len': 24}}], - 'src_ports': [{'start_port': 0, 'end_port': -1}], - 'dst_ports': [{'start_port': 0, 'end_port': -1}], - 'dst_addresses': [{'security_group': 'local'}], - }] - self.res.sg1_fix.replace_rules(rule) - - rule = [{'direction': '<>', - 'protocol': 'udp', - 'dst_addresses': [{'subnet': {'ip_prefix': '10.1.1.0', 'ip_prefix_len': 24}}, - {'subnet': {'ip_prefix': '20.1.1.0', 'ip_prefix_len': 24}}], - 'dst_ports': [{'start_port': 0, 'end_port': -1}], - 'src_ports': [{'start_port': 0, 'end_port': -1}], - 'src_addresses': [{'security_group': 'local'}], - }, - {'direction': '<>', - 'protocol': 'udp', - 'src_addresses': [{'subnet': {'ip_prefix': '10.1.1.0', 'ip_prefix_len': 24}}, - {'subnet': {'ip_prefix': '20.1.1.0', 'ip_prefix_len': 24}}], - 'src_ports': [{'start_port': 0, 'end_port': -1}], - 'dst_ports': [{'start_port': 0, 'end_port': -1}], - 'dst_addresses': [{'security_group': 'local'}], - }] - self.res.sg2_fix.replace_rules(rule) - - self.verify_sec_group_with_udp_and_policy_with_tcp() - return True - - @preposttest_wrapper - def test_sec_group_with_proto_and_policy_to_allow_only_tcp_ports(self): - """Verify security group with allow specific protocol on all ports and policy with allow only TCP on specifif ports between VN's""" - self.logger.info( - "Configure the policy with allow TCP port 8000/9000 only rule.") - rules = [ - { - 'direction': '<>', - 'protocol': 'tcp', - 'source_network': self.res.vn1_name, - 'src_ports': [8000, 8000], - 'dest_network': self.res.vn2_name, - 'dst_ports': [9000, 9000], - 'simple_action': 'pass', - }, - ] - self.config_policy_and_attach_to_vn(rules) - - rule = [{'direction': '<>', - 'protocol': 'tcp', - 'dst_addresses': [{'subnet': {'ip_prefix': '10.1.1.0', 'ip_prefix_len': 24}}, - {'subnet': {'ip_prefix': '20.1.1.0', 'ip_prefix_len': 24}}], - 'dst_ports': [{'start_port': 0, 'end_port': -1}], - 'src_ports': [{'start_port': 0, 'end_port': -1}], - 'src_addresses': [{'security_group': 'local'}], - }, - {'direction': '<>', - 'protocol': 'tcp', - 'src_addresses': [{'subnet': {'ip_prefix': '10.1.1.0', 'ip_prefix_len': 24}}, - {'subnet': {'ip_prefix': '20.1.1.0', 'ip_prefix_len': 24}}], - 'src_ports': [{'start_port': 0, 'end_port': -1}], - 'dst_ports': [{'start_port': 0, 'end_port': -1}], - 'dst_addresses': [{'security_group': 'local'}], - }] - self.res.sg1_fix.replace_rules(rule) - - rule = [{'direction': '<>', - 'protocol': 'udp', - 'dst_addresses': [{'subnet': {'ip_prefix': '10.1.1.0', 'ip_prefix_len': 24}}, - {'subnet': {'ip_prefix': '20.1.1.0', 'ip_prefix_len': 24}}], - 'dst_ports': [{'start_port': 0, 'end_port': -1}], - 'src_ports': [{'start_port': 0, 'end_port': -1}], - 'src_addresses': [{'security_group': 'local'}], - }, - {'direction': '<>', - 'protocol': 'udp', - 'src_addresses': [{'subnet': {'ip_prefix': '10.1.1.0', 'ip_prefix_len': 24}}, - {'subnet': {'ip_prefix': '20.1.1.0', 'ip_prefix_len': 24}}], - 'src_ports': [{'start_port': 0, 'end_port': -1}], - 'dst_ports': [{'start_port': 0, 'end_port': -1}], - 'dst_addresses': [{'security_group': 'local'}], - }] - self.res.sg2_fix.replace_rules(rule) - - self.verify_sec_group_with_udp_and_policy_with_tcp_port() - return True diff --git a/scripts/smgr/sanity.py b/scripts/smgr/sanity.py deleted file mode 100644 index 5f057287b..000000000 --- a/scripts/smgr/sanity.py +++ /dev/null @@ -1,15 +0,0 @@ -from securitygroup.sanity_base import SecurityGroupSanityTestsBase - - -class SecurityGroupSanityTests(SecurityGroupSanityTestsBase): - - def setUp(self): - super(SecurityGroupSanityTests, self).setUp() - - def cleanUp(self): - super(SecurityGroupSanityTests, self).cleanUp() - - # Any new testcases outside of SecurityGroupSanityTestsBase tests go here - -if __name__ == '__main__': - unittest.main() diff --git a/scripts/smgr/sanity_base.py b/scripts/smgr/sanity_base.py deleted file mode 100644 index 88b578f1b..000000000 --- a/scripts/smgr/sanity_base.py +++ /dev/null @@ -1,125 +0,0 @@ -import os -import unittest -import testtools - -from vnc_api.vnc_api import NoIdError - -from connections import ContrailConnections -from contrail_test_init import ContrailTestInit -from tcutils.wrappers import preposttest_wrapper - -from vn_test import VNFixture -from vm_test import VMFixture -from securitygroup.config import ConfigSecGroup - - -class SecurityGroupSanityTestsBase(testtools.TestCase, ConfigSecGroup): - - def setUp(self): - super(SecurityGroupSanityTestsBase, self).setUp() - if 'PARAMS_FILE' in os.environ: - self.ini_file = os.environ.get('PARAMS_FILE') - else: - self.ini_file = 'params.ini' - self.inputs = self.useFixture(ContrailTestInit(self.ini_file)) - self.connections = ContrailConnections(self.inputs) - self.quantum_fixture = self.connections.quantum_fixture - self.nova_fixture = self.connections.nova_fixture - self.vnc_lib = self.connections.vnc_lib - self.logger = self.inputs.logger - self.analytics_obj = self.connections.analytics_obj - - def cleanUp(self): - self.logger.info("Cleaning up Security group tests.") - super(SecurityGroupSanityTestsBase, self).cleanUp() - - @preposttest_wrapper - def test_sec_group_add_delete(self): - """Verify security group add delete - 1. Create custom security group with rule in it - 2. Delete custom security group - Pass criteria: Step 1 and 2 should pass - """ - rule = [{'direction': '>', - 'protocol': 'tcp', - 'dst_addresses': [{'subnet': {'ip_prefix': '10.1.1.0', 'ip_prefix_len': 24}}], - 'dst_ports': [{'start_port': 8000, 'end_port': 8000}], - 'src_ports': [{'start_port': 9000, 'end_port': 9000}], - 'src_addresses': [{'security_group': 'local'}], - }] - secgrp_fix = self.config_sec_group(name='test_sec_group', entries=rule) - self.delete_sec_group(secgrp_fix) - return True - - @preposttest_wrapper - def test_vm_with_sec_group(self): - """Verify attach dettach security group in VM - 1. Create VN with subnet - 2. Create security group with custom rules - 3. Launch VM in custom created security group and verify - 4. Remove secuity group association with VM - 5. Add back custom security group to VM and verify - 6. Try to delete security group with association to VM. It should fail. - Pass criteria: Step 2,3,4,5 and 6 should pass - """ - vn_name = "test_sec_vn" - vn_net = ['11.1.1.0/24'] - vn = self.useFixture(VNFixture( - project_name=self.inputs.project_name, connections=self.connections, - vn_name=vn_name, inputs=self.inputs, subnets=vn_net)) - assert vn.verify_on_setup() - - secgrp_name = 'test_sec_group' - rule = [{'direction': '>', - 'protocol': 'tcp', - 'dst_addresses': [{'subnet': {'ip_prefix': '10.1.1.0', 'ip_prefix_len': 24}}], - 'dst_ports': [{'start_port': 8000, 'end_port': 8000}], - 'src_ports': [{'start_port': 9000, 'end_port': 9000}], - 'src_addresses': [{'security_group': 'local'}], - }] - secgrp = self.config_sec_group(name=secgrp_name, entries=rule) - secgrp_id = secgrp.secgrp_fix._obj.uuid - vm_name = "test_sec_vm" - vm = self.useFixture(VMFixture( - project_name=self.inputs.project_name, connections=self.connections, - vn_obj=vn.obj, vm_name=vm_name, image_name='ubuntu-traffic', flavor='contrail_flavor_small', - sg_ids=[secgrp_id])) - assert vm.verify_on_setup() - assert vm.wait_till_vm_is_up() - result, msg = vm.verify_security_group(secgrp_name) - assert result, msg - - self.logger.info("Remove security group %s from VM %s", - secgrp_name, vm_name) - vm.remove_security_group(secgrp=secgrp_name) - result, msg = vm.verify_security_group(secgrp_name) - if result: - assert False, "Security group %s is not removed from VM %s" % (secgrp_name, - vm_name) - - import time - time.sleep(4) - vm.add_security_group(secgrp=secgrp_name) - result, msg = vm.verify_security_group(secgrp_name) - assert result, msg - - self.logger.info( - "Try deleting the security group %s with back ref.", secgrp_name) - try: - secgrp.secgrp_fix.cleanUp() - except Exception, msg: - self.logger.info(msg) - self.logger.info( - "Not able to delete the security group with back ref as expected") - else: - try: - secgroup = self.vnc_lib.security_group_read( - fq_name=secgrp.secgrp_fq_name) - self.logger.info( - "Not able to delete the security group with back ref as expected") - except NoIdError: - errmsg = "Security group deleted, when it is attached to a VM." - self.logger.error(errmsg) - assert False, errmsg - - return True diff --git a/scripts/smgr/setup.py b/scripts/smgr/setup.py deleted file mode 100644 index afff6fe01..000000000 --- a/scripts/smgr/setup.py +++ /dev/null @@ -1,179 +0,0 @@ -import os - -import fixtures -from testresources import TestResource - -from policy_test import PolicyFixture -from vn_test import MultipleVNFixture -from vm_test import MultipleVMFixture -from connections import ContrailConnections -from securitygroup.config import ConfigSecGroup -from contrail_test_init import ContrailTestInit - - -class SecurityGroupSetup(fixtures.Fixture, ConfigSecGroup): - - """Common resources required for the security group regression test suite. - """ - - def __init__(self, common_resource): - super(SecurityGroupSetup, self).__init__() - self.common_resource = common_resource - - def setUp(self): - super(SecurityGroupSetup, self).setUp() - if 'PARAMS_FILE' in os.environ: - self.ini_file = os.environ.get('PARAMS_FILE') - else: - self.ini_file = 'params.ini' - self.inputs = self.useFixture(ContrailTestInit(self.ini_file)) - self.connections = ContrailConnections(self.inputs) - self.quantum_fixture = self.connections.quantum_fixture - self.nova_fixture = self.connections.nova_fixture - self.vnc_lib = self.connections.vnc_lib - self.logger = self.inputs.logger - - self.logger.info("Configuring setup for security group tests.") - self.setup() - self.logger.info("Verifying setup of security group tests.") - self.verify() - self.logger.info( - "Finished configuring setup for security group tests.") - return self - - def setup(self): - """Config common resources.""" - vn_s = {'vn1': '20.1.1.0/24', 'vn2': ['10.1.1.0/24']} - self.multi_vn_fixture = self.useFixture(MultipleVNFixture( - connections=self.connections, inputs=self.inputs, subnet_count=2, - vn_name_net=vn_s, project_name=self.inputs.project_name)) - vns = self.multi_vn_fixture.get_all_fixture_obj() - (self.vn1_name, self.vn1_fix) = self.multi_vn_fixture._vn_fixtures[0] - (self.vn2_name, self.vn2_fix) = self.multi_vn_fixture._vn_fixtures[1] - - self.logger.info("Configure security groups required for test.") - self.config_sec_groups() - - self.multi_vm_fixture = self.useFixture(MultipleVMFixture( - project_name=self.inputs.project_name, connections=self.connections, - vm_count_per_vn=3, vn_objs=vns, image_name='ubuntu-traffic', - flavor='contrail_flavor_small')) - vms = self.multi_vm_fixture.get_all_fixture() - (self.vm1_name, self.vm1_fix) = vms[0] - (self.vm2_name, self.vm2_fix) = vms[1] - (self.vm3_name, self.vm3_fix) = vms[2] - (self.vm4_name, self.vm4_fix) = vms[3] - (self.vm5_name, self.vm5_fix) = vms[4] - (self.vm6_name, self.vm6_fix) = vms[5] - - self.logger.info("Adding the sec groups to the VM's") - self.vm1_fix.add_security_group(secgrp=self.sg1_name) - self.vm1_fix.add_security_group(secgrp=self.sg2_name) - self.vm2_fix.add_security_group(secgrp=self.sg2_name) - self.vm4_fix.add_security_group(secgrp=self.sg1_name) - self.vm4_fix.add_security_group(secgrp=self.sg2_name) - self.vm5_fix.add_security_group(secgrp=self.sg1_name) - - self.logger.info("Remove the default sec group form the VM's") - self.vm1_fix.remove_security_group(secgrp='default') - self.vm2_fix.remove_security_group(secgrp='default') - self.vm4_fix.remove_security_group(secgrp='default') - self.vm5_fix.remove_security_group(secgrp='default') - - def config_sec_groups(self): - self.sg1_name = 'test_tcp_sec_group' - rule = [{'direction': '<>', - 'protocol': 'tcp', - 'dst_addresses': [{'subnet': {'ip_prefix': '10.1.1.0', 'ip_prefix_len': 24}}, - {'subnet': {'ip_prefix': '20.1.1.0', 'ip_prefix_len': 24}}], - 'dst_ports': [{'start_port': 0, 'end_port': -1}], - 'src_ports': [{'start_port': 0, 'end_port': -1}], - 'src_addresses': [{'security_group': 'local'}], - }, - {'direction': '<>', - 'protocol': 'tcp', - 'src_addresses': [{'subnet': {'ip_prefix': '10.1.1.0', 'ip_prefix_len': 24}}, - {'subnet': {'ip_prefix': '20.1.1.0', 'ip_prefix_len': 24}}], - 'src_ports': [{'start_port': 0, 'end_port': -1}], - 'dst_ports': [{'start_port': 0, 'end_port': -1}], - 'dst_addresses': [{'security_group': 'local'}], - }] - - self.sg1_fix = self.config_sec_group(name=self.sg1_name, entries=rule) - - self.sg2_name = 'test_udp_sec_group' - rule = [{'direction': '<>', - 'protocol': 'udp', - 'dst_addresses': [{'subnet': {'ip_prefix': '10.1.1.0', 'ip_prefix_len': 24}}, - {'subnet': {'ip_prefix': '20.1.1.0', 'ip_prefix_len': 24}}], - 'dst_ports': [{'start_port': 0, 'end_port': -1}], - 'src_ports': [{'start_port': 0, 'end_port': -1}], - 'src_addresses': [{'security_group': 'local'}], - }, - {'direction': '<>', - 'protocol': 'udp', - 'src_addresses': [{'subnet': {'ip_prefix': '10.1.1.0', 'ip_prefix_len': 24}}, - {'subnet': {'ip_prefix': '20.1.1.0', 'ip_prefix_len': 24}}], - 'src_ports': [{'start_port': 0, 'end_port': -1}], - 'dst_ports': [{'start_port': 0, 'end_port': -1}], - 'dst_addresses': [{'security_group': 'local'}], - }] - self.sg2_fix = self.config_sec_group(name=self.sg2_name, entries=rule) - - def verify(self): - """verfiy common resources.""" - self.logger.debug("Verify the configured VN's.") - assert self.multi_vn_fixture.verify_on_setup() - - self.logger.debug("Verify the configured VM's.") - assert self.multi_vm_fixture.verify_on_setup() - - self.logger.info("Installing traffic package in VM.") - self.vm1_fix.install_pkg("Traffic") - self.vm2_fix.install_pkg("Traffic") - self.vm3_fix.install_pkg("Traffic") - self.vm4_fix.install_pkg("Traffic") - self.vm5_fix.install_pkg("Traffic") - self.vm6_fix.install_pkg("Traffic") - - self.logger.debug("Verify the configured security groups.") - result, msg = self.sg1_fix.verify_on_setup() - assert result, msg - result, msg = self.sg2_fix.verify_on_setup() - assert result, msg - - self.logger.debug("Verify the attached security groups in the VM.") - result, msg = self.vm1_fix.verify_security_group(self.sg1_name) - assert result, msg - result, msg = self.vm1_fix.verify_security_group(self.sg2_name) - assert result, msg - result, msg = self.vm2_fix.verify_security_group(self.sg2_name) - assert result, msg - result, msg = self.vm4_fix.verify_security_group(self.sg1_name) - assert result, msg - result, msg = self.vm4_fix.verify_security_group(self.sg2_name) - assert result, msg - result, msg = self.vm5_fix.verify_security_group(self.sg2_name) - assert result, msg - - def tearDown(self): - self.logger.info("Tearing down resources of security group tests") - super(SecurityGroupSetup, self).cleanUp() - - def dirtied(self): - self.common_resource.dirtied(self) - - -class _SecurityGroupSetupResource(TestResource): - - def make(self, dependencyresource): - base_setup = SecurityGroupSetup(self) - base_setup.setUp() - return base_setup - - def clean(self, base_setup): - base_setup.logger.info( - "Cleaning up security group test resources here") - base_setup.tearDown() - -SecurityGroupSetupResource = _SecurityGroupSetupResource() diff --git a/scripts/smgr/smgr_sanity.py b/scripts/smgr/smgr_sanity.py deleted file mode 100644 index 37afb2000..000000000 --- a/scripts/smgr/smgr_sanity.py +++ /dev/null @@ -1,282 +0,0 @@ -import os -import fixtures -import testtools -import unittest - -from testresources import ResourcedTestCase - -from connections import ContrailConnections -from securitygroup.config import ConfigSecGroup -from tcutils.wrappers import preposttest_wrapper -from securitygroup.setup import SecurityGroupSetupResource -from verify import VerifySecGroup - - -class SmgrRegressionTests(testtools.TestCase, ResourcedTestCase, - fixtures.TestWithFixtures, - ConfigSecGroup, VerifySecGroup): - - resources = [('base_setup', SecurityGroupSetupResource)] - - def __init__(self, *args, **kwargs): - testtools.TestCase.__init__(self, *args, **kwargs) - self.res = SecurityGroupSetupResource.getResource() - self.inputs = self.res.inputs - self.connections = self.res.connections - self.logger = self.inputs.logger - self.nova_fixture = self.res.nova_fixture - self.analytics_obj = self.connections.analytics_obj - self.vnc_lib = self.connections.vnc_lib - self.quantum_fixture = self.connections.quantum_fixture - - def __del__(self): - self.logger.debug("Unconfig the common resurces.") - SecurityGroupSetupResource.finishedWith(self.res) - - def setUp(self): - super(SecurityGroupRegressionTests, self).setUp() - if 'PARAMS_FILE' in os.environ: - self.ini_file = os.environ.get('PARAMS_FILE') - else: - self.ini_file = 'params.ini' - - def tearDown(self): - self.logger.debug("Tearing down SecurityGroupRegressionTests.") - super(SecurityGroupRegressionTests, self).tearDown() - SecurityGroupSetupResource.finishedWith(self.res) - - def runTest(self): - pass - - def config_policy_and_attach_to_vn(self, rules): - policy_name = "sec_grp_policy" - policy_fix = self.config_policy(policy_name, rules) - assert policy_fix.verify_on_setup() - policy_vn1_attach_fix = self.attach_policy_to_vn( - policy_fix, self.res.vn1_fix) - policy_vn2_attach_fix = self.attach_policy_to_vn( - policy_fix, self.res.vn2_fix) - - @preposttest_wrapper - def test_sec_group_with_proto(self): - """Verify security group with allow specific protocol on all ports and policy with allow all between VN's""" - self.logger.info("Configure the policy with allow any") - rules = [ - { - 'direction': '<>', - 'protocol': 'any', - 'source_network': self.res.vn1_name, - 'src_ports': [0, -1], - 'dest_network': self.res.vn2_name, - 'dst_ports': [0, -1], - 'simple_action': 'pass', - }, - ] - self.config_policy_and_attach_to_vn(rules) - rule = [{'direction': '<>', - 'protocol': 'tcp', - 'dst_addresses': [{'subnet': {'ip_prefix': '10.1.1.0', 'ip_prefix_len': 24}}, - {'subnet': {'ip_prefix': '20.1.1.0', 'ip_prefix_len': 24}}], - 'dst_ports': [{'start_port': 0, 'end_port': -1}], - 'src_ports': [{'start_port': 0, 'end_port': -1}], - 'src_addresses': [{'security_group': 'local'}], - }, - {'direction': '<>', - 'protocol': 'tcp', - 'src_addresses': [{'subnet': {'ip_prefix': '10.1.1.0', 'ip_prefix_len': 24}}, - {'subnet': {'ip_prefix': '20.1.1.0', 'ip_prefix_len': 24}}], - 'src_ports': [{'start_port': 0, 'end_port': -1}], - 'dst_ports': [{'start_port': 0, 'end_port': -1}], - 'dst_addresses': [{'security_group': 'local'}], - }] - self.res.sg1_fix.replace_rules(rule) - - rule = [{'direction': '<>', - 'protocol': 'udp', - 'dst_addresses': [{'subnet': {'ip_prefix': '10.1.1.0', 'ip_prefix_len': 24}}, - {'subnet': {'ip_prefix': '20.1.1.0', 'ip_prefix_len': 24}}], - 'dst_ports': [{'start_port': 0, 'end_port': -1}], - 'src_ports': [{'start_port': 0, 'end_port': -1}], - 'src_addresses': [{'security_group': 'local'}], - }, - {'direction': '<>', - 'protocol': 'udp', - 'src_addresses': [{'subnet': {'ip_prefix': '10.1.1.0', 'ip_prefix_len': 24}}, - {'subnet': {'ip_prefix': '20.1.1.0', 'ip_prefix_len': 24}}], - 'src_ports': [{'start_port': 0, 'end_port': -1}], - 'dst_ports': [{'start_port': 0, 'end_port': -1}], - 'dst_addresses': [{'security_group': 'local'}], - }] - self.res.sg2_fix.replace_rules(rule) - - self.verify_sec_group_port_proto() - return True - - @preposttest_wrapper - def test_sec_group_with_port(self): - """Verify security group with allow specific protocol/port and policy with allow all between VN's""" - self.logger.info("Configure the policy with allow any") - rules = [ - { - 'direction': '<>', - 'protocol': 'any', - 'source_network': self.res.vn1_name, - 'src_ports': [0, -1], - 'dest_network': self.res.vn2_name, - 'dst_ports': [0, -1], - 'simple_action': 'pass', - }, - ] - self.config_policy_and_attach_to_vn(rules) - - rule = [{'direction': '<>', - 'protocol': 'tcp', - 'dst_addresses': [{'subnet': {'ip_prefix': '10.1.1.0', 'ip_prefix_len': 24}}, - {'subnet': {'ip_prefix': '20.1.1.0', 'ip_prefix_len': 24}}], - 'dst_ports': [{'start_port': 8000, 'end_port': 9000}], - 'src_ports': [{'start_port': 8000, 'end_port': 9000}], - 'src_addresses': [{'security_group': 'local'}], - }, - {'direction': '<>', - 'protocol': 'tcp', - 'src_addresses': [{'subnet': {'ip_prefix': '10.1.1.0', 'ip_prefix_len': 24}}, - {'subnet': {'ip_prefix': '20.1.1.0', 'ip_prefix_len': 24}}], - 'src_ports': [{'start_port': 8000, 'end_port': 9000}], - 'dst_ports': [{'start_port': 8000, 'end_port': 9000}], - 'dst_addresses': [{'security_group': 'local'}], - }] - self.res.sg1_fix.replace_rules(rule) - - rule = [{'direction': '<>', - 'protocol': 'udp', - 'dst_addresses': [{'subnet': {'ip_prefix': '10.1.1.0', 'ip_prefix_len': 24}}, - {'subnet': {'ip_prefix': '20.1.1.0', 'ip_prefix_len': 24}}], - 'dst_ports': [{'start_port': 8000, 'end_port': 9000}], - 'src_ports': [{'start_port': 8000, 'end_port': 9000}], - 'src_addresses': [{'security_group': 'local'}], - }, - {'direction': '<>', - 'protocol': 'udp', - 'src_addresses': [{'subnet': {'ip_prefix': '10.1.1.0', 'ip_prefix_len': 24}}, - {'subnet': {'ip_prefix': '20.1.1.0', 'ip_prefix_len': 24}}], - 'src_ports': [{'start_port': 8000, 'end_port': 9000}], - 'dst_ports': [{'start_port': 8000, 'end_port': 9000}], - 'dst_addresses': [{'security_group': 'local'}], - }] - self.res.sg2_fix.replace_rules(rule) - - self.verify_sec_group_port_proto(port_test=True) - return True - - @preposttest_wrapper - def test_sec_group_with_proto_and_policy_to_allow_only_tcp(self): - """Verify security group with allow specific protocol on all ports and policy with allow only TCP between VN's""" - self.logger.info("Configure the policy with allow TCP only rule.") - rules = [ - { - 'direction': '<>', - 'protocol': 'tcp', - 'source_network': self.res.vn1_name, - 'src_ports': [0, -1], - 'dest_network': self.res.vn2_name, - 'dst_ports': [0, -1], - 'simple_action': 'pass', - }, - ] - self.config_policy_and_attach_to_vn(rules) - - rule = [{'direction': '<>', - 'protocol': 'tcp', - 'dst_addresses': [{'subnet': {'ip_prefix': '10.1.1.0', 'ip_prefix_len': 24}}, - {'subnet': {'ip_prefix': '20.1.1.0', 'ip_prefix_len': 24}}], - 'dst_ports': [{'start_port': 0, 'end_port': -1}], - 'src_ports': [{'start_port': 0, 'end_port': -1}], - 'src_addresses': [{'security_group': 'local'}], - }, - {'direction': '<>', - 'protocol': 'tcp', - 'src_addresses': [{'subnet': {'ip_prefix': '10.1.1.0', 'ip_prefix_len': 24}}, - {'subnet': {'ip_prefix': '20.1.1.0', 'ip_prefix_len': 24}}], - 'src_ports': [{'start_port': 0, 'end_port': -1}], - 'dst_ports': [{'start_port': 0, 'end_port': -1}], - 'dst_addresses': [{'security_group': 'local'}], - }] - self.res.sg1_fix.replace_rules(rule) - - rule = [{'direction': '<>', - 'protocol': 'udp', - 'dst_addresses': [{'subnet': {'ip_prefix': '10.1.1.0', 'ip_prefix_len': 24}}, - {'subnet': {'ip_prefix': '20.1.1.0', 'ip_prefix_len': 24}}], - 'dst_ports': [{'start_port': 0, 'end_port': -1}], - 'src_ports': [{'start_port': 0, 'end_port': -1}], - 'src_addresses': [{'security_group': 'local'}], - }, - {'direction': '<>', - 'protocol': 'udp', - 'src_addresses': [{'subnet': {'ip_prefix': '10.1.1.0', 'ip_prefix_len': 24}}, - {'subnet': {'ip_prefix': '20.1.1.0', 'ip_prefix_len': 24}}], - 'src_ports': [{'start_port': 0, 'end_port': -1}], - 'dst_ports': [{'start_port': 0, 'end_port': -1}], - 'dst_addresses': [{'security_group': 'local'}], - }] - self.res.sg2_fix.replace_rules(rule) - - self.verify_sec_group_with_udp_and_policy_with_tcp() - return True - - @preposttest_wrapper - def test_sec_group_with_proto_and_policy_to_allow_only_tcp_ports(self): - """Verify security group with allow specific protocol on all ports and policy with allow only TCP on specifif ports between VN's""" - self.logger.info( - "Configure the policy with allow TCP port 8000/9000 only rule.") - rules = [ - { - 'direction': '<>', - 'protocol': 'tcp', - 'source_network': self.res.vn1_name, - 'src_ports': [8000, 8000], - 'dest_network': self.res.vn2_name, - 'dst_ports': [9000, 9000], - 'simple_action': 'pass', - }, - ] - self.config_policy_and_attach_to_vn(rules) - - rule = [{'direction': '<>', - 'protocol': 'tcp', - 'dst_addresses': [{'subnet': {'ip_prefix': '10.1.1.0', 'ip_prefix_len': 24}}, - {'subnet': {'ip_prefix': '20.1.1.0', 'ip_prefix_len': 24}}], - 'dst_ports': [{'start_port': 0, 'end_port': -1}], - 'src_ports': [{'start_port': 0, 'end_port': -1}], - 'src_addresses': [{'security_group': 'local'}], - }, - {'direction': '<>', - 'protocol': 'tcp', - 'src_addresses': [{'subnet': {'ip_prefix': '10.1.1.0', 'ip_prefix_len': 24}}, - {'subnet': {'ip_prefix': '20.1.1.0', 'ip_prefix_len': 24}}], - 'src_ports': [{'start_port': 0, 'end_port': -1}], - 'dst_ports': [{'start_port': 0, 'end_port': -1}], - 'dst_addresses': [{'security_group': 'local'}], - }] - self.res.sg1_fix.replace_rules(rule) - - rule = [{'direction': '<>', - 'protocol': 'udp', - 'dst_addresses': [{'subnet': {'ip_prefix': '10.1.1.0', 'ip_prefix_len': 24}}, - {'subnet': {'ip_prefix': '20.1.1.0', 'ip_prefix_len': 24}}], - 'dst_ports': [{'start_port': 0, 'end_port': -1}], - 'src_ports': [{'start_port': 0, 'end_port': -1}], - 'src_addresses': [{'security_group': 'local'}], - }, - {'direction': '<>', - 'protocol': 'udp', - 'src_addresses': [{'subnet': {'ip_prefix': '10.1.1.0', 'ip_prefix_len': 24}}, - {'subnet': {'ip_prefix': '20.1.1.0', 'ip_prefix_len': 24}}], - 'src_ports': [{'start_port': 0, 'end_port': -1}], - 'dst_ports': [{'start_port': 0, 'end_port': -1}], - 'dst_addresses': [{'security_group': 'local'}], - }] - self.res.sg2_fix.replace_rules(rule) - - self.verify_sec_group_with_udp_and_policy_with_tcp_port() - return True diff --git a/scripts/smgr/smgr_tests.py b/scripts/smgr/smgr_tests.py deleted file mode 100644 index 786ff79af..000000000 --- a/scripts/smgr/smgr_tests.py +++ /dev/null @@ -1,55 +0,0 @@ -# Need to import path to test/fixtures and test/scripts/ -# Ex : export PYTHONPATH='$PATH:/root/test/fixtures/:/root/test/scripts/' -# -# To run tests, you can do 'python sanity_tests.py'. To run specific tests, -# You can do 'python -m testtools.run -l tests' -# Set the env variable PARAMS_FILE to point to your ini file. Else it will try to pick params.ini in PWD -# Set the env variable SINGLE_NODE_IP if you are running a single node(No -# need to populate the json file) - -import os -import unittest -from upgrade import * -from util import get_os_env -from tcutils.contrailtestrunner import ContrailHTMLTestRunner - - -if __name__ == "__main__": - - if not get_os_env('SCRIPT_TS'): - os.environ['SCRIPT_TS'] = time.strftime("%Y_%m_%d_%H_%M_%S") - if 'PARAMS_FILE' in os.environ: - ini_file = os.environ.get('PARAMS_FILE') - else: - ini_file = 'params.ini' - inputs = ContrailTestInit(ini_file) - inputs.setUp() - print "\nTest Log File : %s" % (inputs.log_file) - suite = unittest.TestSuite() - test_result = unittest.TestResult() - suite.addTest(Upgrade('test_fiptraffic_before_upgrade')) - suite.addTest(Smgr('test_smgr')) - suite.addTest(Upgrade('test_traffic_after_upgrade')) - descr = inputs.get_html_description() - - if inputs.generate_html_report: - buf = open(inputs.html_report, 'w') - - runner = ContrailHTMLTestRunner( - stream=buf, - title='%s Result %s' % ( - inputs.log_scenario, inputs.build_id), - description=descr - ) - test_result = runner.run(suite) - buf.close() - print "Test HTML Result : %s " % (inputs.html_report) - inputs.upload_results() - file_to_send = inputs.html_report - else: - test_result = unittest.TextTestRunner(verbosity=2).run(suite) - file_to_send = inputs.log_file - - inputs.log_any_issues(test_result) - inputs.send_mail(file_to_send) - print "\nTest Log File : %s" % (inputs.log_file) diff --git a/scripts/smgr/tests_with_setup_base_webui.py b/scripts/smgr/tests_with_setup_base_webui.py deleted file mode 100644 index 7fa3af67e..000000000 --- a/scripts/smgr/tests_with_setup_base_webui.py +++ /dev/null @@ -1,236 +0,0 @@ -# Need to import path to test/fixtures and test/scripts/ -# Ex : export PYTHONPATH='$PATH:/root/test/fixtures/:/root/test/scripts/' -# -# To run tests, you can do 'python -m testtools.run tests'. To run specific tests, -# You can do 'python -m testtools.run -l tests' -# Set the env variable PARAMS_FILE to point to your ini file. Else it will try to pick params.ini in PWD -# -import os -import fixtures -import testtools - -from contrail_test_init import * -from vn_test import * -from vm_test import * -from connections import ContrailConnections -from floating_ip import * -from policy_test import * -from contrail_fixtures import * -from tcutils.wrappers import preposttest_wrapper -from testresources import ResourcedTestCase -from webui_sanity_resource import SolnSetupResource -from selenium import webdriver -from pyvirtualdisplay import Display -from selenium.webdriver.common.keys import Keys -import time -import random -from webui_test import * -from selenium.webdriver.support.ui import WebDriverWait - - -class WebuiTestSanity(testtools.TestCase, ResourcedTestCase, fixtures.TestWithFixtures): - - resources = [('base_setup', SolnSetupResource)] - - def __init__(self, *args, **kwargs): - testtools.TestCase.__init__(self, *args, **kwargs) - self.res = SolnSetupResource.getResource() - self.inputs = self.res.inputs - self.connections = self.res.connections - self.logger = self.res.logger - self.nova_fixture = self.res.nova_fixture - self.analytics_obj = self.connections.analytics_obj - self.vnc_lib = self.connections.vnc_lib - self.quantum_fixture = self.connections.quantum_fixture - self.cn_inspect = self.connections.cn_inspect - if self.inputs.webui_verification_flag: - self.browser = self.connections.browser - self.browser_openstack = self.connections.browser_openstack - self.delay = 10 - self.webui = WebuiTest(self.connections, self.inputs) - self.webui_common = WebuiCommon(self.webui) - - def __del__(self): - print "Deleting test_with_setup now" - SolnSetupResource.finishedWith(self.res) - - def setUp(self): - super(WebuiTestSanity, self).setUp() - if 'PARAMS_FILE' in os.environ: - self.ini_file = os.environ.get('PARAMS_FILE') - else: - self.ini_file = 'params.ini' - - def tearDown(self): - print "Tearing down test" - super(WebuiTestSanity, self).tearDown() - SolnSetupResource.finishedWith(self.res) - - def runTest(self): - pass - # end runTest - - @preposttest_wrapper - def test_control_node_basic_details_in_webui_monitor_infra_control_nodes(self): - '''Test to validate control node basic view details in webui monitor tab - ''' - assert self.webui.verify_bgp_routers_ops_basic_data() - return True - # end - # test_verify_control_node_basic_details_in_webui_monitor_infra_control_nodes - - @preposttest_wrapper - def test_control_node_advance_details_in_webui_monitor_infra_control_nodes(self): - '''Test to validate control node basic view details in webui monitor tab - ''' - assert self.webui.verify_bgp_routers_ops_advance_data() - return True - # end - # test_verify_control_node_advance_details_in_webui_monitor_infra_control_nodes - - @preposttest_wrapper - def test_vrouter_basic_details_in_webui_monitor_infra_virtual_routers(self): - '''Test to validate vrouter basic view details in webui monitor tab - ''' - assert self.webui.verify_vrouter_ops_basic_data() - return True - # end - # test_verify_vrouter_basic_details_in_webui_monitor_infra_virtual_routers - - @preposttest_wrapper - def test_vrouter_advance_details_in_webui_monitor_infra_virtual_routers(self): - '''Test to validate vrouter advance view details in webui monitor tab - ''' - assert self.webui.verify_vrouter_ops_advance_data() - return True - # end - # test_verify_vrouter_node_advance_details_in_webui_monitor_infra_virtual_nodes - - @preposttest_wrapper - def test_analytics_node_basic_details_in_webui_monitor_infra_analytics_nodes(self): - '''Test to validate analytics node basic view details in webui monitor tab - ''' - assert self.webui.verify_analytics_nodes_ops_basic_data() - return True - # end - # test_verify_analytics_basic_details_in_webui_monitor_infra_analytics_nodes - - @preposttest_wrapper - def test_analytics_node_advance_details_in_webui_monitor_infra_analytics_nodes(self): - '''Test to validate analytics node advance view details in webui monitor tab - ''' - assert self.webui.verify_analytics_nodes_ops_advance_data() - return True - # end - # test_verify_analytics_node_advance_details_in_webui_monitor_infra_analytics_nodes - - @preposttest_wrapper - def test_config_node_basic_details_in_webui_monitor_infra_config_nodes(self): - '''Test to validate config node advance view details in webui monitor - ''' - assert self.webui.verify_config_nodes_ops_basic_data() - return True - # end - # test_verify_config_node_basic_details_in_webui_monitor_infra_config_nodes - - @preposttest_wrapper - def test_config_node_advance_details_in_webui_monitor_infra_config_nodes(self): - '''Test to validate config node advance view details in webui monitor tab - ''' - assert self.webui.verify_config_nodes_ops_advance_data() - return True - # end - # test_verify_config_node_advance_details_in_webui_monitor_infra_config_nodes - - @preposttest_wrapper - def test_network_basic_details_in_webui_monitor_networking_networks(self): - '''Test to validate network basic view details in webui monitor - ''' - assert self.webui.verify_vn_ops_basic_data() - return True - # end - # test_verify_networks_basic_details_in_webui_monitor_networking_networks - - @preposttest_wrapper - def test_network_advance_details_in_webui_monitor_networking_networks(self): - '''Test to validate network advance view details in webui monitor tab - ''' - assert self.webui.verify_vn_ops_advance_data() - return True - # end - # test_verify_networks_advance_details_in_webui_monitor_networking_networks - - @preposttest_wrapper - def test_dashboard_details_in_webui_monitor_infra_dashborad(self): - '''Test to validate dashboard details details in webui monitor tab - ''' - assert self.webui.verify_dashboard_details() - return True - # end test_dashboard_details_in_webui_monitor_infra_dashborad - - @preposttest_wrapper - def test_instance_basic_details_in_webui_monitor_networking_networks(self): - '''Test to validate instace basic view details in webui monitor tab - ''' - assert self.webui.verify_vm_ops_basic_data() - return True - # end - # test_verify_instance_basic_details_in_webui_monitor_networking_networks - - @preposttest_wrapper - def test_instance_advance_details_in_webui_monitor_networking_networks(self): - '''Test to validate instance advance view details in webui monitor tab - ''' - assert self.webui.verify_vm_ops_advance_data() - return True - # end - # test_verify_instance_advance_details_in_webui_monitor_networking_networks - - @preposttest_wrapper - def test_floating_ips_in_webui_config_networking_manage_floating_ips(self): - '''Test to validate networks in webui config tab - ''' - assert self.webui.verify_floating_ip_api_data() - return True - # end test_floating_ips_in_webui_config_networking_manage_floating_ips - - @preposttest_wrapper - def test_networks_in_webui_config_networking_networks(self): - '''Test to validate networks in webui config tab - ''' - assert self.webui.verify_vn_api_data() - return True - # end test_verify_networks_in_webui_config_networking_networks - - @preposttest_wrapper - def test_ipam_in_webui_config_networking_ip_address_management(self): - '''Test to validate ipam in webui config networking ip address management - ''' - assert self.webui.verify_ipam_api_data() - return True - # end verify_ipam_api_basic_data_in_webui - - @preposttest_wrapper - def test_policy_in_webui_config_networking_policies(self): - '''Test to validate policies in webui config networking policies - ''' - assert self.webui.verify_policy_api_data() - return True - # end verify_policies_api_basic_data_in_webui - - @preposttest_wrapper - def test_service_templates_in_webui_config_services_service_templates(self): - '''Test to validate service templates in webui config services service templates - ''' - assert self.webui.verify_service_template_api_basic_data() - return True - # end test_service_templates_in_webui_config_services_service_templates - - @preposttest_wrapper - def test_service_instance_in_webui_config_services_service_instance(self): - '''Test to validate service instance in webui config services service instance - ''' - assert self.webui.verify_service_instance_api_basic_data() - return True - # end test_service_instance_in_webui_config_services_service_instance -# end WebuiTestSanity diff --git a/scripts/smgr/upgrade_test.py b/scripts/smgr/upgrade_test.py deleted file mode 100755 index 73d4c5555..000000000 --- a/scripts/smgr/upgrade_test.py +++ /dev/null @@ -1,55 +0,0 @@ -# Need to import path to test/fixtures and test/scripts/ -# Ex : export PYTHONPATH='$PATH:/root/test/fixtures/:/root/test/scripts/' -# -# To run tests, you can do 'python sanity_tests.py'. To run specific tests, -# You can do 'python -m testtools.run -l tests' -# Set the env variable PARAMS_FILE to point to your ini file. Else it will try to pick params.ini in PWD -# Set the env variable SINGLE_NODE_IP if you are running a single node(No -# need to populate the json file) - -import os -import unittest -from upgrade import * -from util import get_os_env -from tcutils.contrailtestrunner import ContrailHTMLTestRunner - - -if __name__ == "__main__": - - if not get_os_env('SCRIPT_TS'): - os.environ['SCRIPT_TS'] = time.strftime("%Y_%m_%d_%H_%M_%S") - if 'PARAMS_FILE' in os.environ: - ini_file = os.environ.get('PARAMS_FILE') - else: - ini_file = 'params.ini' - inputs = ContrailTestInit(ini_file) - inputs.setUp() - print "\nTest Log File : %s" % (inputs.log_file) - suite = unittest.TestSuite() - test_result = unittest.TestResult() - suite.addTest(Upgrade('test_fiptraffic_before_upgrade')) - suite.addTest(Upgrade('test_upgrade')) - suite.addTest(Upgrade('test_traffic_after_upgrade')) - descr = inputs.get_html_description() - - if inputs.generate_html_report: - buf = open(inputs.html_report, 'w') - - runner = ContrailHTMLTestRunner( - stream=buf, - title='%s Result %s' % ( - inputs.log_scenario, inputs.build_id), - description=descr - ) - test_result = runner.run(suite) - buf.close() - print "Test HTML Result : %s " % (inputs.html_report) - inputs.upload_results() - file_to_send = inputs.html_report - else: - test_result = unittest.TextTestRunner(verbosity=2).run(suite) - file_to_send = inputs.log_file - - inputs.log_any_issues(test_result) - inputs.send_mail(file_to_send) - print "\nTest Log File : %s" % (inputs.log_file) diff --git a/scripts/smgr/verify.py b/scripts/smgr/verify.py deleted file mode 100644 index 4488f0945..000000000 --- a/scripts/smgr/verify.py +++ /dev/null @@ -1,338 +0,0 @@ -import os -import sys -from time import sleep - -from util import retry -sys.path.append(os.path.realpath('tcutils/pkgs/Traffic')) -from traffic.core.stream import Stream -from traffic.core.helpers import Host, Sender, Receiver -from traffic.core.profile import StandardProfile, ContinuousProfile - - -class VerifySecGroup(): - - def verify_traffic(self, sender_vm, receiver_vm, proto, sport, dport, count=None, fip=None): - # Create stream and profile - if fip: - stream = Stream( - protocol="ip", sport=sport, dport=dport, proto=proto, src=sender_vm.vm_ip, - dst=fip) - else: - stream = Stream( - protocol="ip", sport=sport, dport=dport, proto=proto, src=sender_vm.vm_ip, - dst=receiver_vm.vm_ip) - profile_kwargs = {'stream': stream} - if fip: - profile_kwargs.update({'listener': receiver_vm.vm_ip}) - if count: - profile_kwargs.update({'count': count}) - profile = StandardProfile(**profile_kwargs) - else: - profile = ContinuousProfile(**profile_kwargs) - - # Set VM credentials - send_node = Host(sender_vm.vm_node_ip, - self.inputs.username, self.inputs.password) - recv_node = Host(receiver_vm.vm_node_ip, - self.inputs.username, self.inputs.password) - send_host = Host(sender_vm.local_ip, - sender_vm.vm_username, sender_vm.vm_password) - recv_host = Host(receiver_vm.local_ip, - receiver_vm.vm_username, receiver_vm.vm_password) - - # Create send, receive helpers - sender = Sender("send%s" % - proto, profile, send_node, send_host, self.inputs.logger) - receiver = Receiver("recv%s" % - proto, profile, recv_node, recv_host, self.inputs.logger) - - # start traffic - receiver.start() - sender.start() - sleep(5) - - # stop traffic - sender.stop() - receiver.stop() - self.logger.info("Sent: %s; Received: %s", sender.sent, receiver.recv) - return (sender.sent, receiver.recv) - - def assert_traffic(self, sender, receiver, proto, sport, dport, - expectation='pass'): - self.logger.info("Sending %s traffic from %s with %s to %s with %s" % - (proto, sender[0].vm_name, sender[1], receiver[0].vm_name, receiver[1])) - sent, recv = self.verify_traffic(sender[0], receiver[0], - proto, sport, dport) - if expectation == 'pass': - msg = "%s traffic from %s with %s to %s with %s passed " % (proto, - sender[0].vm_name, sender[1], receiver[0].vm_name, receiver[1]) - errmsg = "%s traffic from %s with %s to %s with %s Failed " % (proto, - sender[0].vm_name, sender[1], receiver[0].vm_name, receiver[1]) - if (sent and recv == sent): - self.logger.info(msg) - return (True, msg) - else: - self.logger.error(errmsg) - if self.inputs.stop_on_fail: - self.logger.info( - "Sub test failed; Stopping test for debugging.") - import pdb - pdb.set_trace() - return (False, errmsg) - - elif expectation == 'fail': - msg = "%s traffic from %s with %s to %s with %s "\ - "failed as expected" % (proto, sender[0].vm_name, sender[1], - receiver[0].vm_name, receiver[1]) - errmsg = "%s traffic from %s with %s to %s with %s "\ - "passed; Expcted to fail " % (proto, sender[0].vm_name, sender[1], - receiver[0].vm_name, receiver[1]) - if (recv == 0): - self.logger.info(msg) - return (True, msg) - else: - self.logger.error(errmsg) - if self.inputs.stop_on_fail: - self.logger.info( - "Sub test failed; Stopping test for debugging.") - import pdb - pdb.set_trace() - return (False, errmsg) - - def verify_sec_group_port_proto(self, port_test=False): - results = [] - self.logger.info("Verifcations with UDP traffic") - sender = (self.res.vm1_fix, self.res.sg2_fix.secgrp_name) - receiver = (self.res.vm2_fix, self.res.sg2_fix.secgrp_name) - results.append( - self.assert_traffic(sender, receiver, 'udp', 8000, 9000, 'pass')) - if port_test: - results.append( - self.assert_traffic(sender, receiver, 'udp', 8010, 9010, 'fail')) - - sender = (self.res.vm1_fix, self.res.sg2_fix.secgrp_name) - receiver = (self.res.vm3_fix, 'default') - results.append( - self.assert_traffic(sender, receiver, 'udp', 8000, 9000, 'fail')) - if port_test: - results.append( - self.assert_traffic(sender, receiver, 'udp', 8010, 9010, 'fail')) - - sender = (self.res.vm1_fix, self.res.sg2_fix.secgrp_name) - receiver = (self.res.vm4_fix, self.res.sg2_fix.secgrp_name) - results.append( - self.assert_traffic(sender, receiver, 'udp', 8000, 9000, 'pass')) - if port_test: - results.append( - self.assert_traffic(sender, receiver, 'udp', 8010, 9010, 'fail')) - - sender = (self.res.vm1_fix, self.res.sg2_fix.secgrp_name) - receiver = (self.res.vm5_fix, self.res.sg1_fix.secgrp_name) - results.append( - self.assert_traffic(sender, receiver, 'udp', 8000, 9000, 'fail')) - if port_test: - results.append( - self.assert_traffic(sender, receiver, 'udp', 8010, 9010, 'fail')) - - sender = (self.res.vm1_fix, self.res.sg2_fix.secgrp_name) - receiver = (self.res.vm6_fix, 'default') - results.append( - self.assert_traffic(sender, receiver, 'udp', 8000, 9000, 'fail')) - if port_test: - results.append( - self.assert_traffic(sender, receiver, 'udp', 8010, 9010, 'fail')) - - self.logger.info("Verifcations with TCP traffic") - sender = (self.res.vm1_fix, self.res.sg1_fix.secgrp_name) - receiver = (self.res.vm2_fix, self.res.sg2_fix.secgrp_name) - results.append( - self.assert_traffic(sender, receiver, 'tcp', 8000, 9000, 'fail')) - if port_test: - results.append( - self.assert_traffic(sender, receiver, 'tcp', 8010, 9010, 'fail')) - - sender = (self.res.vm1_fix, self.res.sg1_fix.secgrp_name) - receiver = (self.res.vm3_fix, 'default') - results.append( - self.assert_traffic(sender, receiver, 'tcp', 8000, 9000, 'fail')) - if port_test: - results.append( - self.assert_traffic(sender, receiver, 'tcp', 8010, 9010, 'fail')) - - sender = (self.res.vm1_fix, self.res.sg1_fix.secgrp_name) - receiver = (self.res.vm4_fix, self.res.sg1_fix.secgrp_name) - results.append( - self.assert_traffic(sender, receiver, 'tcp', 8000, 9000, 'pass')) - if port_test: - results.append( - self.assert_traffic(sender, receiver, 'tcp', 8010, 9010, 'fail')) - - sender = (self.res.vm1_fix, self.res.sg1_fix.secgrp_name) - receiver = (self.res.vm5_fix, self.res.sg1_fix.secgrp_name) - results.append( - self.assert_traffic(sender, receiver, 'tcp', 8000, 9000, 'pass')) - if port_test: - results.append( - self.assert_traffic(sender, receiver, 'tcp', 8010, 9010, 'fail')) - - sender = (self.res.vm1_fix, self.res.sg1_fix.secgrp_name) - receiver = (self.res.vm6_fix, 'default') - results.append( - self.assert_traffic(sender, receiver, 'tcp', 8000, 9000, 'fail')) - if port_test: - results.append( - self.assert_traffic(sender, receiver, 'tcp', 8010, 9010, 'fail')) - - errmsg = '' - for (rc, msg) in results: - if rc: - self.logger.debug(msg) - else: - errmsg += msg + '\n' - if errmsg: - assert False, errmsg - - def verify_sec_group_with_udp_and_policy_with_tcp(self): - results = [] - self.logger.info("Verifcations with TCP traffic") - sender = (self.res.vm1_fix, self.res.sg1_fix.secgrp_name) - receiver = (self.res.vm2_fix, self.res.sg2_fix.secgrp_name) - results.append( - self.assert_traffic(sender, receiver, 'tcp', 8000, 9000, 'fail')) - - sender = (self.res.vm1_fix, self.res.sg1_fix.secgrp_name) - receiver = (self.res.vm3_fix, 'default') - results.append( - self.assert_traffic(sender, receiver, 'tcp', 8000, 9000, 'fail')) - - sender = (self.res.vm1_fix, self.res.sg1_fix.secgrp_name) - receiver = (self.res.vm4_fix, self.res.sg1_fix.secgrp_name) - results.append( - self.assert_traffic(sender, receiver, 'tcp', 8000, 9000, 'pass')) - - sender = (self.res.vm1_fix, self.res.sg1_fix.secgrp_name) - receiver = (self.res.vm5_fix, self.res.sg1_fix.secgrp_name) - results.append( - self.assert_traffic(sender, receiver, 'tcp', 8000, 9000, 'pass')) - - sender = (self.res.vm1_fix, self.res.sg1_fix.secgrp_name) - receiver = (self.res.vm6_fix, 'default') - results.append( - self.assert_traffic(sender, receiver, 'tcp', 8000, 9000, 'fail')) - - self.logger.info("Verifcations with UDP traffic") - sender = (self.res.vm1_fix, self.res.sg2_fix.secgrp_name) - receiver = (self.res.vm2_fix, self.res.sg2_fix.secgrp_name) - results.append( - self.assert_traffic(sender, receiver, 'udp', 8000, 9000, 'pass')) - - sender = (self.res.vm1_fix, self.res.sg2_fix.secgrp_name) - receiver = (self.res.vm3_fix, 'default') - results.append( - self.assert_traffic(sender, receiver, 'udp', 8000, 9000, 'fail')) - - sender = (self.res.vm1_fix, self.res.sg2_fix.secgrp_name) - receiver = (self.res.vm4_fix, self.res.sg2_fix.secgrp_name) - results.append( - self.assert_traffic(sender, receiver, 'udp', 8000, 9000, 'fail')) - - sender = (self.res.vm1_fix, self.res.sg2_fix.secgrp_name) - receiver = (self.res.vm5_fix, self.res.sg1_fix.secgrp_name) - results.append( - self.assert_traffic(sender, receiver, 'udp', 8000, 9000, 'fail')) - - sender = (self.res.vm1_fix, self.res.sg2_fix.secgrp_name) - receiver = (self.res.vm6_fix, 'default') - results.append( - self.assert_traffic(sender, receiver, 'udp', 8000, 9000, 'fail')) - - errmsg = '' - for (rc, msg) in results: - if rc: - self.logger.debug(msg) - else: - errmsg += msg + '\n' - if errmsg: - assert False, errmsg - - def verify_sec_group_with_udp_and_policy_with_tcp_port(self): - results = [] - self.logger.info("Verifcations with TCP traffic") - sender = (self.res.vm1_fix, self.res.sg1_fix.secgrp_name) - receiver = (self.res.vm2_fix, self.res.sg2_fix.secgrp_name) - results.append( - self.assert_traffic(sender, receiver, 'tcp', 8000, 9000, 'fail')) - results.append( - self.assert_traffic(sender, receiver, 'tcp', 8010, 9000, 'fail')) - - sender = (self.res.vm1_fix, self.res.sg1_fix.secgrp_name) - receiver = (self.res.vm3_fix, 'default') - results.append( - self.assert_traffic(sender, receiver, 'tcp', 8000, 9000, 'fail')) - results.append( - self.assert_traffic(sender, receiver, 'tcp', 8010, 9010, 'fail')) - - sender = (self.res.vm1_fix, self.res.sg1_fix.secgrp_name) - receiver = (self.res.vm4_fix, self.res.sg1_fix.secgrp_name) - results.append( - self.assert_traffic(sender, receiver, 'tcp', 8000, 9000, 'pass')) - results.append( - self.assert_traffic(sender, receiver, 'tcp', 8000, 9010, 'fail')) - - sender = (self.res.vm1_fix, self.res.sg1_fix.secgrp_name) - receiver = (self.res.vm5_fix, self.res.sg1_fix.secgrp_name) - results.append( - self.assert_traffic(sender, receiver, 'tcp', 8000, 9000, 'pass')) - results.append( - self.assert_traffic(sender, receiver, 'tcp', 8010, 9000, 'fail')) - sender = (self.res.vm1_fix, self.res.sg1_fix.secgrp_name) - receiver = (self.res.vm6_fix, 'default') - results.append( - self.assert_traffic(sender, receiver, 'tcp', 8000, 9000, 'fail')) - results.append( - self.assert_traffic(sender, receiver, 'tcp', 8010, 9000, 'fail')) - - self.logger.info("Verifcations with UDP traffic") - sender = (self.res.vm1_fix, self.res.sg2_fix.secgrp_name) - receiver = (self.res.vm2_fix, self.res.sg2_fix.secgrp_name) - results.append( - self.assert_traffic(sender, receiver, 'udp', 8000, 9000, 'pass')) - results.append( - self.assert_traffic(sender, receiver, 'udp', 8010, 9000, 'pass')) - - sender = (self.res.vm1_fix, self.res.sg2_fix.secgrp_name) - receiver = (self.res.vm3_fix, 'default') - results.append( - self.assert_traffic(sender, receiver, 'udp', 8000, 9000, 'fail')) - results.append( - self.assert_traffic(sender, receiver, 'udp', 8010, 9000, 'fail')) - - sender = (self.res.vm1_fix, self.res.sg2_fix.secgrp_name) - receiver = (self.res.vm4_fix, self.res.sg2_fix.secgrp_name) - results.append( - self.assert_traffic(sender, receiver, 'udp', 8000, 9000, 'fail')) - results.append( - self.assert_traffic(sender, receiver, 'udp', 8010, 9000, 'fail')) - - sender = (self.res.vm1_fix, self.res.sg2_fix.secgrp_name) - receiver = (self.res.vm5_fix, self.res.sg1_fix.secgrp_name) - results.append( - self.assert_traffic(sender, receiver, 'udp', 8000, 9000, 'fail')) - results.append( - self.assert_traffic(sender, receiver, 'udp', 8010, 9000, 'fail')) - - sender = (self.res.vm1_fix, self.res.sg2_fix.secgrp_name) - receiver = (self.res.vm6_fix, 'default') - results.append( - self.assert_traffic(sender, receiver, 'udp', 8000, 9000, 'fail')) - results.append( - self.assert_traffic(sender, receiver, 'udp', 8010, 9000, 'fail')) - - errmsg = '' - for (rc, msg) in results: - if rc: - self.logger.debug(msg) - else: - errmsg += msg + '\n' - if errmsg: - assert False, errmsg diff --git a/scripts/smgr/webui_sanity_resource.py b/scripts/smgr/webui_sanity_resource.py deleted file mode 100644 index d88bdc709..000000000 --- a/scripts/smgr/webui_sanity_resource.py +++ /dev/null @@ -1,70 +0,0 @@ -import fixtures -import testtools -import os -import uuid -from connections import ContrailConnections -from contrail_test_init import * -from vn_test import * -from vm_test import * -from quantum_test import * -from vnc_api_test import * -from nova_test import * -from testresources import OptimisingTestSuite, TestResource -import time -from sdn_topo_setup import * -from webui_topology import * - - -class SolnSetup(fixtures.Fixture): - - def __init__(self, test_resource): - super(SolnSetup, self).__init__() - self.test_resource = test_resource - - def setUp(self): - super(SolnSetup, self).setUp() - if 'PARAMS_FILE' in os.environ: - self.ini_file = os.environ.get('PARAMS_FILE') - else: - self.ini_file = 'params.ini' - self.inputs = self.useFixture(ContrailTestInit(self.ini_file)) - self.connections = ContrailConnections(self.inputs) - self.quantum_fixture = self.connections.quantum_fixture - self.nova_fixture = self.connections.nova_fixture - self.vnc_lib = self.connections.vnc_lib - self.logger = self.inputs.logger - self.setup_common_objects() - return self - # end setUp - - def setup_common_objects(self): - time.sleep(5) - topo_obj = sdn_webui_config() - setup_obj = self.useFixture( - sdnTopoSetupFixture(self.connections, topo_obj)) - out = setup_obj.topo_setup(skip_verify='yes') - # end setup_webui_objects - - def tearDown(self): - print "Tearing down resources" - super(SolnSetup, self).cleanUp() - - def dirtied(self): - self.test_resource.dirtied(self) - - -class _SolnSetupResource(TestResource): - - def make(self, dependencyresource): - base_setup = SolnSetup(self) - base_setup.setUp() - return base_setup - # end make - - def clean(self, base_setup): - print "Am cleaning up here" -# super(_SolnSetupResource,self).clean() - base_setup.tearDown() - # end - -SolnSetupResource = _SolnSetupResource() diff --git a/scripts/smgr/webui_topology.py b/scripts/smgr/webui_topology.py deleted file mode 100644 index 5a842f5be..000000000 --- a/scripts/smgr/webui_topology.py +++ /dev/null @@ -1,94 +0,0 @@ -'''*******AUTO-GENERATED TOPOLOGY*********''' - - -class sdn_webui_config (): - - def __init__(self, domain='default-domain', project='admin', username=None, password=None): - # - # Domain and project defaults: Do not change until support for - # non-default is tested! - self.domain = domain - self.project = project - self.username = username - self.password = password - # - # Define VN's in the project: - self.vnet_list = ['vnet0', 'vnet1', - 'vnet2', 'vnet3', 'left_vn', 'right_vn'] - # - # Define network info for each VN: - self.vn_nets = { - 'left_vn': ['31.1.1.0/24'], 'right_vn': ['41.2.2.0/24'], 'vnet0': ['10.1.1.0/30', '11.1.1.0/30'], - 'vnet1': ['12.1.1.0/30', '13.1.1.0/30'], 'vnet2': ['14.1.1.0/30', '15.1.1.0/30'], 'vnet3': ['16.1.1.0/30', '17.1.1.0/30']} - # - # Define network policies - self.policy_list = ['allow_tcp', 'policy0', - 'policy1', 'policy2', 'policy3'] - self.vn_policy = {'left_vn': ['allow_tcp'], 'right_vn': ['allow_tcp'], 'vnet0': ['policy0', 'policy1'], 'vnet1': [ - 'policy2', 'policy3'], 'vnet2': ['policy2', 'policy3'], 'vnet3': ['policy2', 'policy3']} - # - # Define ipams ## - self.vn_ipams = {'vnet1': 'ipam1', 'vnet2': 'ipam2', 'vnet3': 'ipam3'} - # - # define service templates ## - self.st_list = ['tcp_svc_template'] - self.st_params = {'tcp_svc_template': {'svc_img_name': 'vsrx-bridge', 'svc_type': 'firewall', 'if_list': - [['management', False, False], ['left', False, False], ['right', False, False]], 'svc_mode': 'transparent', 'svc_scaling': False, 'flavor': 'm1.medium', 'ordered_interfaces': True}} - - # define service instance - self.si_list = ['svcinst1'] - self.si_params = { - 'svcinst1': {'if_list': [['management', False, False], ['left', False, False], - ['right', False, False]], 'svc_template': 'tcp_svc_template', 'left_vn': None, 'right_vn': None}} - # Define VM's - # VM distribution on available compute nodes is handled by nova - # scheduler or contrail vm naming scheme - self.vn_of_vm = {'left_vm': 'left_vn', - 'right_vm': 'right_vn', 'vmc0': 'vnet0'} - # - # Define VN to VM mappings for each of the floating ip pools to be - # created. - self.fvn_vm_map = {'vnet3': ['vmc0']} - # Define network policy rules - self.rules = {} - - self.rules[ - 'allow_tcp'] = [{'direction': '<>', 'protocol': 'tcp', 'dest_network': 'right_vn', - 'source_network': 'left_vn', 'dst_ports': [9000, 9001], 'simple_action': 'pass', 'src_ports': [8000, 8001]}] - - self.rules['policy0'] = [{'direction': '>', 'protocol': 'any', 'dest_network': 'vnet0', 'source_network': 'vnet0', 'dst_ports': 'any', 'simple_action': 'deny', 'src_ports': [4, 5]}, {'direction': '>', 'protocol': 'any', 'dest_network': 'vnet0', 'source_network': 'vnet0', 'dst_ports': 'any', 'simple_action': 'deny', 'src_ports': [ - 1, 2]}, {'direction': '>', 'protocol': 'any', 'dest_network': 'vnet0', 'source_network': 'vnet0', 'dst_ports': 'any', 'simple_action': 'deny', 'src_ports': [2, 3]}, {'direction': '>', 'protocol': 'any', 'dest_network': 'vnet0', 'source_network': 'vnet0', 'dst_ports': 'any', 'simple_action': 'deny', 'src_ports': [3, 4]}] - - self.rules['policy1'] = [{'direction': '>', 'protocol': 'any', 'dest_network': 'vnet0', 'source_network': 'vnet0', 'dst_ports': 'any', 'simple_action': 'deny', 'src_ports': [4, 5]}, {'direction': '>', 'protocol': 'any', 'dest_network': 'vnet0', 'source_network': 'vnet0', 'dst_ports': 'any', 'simple_action': 'deny', 'src_ports': [ - 1, 2]}, {'direction': '>', 'protocol': 'any', 'dest_network': 'vnet0', 'source_network': 'vnet0', 'dst_ports': 'any', 'simple_action': 'deny', 'src_ports': [2, 3]}, {'direction': '>', 'protocol': 'any', 'dest_network': 'vnet0', 'source_network': 'vnet0', 'dst_ports': 'any', 'simple_action': 'deny', 'src_ports': [3, 4]}] - - self.rules['policy2'] = [{'direction': '>', 'protocol': 'udp', 'dest_network': 'vnet1', 'source_network': 'vnet1', 'dst_ports': 'any', 'simple_action': 'deny', 'src_ports': [4, 5]}, {'direction': '>', 'protocol': 'udp', 'dest_network': 'vnet1', 'source_network': 'vnet1', 'dst_ports': 'any', 'simple_action': 'deny', 'src_ports': [ - 1, 2]}, {'direction': '>', 'protocol': 'udp', 'dest_network': 'vnet1', 'source_network': 'vnet1', 'dst_ports': 'any', 'simple_action': 'deny', 'src_ports': [2, 3]}, {'direction': '>', 'protocol': 'udp', 'dest_network': 'vnet1', 'source_network': 'vnet1', 'dst_ports': 'any', 'simple_action': 'deny', 'src_ports': [3, 4]}] - - self.rules['policy3'] = [{'direction': '>', 'protocol': 'icmp', 'dest_network': 'vnet1', 'source_network': 'vnet1', 'dst_ports': 'any', 'simple_action': 'deny', 'src_ports': [4, 5]}, {'direction': '>', 'protocol': 'icmp', 'dest_network': 'vnet1', 'source_network': 'vnet1', 'dst_ports': 'any', 'simple_action': 'deny', 'src_ports': [ - 1, 2]}, {'direction': '>', 'protocol': 'icmp', 'dest_network': 'vnet1', 'source_network': 'vnet1', 'dst_ports': 'any', 'simple_action': 'deny', 'src_ports': [2, 3]}, {'direction': '>', 'protocol': 'icmp', 'dest_network': 'vnet1', 'source_network': 'vnet1', 'dst_ports': 'any', 'simple_action': 'deny', 'src_ports': [3, 4]}] - - - # end __init__ - -if __name__ == '__main__': - print "Currently topology limited to one domain/project.." - print "Based on need, can be extended to cover config for multiple domain/projects" - print "Running unit test for this module ..." - my_topo = sdn_webui_config(domain='default-domain', project='admin') - x = my_topo.__dict__ - print "\nprinting keys of topology dict:" - for key, value in x.iteritems(): - print key - print - # print "keys & values:" - # for key, value in x.iteritems(): print key, "-->", value - # Use topology_helper to extend/derive data from user-defined topology to help verifications. - # ex. get list of all vm's from topology; get list of vn's associated to a - # policy - import topo_helper - topo_h = topo_helper.topology_helper(my_topo) - #vmc_list= topo_h.get_vmc_list() - policy_vn = topo_h.get_policy_vn() - print "printing derived topo data - vn's associated to a policy: \n", policy_vn -# From 9ccc96265492feb8ed419207da8a2baa822da999 Mon Sep 17 00:00:00 2001 From: Rishi Verma Date: Fri, 25 Jul 2014 19:56:31 +0530 Subject: [PATCH 03/15] fixture server manager --- fixtures/smgr_test_fixture.py | 614 ++++++++++++++++++++++++++++++++++ 1 file changed, 614 insertions(+) create mode 100644 fixtures/smgr_test_fixture.py diff --git a/fixtures/smgr_test_fixture.py b/fixtures/smgr_test_fixture.py new file mode 100644 index 000000000..1121a11ce --- /dev/null +++ b/fixtures/smgr_test_fixture.py @@ -0,0 +1,614 @@ +import fixtures +from contrail_fixtures import * +import sys +import pdb +import json +import string +import textwrap +import tempfile +import os +import re +import fabric +import ConfigParser +import argparse +import sys +import fabfile.testbeds.testbed as testbed +from datetime import datetime as dt +from fabric.api import settings, run +from fabric.api import hosts, run, task +from fabric.api import local, put, get +from fabric.tasks import execute +from os.path import expanduser +import imp + + + +class SmgrFixture(fixtures.Fixture): + + ''' Fixture to bring up a vns cluster using server manager . + + ''' + + def __init__(self, connections, inputs, smgr_config_ini="./smgr_input.ini", test_local=False): + self.connections = connections + self.inputs = inputs + self.smgr_config_ini = smgr_config_ini + self.test_local = test_local + self.params = read_ini_file(smgr_config_ini) + self.svrmgr = self.params['svrmgr'] + # end __init__ + + def svrmgr_add_all(self): + self.create_json() + self.add_vns() + self.add_image() + self.add_pkg() + self.add_server() + + + def create_json(self): + self.modify_server_json() + self.modify_vns_json() + + def modify_server_json(self): + params=self.params + if not params: + return None + if not params.has_key('server_file'): + return None + server_file = params['server_file'] + + timestamp = dt.now().strftime("%Y_%m_%d_%H_%M_%S") + local('cp %s %s.org.%s' %(server_file, server_file, timestamp)) + + in_file = open( server_file, 'r' ) + in_data = in_file.read() + server_dict = json.loads(in_data) + + self.update_roles_from_testbed_py(server_dict) + self.update_bond_from_testbed_py(server_dict) + self.update_multi_if_from_testbed_py(server_dict) + + out_file = open(server_file, 'w') + out_data = json.dumps(server_dict, indent=4) + out_file.write(out_data) + out_file.close() + + return server_dict + + def update_roles_from_testbed_py(self, server_dict): + if not testbed.env.has_key('roledefs'): + return server_dict + for node in server_dict['server']: + roles = [] + for key in testbed.env.roledefs: + if key == 'all' or key == 'build' : + continue + for host_string in testbed.env.roledefs[key]: + ip = getIp(host_string) + if node['ip'] == ip: + if key == 'cfgm': + roles.append("config") + else: + roles.append(key) + if not len(roles): + node['roles'] = [ "compute" ] + else: + node['roles'] = roles + + for node in server_dict['server']: + node['vns_id'] = get_pref_vns_id() + + return server_dict +# end update_roles_from_testbed_py + + def update_bond_from_testbed_py(self, server_dict): + + if 'control_data' in dir(testbed): + + for node in server_dict['server']: + for key in testbed.bond: + ip = getIp(key) + if node['ip'] == ip: + node['server_params']['setup_interface'] = "Yes" + node['server_params']['compute_non_mgmt_ip'] = "" + node['server_params']['compute_non_mgmt_gw'] = "" + + name = testbed.bond[key]['name'] + mode = testbed.bond[key]['mode'] + member = testbed.bond[key]['member'] + option = {} + option['miimon'] = '100' + option['mode'] = mode + option['xmit_hash_policy'] = 'layer3+4' + + node['bond']={} + node['bond'][name]={} + node['bond'][name]['bond_options'] = "%s"%option + node['bond'][name]['member'] = "%s"%member + + return server_dict +#End update_bond_from_testbed_py(server_dict): + + def update_multi_if_from_testbed_py(self, server_dict): + + if 'control_data' in dir(testbed): + + for node in server_dict['server']: + for key in testbed.control_data: + ip = getIp(key) + if node['ip'] == ip: + node['server_params']['setup_interface'] = "Yes" + node['server_params']['compute_non_mgmt_ip'] = "" + node['server_params']['compute_non_mgmt_gway'] = "" + + ip = testbed.control_data[key]['ip'] + gw = testbed.control_data[key]['gw'] + device = testbed.control_data[key]['device'] + + node['control']={} + node['control'][device] = {} + node['control'][device]['ip'] = ip + node['control'][device]['gw'] = gw + + return server_dict + +#End update_multi_if_from_testbed_py(server_dict): + + + def get_image_id(self) : + params=self.params + image_file = params['image_file'] + + image_file = open( image_file, 'r' ) + image_data = image_file.read() + image_json = json.loads(image_data) + image_id = image_json['image'][0]['image_id'] + image_file.close() + return image_id +# end get_image_id() + + def get_pkg_id(self) : + params=self.params + pkg_file = params['pkg_file'] + + pkg_file = open( pkg_file, 'r' ) + pkg_data = pkg_file.read() + pkg_json = json.loads(pkg_data) + pkg_id = pkg_json['image'][0]['image_id'] + pkg_file.close() + return pkg_id +# end get_pkg_id() + + def get_vns_id(self) : + vns_id = None + params=self.params + vns_file = params['vns_file'] + + vns_file = open( vns_file, 'r' ) + vns_data = vns_file.read() + vns_json = json.loads(vns_data) + vns_id = vns_json['vns'][0]['vns_id'] + if params.has_key('vns_id'): + vns_id = params['vns_id'] + vns_file.close() + return vns_id + +# end get_vns_id() + + + def add_vns(self): + vns_file = None + params=self.params + if params.has_key('vns_file'): + vns_file = params['vns_file'] + + vns_id = self.get_pref_vns_id() + if not vns_file: + vns_dict = self.get_vns_with_vns_id_from_db() + if not len(vns_dict['vns']): + vns_dict = new_vns() + else: + vns_dict = { + "vns" : [ + { + "vns_id" : "", + "vns_params" : { + + } + } + ] + } + + vns_dict['vns'][0]['vns_id'] = vns_id + self.modify_vns_from_testbed_py(vns_dict) + temp_dir= expanduser("~") + vns_file = '%s/vns.json' %temp_dir + local('touch %s' %vns_file) + out_file = open(vns_file, 'w') + out_data = json.dumps(vns_dict, indent=4) + + out_file.write(out_data) + out_file.close() + else : + timestamp = dt.now().strftime("%Y_%m_%d_%H_%M_%S") + local('cp %s %s.org.%s' %(vns_file, vns_file, timestamp)) + local("sed -i 's/\"vns_id\".*,/\"vns_id\":\"%s\",/' %s" %(vns_id,vns_file)) + local("sed -i 's/\"vns_id\".*/\"vns_id\":\"%s\"/' %s" %(vns_id,vns_file)) + + if self.test_local: + local('server-manager add vns -f %s' %(vns_file)) + else: + #svrmgr = get_svrmgr() + svrmgr = self.svrmgr + with settings(host_string=svrmgr, warn_only=True): + file_name = os.path.basename(vns_file) + temp_dir= tempfile.mkdtemp() + run('mkdir -p %s' % temp_dir) + put(vns_file, '%s/%s' % (temp_dir, file_name)) + + run('server-manager add vns -f %s/%s' %(temp_dir, file_name) ) + run('server-manager show all | python -m json.tool') + + +# end add_vns() + + def add_server(self): + self.add_server_using_json() + self.update_server_in_db_with_testbed_py() + + def add_image(self): + params=self.params + if not params: + return None + if not params.has_key('image_file'): + return None + image_file = params['image_file'] + + if self.test_local: + local('server-manager add image -f %s' %(image_file)) + local('server-manager show all') + else: + svrmgr = self.svrmgr + with settings(host_string=svrmgr, warn_only=True): + file_name = os.path.basename(image_file) + temp_dir = tempfile.mkdtemp() + run('mkdir -p %s' % temp_dir) + put(image_file, '%s/%s' % (temp_dir, file_name)) + + run('server-manager add image -f %s/%s' %(temp_dir, file_name) ) + run('server-manager show all | python -m json.tool') + + def add_pkg(self): + params=self.params + if not params: + return None + if not params.has_key('pkg_file'): + return None + pkg_file = params['pkg_file'] + + if self.test_local: + local('server-manager add image -f %s' %(pkg_file)) + local('server-manager show image ') + else: + svrmgr = self.svrmgr + with settings(host_string=svrmgr, warn_only=True): + file_name = os.path.basename(pkg_file) + temp_dir= tempfile.mkdtemp() + run('mkdir -p %s' % temp_dir) + put(pkg_file, '%s/%s' % (temp_dir, file_name)) + + run('server-manager add image -f %s/%s' %(temp_dir, file_name) ) + run('server-manager show all | python -m json.tool') + + def add_server_using_json(self): + params=self.params + if not params: + return None + + if not params.has_key('server_file'): + return None + server_file = params['server_file'] + + if self.test_local: + local('server-manager add server -f %s' %(server_file)) + local('server-manager show server') + else: + svrmgr = self.svrmgr + with settings(host_string=svrmgr, warn_only=True): + file_name = os.path.basename(server_file) + temp_dir= tempfile.mkdtemp() + run('mkdir -p %s' % temp_dir) + put(server_file, '%s/%s' % (temp_dir, file_name)) + run('server-manager add server -f %s/%s' %(temp_dir, file_name) ) + run('server-manager show all | python -m json.tool') + + + def modify_vns_json(self): + params=self.params + if not params: + return None + if not params.has_key('vns_file'): + return None + vns_file = params['vns_file'] + + timestamp = dt.now().strftime("%Y_%m_%d_%H_%M_%S") + local('cp %s %s.org.%s' %(vns_file, vns_file, timestamp)) + + in_file = open( vns_file, 'r' ) + in_data = in_file.read() + vns_dict = json.loads(in_data) + + self.modify_vns_from_testbed_py(vns_dict) + + out_file = open(vns_file, 'w') + out_data = json.dumps(vns_dict, indent=4) + out_file.write(out_data) + out_file.close() + + + def modify_vns_from_testbed_py(self, vns_dict): + if testbed.env.has_key('mail_to'): + vns_dict['vns'][0]['email'] = testbed.env.mail_to + if testbed.env.has_key('encap_priority'): + vns_dict['vns'][0]['vns_params']['encap_priority'] = testbed.env.encap_priority + if 'multi_tenancy' in dir(testbed): + vns_dict['vns'][0]['vns_params']['multi_tenancy'] = testbed.multi_tenancy + if 'os_username' in dir(testbed): + vns_dict['vns'][0]['vns_params']['ks_user'] = testbed.os_username + if 'os_password' in dir(testbed): + vns_dict['vns'][0]['vns_params']['ks_passwd'] = testbed.os_password + if 'os_tenant_name' in dir(testbed): + vns_dict['vns'][0]['vns_params']['ks_tenant'] = testbed.os_tenant_name + if 'router_asn' in dir(testbed): + vns_dict['vns'][0]['vns_params']['router_asn'] = testbed.router_asn + + + def new_vns(self): + params=self.params + vns_id = params['vns_id'] + vns_dict = { + "vns" : [ + { + "vns_id" : vns_id, + "vns_params" : { + "router_asn": "64512", + "database_dir": "/home/cassandra", + "db_initial_token": "", + "openstack_mgmt_ip": "", + "use_certs": "False", + "multi_tenancy": "False", + "encap_priority": "'MPLSoUDP','MPLSoGRE','VXLAN'", + "service_token": "contrail123", + "ks_user": "admin", + "ks_passwd": "contrail123", + "ks_tenant": "admin", + "openstack_passwd": "contrail123", + "analytics_data_ttl": "168", + "mask": "255.255.255.0", + "gway": "1.1.1.254", + "passwd": "c0ntrail123", + "domain": "contrail.juniper.net", + "haproxy": "disable" + } + } + ] + } + return vns_dict + + + + # End new_vns() + + + def read_ini_file(self, config_ini): + try: + config = ConfigParser.SafeConfigParser() + config.read([config_ini]) + smgr_config = dict(config.items("SERVER-MANAGER")) + return smgr_config + except: + sys.exit("Error reading config file %s" %config_ini) + + return smgr_config + + # End read_ini_file + + + def get_server_with_vns_id_from_db(self): + vns_id = self.get_pref_vns_id() + + temp_dir= expanduser("~") + file_name = '%s/server_with_vns_id_from_db.json' %(temp_dir) + + if self.test_local: + local('server-manager show --detail server --vns_id %s \ + | tr -d "\n" \ + | sed "s/[^{]*//" \ + > %s' %(vns_id, file_name)) + + else: + svrmgr = self.params + with settings(host_string=svrmgr, warn_only=True): + temp_dir= tempfile.mkdtemp() + run('mkdir -p %s' % temp_dir) + file_name = '%s/server_list.json' %(temp_dir) + + run('server-manager show --detail server --vns_id %s \ + | tr -d "\n" \ + | sed \'s/[^{]*//\' \ + | python -m json.tool \ + > %s' %(vns_id, file_name) ) + + local('mkdir -p %s' % temp_dir) + get( file_name, file_name ) + + in_file = open( file_name, 'r' ) + in_data = in_file.read() + server_dict = json.loads(in_data) + return server_dict + + def get_vns_with_vns_id_from_db(self): + params=self.params + vns_id = params['vns_id'] + + vns_dict = {"vns": []} + + temp_dir= expanduser("~") + + file_name = '%s/vns.json' %(temp_dir) + + if self.test_local: + local('server-manager show --detail vns --vns_id %s \ + | tr -d "\n" \ + | sed "s/[^{]*//" \ + > %s' %(vns_id, file_name)) + else: + svrmgr = self.svrmgr + with settings(host_string=svrmgr, warn_only=True): + temp_dir= tempfile.mkdtemp() + run('mkdir -p %s' % temp_dir) + file_name = '%s/vns.json' %(temp_dir) + run('server-manager show --detail vns --vns_id %s \ + | tr -d "\n" \ + | sed \'s/[^{]*//\' \ + | python -m json.tool \ + > %s' %(vns_id, file_name) ) + local('mkdir -p %s' % temp_dir) + get( file_name, file_name ) + + in_file = open( file_name, 'r' ) + in_data = in_file.read() + + vns_dict = json.loads(in_data) + return vns_dict + + + def get_server_with_ip_from_db(self, ip=None): + params=self.params + + server_dict={} + if not ip: + print "Please provide an ip as input arg" + return ip + + temp_dir= expanduser("~") + + file_name = '%s/server.json' %(temp_dir) + + if self.test_local: + local('server-manager show --detail server --ip %s \ + | tr -d "\n" \ + | sed "s/[^{]*//" \ + > %s' %(ip, file_name)) + else: + svrmgr = self.svrmgr + with settings(host_string=svrmgr, warn_only=True): + temp_dir= tempfile.mkdtemp() + run('mkdir -p %s' % temp_dir) + file_name = '%s/server.json' %(temp_dir) + run('server-manager show --detail server --ip %s \ + | tr -d "\n" \ + | sed \'s/[^{]*//\' \ + | python -m json.tool \ + > %s' %(ip, file_name) ) + local('mkdir -p %s' % temp_dir) + get( file_name, file_name ) + + in_file = open( file_name, 'r' ) + in_data = in_file.read() + server_dict = json.loads(in_data) + return server_dict + + def get_host_roles_from_testbed_py(self): + node = {} + if not testbed.env.has_key('roledefs'): + return node + for key in testbed.env.roledefs: + if key == 'all' or key == 'build': + continue + for host_string in testbed.env.roledefs[key]: + ip = getIp(host_string) + if not node.has_key(ip): + node[ip] = [] + if key == 'cfgm': + node[ip].append('config') + else: + node[ip].append(key) + return node + # end get_host_roles_from_testbed_py + + def update_server_in_db_with_testbed_py(self): + vns_id = self.get_pref_vns_id() + node = self.get_host_roles_from_testbed_py() + if not node: + return + u_server_dict = {} + u_server_dict['server'] = [] + for key in node: + server_dict = {} + server_dict = get_server_with_ip_from_db(key) + if not server_dict or not server_dict['server']: + print ("ERROR: Server with ip %s not present in Server Manager" % key) + continue + server_id = server_dict['server'][0]['server_id'] + u_server = {} + u_server['server_id'] = server_id + u_server['vns_id'] = vns_id + u_server['roles'] = node[key] + u_server_dict['server'].append(u_server) + + temp_dir= expanduser("~") + server_file = '%s/server.json' %temp_dir + local('touch %s' %server_file) + out_file = open(server_file, 'w') + out_data = json.dumps(u_server_dict, indent=4) + out_file.write(out_data) + out_file.close() + + if self.test_local: + local('server-manager add server -f %s' %(server_file) ) + for u_server in u_server_dict['server']: + local('server-manager show --detail server --server_id %s' \ + % u_server['server_id'] ) + else: + svrmgr = self.svrmgr + with settings(host_string=svrmgr, warn_only=True): + file_name = os.path.basename(server_file) + temp_dir= tempfile.mkdtemp() + run('mkdir -p %s' % temp_dir) + put(server_file, '%s/%s' % (temp_dir, file_name)) + run('server-manager add server -f %s/%s' %(temp_dir, file_name) ) + run('server-manager show --detail server --server_id %s | python -m json.tool' %server_id) + + #End update_server_in_db_with_vns_id + + + def get_pref_vns_id(self): + vns_id = None + params=read_ini_file(config_ini) + if params.has_key('vns_id'): + vns_id = params['vns_id'] + else: + vns_id = get_vns_id() + + return vns_id + + def get_svrmgr(self): + svrmgr = None + params=self.params + if params.has_key('svrmgr'): + svrmgr = params['svrmgr'] + return params['svrmgr'] + + def get_server_file(self): + params=self.params + if not params: + return None + if not params.has_key('server_file'): + return None + server_file = params['server_file'] + return server_file + + +# end SmgrFixture From a721f657ab01548a9e71101ae6bba31b4db4d0a5 Mon Sep 17 00:00:00 2001 From: Rishi Verma Date: Wed, 30 Jul 2014 12:46:01 +0530 Subject: [PATCH 04/15] verify roles --- fixtures/smgr_common.py | 655 ++++++++++++++++++++++++++++++++++++++++ 1 file changed, 655 insertions(+) create mode 100644 fixtures/smgr_common.py diff --git a/fixtures/smgr_common.py b/fixtures/smgr_common.py new file mode 100644 index 000000000..4da4d368a --- /dev/null +++ b/fixtures/smgr_common.py @@ -0,0 +1,655 @@ +import fixtures +from contrail_fixtures import * +import sys +import pdb +import json +import string +import textwrap +import tempfile +import os +import re +import fabric +import ConfigParser +import argparse +import sys +from datetime import datetime as dt +from fabric.api import settings, run +from fabric.api import env +from fabric.api import hosts, run, task +from fabric.api import local, put, get +from fabric.tasks import execute +from os.path import expanduser +import imp +import fabfile.tasks.verify as verify + + +class SmgrFixture(fixtures.Fixture): + + ''' Fixture to bring up a vns cluster using server manager . + + ''' + + def __init__(self, testbed_py="./testbed.py", smgr_config_ini="./smgr_input.ini", test_local=False): + self.testbed_py = testbed_py + self.testbed = self.get_testbed() + self.smgr_config_ini = smgr_config_ini + self.test_local = test_local + self.params = self.read_ini_file(smgr_config_ini) + self.svrmgr = self.params['svrmgr'] + # end __init__ + + def svrmgr_add_all(self): + self.create_json() + self.add_vns() + self.add_image() + self.add_pkg() + self.add_server() + + + def create_json(self): + self.modify_server_json() + self.modify_vns_json() + + def modify_server_json(self): + params=self.params + if not params: + return None + if not params.has_key('server_file'): + return None + server_file = params['server_file'] + + timestamp = dt.now().strftime("%Y_%m_%d_%H_%M_%S") + local('cp %s %s.org.%s' %(server_file, server_file, timestamp)) + + in_file = open( server_file, 'r' ) + in_data = in_file.read() + server_dict = json.loads(in_data) + + self.update_roles_from_testbed_py(server_dict) + self.update_bond_from_testbed_py(server_dict) + self.update_multi_if_from_testbed_py(server_dict) + + out_file = open(server_file, 'w') + out_data = json.dumps(server_dict, indent=4) + out_file.write(out_data) + out_file.close() + + return server_dict + + def update_roles_from_testbed_py(self, server_dict): + testbed = self.testbed + if not testbed.env.has_key('roledefs'): + return server_dict + for node in server_dict['server']: + roles = [] + for key in testbed.env.roledefs: + if key == 'all' or key == 'build' : + continue + for host_string in testbed.env.roledefs[key]: + ip = getIp(host_string) + if node['ip'] == ip: + if key == 'cfgm': + roles.append("config") + else: + roles.append(key) + if not len(roles): + node['roles'] = [ "compute" ] + else: + node['roles'] = roles + + for node in server_dict['server']: + node['vns_id'] = self.get_pref_vns_id() + + return server_dict + # end update_roles_from_testbed_py + + def update_bond_from_testbed_py(self, server_dict): + testbed = self.testbed + if 'control_data' in dir(testbed): + + for node in server_dict['server']: + for key in testbed.bond: + ip = getIp(key) + if node['ip'] == ip: + node['server_params']['setup_interface'] = "Yes" + node['server_params']['compute_non_mgmt_ip'] = "" + node['server_params']['compute_non_mgmt_gw'] = "" + + name = testbed.bond[key]['name'] + mode = testbed.bond[key]['mode'] + member = testbed.bond[key]['member'] + option = {} + option['miimon'] = '100' + option['mode'] = mode + option['xmit_hash_policy'] = 'layer3+4' + + node['bond']={} + node['bond'][name]={} + node['bond'][name]['bond_options'] = "%s"%option + node['bond'][name]['member'] = "%s"%member + + return server_dict + #End update_bond_from_testbed_py(server_dict): + + def update_multi_if_from_testbed_py(self, server_dict): + + testbed = self.testbed + if 'control_data' in dir(testbed): + + for node in server_dict['server']: + for key in testbed.control_data: + ip = getIp(key) + if node['ip'] == ip: + node['server_params']['setup_interface'] = "Yes" + node['server_params']['compute_non_mgmt_ip'] = "" + node['server_params']['compute_non_mgmt_gway'] = "" + + ip = testbed.control_data[key]['ip'] + gw = testbed.control_data[key]['gw'] + device = testbed.control_data[key]['device'] + + node['control']={} + node['control'][device] = {} + node['control'][device]['ip'] = ip + node['control'][device]['gw'] = gw + + return server_dict + + #End update_multi_if_from_testbed_py(server_dict): + + + def get_image_id(self) : + params=self.params + image_file = params['image_file'] + + image_file = open( image_file, 'r' ) + image_data = image_file.read() + image_json = json.loads(image_data) + image_id = image_json['image'][0]['image_id'] + image_file.close() + return image_id + # end get_image_id() + + def get_pkg_id(self) : + params=self.params + pkg_file = params['pkg_file'] + + pkg_file = open( pkg_file, 'r' ) + pkg_data = pkg_file.read() + pkg_json = json.loads(pkg_data) + pkg_id = pkg_json['image'][0]['image_id'] + pkg_file.close() + return pkg_id + # end get_pkg_id() + + def get_vns_id(self) : + vns_id = None + params=self.params + vns_file = params['vns_file'] + + vns_file = open( vns_file, 'r' ) + vns_data = vns_file.read() + vns_json = json.loads(vns_data) + vns_id = vns_json['vns'][0]['vns_id'] + if params.has_key('vns_id'): + vns_id = params['vns_id'] + vns_file.close() + return vns_id + + # end get_vns_id() + + + def add_vns(self): + vns_file = None + params=self.params + if params.has_key('vns_file'): + vns_file = params['vns_file'] + + vns_id = self.get_pref_vns_id() + if not vns_file: + vns_dict = self.get_vns_with_vns_id_from_db() + if not len(vns_dict['vns']): + vns_dict = new_vns() + else: + vns_dict = { + "vns" : [ + { + "vns_id" : "", + "vns_params" : { + + } + } + ] + } + + vns_dict['vns'][0]['vns_id'] = vns_id + self.modify_vns_from_testbed_py(vns_dict) + temp_dir= expanduser("~") + vns_file = '%s/vns.json' %temp_dir + local('touch %s' %vns_file) + out_file = open(vns_file, 'w') + out_data = json.dumps(vns_dict, indent=4) + + out_file.write(out_data) + out_file.close() + else : + timestamp = dt.now().strftime("%Y_%m_%d_%H_%M_%S") + local('cp %s %s.org.%s' %(vns_file, vns_file, timestamp)) + local("sed -i 's/\"vns_id\".*,/\"vns_id\":\"%s\",/' %s" %(vns_id,vns_file)) + local("sed -i 's/\"vns_id\".*/\"vns_id\":\"%s\"/' %s" %(vns_id,vns_file)) + + if self.test_local: + local('server-manager add vns -f %s' %(vns_file)) + else: + #svrmgr = get_svrmgr() + svrmgr = self.svrmgr + with settings(host_string=svrmgr, warn_only=True): + file_name = os.path.basename(vns_file) + temp_dir= tempfile.mkdtemp() + run('mkdir -p %s' % temp_dir) + put(vns_file, '%s/%s' % (temp_dir, file_name)) + + run('server-manager add vns -f %s/%s' %(temp_dir, file_name) ) + run('server-manager show all | python -m json.tool') + + + # end add_vns() + + def add_server(self): + self.add_server_using_json() + self.update_server_in_db_with_testbed_py() + + def add_image(self): + params=self.params + if not params: + return None + if not params.has_key('image_file'): + return None + image_file = params['image_file'] + + if self.test_local: + local('server-manager add image -f %s' %(image_file)) + local('server-manager show all') + else: + svrmgr = self.svrmgr + with settings(host_string=svrmgr, warn_only=True): + file_name = os.path.basename(image_file) + temp_dir = tempfile.mkdtemp() + run('mkdir -p %s' % temp_dir) + put(image_file, '%s/%s' % (temp_dir, file_name)) + + run('server-manager add image -f %s/%s' %(temp_dir, file_name) ) + run('server-manager show all | python -m json.tool') + + def add_pkg(self): + params=self.params + if not params: + return None + if not params.has_key('pkg_file'): + return None + pkg_file = params['pkg_file'] + + if self.test_local: + local('server-manager add image -f %s' %(pkg_file)) + local('server-manager show image ') + else: + svrmgr = self.svrmgr + with settings(host_string=svrmgr, warn_only=True): + file_name = os.path.basename(pkg_file) + temp_dir= tempfile.mkdtemp() + run('mkdir -p %s' % temp_dir) + put(pkg_file, '%s/%s' % (temp_dir, file_name)) + + run('server-manager add image -f %s/%s' %(temp_dir, file_name) ) + run('server-manager show all | python -m json.tool') + + def add_server_using_json(self): + params=self.params + if not params: + return None + + if not params.has_key('server_file'): + return None + server_file = params['server_file'] + + if self.test_local: + local('server-manager add server -f %s' %(server_file)) + local('server-manager show server') + else: + svrmgr = self.svrmgr + with settings(host_string=svrmgr, warn_only=True): + file_name = os.path.basename(server_file) + temp_dir= tempfile.mkdtemp() + run('mkdir -p %s' % temp_dir) + put(server_file, '%s/%s' % (temp_dir, file_name)) + run('server-manager add server -f %s/%s' %(temp_dir, file_name) ) + run('server-manager show all | python -m json.tool') + + + def modify_vns_json(self): + params=self.params + if not params: + return None + if not params.has_key('vns_file'): + return None + vns_file = params['vns_file'] + + timestamp = dt.now().strftime("%Y_%m_%d_%H_%M_%S") + local('cp %s %s.org.%s' %(vns_file, vns_file, timestamp)) + + in_file = open( vns_file, 'r' ) + in_data = in_file.read() + vns_dict = json.loads(in_data) + + self.modify_vns_from_testbed_py(vns_dict) + + out_file = open(vns_file, 'w') + out_data = json.dumps(vns_dict, indent=4) + out_file.write(out_data) + out_file.close() + + + def modify_vns_from_testbed_py(self, vns_dict): + testbed = self.testbed + if testbed.env.has_key('mail_to'): + vns_dict['vns'][0]['email'] = testbed.env.mail_to + if testbed.env.has_key('encap_priority'): + vns_dict['vns'][0]['vns_params']['encap_priority'] = testbed.env.encap_priority + if 'multi_tenancy' in dir(testbed): + vns_dict['vns'][0]['vns_params']['multi_tenancy'] = testbed.multi_tenancy + if 'os_username' in dir(testbed): + vns_dict['vns'][0]['vns_params']['ks_user'] = testbed.os_username + if 'os_password' in dir(testbed): + vns_dict['vns'][0]['vns_params']['ks_passwd'] = testbed.os_password + if 'os_tenant_name' in dir(testbed): + vns_dict['vns'][0]['vns_params']['ks_tenant'] = testbed.os_tenant_name + if 'router_asn' in dir(testbed): + vns_dict['vns'][0]['vns_params']['router_asn'] = testbed.router_asn + + + def new_vns(self): + params=self.params + vns_id = params['vns_id'] + vns_dict = { + "vns" : [ + { + "vns_id" : vns_id, + "vns_params" : { + "router_asn": "64512", + "database_dir": "/home/cassandra", + "db_initial_token": "", + "openstack_mgmt_ip": "", + "use_certs": "False", + "multi_tenancy": "False", + "encap_priority": "'MPLSoUDP','MPLSoGRE','VXLAN'", + "service_token": "contrail123", + "ks_user": "admin", + "ks_passwd": "contrail123", + "ks_tenant": "admin", + "openstack_passwd": "contrail123", + "analytics_data_ttl": "168", + "mask": "255.255.255.0", + "gway": "1.1.1.254", + "passwd": "c0ntrail123", + "domain": "contrail.juniper.net", + "haproxy": "disable" + } + } + ] + } + return vns_dict + + + + # End new_vns() + + + def read_ini_file(self, config_ini): + try: + config = ConfigParser.SafeConfigParser() + config.read([config_ini]) + smgr_config = dict(config.items("SERVER-MANAGER")) + return smgr_config + except: + sys.exit("Error reading config file %s" %config_ini) + + return smgr_config + + # End read_ini_file + + + def get_server_with_vns_id_from_db(self): + vns_id = self.get_pref_vns_id() + + temp_dir= expanduser("~") + file_name = '%s/server_with_vns_id_from_db.json' %(temp_dir) + + if self.test_local: + local('server-manager show --detail server --vns_id %s \ + | tr -d "\n" \ + | sed "s/[^{]*//" \ + > %s' %(vns_id, file_name)) + + else: + svrmgr = self.params + with settings(host_string=svrmgr, warn_only=True): + temp_dir= tempfile.mkdtemp() + run('mkdir -p %s' % temp_dir) + file_name = '%s/server_list.json' %(temp_dir) + + run('server-manager show --detail server --vns_id %s \ + | tr -d "\n" \ + | sed \'s/[^{]*//\' \ + | python -m json.tool \ + > %s' %(vns_id, file_name) ) + + local('mkdir -p %s' % temp_dir) + get( file_name, file_name ) + + in_file = open( file_name, 'r' ) + in_data = in_file.read() + server_dict = json.loads(in_data) + return server_dict + + def get_vns_with_vns_id_from_db(self): + params=self.params + vns_id = params['vns_id'] + + vns_dict = {"vns": []} + + temp_dir= expanduser("~") + + file_name = '%s/vns.json' %(temp_dir) + + if self.test_local: + local('server-manager show --detail vns --vns_id %s \ + | tr -d "\n" \ + | sed "s/[^{]*//" \ + > %s' %(vns_id, file_name)) + else: + svrmgr = self.svrmgr + with settings(host_string=svrmgr, warn_only=True): + temp_dir= tempfile.mkdtemp() + run('mkdir -p %s' % temp_dir) + file_name = '%s/vns.json' %(temp_dir) + run('server-manager show --detail vns --vns_id %s \ + | tr -d "\n" \ + | sed \'s/[^{]*//\' \ + | python -m json.tool \ + > %s' %(vns_id, file_name) ) + local('mkdir -p %s' % temp_dir) + get( file_name, file_name ) + + in_file = open( file_name, 'r' ) + in_data = in_file.read() + + vns_dict = json.loads(in_data) + return vns_dict + + + def get_server_with_ip_from_db(self, ip=None): + params=self.params + + server_dict={} + if not ip: + print "Please provide an ip as input arg" + return ip + + temp_dir= expanduser("~") + + file_name = '%s/server.json' %(temp_dir) + + if self.test_local: + local('server-manager show --detail server --ip %s \ + | tr -d "\n" \ + | sed "s/[^{]*//" \ + > %s' %(ip, file_name)) + else: + svrmgr = self.svrmgr + with settings(host_string=svrmgr, warn_only=True): + temp_dir= tempfile.mkdtemp() + run('mkdir -p %s' % temp_dir) + file_name = '%s/server.json' %(temp_dir) + run('server-manager show --detail server --ip %s \ + | tr -d "\n" \ + | sed \'s/[^{]*//\' \ + | python -m json.tool \ + > %s' %(ip, file_name) ) + local('mkdir -p %s' % temp_dir) + get( file_name, file_name ) + + in_file = open( file_name, 'r' ) + in_data = in_file.read() + server_dict = json.loads(in_data) + return server_dict + + def get_host_roles_from_testbed_py(self): + testbed = self.testbed + node = {} + if not testbed.env.has_key('roledefs'): + return node + for key in testbed.env.roledefs: + if key == 'all' or key == 'build': + continue + for host_string in testbed.env.roledefs[key]: + ip = getIp(host_string) + if not node.has_key(ip): + node[ip] = [] + if key == 'cfgm': + node[ip].append('config') + else: + node[ip].append(key) + return node + # end get_host_roles_from_testbed_py + + def update_server_in_db_with_testbed_py(self): + vns_id = self.get_pref_vns_id() + node = self.get_host_roles_from_testbed_py() + if not node: + return + u_server_dict = {} + u_server_dict['server'] = [] + for key in node: + server_dict = {} + server_dict = self.get_server_with_ip_from_db(key) + if not server_dict or not server_dict['server']: + print ("ERROR: Server with ip %s not present in Server Manager" % key) + continue + server_id = server_dict['server'][0]['server_id'] + u_server = {} + u_server['server_id'] = server_id + u_server['vns_id'] = vns_id + u_server['roles'] = node[key] + u_server_dict['server'].append(u_server) + + temp_dir= expanduser("~") + server_file = '%s/server.json' %temp_dir + local('touch %s' %server_file) + out_file = open(server_file, 'w') + out_data = json.dumps(u_server_dict, indent=4) + out_file.write(out_data) + out_file.close() + + if self.test_local: + local('server-manager add server -f %s' %(server_file) ) + for u_server in u_server_dict['server']: + local('server-manager show --detail server --server_id %s' \ + % u_server['server_id'] ) + else: + svrmgr = self.svrmgr + with settings(host_string=svrmgr, warn_only=True): + file_name = os.path.basename(server_file) + temp_dir= tempfile.mkdtemp() + run('mkdir -p %s' % temp_dir) + put(server_file, '%s/%s' % (temp_dir, file_name)) + run('server-manager add server -f %s/%s' %(temp_dir, file_name) ) + run('server-manager show --detail server --server_id %s | python -m json.tool' %server_id) + + #End update_server_in_db_with_vns_id + + + def get_pref_vns_id(self): + vns_id = None + params=self.read_ini_file(self.smgr_config_ini) + if params.has_key('vns_id'): + vns_id = params['vns_id'] + else: + vns_id = self.get_vns_id() + + return vns_id + + def get_svrmgr(self): + svrmgr = None + params=self.params + if params.has_key('svrmgr'): + svrmgr = params['svrmgr'] + return params['svrmgr'] + + def get_server_file(self): + params=self.params + if not params: + return None + if not params.has_key('server_file'): + return None + server_file = params['server_file'] + return server_file + + def get_testbed(self): + filepath = self.testbed_py + if not filepath: + sys.exit("tesbed.py missing in args ") + mod_name,file_ext = os.path.splitext(os.path.split(filepath)[-1]) + + if file_ext.lower() == '.py': + py_mod = imp.load_source(mod_name, filepath) + + return py_mod + + def verify_roles(self): + pdb.set_trace() + with settings(host_string=env.roledefs['database'], warn_only=True): + verify.verify_database() + with settings(host_string=env.roledefs['cfgm'], warn_only=True): + verify.verify_cfgm() + with settings(host_string=env.roledefs['control'], warn_only=True): + verify.verify_control() + with settings(host_string=env.roledefs['collector'], warn_only=True): + verify.verify_collector() + with settings(host_string=env.roledefs['webui'], warn_only=True): + verify.verify_webui() + with settings(host_string=env.roledefs['compute'], warn_only=True): + verify.verify_compute() + with settings(host_string=env.roledefs['openstack'], warn_only=True): + verify.verify_openstack() + + +# end SmgrFixture + +def getIp(string) : + regEx = re.compile( '\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}' ) + result = regEx.search(string) + + if result: + return result.group() + else: + return None From 327cef2bb88af4ef2f8df43e05ff0cb569849344 Mon Sep 17 00:00:00 2001 From: Rishi Verma Date: Wed, 30 Jul 2014 18:32:38 +0530 Subject: [PATCH 05/15] reimage provision --- fixtures/smgr_common.py | 108 ++++++++++++++++++++++++++++++++++++++-- 1 file changed, 104 insertions(+), 4 deletions(-) diff --git a/fixtures/smgr_common.py b/fixtures/smgr_common.py index 4da4d368a..88b2a85cb 100644 --- a/fixtures/smgr_common.py +++ b/fixtures/smgr_common.py @@ -14,13 +14,21 @@ import sys from datetime import datetime as dt from fabric.api import settings, run -from fabric.api import env -from fabric.api import hosts, run, task +from fabric.api import hosts, env, task from fabric.api import local, put, get from fabric.tasks import execute from os.path import expanduser import imp import fabfile.tasks.verify as verify +from fabric.state import connections +from fabfile.utils.host import verify_sshd +from time import sleep + + + +REIMAGE_WAIT=360 +SERVER_RETRY_TIME=1000 +PROVISION_TIME = 1000 class SmgrFixture(fixtures.Fixture): @@ -241,7 +249,6 @@ def add_vns(self): if self.test_local: local('server-manager add vns -f %s' %(vns_file)) else: - #svrmgr = get_svrmgr() svrmgr = self.svrmgr with settings(host_string=svrmgr, warn_only=True): file_name = os.path.basename(vns_file) @@ -626,7 +633,7 @@ def get_testbed(self): return py_mod def verify_roles(self): - pdb.set_trace() + with settings(host_string=env.roledefs['database'], warn_only=True): verify.verify_database() with settings(host_string=env.roledefs['cfgm'], warn_only=True): @@ -642,6 +649,99 @@ def verify_roles(self): with settings(host_string=env.roledefs['openstack'], warn_only=True): verify.verify_openstack() + def reimage(self): + """ using svrmgr, reimage all the nodes """ + + image_id = self.get_image_id() + pkg_id = self.get_pkg_id() + vns_id = self.get_vns_id() + svrmgr = self.get_svrmgr() + + with settings(host_string=svrmgr, warn_only=True): + + run('server-manager show all | python -m json.tool') + run('server-manager reimage --package_image_id %s --vns_id %s %s' %(pkg_id,vns_id,image_id)) + + sleep(REIMAGE_WAIT) + + user = "root" + server_state = {} + + server_file = self.get_server_file() + in_file = open( server_file, 'r' ) + in_data = in_file.read() + server_dict = json.loads(in_data) + + for node in server_dict['server']: + server_ip = node['ip'] + server_state[server_ip] = False + + for retry in range(SERVER_RETRY_TIME): + for node in server_dict['server']: + server_ip = node['ip'] + if not verify_sshd(server_ip, user, env.password): + sleep(1) + print "Node %s not reachable....retrying" %(server_ip) + server_state[server_ip] = False + else: + print "Node %s is UP" %(server_ip) + if server_state[server_ip] == False: + target_node = '%s@%s' %(user,server_ip) + with settings( host_string = target_node ): + connections.connect(env.host_string) + with settings( host_string = target_node ) : + output = run('uptime') + uptime = int(output.split()[2]) + if uptime > 3 : + raise RuntimeError('Restart failed for Host (%s)' %server_ip) + else : + print "Node %s has rebooted and UP now" %(server_ip) + output = run('dpkg -l | grep contrail') + match = re.search('contrail-fabric-utils\s+(\S+)\s+', output, re.M) + if pkg_id not in match.group(1) : + raise RuntimeError('Reimage not able to download package %s on targetNode (%s)' \ + %(pkg_id, server_ip) ) + match = re.search('contrail-install-packages\s+(\S+)\s+', output, re.M) + if pkg_id not in match.group(1) : + raise RuntimeError('Reimage not able to download package %s on targetNode (%s)' \ + %(pkg_id, server_ip) ) + server_state[server_ip] = True + + #End for node in server_dict['server']: + + result = True + for key in server_state: + result = result and server_state[key] + + if result == True: + break + #End for key in server: + + #End for retry in range(SERVER_RETRY_TIME): + + if not result: + raise RuntimeError('Unable to SSH to one or more Host ' ) + + def provision(self): + """ using svrmgr, provision the vns """ + image_id = self.get_image_id() + pkg_id = self.get_pkg_id() + vns_id = self.get_vns_id() + svrmgr = self.get_svrmgr() + + with settings(host_string=svrmgr, warn_only=True): + run('server-manager provision --vns_id %s %s' %(vns_id,pkg_id) ) + run('server-manager show all | python -m json.tool') + + def run_sanity(): + self.reimage() + self.provision() + sleep(PROVISION_TIME) + self.verify_roles() + + + + # end SmgrFixture From cd88de6ad0a9b4e94d710e09924f070a9e7215e1 Mon Sep 17 00:00:00 2001 From: Rishi Verma Date: Wed, 30 Jul 2014 19:37:20 +0530 Subject: [PATCH 06/15] test suite to bringup a cluster using SM --- fixtures/smgr_common.py | 2 +- scripts/smgr/smgr_regression.py | 31 +++++++++++++++---------- scripts/smgr/smgr_setup.py | 40 +++++++++++++++++---------------- 3 files changed, 41 insertions(+), 32 deletions(-) diff --git a/fixtures/smgr_common.py b/fixtures/smgr_common.py index 88b2a85cb..287233248 100644 --- a/fixtures/smgr_common.py +++ b/fixtures/smgr_common.py @@ -733,7 +733,7 @@ def provision(self): run('server-manager provision --vns_id %s %s' %(vns_id,pkg_id) ) run('server-manager show all | python -m json.tool') - def run_sanity(): + def setup_cluster(self): self.reimage() self.provision() sleep(PROVISION_TIME) diff --git a/scripts/smgr/smgr_regression.py b/scripts/smgr/smgr_regression.py index 742cbaee4..bad248153 100644 --- a/scripts/smgr/smgr_regression.py +++ b/scripts/smgr/smgr_regression.py @@ -1,11 +1,13 @@ +import pdb import os import fixtures import testtools import unittest + from testresources import ResourcedTestCase -from connections import ContrailConnections +#from connections import ContrailConnections from tcutils.wrappers import preposttest_wrapper from smgr.smgr_setup import SmgrSetupResource @@ -18,12 +20,13 @@ class SmgrRegressionTests(testtools.TestCase, ResourcedTestCase, def __init__(self, *args, **kwargs): testtools.TestCase.__init__(self, *args, **kwargs) self.res = SmgrSetupResource.getResource() - self.inputs = self.res.inputs - self.connections = self.res.connections - self.logger = self.inputs.logger + #self.inputs = self.res.inputs + #self.connections = self.res.connections + #self.logger = self.inputs.logger def __del__(self): - self.logger.debug("Unconfig the common resurces.") + #self.logger.debug("Unconfig the common resurces.") + print "Unconfig the common resurces." SmgrSetupResource.finishedWith(self.res) def setUp(self): @@ -34,7 +37,8 @@ def setUp(self): self.ini_file = 'params.ini' def tearDown(self): - self.logger.debug("Tearing down SmgrRegressionTests.") + #self.logger.debug("Tearing down SmgrRegressionTests.") + print "Tearing down SmgrRegressionTests." super(SmgrRegressionTests, self).tearDown() SmgrSetupResource.finishedWith(self.res) @@ -42,19 +46,22 @@ def runTest(self): pass - @preposttest_wrapper + #@preposttest_wrapper def test_reimage(self): """Verify reimage using server manager in a multinode setup""" - self.logger.info("Verify reimage using server manager in a multinode setup") - self.res.smgr_fix.reimage() + #self.logger.info("Verify reimage using server manager in a multinode setup") + print "Verify reimage using server manager in a multinode setup" + #self.res.smgr_fixture.reimage() + pass return True - @preposttest_wrapper + #@preposttest_wrapper def test_provision(self): """Verify provision using server manager in a multinode setup""" - self.logger.info("Verify provision using server manager in a multinode setup") - self.res.smgr_fix.provision() + #self.logger.info("Verify provision using server manager in a multinode setup") + #self.res.smgr_fixture.provision() + self.res.smgr_fixture.setup_cluster() return True diff --git a/scripts/smgr/smgr_setup.py b/scripts/smgr/smgr_setup.py index 95a7cf8b3..68de44d90 100644 --- a/scripts/smgr/smgr_setup.py +++ b/scripts/smgr/smgr_setup.py @@ -3,9 +3,9 @@ import fixtures from testresources import TestResource -from smgr_test import CreateSmgrDbFixture -from connections import ContrailConnections -from contrail_test_init import ContrailTestInit +from smgr_common import SmgrFixture +#from connections import ContrailConnections +#from contrail_test_init import ContrailTestInit class SmgrSetup(fixtures.Fixture): @@ -23,34 +23,35 @@ def setUp(self): self.ini_file = os.environ.get('PARAMS_FILE') else: self.ini_file = 'params.ini' - self.inputs = self.useFixture(ContrailTestInit(self.ini_file)) - self.connections = ContrailConnections(self.inputs) - self.logger = self.inputs.logger + #self.inputs = self.useFixture(ContrailTestInit(self.ini_file)) + #self.connections = ContrailConnections(self.inputs) + #self.logger = self.inputs.logger - self.logger.info("Configuring setup for smgr tests.") + #self.logger.info("Configuring setup for smgr tests.") self.setup() - self.logger.info("Verifying setup of smgr tests.") - self.verify() - self.logger.info( - "Finished configuring setup for smgr tests.") + #self.logger.info("Verifying setup of smgr tests.") + #self.verify() + #self.logger.info( + # "Finished configuring setup for smgr tests.") return self def setup(self): """Config common resources.""" self.smgr_fixture = self.useFixture(SmgrFixture( - connections=self.connections, inputs=self.inputs, - smgr_config_ini="smgr_config.ini")) + testbed_py="./testbed.py", smgr_config_ini="./smgr_input.ini", + test_local=False)) - self.logger.info("Adding Server to smgr DB") + #self.logger.info("Adding Server to smgr DB") self.smgr_fixture.svrmgr_add_all() def verify(self): """verfiy common resources.""" - self.logger.debug("Verify the configured roles") - assert self.smgr_fixture.verify_roles() + #self.logger.debug("Verify the configured roles") + #assert self.smgr_fixture.verify_roles() + pass def tearDown(self): - self.logger.info("Tearing down resources of smgr tests") + #self.logger.info("Tearing down resources of smgr tests") super(SmgrSetup, self).cleanUp() @@ -63,8 +64,9 @@ def make(self, dependencyresource): return base_setup def clean(self, base_setup): - base_setup.logger.info( - "Cleaning up smgr test resources here") + #base_setup.logger.info( + # "Cleaning up smgr test resources here") + print "Cleaning up smgr test resources here" base_setup.tearDown() SmgrSetupResource = _SmgrSetupResource() From 378874257d1eafffe9bd8bca1021da6537f20880 Mon Sep 17 00:00:00 2001 From: Rishi Verma Date: Thu, 31 Jul 2014 13:49:24 +0530 Subject: [PATCH 07/15] verify roles modified --- fixtures/smgr_common.py | 44 ++++++++++++++++++++++++----------------- 1 file changed, 26 insertions(+), 18 deletions(-) diff --git a/fixtures/smgr_common.py b/fixtures/smgr_common.py index 287233248..79d55c2d0 100644 --- a/fixtures/smgr_common.py +++ b/fixtures/smgr_common.py @@ -633,21 +633,29 @@ def get_testbed(self): return py_mod def verify_roles(self): - - with settings(host_string=env.roledefs['database'], warn_only=True): - verify.verify_database() - with settings(host_string=env.roledefs['cfgm'], warn_only=True): - verify.verify_cfgm() - with settings(host_string=env.roledefs['control'], warn_only=True): - verify.verify_control() - with settings(host_string=env.roledefs['collector'], warn_only=True): - verify.verify_collector() - with settings(host_string=env.roledefs['webui'], warn_only=True): - verify.verify_webui() - with settings(host_string=env.roledefs['compute'], warn_only=True): - verify.verify_compute() - with settings(host_string=env.roledefs['openstack'], warn_only=True): - verify.verify_openstack() + import pdb + pdb.set_trace() + for node in env.roledefs['database']: + with settings(host_string=node, warn_only=True): + verify.verify_database() + for node in env.roledefs['cfgm']: + with settings(host_string=node, warn_only=True): + verify.verify_cfgm() + for node in env.roledefs['control']: + with settings(host_string=node, warn_only=True): + verify.verify_control() + for node in env.roledefs['collector']: + with settings(host_string=node, warn_only=True): + verify.verify_collector() + for node in env.roledefs['webui']: + with settings(host_string=node, warn_only=True): + verify.verify_webui() + for node in env.roledefs['compute']: + with settings(host_string=node, warn_only=True): + verify.verify_compute() + for node in env.roledefs['openstack']: + with settings(host_string=node, warn_only=True): + verify.verify_openstack() def reimage(self): """ using svrmgr, reimage all the nodes """ @@ -734,9 +742,9 @@ def provision(self): run('server-manager show all | python -m json.tool') def setup_cluster(self): - self.reimage() - self.provision() - sleep(PROVISION_TIME) + #self.reimage() + #self.provision() + #sleep(PROVISION_TIME) self.verify_roles() From f000059a6f2e8863bf51dd7455c991cd4b80c349 Mon Sep 17 00:00:00 2001 From: Rishi Verma Date: Thu, 31 Jul 2014 15:10:58 +0530 Subject: [PATCH 08/15] remove pdb. other minor changes --- fixtures/smgr_common.py | 8 +++----- 1 file changed, 3 insertions(+), 5 deletions(-) diff --git a/fixtures/smgr_common.py b/fixtures/smgr_common.py index 79d55c2d0..9ede251c3 100644 --- a/fixtures/smgr_common.py +++ b/fixtures/smgr_common.py @@ -633,8 +633,6 @@ def get_testbed(self): return py_mod def verify_roles(self): - import pdb - pdb.set_trace() for node in env.roledefs['database']: with settings(host_string=node, warn_only=True): verify.verify_database() @@ -742,9 +740,9 @@ def provision(self): run('server-manager show all | python -m json.tool') def setup_cluster(self): - #self.reimage() - #self.provision() - #sleep(PROVISION_TIME) + self.reimage() + self.provision() + sleep(PROVISION_TIME) self.verify_roles() From 572f4bfbeddd0ab8d5af94cc04c6aabfe8d03f74 Mon Sep 17 00:00:00 2001 From: Rishi Verma Date: Fri, 1 Aug 2014 00:30:32 +0530 Subject: [PATCH 09/15] call ContrailTestInit --- scripts/smgr/smgr_regression.py | 17 +++++-------- scripts/smgr/smgr_setup.py | 42 ++++++++++++++++++++------------- 2 files changed, 32 insertions(+), 27 deletions(-) diff --git a/scripts/smgr/smgr_regression.py b/scripts/smgr/smgr_regression.py index bad248153..b98252a30 100644 --- a/scripts/smgr/smgr_regression.py +++ b/scripts/smgr/smgr_regression.py @@ -1,4 +1,3 @@ -import pdb import os import fixtures import testtools @@ -20,13 +19,12 @@ class SmgrRegressionTests(testtools.TestCase, ResourcedTestCase, def __init__(self, *args, **kwargs): testtools.TestCase.__init__(self, *args, **kwargs) self.res = SmgrSetupResource.getResource() - #self.inputs = self.res.inputs + self.inputs = self.res.inputs #self.connections = self.res.connections - #self.logger = self.inputs.logger + self.logger = self.inputs.logger def __del__(self): - #self.logger.debug("Unconfig the common resurces.") - print "Unconfig the common resurces." + self.logger.debug("Unconfig the common resurces.") SmgrSetupResource.finishedWith(self.res) def setUp(self): @@ -37,8 +35,7 @@ def setUp(self): self.ini_file = 'params.ini' def tearDown(self): - #self.logger.debug("Tearing down SmgrRegressionTests.") - print "Tearing down SmgrRegressionTests." + self.logger.debug("Tearing down SmgrRegressionTests.") super(SmgrRegressionTests, self).tearDown() SmgrSetupResource.finishedWith(self.res) @@ -49,8 +46,7 @@ def runTest(self): #@preposttest_wrapper def test_reimage(self): """Verify reimage using server manager in a multinode setup""" - #self.logger.info("Verify reimage using server manager in a multinode setup") - print "Verify reimage using server manager in a multinode setup" + self.logger.info("Verify reimage using server manager ") #self.res.smgr_fixture.reimage() pass @@ -59,8 +55,7 @@ def test_reimage(self): #@preposttest_wrapper def test_provision(self): """Verify provision using server manager in a multinode setup""" - #self.logger.info("Verify provision using server manager in a multinode setup") - #self.res.smgr_fixture.provision() + self.logger.info("Verify provision using server manager in a multinode setup") self.res.smgr_fixture.setup_cluster() return True diff --git a/scripts/smgr/smgr_setup.py b/scripts/smgr/smgr_setup.py index 68de44d90..3d3544406 100644 --- a/scripts/smgr/smgr_setup.py +++ b/scripts/smgr/smgr_setup.py @@ -5,7 +5,7 @@ from smgr_common import SmgrFixture #from connections import ContrailConnections -#from contrail_test_init import ContrailTestInit +from contrail_test_init import ContrailTestInit class SmgrSetup(fixtures.Fixture): @@ -22,36 +22,47 @@ def setUp(self): if 'PARAMS_FILE' in os.environ: self.ini_file = os.environ.get('PARAMS_FILE') else: - self.ini_file = 'params.ini' - #self.inputs = self.useFixture(ContrailTestInit(self.ini_file)) + self.ini_file = 'sanity_params.ini' + + if 'TESTBED_FILE' in os.environ: + self.testbed_py = os.environ.get('TESTBED_FILE') + else: + self.testbed_py = 'testbed.py' + + if 'SMGR_FILE' in os.environ: + self.smgr_file = os.environ.get('SMGR_FILE') + else: + self.smgr_file = 'smgr_input.ini' + + self.inputs = self.useFixture(ContrailTestInit(self.ini_file)) #self.connections = ContrailConnections(self.inputs) - #self.logger = self.inputs.logger + self.logger = self.inputs.logger - #self.logger.info("Configuring setup for smgr tests.") + self.logger.info("Configuring setup for smgr tests.") self.setup() - #self.logger.info("Verifying setup of smgr tests.") - #self.verify() - #self.logger.info( - # "Finished configuring setup for smgr tests.") + self.logger.info("Verifying setup of smgr tests.") + self.verify() + self.logger.info( + "Finished configuring setup for smgr tests.") return self def setup(self): """Config common resources.""" self.smgr_fixture = self.useFixture(SmgrFixture( - testbed_py="./testbed.py", smgr_config_ini="./smgr_input.ini", + self.inputs, testbed_py=self.testbed_py, smgr_config_ini=self.smgr_file, test_local=False)) - #self.logger.info("Adding Server to smgr DB") + self.logger.info("Adding Server to smgr DB") self.smgr_fixture.svrmgr_add_all() def verify(self): """verfiy common resources.""" - #self.logger.debug("Verify the configured roles") + self.logger.debug("Verify the common resources") #assert self.smgr_fixture.verify_roles() pass def tearDown(self): - #self.logger.info("Tearing down resources of smgr tests") + self.logger.info("Tearing down resources of smgr tests") super(SmgrSetup, self).cleanUp() @@ -64,9 +75,8 @@ def make(self, dependencyresource): return base_setup def clean(self, base_setup): - #base_setup.logger.info( - # "Cleaning up smgr test resources here") - print "Cleaning up smgr test resources here" + base_setup.logger.info( + "Cleaning up smgr test resources here") base_setup.tearDown() SmgrSetupResource = _SmgrSetupResource() From f349c01f5d6f71bd362ac4b7a2eef2683aa20dbd Mon Sep 17 00:00:00 2001 From: Rishi Verma Date: Fri, 1 Aug 2014 00:52:52 +0530 Subject: [PATCH 10/15] add inputs from ContrailTestInit --- fixtures/smgr_common.py | 9 ++++----- 1 file changed, 4 insertions(+), 5 deletions(-) diff --git a/fixtures/smgr_common.py b/fixtures/smgr_common.py index 9ede251c3..26c801130 100644 --- a/fixtures/smgr_common.py +++ b/fixtures/smgr_common.py @@ -37,13 +37,15 @@ class SmgrFixture(fixtures.Fixture): ''' - def __init__(self, testbed_py="./testbed.py", smgr_config_ini="./smgr_input.ini", test_local=False): + def __init__(self, inputs, testbed_py="./testbed.py", smgr_config_ini="./smgr_input.ini", test_local=False): self.testbed_py = testbed_py self.testbed = self.get_testbed() self.smgr_config_ini = smgr_config_ini self.test_local = test_local self.params = self.read_ini_file(smgr_config_ini) self.svrmgr = self.params['svrmgr'] + self.inputs = inputs + self.logger = self.inputs.logger # end __init__ def svrmgr_add_all(self): @@ -745,12 +747,9 @@ def setup_cluster(self): sleep(PROVISION_TIME) self.verify_roles() - - - - # end SmgrFixture + def getIp(string) : regEx = re.compile( '\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}' ) result = regEx.search(string) From 5917826a6fd03c9d016dac0108ead6e97a75b8e8 Mon Sep 17 00:00:00 2001 From: Rishi Verma Date: Tue, 19 Aug 2014 00:01:34 +0530 Subject: [PATCH 11/15] unused file --- fixtures/smgr_test_fixture.py | 614 ---------------------------------- 1 file changed, 614 deletions(-) delete mode 100644 fixtures/smgr_test_fixture.py diff --git a/fixtures/smgr_test_fixture.py b/fixtures/smgr_test_fixture.py deleted file mode 100644 index 1121a11ce..000000000 --- a/fixtures/smgr_test_fixture.py +++ /dev/null @@ -1,614 +0,0 @@ -import fixtures -from contrail_fixtures import * -import sys -import pdb -import json -import string -import textwrap -import tempfile -import os -import re -import fabric -import ConfigParser -import argparse -import sys -import fabfile.testbeds.testbed as testbed -from datetime import datetime as dt -from fabric.api import settings, run -from fabric.api import hosts, run, task -from fabric.api import local, put, get -from fabric.tasks import execute -from os.path import expanduser -import imp - - - -class SmgrFixture(fixtures.Fixture): - - ''' Fixture to bring up a vns cluster using server manager . - - ''' - - def __init__(self, connections, inputs, smgr_config_ini="./smgr_input.ini", test_local=False): - self.connections = connections - self.inputs = inputs - self.smgr_config_ini = smgr_config_ini - self.test_local = test_local - self.params = read_ini_file(smgr_config_ini) - self.svrmgr = self.params['svrmgr'] - # end __init__ - - def svrmgr_add_all(self): - self.create_json() - self.add_vns() - self.add_image() - self.add_pkg() - self.add_server() - - - def create_json(self): - self.modify_server_json() - self.modify_vns_json() - - def modify_server_json(self): - params=self.params - if not params: - return None - if not params.has_key('server_file'): - return None - server_file = params['server_file'] - - timestamp = dt.now().strftime("%Y_%m_%d_%H_%M_%S") - local('cp %s %s.org.%s' %(server_file, server_file, timestamp)) - - in_file = open( server_file, 'r' ) - in_data = in_file.read() - server_dict = json.loads(in_data) - - self.update_roles_from_testbed_py(server_dict) - self.update_bond_from_testbed_py(server_dict) - self.update_multi_if_from_testbed_py(server_dict) - - out_file = open(server_file, 'w') - out_data = json.dumps(server_dict, indent=4) - out_file.write(out_data) - out_file.close() - - return server_dict - - def update_roles_from_testbed_py(self, server_dict): - if not testbed.env.has_key('roledefs'): - return server_dict - for node in server_dict['server']: - roles = [] - for key in testbed.env.roledefs: - if key == 'all' or key == 'build' : - continue - for host_string in testbed.env.roledefs[key]: - ip = getIp(host_string) - if node['ip'] == ip: - if key == 'cfgm': - roles.append("config") - else: - roles.append(key) - if not len(roles): - node['roles'] = [ "compute" ] - else: - node['roles'] = roles - - for node in server_dict['server']: - node['vns_id'] = get_pref_vns_id() - - return server_dict -# end update_roles_from_testbed_py - - def update_bond_from_testbed_py(self, server_dict): - - if 'control_data' in dir(testbed): - - for node in server_dict['server']: - for key in testbed.bond: - ip = getIp(key) - if node['ip'] == ip: - node['server_params']['setup_interface'] = "Yes" - node['server_params']['compute_non_mgmt_ip'] = "" - node['server_params']['compute_non_mgmt_gw'] = "" - - name = testbed.bond[key]['name'] - mode = testbed.bond[key]['mode'] - member = testbed.bond[key]['member'] - option = {} - option['miimon'] = '100' - option['mode'] = mode - option['xmit_hash_policy'] = 'layer3+4' - - node['bond']={} - node['bond'][name]={} - node['bond'][name]['bond_options'] = "%s"%option - node['bond'][name]['member'] = "%s"%member - - return server_dict -#End update_bond_from_testbed_py(server_dict): - - def update_multi_if_from_testbed_py(self, server_dict): - - if 'control_data' in dir(testbed): - - for node in server_dict['server']: - for key in testbed.control_data: - ip = getIp(key) - if node['ip'] == ip: - node['server_params']['setup_interface'] = "Yes" - node['server_params']['compute_non_mgmt_ip'] = "" - node['server_params']['compute_non_mgmt_gway'] = "" - - ip = testbed.control_data[key]['ip'] - gw = testbed.control_data[key]['gw'] - device = testbed.control_data[key]['device'] - - node['control']={} - node['control'][device] = {} - node['control'][device]['ip'] = ip - node['control'][device]['gw'] = gw - - return server_dict - -#End update_multi_if_from_testbed_py(server_dict): - - - def get_image_id(self) : - params=self.params - image_file = params['image_file'] - - image_file = open( image_file, 'r' ) - image_data = image_file.read() - image_json = json.loads(image_data) - image_id = image_json['image'][0]['image_id'] - image_file.close() - return image_id -# end get_image_id() - - def get_pkg_id(self) : - params=self.params - pkg_file = params['pkg_file'] - - pkg_file = open( pkg_file, 'r' ) - pkg_data = pkg_file.read() - pkg_json = json.loads(pkg_data) - pkg_id = pkg_json['image'][0]['image_id'] - pkg_file.close() - return pkg_id -# end get_pkg_id() - - def get_vns_id(self) : - vns_id = None - params=self.params - vns_file = params['vns_file'] - - vns_file = open( vns_file, 'r' ) - vns_data = vns_file.read() - vns_json = json.loads(vns_data) - vns_id = vns_json['vns'][0]['vns_id'] - if params.has_key('vns_id'): - vns_id = params['vns_id'] - vns_file.close() - return vns_id - -# end get_vns_id() - - - def add_vns(self): - vns_file = None - params=self.params - if params.has_key('vns_file'): - vns_file = params['vns_file'] - - vns_id = self.get_pref_vns_id() - if not vns_file: - vns_dict = self.get_vns_with_vns_id_from_db() - if not len(vns_dict['vns']): - vns_dict = new_vns() - else: - vns_dict = { - "vns" : [ - { - "vns_id" : "", - "vns_params" : { - - } - } - ] - } - - vns_dict['vns'][0]['vns_id'] = vns_id - self.modify_vns_from_testbed_py(vns_dict) - temp_dir= expanduser("~") - vns_file = '%s/vns.json' %temp_dir - local('touch %s' %vns_file) - out_file = open(vns_file, 'w') - out_data = json.dumps(vns_dict, indent=4) - - out_file.write(out_data) - out_file.close() - else : - timestamp = dt.now().strftime("%Y_%m_%d_%H_%M_%S") - local('cp %s %s.org.%s' %(vns_file, vns_file, timestamp)) - local("sed -i 's/\"vns_id\".*,/\"vns_id\":\"%s\",/' %s" %(vns_id,vns_file)) - local("sed -i 's/\"vns_id\".*/\"vns_id\":\"%s\"/' %s" %(vns_id,vns_file)) - - if self.test_local: - local('server-manager add vns -f %s' %(vns_file)) - else: - #svrmgr = get_svrmgr() - svrmgr = self.svrmgr - with settings(host_string=svrmgr, warn_only=True): - file_name = os.path.basename(vns_file) - temp_dir= tempfile.mkdtemp() - run('mkdir -p %s' % temp_dir) - put(vns_file, '%s/%s' % (temp_dir, file_name)) - - run('server-manager add vns -f %s/%s' %(temp_dir, file_name) ) - run('server-manager show all | python -m json.tool') - - -# end add_vns() - - def add_server(self): - self.add_server_using_json() - self.update_server_in_db_with_testbed_py() - - def add_image(self): - params=self.params - if not params: - return None - if not params.has_key('image_file'): - return None - image_file = params['image_file'] - - if self.test_local: - local('server-manager add image -f %s' %(image_file)) - local('server-manager show all') - else: - svrmgr = self.svrmgr - with settings(host_string=svrmgr, warn_only=True): - file_name = os.path.basename(image_file) - temp_dir = tempfile.mkdtemp() - run('mkdir -p %s' % temp_dir) - put(image_file, '%s/%s' % (temp_dir, file_name)) - - run('server-manager add image -f %s/%s' %(temp_dir, file_name) ) - run('server-manager show all | python -m json.tool') - - def add_pkg(self): - params=self.params - if not params: - return None - if not params.has_key('pkg_file'): - return None - pkg_file = params['pkg_file'] - - if self.test_local: - local('server-manager add image -f %s' %(pkg_file)) - local('server-manager show image ') - else: - svrmgr = self.svrmgr - with settings(host_string=svrmgr, warn_only=True): - file_name = os.path.basename(pkg_file) - temp_dir= tempfile.mkdtemp() - run('mkdir -p %s' % temp_dir) - put(pkg_file, '%s/%s' % (temp_dir, file_name)) - - run('server-manager add image -f %s/%s' %(temp_dir, file_name) ) - run('server-manager show all | python -m json.tool') - - def add_server_using_json(self): - params=self.params - if not params: - return None - - if not params.has_key('server_file'): - return None - server_file = params['server_file'] - - if self.test_local: - local('server-manager add server -f %s' %(server_file)) - local('server-manager show server') - else: - svrmgr = self.svrmgr - with settings(host_string=svrmgr, warn_only=True): - file_name = os.path.basename(server_file) - temp_dir= tempfile.mkdtemp() - run('mkdir -p %s' % temp_dir) - put(server_file, '%s/%s' % (temp_dir, file_name)) - run('server-manager add server -f %s/%s' %(temp_dir, file_name) ) - run('server-manager show all | python -m json.tool') - - - def modify_vns_json(self): - params=self.params - if not params: - return None - if not params.has_key('vns_file'): - return None - vns_file = params['vns_file'] - - timestamp = dt.now().strftime("%Y_%m_%d_%H_%M_%S") - local('cp %s %s.org.%s' %(vns_file, vns_file, timestamp)) - - in_file = open( vns_file, 'r' ) - in_data = in_file.read() - vns_dict = json.loads(in_data) - - self.modify_vns_from_testbed_py(vns_dict) - - out_file = open(vns_file, 'w') - out_data = json.dumps(vns_dict, indent=4) - out_file.write(out_data) - out_file.close() - - - def modify_vns_from_testbed_py(self, vns_dict): - if testbed.env.has_key('mail_to'): - vns_dict['vns'][0]['email'] = testbed.env.mail_to - if testbed.env.has_key('encap_priority'): - vns_dict['vns'][0]['vns_params']['encap_priority'] = testbed.env.encap_priority - if 'multi_tenancy' in dir(testbed): - vns_dict['vns'][0]['vns_params']['multi_tenancy'] = testbed.multi_tenancy - if 'os_username' in dir(testbed): - vns_dict['vns'][0]['vns_params']['ks_user'] = testbed.os_username - if 'os_password' in dir(testbed): - vns_dict['vns'][0]['vns_params']['ks_passwd'] = testbed.os_password - if 'os_tenant_name' in dir(testbed): - vns_dict['vns'][0]['vns_params']['ks_tenant'] = testbed.os_tenant_name - if 'router_asn' in dir(testbed): - vns_dict['vns'][0]['vns_params']['router_asn'] = testbed.router_asn - - - def new_vns(self): - params=self.params - vns_id = params['vns_id'] - vns_dict = { - "vns" : [ - { - "vns_id" : vns_id, - "vns_params" : { - "router_asn": "64512", - "database_dir": "/home/cassandra", - "db_initial_token": "", - "openstack_mgmt_ip": "", - "use_certs": "False", - "multi_tenancy": "False", - "encap_priority": "'MPLSoUDP','MPLSoGRE','VXLAN'", - "service_token": "contrail123", - "ks_user": "admin", - "ks_passwd": "contrail123", - "ks_tenant": "admin", - "openstack_passwd": "contrail123", - "analytics_data_ttl": "168", - "mask": "255.255.255.0", - "gway": "1.1.1.254", - "passwd": "c0ntrail123", - "domain": "contrail.juniper.net", - "haproxy": "disable" - } - } - ] - } - return vns_dict - - - - # End new_vns() - - - def read_ini_file(self, config_ini): - try: - config = ConfigParser.SafeConfigParser() - config.read([config_ini]) - smgr_config = dict(config.items("SERVER-MANAGER")) - return smgr_config - except: - sys.exit("Error reading config file %s" %config_ini) - - return smgr_config - - # End read_ini_file - - - def get_server_with_vns_id_from_db(self): - vns_id = self.get_pref_vns_id() - - temp_dir= expanduser("~") - file_name = '%s/server_with_vns_id_from_db.json' %(temp_dir) - - if self.test_local: - local('server-manager show --detail server --vns_id %s \ - | tr -d "\n" \ - | sed "s/[^{]*//" \ - > %s' %(vns_id, file_name)) - - else: - svrmgr = self.params - with settings(host_string=svrmgr, warn_only=True): - temp_dir= tempfile.mkdtemp() - run('mkdir -p %s' % temp_dir) - file_name = '%s/server_list.json' %(temp_dir) - - run('server-manager show --detail server --vns_id %s \ - | tr -d "\n" \ - | sed \'s/[^{]*//\' \ - | python -m json.tool \ - > %s' %(vns_id, file_name) ) - - local('mkdir -p %s' % temp_dir) - get( file_name, file_name ) - - in_file = open( file_name, 'r' ) - in_data = in_file.read() - server_dict = json.loads(in_data) - return server_dict - - def get_vns_with_vns_id_from_db(self): - params=self.params - vns_id = params['vns_id'] - - vns_dict = {"vns": []} - - temp_dir= expanduser("~") - - file_name = '%s/vns.json' %(temp_dir) - - if self.test_local: - local('server-manager show --detail vns --vns_id %s \ - | tr -d "\n" \ - | sed "s/[^{]*//" \ - > %s' %(vns_id, file_name)) - else: - svrmgr = self.svrmgr - with settings(host_string=svrmgr, warn_only=True): - temp_dir= tempfile.mkdtemp() - run('mkdir -p %s' % temp_dir) - file_name = '%s/vns.json' %(temp_dir) - run('server-manager show --detail vns --vns_id %s \ - | tr -d "\n" \ - | sed \'s/[^{]*//\' \ - | python -m json.tool \ - > %s' %(vns_id, file_name) ) - local('mkdir -p %s' % temp_dir) - get( file_name, file_name ) - - in_file = open( file_name, 'r' ) - in_data = in_file.read() - - vns_dict = json.loads(in_data) - return vns_dict - - - def get_server_with_ip_from_db(self, ip=None): - params=self.params - - server_dict={} - if not ip: - print "Please provide an ip as input arg" - return ip - - temp_dir= expanduser("~") - - file_name = '%s/server.json' %(temp_dir) - - if self.test_local: - local('server-manager show --detail server --ip %s \ - | tr -d "\n" \ - | sed "s/[^{]*//" \ - > %s' %(ip, file_name)) - else: - svrmgr = self.svrmgr - with settings(host_string=svrmgr, warn_only=True): - temp_dir= tempfile.mkdtemp() - run('mkdir -p %s' % temp_dir) - file_name = '%s/server.json' %(temp_dir) - run('server-manager show --detail server --ip %s \ - | tr -d "\n" \ - | sed \'s/[^{]*//\' \ - | python -m json.tool \ - > %s' %(ip, file_name) ) - local('mkdir -p %s' % temp_dir) - get( file_name, file_name ) - - in_file = open( file_name, 'r' ) - in_data = in_file.read() - server_dict = json.loads(in_data) - return server_dict - - def get_host_roles_from_testbed_py(self): - node = {} - if not testbed.env.has_key('roledefs'): - return node - for key in testbed.env.roledefs: - if key == 'all' or key == 'build': - continue - for host_string in testbed.env.roledefs[key]: - ip = getIp(host_string) - if not node.has_key(ip): - node[ip] = [] - if key == 'cfgm': - node[ip].append('config') - else: - node[ip].append(key) - return node - # end get_host_roles_from_testbed_py - - def update_server_in_db_with_testbed_py(self): - vns_id = self.get_pref_vns_id() - node = self.get_host_roles_from_testbed_py() - if not node: - return - u_server_dict = {} - u_server_dict['server'] = [] - for key in node: - server_dict = {} - server_dict = get_server_with_ip_from_db(key) - if not server_dict or not server_dict['server']: - print ("ERROR: Server with ip %s not present in Server Manager" % key) - continue - server_id = server_dict['server'][0]['server_id'] - u_server = {} - u_server['server_id'] = server_id - u_server['vns_id'] = vns_id - u_server['roles'] = node[key] - u_server_dict['server'].append(u_server) - - temp_dir= expanduser("~") - server_file = '%s/server.json' %temp_dir - local('touch %s' %server_file) - out_file = open(server_file, 'w') - out_data = json.dumps(u_server_dict, indent=4) - out_file.write(out_data) - out_file.close() - - if self.test_local: - local('server-manager add server -f %s' %(server_file) ) - for u_server in u_server_dict['server']: - local('server-manager show --detail server --server_id %s' \ - % u_server['server_id'] ) - else: - svrmgr = self.svrmgr - with settings(host_string=svrmgr, warn_only=True): - file_name = os.path.basename(server_file) - temp_dir= tempfile.mkdtemp() - run('mkdir -p %s' % temp_dir) - put(server_file, '%s/%s' % (temp_dir, file_name)) - run('server-manager add server -f %s/%s' %(temp_dir, file_name) ) - run('server-manager show --detail server --server_id %s | python -m json.tool' %server_id) - - #End update_server_in_db_with_vns_id - - - def get_pref_vns_id(self): - vns_id = None - params=read_ini_file(config_ini) - if params.has_key('vns_id'): - vns_id = params['vns_id'] - else: - vns_id = get_vns_id() - - return vns_id - - def get_svrmgr(self): - svrmgr = None - params=self.params - if params.has_key('svrmgr'): - svrmgr = params['svrmgr'] - return params['svrmgr'] - - def get_server_file(self): - params=self.params - if not params: - return None - if not params.has_key('server_file'): - return None - server_file = params['server_file'] - return server_file - - -# end SmgrFixture From ab770474c8804998bd24598ed29f04b0982ad336 Mon Sep 17 00:00:00 2001 From: Rishi Verma Date: Tue, 19 Aug 2014 00:10:01 +0530 Subject: [PATCH 12/15] review-name-changes and new tags --- scripts/smgr/smgr_regression.py | 20 +++++++++----------- scripts/smgr/smgr_setup.py | 2 +- 2 files changed, 10 insertions(+), 12 deletions(-) diff --git a/scripts/smgr/smgr_regression.py b/scripts/smgr/smgr_regression.py index b98252a30..a48ce5999 100644 --- a/scripts/smgr/smgr_regression.py +++ b/scripts/smgr/smgr_regression.py @@ -44,19 +44,17 @@ def runTest(self): #@preposttest_wrapper - def test_reimage(self): - """Verify reimage using server manager in a multinode setup""" - self.logger.info("Verify reimage using server manager ") - #self.res.smgr_fixture.reimage() - pass - + def test_setup_cluster(self): + """Verify setup cluster using server Manager""" + self.logger.info("Verify setup cluster using server manager ") + assert self.res.smgr_fixture.setup_cluster() return True #@preposttest_wrapper - def test_provision(self): - """Verify provision using server manager in a multinode setup""" - self.logger.info("Verify provision using server manager in a multinode setup") - self.res.smgr_fixture.setup_cluster() - + def test_setup_cluster_with_no_pkg_during_reimage(self): + """Verify setup cluster using server manager. Reimage with base os only.""" + self.logger.info("Verify setup cluster using server manager. Reimage with base os only. ") + assert self.res.smgr_fixture.setup_cluster(no_reimage_pkg=True) return True + diff --git a/scripts/smgr/smgr_setup.py b/scripts/smgr/smgr_setup.py index 3d3544406..98bbb10b1 100644 --- a/scripts/smgr/smgr_setup.py +++ b/scripts/smgr/smgr_setup.py @@ -50,7 +50,7 @@ def setup(self): """Config common resources.""" self.smgr_fixture = self.useFixture(SmgrFixture( self.inputs, testbed_py=self.testbed_py, smgr_config_ini=self.smgr_file, - test_local=False)) + test_local=True)) self.logger.info("Adding Server to smgr DB") self.smgr_fixture.svrmgr_add_all() From c7fe4a14524103c53f32b6dd3f798aedec3edd96 Mon Sep 17 00:00:00 2001 From: Rishi Verma Date: Tue, 19 Aug 2014 00:16:10 +0530 Subject: [PATCH 13/15] review name changes and new tag --- fixtures/smgr_common.py | 1 - 1 file changed, 1 deletion(-) diff --git a/fixtures/smgr_common.py b/fixtures/smgr_common.py index 26c801130..1c978bb31 100644 --- a/fixtures/smgr_common.py +++ b/fixtures/smgr_common.py @@ -1,7 +1,6 @@ import fixtures from contrail_fixtures import * import sys -import pdb import json import string import textwrap From 7cfd592ed4d68eabe1ed98dc1bc2f84967bd43bc Mon Sep 17 00:00:00 2001 From: Rishi Verma Date: Tue, 19 Aug 2014 00:22:13 +0530 Subject: [PATCH 14/15] cluster status verification and other changes --- fixtures/smgr_common.py | 666 +++++++++++++++++++++++++++++----------- 1 file changed, 486 insertions(+), 180 deletions(-) diff --git a/fixtures/smgr_common.py b/fixtures/smgr_common.py index 1c978bb31..6daca80b4 100644 --- a/fixtures/smgr_common.py +++ b/fixtures/smgr_common.py @@ -1,6 +1,7 @@ import fixtures from contrail_fixtures import * import sys +import pdb import json import string import textwrap @@ -20,14 +21,14 @@ import imp import fabfile.tasks.verify as verify from fabric.state import connections -from fabfile.utils.host import verify_sshd +#from fabfile.utils.host import verify_sshd from time import sleep REIMAGE_WAIT=360 SERVER_RETRY_TIME=1000 -PROVISION_TIME = 1000 +PROVISION_TIME = 1200 class SmgrFixture(fixtures.Fixture): @@ -49,15 +50,17 @@ def __init__(self, inputs, testbed_py="./testbed.py", smgr_config_ini="./smgr_in def svrmgr_add_all(self): self.create_json() - self.add_vns() + self.add_cluster() self.add_image() self.add_pkg() self.add_server() + # end svrmgr_add_all def create_json(self): self.modify_server_json() - self.modify_vns_json() + self.modify_cluster_json() + # end create_json def modify_server_json(self): params=self.params @@ -84,6 +87,7 @@ def modify_server_json(self): out_file.close() return server_dict + # end modify_server_json def update_roles_from_testbed_py(self, server_dict): testbed = self.testbed @@ -96,7 +100,7 @@ def update_roles_from_testbed_py(self, server_dict): continue for host_string in testbed.env.roledefs[key]: ip = getIp(host_string) - if node['ip'] == ip: + if node['ip_address'] == ip: if key == 'cfgm': roles.append("config") else: @@ -107,7 +111,7 @@ def update_roles_from_testbed_py(self, server_dict): node['roles'] = roles for node in server_dict['server']: - node['vns_id'] = self.get_pref_vns_id() + node['cluster_id'] = self.get_pref_cluster_id() return server_dict # end update_roles_from_testbed_py @@ -119,10 +123,8 @@ def update_bond_from_testbed_py(self, server_dict): for node in server_dict['server']: for key in testbed.bond: ip = getIp(key) - if node['ip'] == ip: - node['server_params']['setup_interface'] = "Yes" - node['server_params']['compute_non_mgmt_ip'] = "" - node['server_params']['compute_non_mgmt_gw'] = "" + if node['ip_address'] == ip: + node['parameters']['setup_interface'] = "Yes" name = testbed.bond[key]['name'] mode = testbed.bond[key]['mode'] @@ -136,7 +138,6 @@ def update_bond_from_testbed_py(self, server_dict): node['bond'][name]={} node['bond'][name]['bond_options'] = "%s"%option node['bond'][name]['member'] = "%s"%member - return server_dict #End update_bond_from_testbed_py(server_dict): @@ -148,19 +149,17 @@ def update_multi_if_from_testbed_py(self, server_dict): for node in server_dict['server']: for key in testbed.control_data: ip = getIp(key) - if node['ip'] == ip: - node['server_params']['setup_interface'] = "Yes" - node['server_params']['compute_non_mgmt_ip'] = "" - node['server_params']['compute_non_mgmt_gway'] = "" + if node['ip_address'] == ip: + node['parameters']['setup_interface'] = "Yes" ip = testbed.control_data[key]['ip'] gw = testbed.control_data[key]['gw'] device = testbed.control_data[key]['device'] - node['control']={} - node['control'][device] = {} - node['control'][device]['ip'] = ip - node['control'][device]['gw'] = gw + node['control_data_network']={} + node['control_data_network'][device] = {} + node['control_data_network'][device]['ip_address'] = ip + node['control_data_network'][device]['gateway'] = gw return server_dict @@ -174,7 +173,7 @@ def get_image_id(self) : image_file = open( image_file, 'r' ) image_data = image_file.read() image_json = json.loads(image_data) - image_id = image_json['image'][0]['image_id'] + image_id = image_json['image'][0]['id'] image_file.close() return image_id # end get_image_id() @@ -186,86 +185,83 @@ def get_pkg_id(self) : pkg_file = open( pkg_file, 'r' ) pkg_data = pkg_file.read() pkg_json = json.loads(pkg_data) - pkg_id = pkg_json['image'][0]['image_id'] + pkg_id = pkg_json['image'][0]['id'] pkg_file.close() return pkg_id # end get_pkg_id() - def get_vns_id(self) : - vns_id = None + def get_cluster_id(self) : + cluster_id = None params=self.params - vns_file = params['vns_file'] - - vns_file = open( vns_file, 'r' ) - vns_data = vns_file.read() - vns_json = json.loads(vns_data) - vns_id = vns_json['vns'][0]['vns_id'] - if params.has_key('vns_id'): - vns_id = params['vns_id'] - vns_file.close() - return vns_id + cluster_file = params['cluster_file'] - # end get_vns_id() + cluster_file = open( cluster_file, 'r' ) + cluster_data = cluster_file.read() + cluster_json = json.loads(cluster_data) + cluster_id = cluster_json['cluster'][0]['id'] + if params.has_key('cluster_id'): + cluster_id = params['cluster_id'] + cluster_file.close() + return cluster_id + # end get_cluster_id() - def add_vns(self): - vns_file = None + def add_cluster(self): + cluster_file = None params=self.params - if params.has_key('vns_file'): - vns_file = params['vns_file'] - - vns_id = self.get_pref_vns_id() - if not vns_file: - vns_dict = self.get_vns_with_vns_id_from_db() - if not len(vns_dict['vns']): - vns_dict = new_vns() + if params.has_key('cluster_file'): + cluster_file = params['cluster_file'] + + cluster_id = self.get_pref_cluster_id() + if not cluster_file: + cluster_dict = self.get_cluster_with_cluster_id_from_db() + if not len(cluster_dict['cluster']): + cluster_dict = new_cluster() else: - vns_dict = { - "vns" : [ + cluster_dict = { + "cluster" : [ { - "vns_id" : "", - "vns_params" : { + "cluster_id" : "", + "parameters" : { } } ] } - vns_dict['vns'][0]['vns_id'] = vns_id - self.modify_vns_from_testbed_py(vns_dict) + cluster_dict['cluster'][0]['id'] = cluster_id + self.modify_cluster_from_testbed_py(cluster_dict) temp_dir= expanduser("~") - vns_file = '%s/vns.json' %temp_dir - local('touch %s' %vns_file) - out_file = open(vns_file, 'w') - out_data = json.dumps(vns_dict, indent=4) + cluster_file = '%s/cluster.json' %temp_dir + local('touch %s' %cluster_file) + out_file = open(cluster_file, 'w') + out_data = json.dumps(cluster_dict, indent=4) out_file.write(out_data) out_file.close() else : timestamp = dt.now().strftime("%Y_%m_%d_%H_%M_%S") - local('cp %s %s.org.%s' %(vns_file, vns_file, timestamp)) - local("sed -i 's/\"vns_id\".*,/\"vns_id\":\"%s\",/' %s" %(vns_id,vns_file)) - local("sed -i 's/\"vns_id\".*/\"vns_id\":\"%s\"/' %s" %(vns_id,vns_file)) + local('cp %s %s.org.%s' %(cluster_file, cluster_file, timestamp)) + local("sed -i 's/\"id\"\s*:\s*\".*\"/\"id\":\"%s\"/' %s" %(cluster_id,cluster_file)) if self.test_local: - local('server-manager add vns -f %s' %(vns_file)) + local('server-manager add cluster -f %s' %(cluster_file)) else: svrmgr = self.svrmgr with settings(host_string=svrmgr, warn_only=True): - file_name = os.path.basename(vns_file) + file_name = os.path.basename(cluster_file) temp_dir= tempfile.mkdtemp() run('mkdir -p %s' % temp_dir) - put(vns_file, '%s/%s' % (temp_dir, file_name)) + put(cluster_file, '%s/%s' % (temp_dir, file_name)) - run('server-manager add vns -f %s/%s' %(temp_dir, file_name) ) + run('server-manager add cluster -f %s/%s' %(temp_dir, file_name) ) run('server-manager show all | python -m json.tool') - - - # end add_vns() + # end add_cluster() def add_server(self): self.add_server_using_json() self.update_server_in_db_with_testbed_py() + #end add_server def add_image(self): params=self.params @@ -288,6 +284,7 @@ def add_image(self): run('server-manager add image -f %s/%s' %(temp_dir, file_name) ) run('server-manager show all | python -m json.tool') + #end add_image def add_pkg(self): params=self.params @@ -310,6 +307,7 @@ def add_pkg(self): run('server-manager add image -f %s/%s' %(temp_dir, file_name) ) run('server-manager show all | python -m json.tool') + #end add_pkg def add_server_using_json(self): params=self.params @@ -332,57 +330,64 @@ def add_server_using_json(self): put(server_file, '%s/%s' % (temp_dir, file_name)) run('server-manager add server -f %s/%s' %(temp_dir, file_name) ) run('server-manager show all | python -m json.tool') + #end add_server_using_json - - def modify_vns_json(self): + def modify_cluster_json(self): params=self.params if not params: return None - if not params.has_key('vns_file'): + if not params.has_key('cluster_file'): return None - vns_file = params['vns_file'] + cluster_file = params['cluster_file'] timestamp = dt.now().strftime("%Y_%m_%d_%H_%M_%S") - local('cp %s %s.org.%s' %(vns_file, vns_file, timestamp)) + local('cp %s %s.org.%s' %(cluster_file, cluster_file, timestamp)) - in_file = open( vns_file, 'r' ) + in_file = open( cluster_file, 'r' ) in_data = in_file.read() - vns_dict = json.loads(in_data) + cluster_dict = json.loads(in_data) - self.modify_vns_from_testbed_py(vns_dict) + self.modify_cluster_from_testbed_py(cluster_dict) - out_file = open(vns_file, 'w') - out_data = json.dumps(vns_dict, indent=4) + out_file = open(cluster_file, 'w') + out_data = json.dumps(cluster_dict, indent=4) out_file.write(out_data) out_file.close() + #end modify_cluster_json - def modify_vns_from_testbed_py(self, vns_dict): + def modify_cluster_from_testbed_py(self, cluster_dict): testbed = self.testbed if testbed.env.has_key('mail_to'): - vns_dict['vns'][0]['email'] = testbed.env.mail_to + cluster_dict['cluster'][0]['email'] = testbed.env.mail_to if testbed.env.has_key('encap_priority'): - vns_dict['vns'][0]['vns_params']['encap_priority'] = testbed.env.encap_priority + cluster_dict['cluster'][0]['parameters']['encapsulation_priority'] = testbed.env.encap_priority if 'multi_tenancy' in dir(testbed): - vns_dict['vns'][0]['vns_params']['multi_tenancy'] = testbed.multi_tenancy + if testbed.multi_tenancy == True : + cluster_dict['cluster'][0]['parameters']['multi_tenancy'] = "True" + elif testbed.multi_tenancy == False : + cluster_dict['cluster'][0]['parameters']['multi_tenancy'] = "False" + else: + cluster_dict['cluster'][0]['parameters']['multi_tenancy'] = "False" if 'os_username' in dir(testbed): - vns_dict['vns'][0]['vns_params']['ks_user'] = testbed.os_username + cluster_dict['cluster'][0]['parameters']['keystone_username'] = testbed.os_username if 'os_password' in dir(testbed): - vns_dict['vns'][0]['vns_params']['ks_passwd'] = testbed.os_password + cluster_dict['cluster'][0]['parameters']['keystone_password'] = testbed.os_password if 'os_tenant_name' in dir(testbed): - vns_dict['vns'][0]['vns_params']['ks_tenant'] = testbed.os_tenant_name + cluster_dict['cluster'][0]['parameters']['keystone_tenant'] = testbed.os_tenant_name if 'router_asn' in dir(testbed): - vns_dict['vns'][0]['vns_params']['router_asn'] = testbed.router_asn + cluster_dict['cluster'][0]['parameters']['router_asn'] = testbed.router_asn + #end modify_cluster_from_testbed_py - def new_vns(self): + def new_cluster(self): params=self.params - vns_id = params['vns_id'] - vns_dict = { - "vns" : [ + cluster_id = params['cluster'] + cluster_dict = { + "cluster" : [ { - "vns_id" : vns_id, - "vns_params" : { + "id" : cluster_id, + "parameters" : { "router_asn": "64512", "database_dir": "/home/cassandra", "db_initial_token": "", @@ -391,26 +396,22 @@ def new_vns(self): "multi_tenancy": "False", "encap_priority": "'MPLSoUDP','MPLSoGRE','VXLAN'", "service_token": "contrail123", - "ks_user": "admin", - "ks_passwd": "contrail123", - "ks_tenant": "admin", - "openstack_passwd": "contrail123", + "keystone_user": "admin", + "keystone_password": "contrail123", + "keystone_tenant": "admin", + "openstack_password": "contrail123", "analytics_data_ttl": "168", - "mask": "255.255.255.0", - "gway": "1.1.1.254", - "passwd": "c0ntrail123", + "subnet_mask": "255.255.255.0", + "gateway": "1.1.1.254", + "password": "c0ntrail123", "domain": "contrail.juniper.net", "haproxy": "disable" } } ] } - return vns_dict - - - - # End new_vns() - + return cluster_dict + # End new_cluster() def read_ini_file(self, config_ini): try: @@ -422,21 +423,20 @@ def read_ini_file(self, config_ini): sys.exit("Error reading config file %s" %config_ini) return smgr_config + #end read_ini_file - # End read_ini_file - - def get_server_with_vns_id_from_db(self): - vns_id = self.get_pref_vns_id() + def get_server_with_cluster_id_from_db(self): + cluster_id = self.get_pref_cluster_id() temp_dir= expanduser("~") - file_name = '%s/server_with_vns_id_from_db.json' %(temp_dir) + file_name = '%s/server_with_cluster_id_from_db.json' %(temp_dir) if self.test_local: - local('server-manager show --detail server --vns_id %s \ + local('server-manager show server --cluster_id %s --detail \ | tr -d "\n" \ | sed "s/[^{]*//" \ - > %s' %(vns_id, file_name)) + > %s' %(cluster_id, file_name)) else: svrmgr = self.params @@ -445,11 +445,11 @@ def get_server_with_vns_id_from_db(self): run('mkdir -p %s' % temp_dir) file_name = '%s/server_list.json' %(temp_dir) - run('server-manager show --detail server --vns_id %s \ + run('server-manager show server --cluster_id %s --detail \ | tr -d "\n" \ | sed \'s/[^{]*//\' \ | python -m json.tool \ - > %s' %(vns_id, file_name) ) + > %s' %(cluster_id, file_name) ) local('mkdir -p %s' % temp_dir) get( file_name, file_name ) @@ -458,41 +458,43 @@ def get_server_with_vns_id_from_db(self): in_data = in_file.read() server_dict = json.loads(in_data) return server_dict + #end get_server_with_cluster_id_from_db - def get_vns_with_vns_id_from_db(self): + def get_cluster_with_cluster_id_from_db(self): params=self.params - vns_id = params['vns_id'] + cluster_id = params['cluster_id'] - vns_dict = {"vns": []} + cluster_dict = {"cluster": []} temp_dir= expanduser("~") - file_name = '%s/vns.json' %(temp_dir) + file_name = '%s/cluster.json' %(temp_dir) if self.test_local: - local('server-manager show --detail vns --vns_id %s \ + local('server-manager show cluster --cluster_id %s --detail \ | tr -d "\n" \ | sed "s/[^{]*//" \ - > %s' %(vns_id, file_name)) + > %s' %(cluster_id, file_name)) else: svrmgr = self.svrmgr with settings(host_string=svrmgr, warn_only=True): temp_dir= tempfile.mkdtemp() run('mkdir -p %s' % temp_dir) - file_name = '%s/vns.json' %(temp_dir) - run('server-manager show --detail vns --vns_id %s \ + file_name = '%s/cluster.json' %(temp_dir) + run('server-manager show cluster --cluster_id %s --detail\ | tr -d "\n" \ | sed \'s/[^{]*//\' \ | python -m json.tool \ - > %s' %(vns_id, file_name) ) + > %s' %(cluster_id, file_name) ) local('mkdir -p %s' % temp_dir) get( file_name, file_name ) in_file = open( file_name, 'r' ) in_data = in_file.read() - vns_dict = json.loads(in_data) - return vns_dict + cluster_dict = json.loads(in_data) + return cluster_dict + #end get_cluster_with_cluster_id_from_db(self): def get_server_with_ip_from_db(self, ip=None): @@ -508,7 +510,7 @@ def get_server_with_ip_from_db(self, ip=None): file_name = '%s/server.json' %(temp_dir) if self.test_local: - local('server-manager show --detail server --ip %s \ + local('server-manager show server --ip %s --detail \ | tr -d "\n" \ | sed "s/[^{]*//" \ > %s' %(ip, file_name)) @@ -518,7 +520,7 @@ def get_server_with_ip_from_db(self, ip=None): temp_dir= tempfile.mkdtemp() run('mkdir -p %s' % temp_dir) file_name = '%s/server.json' %(temp_dir) - run('server-manager show --detail server --ip %s \ + run('server-manager show server --ip %s --detail \ | tr -d "\n" \ | sed \'s/[^{]*//\' \ | python -m json.tool \ @@ -530,6 +532,7 @@ def get_server_with_ip_from_db(self, ip=None): in_data = in_file.read() server_dict = json.loads(in_data) return server_dict + #end get_server_with_ip_from_db(self, ip=None): def get_host_roles_from_testbed_py(self): testbed = self.testbed @@ -551,7 +554,7 @@ def get_host_roles_from_testbed_py(self): # end get_host_roles_from_testbed_py def update_server_in_db_with_testbed_py(self): - vns_id = self.get_pref_vns_id() + cluster_id = self.get_pref_cluster_id() node = self.get_host_roles_from_testbed_py() if not node: return @@ -561,12 +564,12 @@ def update_server_in_db_with_testbed_py(self): server_dict = {} server_dict = self.get_server_with_ip_from_db(key) if not server_dict or not server_dict['server']: - print ("ERROR: Server with ip %s not present in Server Manager" % key) + self.logger.error("Server with ip %s not present in Server Manager" % key) continue - server_id = server_dict['server'][0]['server_id'] + server_id = server_dict['server'][0]['id'] u_server = {} - u_server['server_id'] = server_id - u_server['vns_id'] = vns_id + u_server['id'] = server_id + u_server['cluster_id'] = cluster_id u_server['roles'] = node[key] u_server_dict['server'].append(u_server) @@ -581,8 +584,8 @@ def update_server_in_db_with_testbed_py(self): if self.test_local: local('server-manager add server -f %s' %(server_file) ) for u_server in u_server_dict['server']: - local('server-manager show --detail server --server_id %s' \ - % u_server['server_id'] ) + local('server-manager show server --server_id %s --detail' \ + % u_server['id'] ) else: svrmgr = self.svrmgr with settings(host_string=svrmgr, warn_only=True): @@ -591,20 +594,18 @@ def update_server_in_db_with_testbed_py(self): run('mkdir -p %s' % temp_dir) put(server_file, '%s/%s' % (temp_dir, file_name)) run('server-manager add server -f %s/%s' %(temp_dir, file_name) ) - run('server-manager show --detail server --server_id %s | python -m json.tool' %server_id) - - #End update_server_in_db_with_vns_id - + run('server-manager show server --server_id %s --detail | python -m json.tool' %server_id) + #end update_server_in_db_with_cluster_id - def get_pref_vns_id(self): - vns_id = None + def get_pref_cluster_id(self): + cluster_id = None params=self.read_ini_file(self.smgr_config_ini) - if params.has_key('vns_id'): - vns_id = params['vns_id'] + if params.has_key('cluster_id'): + cluster_id = params['cluster_id'] else: - vns_id = self.get_vns_id() - - return vns_id + cluster_id = self.get_cluster_id() + return cluster_id + #end get_pref_cluster_id(self): def get_svrmgr(self): svrmgr = None @@ -612,6 +613,7 @@ def get_svrmgr(self): if params.has_key('svrmgr'): svrmgr = params['svrmgr'] return params['svrmgr'] + #end get_svrmgr(self): def get_server_file(self): params=self.params @@ -621,6 +623,7 @@ def get_server_file(self): return None server_file = params['server_file'] return server_file + #end get_server_file(self): def get_testbed(self): filepath = self.testbed_py @@ -630,45 +633,239 @@ def get_testbed(self): if file_ext.lower() == '.py': py_mod = imp.load_source(mod_name, filepath) - return py_mod + #end get_testbed(self): def verify_roles(self): + result = True for node in env.roledefs['database']: with settings(host_string=node, warn_only=True): - verify.verify_database() + try: + verify.verify_database() + except SystemExit: + self.logger.error('verify_database has Failed') + result = result and False for node in env.roledefs['cfgm']: with settings(host_string=node, warn_only=True): - verify.verify_cfgm() + try: + verify.verify_cfgm() + except SystemExit: + self.logger.error('verify_cfgm has Failed') + result = result and False for node in env.roledefs['control']: with settings(host_string=node, warn_only=True): - verify.verify_control() + try: + verify.verify_control() + except SystemExit: + self.logger.error('verify_control has Failed') + result = result and False for node in env.roledefs['collector']: with settings(host_string=node, warn_only=True): - verify.verify_collector() + try: + verify.verify_collector() + except SystemExit: + self.logger.error('verify_collector has Failed') + result = result and False for node in env.roledefs['webui']: with settings(host_string=node, warn_only=True): - verify.verify_webui() + try: + verify.verify_webui() + except SystemExit: + self.logger.error('verify_webui has Failed') + result = result and False for node in env.roledefs['compute']: with settings(host_string=node, warn_only=True): - verify.verify_compute() + try: + verify.verify_compute() + except SystemExit: + self.logger.error('verify_compute has Failed') + result = result and False for node in env.roledefs['openstack']: with settings(host_string=node, warn_only=True): - verify.verify_openstack() - - def reimage(self): + try: + verify.verify_openstack() + except SystemExit: + self.logger.error('verify_openstack has Failed') + result = result and False + return result + #end verify_roles(self): + + def verify_contrail_status(self): + result = True + if not self.verify_database(): + result = result and False + if not self.verify_cfgm(): + result = result and False + if not self.verify_control(): + result = result and False + if not self.verify_collector(): + result = result and False + if not self.verify_webui(): + result = result and False + if not self.verify_compute(): + result = result and False + if not self.verify_openstack(): + result = result and False + return result + #end verify_contrail_status + + def verify_openstack(self): + result = True + for node in env.roledefs['openstack']: + with settings(host_string=node, warn_only=True): + output = run('source /etc/contrail/keystonerc') + output = run('openstack-status') + pattern = ["== Nova services ==", + "openstack-nova-api: active", + "openstack-nova-compute: inactive (disabled on boot)", + "openstack-nova-network: inactive (disabled on boot)", + "openstack-nova-scheduler: active", + "openstack-nova-volume: inactive (disabled on boot)", + "openstack-nova-conductor: active", + "== Glance services ==", + "openstack-glance-api: active", + "openstack-glance-registry: active", + "== Keystone service ==", + "openstack-keystone: active", + "== Cinder services ==", + "openstack-cinder-api: active", + "openstack-cinder-scheduler: active", + "openstack-cinder-volume: inactive (disabled on boot)", + "== Support services ==", + "mysql: inactive (disabled on boot)", + "rabbitmq-server: active", + "memcached: inactive (disabled on boot)", + "== Keystone users =="] + for line in pattern: + if line not in output: + self.logger.error('verify %s has Failed' %line) + result = result and False + return result + #end verify_openstack(self): + + def verify_compute(self): + result = True + for node in env.roledefs['compute']: + with settings(host_string=node, warn_only=True): + output = run('contrail-status') + pattern = ["supervisor-vrouter: active", + "contrail-vrouter-agent active", + "contrail-vrouter-nodemgr active"] + for line in pattern: + if line not in output: + self.logger.error('verify %s has Failed' %line) + result = result and False + return result + #end verify_compute(self): + + def verify_webui(self): + result = True + for node in env.roledefs['webui']: + with settings(host_string=node, warn_only=True): + output = run('contrail-status') + pattern = ["supervisor-webui: active", + "contrail-webui active", + "contrail-webui-middleware active", + "redis-webui active"] + for line in pattern: + if line not in output: + self.logger.error('verify %s has Failed' %line) + result = result and False + return result + #end verify_webui(self): + + def verify_collector(self): + result = True + for node in env.roledefs['collector']: + with settings(host_string=node, warn_only=True): + output = run('contrail-status') + pattern = ["supervisor-analytics: active", + "contrail-analytics-api active", + "contrail-analytics-nodemgr active", + "contrail-collector active", + "contrail-query-engine active"] + for line in pattern: + if line not in output: + self.logger.error('verify %s has Failed' %line) + result = result and False + return result + #end verify_collector(self): + + def verify_database(self): + result = True + for node in env.roledefs['database']: + with settings(host_string=node, warn_only=True): + output = run('contrail-status') + pattern = ["supervisord-contrail-database:active", + "contrail-database active", + "contrail-database-nodemgr active"] + for line in pattern: + if line not in output: + self.logger.error('verify %s has Failed' %line) + result = result and False + return result + #end verify_database(self): + + def verify_cfgm(self): + result = True + for node in env.roledefs['cfgm']: + with settings(host_string=node, warn_only=True): + output = run('contrail-status') + pattern = ["supervisor-config: active", + "contrail-api:0 active", + "contrail-config-nodemgr active", + "contrail-discovery:0 active", + "contrail-schema active", + "contrail-svc-monitor active", + "ifmap active", + "rabbitmq-server active"] + + for line in pattern: + if line not in output: + self.logger.error('verify %s has Failed' %line) + result = result and False + return result + #end verify_cfgm(self): + + def verify_control(self): + result = True + for node in env.roledefs['control']: + with settings(host_string=node, warn_only=True): + output = run('contrail-status') + pattern = ["supervisor-control: active", + "contrail-control active", + "contrail-control-nodemgr active", + "contrail-dns active", + "contrail-named active"] + for line in pattern: + if line not in output: + self.logger.error('verify %s has Failed' %line) + result = result and False + return result + #end verify_control(self): + + def reimage(self, no_pkg=False): """ using svrmgr, reimage all the nodes """ + result = True image_id = self.get_image_id() pkg_id = self.get_pkg_id() - vns_id = self.get_vns_id() + cluster_id = self.get_cluster_id() svrmgr = self.get_svrmgr() with settings(host_string=svrmgr, warn_only=True): - run('server-manager show all | python -m json.tool') - run('server-manager reimage --package_image_id %s --vns_id %s %s' %(pkg_id,vns_id,image_id)) - + if no_pkg: + output=run('server-manager reimage --cluster_id %s %s' %(cluster_id,image_id)) + else: + output=run('server-manager reimage --package_image_id %s --cluster_id %s %s' %(pkg_id,cluster_id,image_id)) + if "reimage issued" not in output: + self.logger.warn("Reimage command was not successfull") + + if not self.verify_server_status("reimage_issued") : + self.logger.error("server status \"reimage_issued\" not correctly updated") + result = result and False + self.logger.info("Server Rebooted. Going to sleep for %d seconds...." %REIMAGE_WAIT) sleep(REIMAGE_WAIT) user = "root" @@ -680,18 +877,18 @@ def reimage(self): server_dict = json.loads(in_data) for node in server_dict['server']: - server_ip = node['ip'] + server_ip = node['ip_address'] server_state[server_ip] = False for retry in range(SERVER_RETRY_TIME): for node in server_dict['server']: - server_ip = node['ip'] + server_ip = node['ip_address'] if not verify_sshd(server_ip, user, env.password): sleep(1) - print "Node %s not reachable....retrying" %(server_ip) + self.logger.info("Node %s not reachable....retrying" %(server_ip)) server_state[server_ip] = False else: - print "Node %s is UP" %(server_ip) + self.logger.info("Node %s is UP" %(server_ip)) if server_state[server_ip] == False: target_node = '%s@%s' %(user,server_ip) with settings( host_string = target_node ): @@ -702,49 +899,146 @@ def reimage(self): if uptime > 3 : raise RuntimeError('Restart failed for Host (%s)' %server_ip) else : - print "Node %s has rebooted and UP now" %(server_ip) - output = run('dpkg -l | grep contrail') - match = re.search('contrail-fabric-utils\s+(\S+)\s+', output, re.M) - if pkg_id not in match.group(1) : - raise RuntimeError('Reimage not able to download package %s on targetNode (%s)' \ + self.logger.info("Node %s has rebooted and UP now" %(server_ip)) + if not no_pkg: + output = run('dpkg -l | grep contrail') + match = re.search('contrail-fabric-utils\s+(\S+)\s+', output, re.M) + if pkg_id not in match.group(1) : + raise RuntimeError('Reimage not able to download package %s on targetNode (%s)' \ %(pkg_id, server_ip) ) - match = re.search('contrail-install-packages\s+(\S+)\s+', output, re.M) - if pkg_id not in match.group(1) : - raise RuntimeError('Reimage not able to download package %s on targetNode (%s)' \ + match = re.search('contrail-install-packages\s+(\S+)\s+', output, re.M) + if pkg_id not in match.group(1) : + raise RuntimeError('Reimage not able to download package %s on targetNode (%s)' \ %(pkg_id, server_ip) ) server_state[server_ip] = True #End for node in server_dict['server']: - result = True + cluster_state = True for key in server_state: - result = result and server_state[key] + cluster_state = cluster_state and server_state[key] - if result == True: + if cluster_state == True: break #End for key in server: #End for retry in range(SERVER_RETRY_TIME): - if not result: + if not cluster_state: raise RuntimeError('Unable to SSH to one or more Host ' ) + if not self.verify_server_status("datacenter", "demo-dc", "reimage_completed") : + result = result and False + + return result + #end reimage + def provision(self): - """ using svrmgr, provision the vns """ + """ using svrmgr, provision the cluster """ + result = True image_id = self.get_image_id() pkg_id = self.get_pkg_id() - vns_id = self.get_vns_id() + cluster_id = self.get_cluster_id() svrmgr = self.get_svrmgr() with settings(host_string=svrmgr, warn_only=True): - run('server-manager provision --vns_id %s %s' %(vns_id,pkg_id) ) + output = run('server-manager provision --cluster_id %s %s' %(cluster_id,pkg_id) ) + if "provisioned" not in output: + self.logger.error("provision command was not successfull") + result = result and False run('server-manager show all | python -m json.tool') - - def setup_cluster(self): - self.reimage() - self.provision() + return result + #end provision(self): + + def setup_cluster(self, no_reimage_pkg=False): + result = True + if no_reimage_pkg: + if not self.reimage(no_pkg=True) : + result = result and False + else: + if not self.reimage() : + result = result and False + if not self.provision() : + result = result and False + self.logger.info("Cluster provisioning initiated... Going to sleep for %d seconds...." %PROVISION_TIME) sleep(PROVISION_TIME) - self.verify_roles() + #if not self.verify_roles(): + # result = result and False + if not self.verify_server_status("provision_completed"): + result = result and False + if not self.verify_contrail_status(): + result = result and False + + return result + #end setup_cluster + + def get_cluster_status_having_this_tag(self, tag_name="datacenter", tag_value="demo-dc"): + params=self.params + + server_dict={} + + temp_dir= expanduser("~") + + file_name = '%s/status.json' %(temp_dir) + + if self.test_local: + local('server-manager status server --tag %s=%s \ + | tr -d "\n" \ + | sed "s/[^{]*//" \ + | python -m json.tool \ + > %s' %(tag_name, tag_value, file_name)) + else: + svrmgr = self.svrmgr + with settings(host_string=svrmgr, warn_only=True): + temp_dir= tempfile.mkdtemp() + run('mkdir -p %s' % temp_dir) + file_name = '%s/status.json' %(temp_dir) + run('server-manager status server --tag %s=%s \ + | tr -d "\n" \ + | sed \'s/[^{]*//\' \ + | python -m json.tool \ + > %s' %(tag_name, tag_value, file_name) ) + local('mkdir -p %s' % temp_dir) + get( file_name, file_name ) + + in_file = open( file_name, 'r' ) + in_data = in_file.read() + server_dict = json.loads(in_data) + return server_dict + #end get_cluster_status_having_this_tag + + def verify_server_status(self, status, tag_name="datacenter", tag_value="demo-dc"): + """ verify status of server """ + result = True + expected_state = {} + actual_state = {} + server_file = self.get_server_file() + in_file = open( server_file, 'r' ) + in_data = in_file.read() + in_file.close() + server_dict = json.loads(in_data) + + for node in server_dict['server']: + server_ip = node['ip_address'] + expected_state[server_ip] = status + + status_dict = self.get_cluster_status_having_this_tag() + + for node in status_dict['server']: + server_ip = node['ip_address'] + actual_state[server_ip] = status + + if cmp(expected_state,actual_state) != 0: + self.logger.error( + 'Cluster status \"%s\" is incorrectly updated for %s=%s ' % + (status, tag_name, tag_value)) + result = result and False + else: + self.logger.info( + 'Cluster status \"%s\" is correctly updated for %s=%s ' % + (status, tag_name, tag_value)) + return result + #end verify_server_status # end SmgrFixture @@ -752,8 +1046,20 @@ def setup_cluster(self): def getIp(string) : regEx = re.compile( '\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}' ) result = regEx.search(string) - if result: return result.group() else: return None +#end getIp(string) : + +def verify_sshd(host, user, password): + import paramiko + try: + client = paramiko.SSHClient() + client.set_missing_host_key_policy(paramiko.AutoAddPolicy()) + client.connect(host, username=user, password=password, timeout=5) + except Exception: + return False + client.close() + return True +#end verify_sshd From 69d7f38708243016cd5a7b8e8b75c2a525f3c92a Mon Sep 17 00:00:00 2001 From: Rishi Verma Date: Tue, 19 Aug 2014 00:31:24 +0530 Subject: [PATCH 15/15] corrected description --- scripts/smgr/__init__.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/scripts/smgr/__init__.py b/scripts/smgr/__init__.py index a82e9e238..5096e714a 100644 --- a/scripts/smgr/__init__.py +++ b/scripts/smgr/__init__.py @@ -1 +1 @@ -"""Security group tests.""" +"""server manager test"""