Ejemplo n.º 1
0
    def test_least_loaded_node_scheduler_create_label(self):
        with patch.object(Node.objects, "get_items") as node_objects, \
             patch.object(NodeLabel, "save", autospec=True) as nodelabel_save, \
             patch.object(NodeLabel, "node") as nodelabel_node_add:
            slice = Slice(name="mysite_test1",
                          default_flavor=None,
                          default_isolation="vm")
            instance1 = Instance(id=1)
            node1 = Node(hostname="my.node.com", id=4567)
            node1.instances = MockObjectList(initial=[])
            node2 = Node(hostname="my.node.com", id=8910)
            node2.instances = MockObjectList(initial=[instance1])
            # Fake out the existence of a NodeLabel object. TODO: Extend the mock framework to support the model__field
            # syntax.
            node1.nodelabels__name = None
            node2.nodelabels__name = None
            node_objects.return_value = [node1, node2]

            # should pick the node with the least number of instances

            sched = LeastLoadedNodeScheduler(
                slice, label="foo", constrain_by_service_instance=True)
            (picked_node, parent) = sched.pick()

            self.assertNotEqual(picked_node, None)
            self.assertEqual(picked_node.id, node1.id)

            # NodeLabel should have been created and saved

            self.assertEqual(nodelabel_save.call_count, 1)
            self.assertEqual(nodelabel_save.call_args[0][0].name, "foo")

            # The NodeLabel's node field should have been added to

            NodeLabel.node.add.assert_called_with(node1)
Ejemplo n.º 2
0
 def test_get_lan_network(self):
     with patch.object(VEGService.objects,
                       "get_items") as vegservice_objects:
         vegservice = VEGService(
             name="myvegservice",
             id=1,
             slices=MockObjectList(initial=[self.slice]))
         vegservice_objects.return_value = [vegservice]
         self.tenant.owner = vegservice
         self.slice.networks = MockObjectList([self.priv_network])
         lan_network = self.policy.get_lan_network(self.tenant, None)
         self.assertEqual(lan_network, self.priv_network)
Ejemplo n.º 3
0
 def test_get_lan_network_noexist(self):
     with patch.object(VEGService.objects,
                       "get_items") as vegservice_objects:
         vegservice = VEGService(
             name="myvegservice",
             id=1,
             slices=MockObjectList(initial=[self.slice]))
         vegservice_objects.return_value = [vegservice]
         self.tenant.owner = vegservice
         self.slice.networks = MockObjectList()
         with self.assertRaises(Exception) as e:
             self.policy.get_lan_network(self.tenant, None)
         self.assertEqual(e.exception.message, "No lan_network")
Ejemplo n.º 4
0
    def test_least_loaded_node_scheduler_two_nodes(self):
        with patch.object(Node.objects, "get_items") as node_objects:
            slice = Slice(name="mysite_test1",
                          default_flavor=None,
                          default_isolation="vm")
            instance1 = Instance(id=1)
            node1 = Node(hostname="my.node.com", id=4567)
            node1.instances = MockObjectList(initial=[])
            node2 = Node(hostname="my.node.com", id=8910)
            node2.instances = MockObjectList(initial=[instance1])
            node_objects.return_value = [node1, node2]

            # should pick the node with the fewest instance (node1)

            sched = LeastLoadedNodeScheduler(slice)
            (picked_node, parent) = sched.pick()

            self.assertNotEqual(picked_node, None)
            self.assertEqual(picked_node.id, node1.id)
Ejemplo n.º 5
0
 def test_get_lan_network_toomany(self):
     with patch.object(VEGService.objects,
                       "get_items") as vegservice_objects:
         some_other_network = Network(name="mysite_test1_private",
                                      template=self.priv_template)
         vegservice = VEGService(
             name="myvegservice",
             id=1,
             slices=MockObjectList(initial=[self.slice]))
         vegservice_objects.return_value = [vegservice]
         self.tenant.owner = vegservice
         self.slice.networks = MockObjectList(
             [self.priv_network, some_other_network])
         with self.assertRaises(Exception) as e:
             lan_network = self.policy.get_lan_network(self.tenant, None)
         self.assertEqual(
             e.exception.message,
             "The vEG slice should only have one non-management private network"
         )
Ejemplo n.º 6
0
 def test_cleanup_orphans(self):
     with patch.object(AddressManagerServiceInstance.objects, "get_items") as amsi_objects, \
          patch.object(AddressManagerServiceInstance, "delete") as amsi_delete:
         vrtenant = AddressManagerServiceInstance(id=1)
         self.tenant.address_service_instance = vrtenant
         some_other_vrtenant = AddressManagerServiceInstance(id=2)
         link = ServiceInstanceLink(
             subscriber_service_instance=self.tenant,
             provider_service_instance=some_other_vrtenant)
         self.tenant.subscribed_links = MockObjectList(initial=[link])
         amsi_objects.return_value = [some_other_vrtenant]
         self.policy.cleanup_orphans(self.tenant)
         amsi_delete.assert_called()
Ejemplo n.º 7
0
    def test_least_loaded_node_scheduler_with_label(self):
        with patch.object(Node.objects, "get_items") as node_objects:
            slice = Slice(name="mysite_test1",
                          default_flavor=None,
                          default_isolation="vm")
            instance1 = Instance(id=1)
            node1 = Node(hostname="my.node.com", id=4567)
            node1.instances = MockObjectList(initial=[])
            node2 = Node(hostname="my.node.com", id=8910)
            node2.instances = MockObjectList(initial=[instance1])
            # Fake out the existence of a NodeLabel object. TODO: Extend the mock framework to support the model__field
            # syntax.
            node1.nodelabels__name = None
            node2.nodelabels__name = "foo"
            node_objects.return_value = [node1, node2]

            # should pick the node with the label, even if it has a greater number of instances

            sched = LeastLoadedNodeScheduler(slice, label="foo")
            (picked_node, parent) = sched.pick()

            self.assertNotEqual(picked_node, None)
            self.assertEqual(picked_node.id, node2.id)
Ejemplo n.º 8
0
    def test_least_loaded_node_scheduler(self):
        with patch.object(Node.objects, "get_items") as node_objects:
            slice = Slice(name="mysite_test1",
                          default_flavor=None,
                          default_isolation="vm")
            node = Node(hostname="my.node.com", id=4567)
            node.instances = MockObjectList(initial=[])
            node_objects.return_value = [node]

            sched = LeastLoadedNodeScheduler(slice)
            (picked_node, parent) = sched.pick()

            self.assertNotEqual(picked_node, None)
            self.assertEqual(picked_node.id, node.id)
Ejemplo n.º 9
0
    def setUp(self):
        global DeferredException

        self.sys_path_save = sys.path

        # Setting up the config module
        from xosconfig import Config
        config = os.path.join(test_path, "../test_config.yaml")
        Config.clear()
        Config.init(config, "synchronizer-config-schema.yaml")

        # Mock the kafka producer
        self.mockxoskafka = MagicMock()
        modules = {
            'xoskafka': self.mockxoskafka,
            'xoskafka.XOSKafkaProducer': self.mockxoskafka.XOSKafkaProducer,
        }
        self.module_patcher = patch.dict('sys.modules', modules)
        self.module_patcher.start()

        from xossynchronizer.mock_modelaccessor_build import mock_modelaccessor_config
        mock_modelaccessor_config(test_path, [("olt-service", "volt.xproto"),
                                              ("rcord", "rcord.xproto")])

        import xossynchronizer.modelaccessor
        import mock_modelaccessor
        reload(mock_modelaccessor)  # in case nose2 loaded it in a previous test
        reload(xossynchronizer.modelaccessor)  # in case nose2 loaded it in a previous test

        from mock_modelaccessor import MockObjectList
        from xossynchronizer.modelaccessor import model_accessor
        self.model_accessor = model_accessor

        # necessary to reset XOSKafkaProducer's call_count
        import onos_event
        reload(onos_event)

        from onos_event import OnosPortEventStep, XOSKafkaProducer
        from onos_event import XOSKafkaProducer
        self.XOSKafkaProducer = XOSKafkaProducer

        # import all class names to globals
        for (k, v) in model_accessor.all_model_classes.items():
            globals()[k] = v

        self.event_step = OnosPortEventStep

        self.volt_service = VOLTService(name="volt",
                                        id=1112,
                                        backend_code=1,
                                        backend_status="succeeded")

        self.oltdevice = OLTDevice(name="myolt",
                                   device_id="of:0000000000000001",
                                   switch_datapath_id="of:0000000000000001",
                                   switch_port="1")

        self.ponport = PONPort(olt_device = self.oltdevice)

        self.onudevice = ONUDevice(pon_port = self.ponport)

        self.subscriber = RCORDSubscriber(name="somesubscriber")
        self.voltsi = VOLTServiceInstance()

        # chain it all together
        self.oltdevice.pon_ports = MockObjectList([self.ponport])
        self.ponport.onu_devices = MockObjectList([self.onudevice])
        self.onudevice.volt_service_instances = MockObjectList([self.voltsi])
        self.voltsi.westbound_service_instances = [self.subscriber]

        self.log = Mock()
    def setUp(self):
        global DeferredException

        self.sys_path_save = sys.path

        config = os.path.join(test_path, "../test_config.yaml")
        from xosconfig import Config
        Config.clear()
        Config.init(config, 'synchronizer-config-schema.yaml')

        from xossynchronizer.mock_modelaccessor_build import mock_modelaccessor_config
        mock_modelaccessor_config(test_path, [("olt-service", "volt.xproto"),
                                              ("rcord", "rcord.xproto"),
                                              ("onos-service", "onos.xproto")])

        import xossynchronizer.modelaccessor
        import mock_modelaccessor
        reload(
            mock_modelaccessor)  # in case nose2 loaded it in a previous test
        reload(xossynchronizer.modelaccessor
               )  # in case nose2 loaded it in a previous test

        from xossynchronizer.modelaccessor import model_accessor
        from mock_modelaccessor import MockObjectList

        from kubernetes_event import KubernetesPodDetailsEventStep

        # import all class names to globals
        for (k, v) in model_accessor.all_model_classes.items():
            globals()[k] = v

        self.model_accessor = model_accessor
        self.event_step = KubernetesPodDetailsEventStep

        self.onos = ONOSService(name="myonos",
                                id=1111,
                                rest_hostname="onos-url",
                                rest_port="8181",
                                rest_username="******",
                                rest_password="******",
                                backend_code=1,
                                backend_status="succeeded")

        self.fcservice = VOLTService(name="myoltservice",
                                     id=1112,
                                     backend_code=1,
                                     backend_status="succeeded",
                                     provider_services=[self.onos])

        self.fcsi1 = VOLTServiceInstance(name="myfcsi1",
                                         owner=self.fcservice,
                                         backend_code=1,
                                         backend_status="succeeded")

        self.fcsi2 = VOLTServiceInstance(name="myfcsi2",
                                         owner=self.fcservice,
                                         backend_code=1,
                                         backend_status="succeeded")

        self.fcservice.service_instances = MockObjectList(
            [self.fcsi1, self.fcsi2])

        self.log = Mock()
    def setUp(self):
        global DeferredException

        self.sys_path_save = sys.path

        # Setting up the config module
        from xosconfig import Config
        config = os.path.join(test_path, "../test_config.yaml")
        Config.clear()
        Config.init(config, "synchronizer-config-schema.yaml")
        # END Setting up the config module

        from xossynchronizer.mock_modelaccessor_build import mock_modelaccessor_config
        mock_modelaccessor_config(test_path, [("onos-service", "onos.xproto"), ])

        import xossynchronizer.modelaccessor
        import mock_modelaccessor
        reload(mock_modelaccessor)  # in case nose2 loaded it in a previous test
        reload(xossynchronizer.modelaccessor)      # in case nose2 loaded it in a previous test

        from xossynchronizer.modelaccessor import model_accessor

        self.model_accessor = model_accessor

        from mock_modelaccessor import MockObjectList

        from kubernetes_event import KubernetesPodDetailsEventStep

        # import all class names to globals
        for (k, v) in model_accessor.all_model_classes.items():
            globals()[k] = v

        self.event_step = KubernetesPodDetailsEventStep

        self.onos = ONOSService(name="myonos",
                                rest_hostname="onos-url",
                                rest_port="8181",
                                rest_username="******",
                                rest_password="******",
                                backend_code=1,
                                backend_status="succeeded")

        self.attr = ServiceInstanceAttribute(
            name="foo",
            value="bar"
        )

        self.mockAllAttr = Mock()
        self.mockAllAttr.all.return_value = [self.attr]

        self.app1 = ONOSApp(name="myapp1",
                            owner=self.onos,
                            backend_code=1,
                            backend_status="succeeded",
                            service_instance_attributes=self.mockAllAttr)

        self.app2 = ONOSApp(name="myapp2",
                            owner=self.onos,
                            backend_code=1,
                            backend_status="succeeded",
                            service_instance_attributes=self.mockAllAttr)

        self.onos.service_instances = MockObjectList([self.app1, self.app2])

        self.log = Mock()
Ejemplo n.º 12
0
    def setUp(self):
        global DeferredException

        self.sys_path_save = sys.path

        # Setting up the config module
        from xosconfig import Config
        config = os.path.join(test_path, "../test_config.yaml")
        Config.clear()
        Config.init(config, "synchronizer-config-schema.yaml")
        # END Setting up the config module

        from xossynchronizer.mock_modelaccessor_build import mock_modelaccessor_config
        mock_modelaccessor_config(test_path, [("fabric", "fabric.xproto"),
                                              ("onos-service", "onos.xproto")])

        import xossynchronizer.modelaccessor
        import mock_modelaccessor
        reload(
            mock_modelaccessor)  # in case nose2 loaded it in a previous test
        reload(xossynchronizer.modelaccessor
               )  # in case nose2 loaded it in a previous test

        from xossynchronizer.modelaccessor import model_accessor
        self.model_accessor = model_accessor

        from mock_modelaccessor import MockObjectList
        from kubernetes_event import KubernetesPodDetailsEventStep

        # import all class names to globals
        for (k, v) in model_accessor.all_model_classes.items():
            globals()[k] = v

        self.event_step = KubernetesPodDetailsEventStep

        self.onos = ONOSService(name="myonos",
                                id=1111,
                                rest_hostname="onos-url",
                                rest_port="8181",
                                rest_username="******",
                                rest_password="******",
                                backend_code=1,
                                backend_status="succeeded")

        self.fabric_service = FabricService(name="fabric",
                                            id=1112,
                                            backend_code=1,
                                            backend_status="succeeded",
                                            provider_services=[self.onos])

        self.switch = Switch(name="switch1",
                             backend_code=1,
                             backend_status="succeeded")

        self.port1 = SwitchPort(name="switch1port1",
                                switch=self.switch,
                                backend_code=1,
                                backend_status="succeeded")

        self.port2 = SwitchPort(name="switch1port2",
                                switch=self.switch,
                                backend_code=1,
                                backend_status="succeeded")

        self.switch.ports = MockObjectList([self.port1, self.port2])

        self.log = Mock()
Ejemplo n.º 13
0
    def setUp(self):
        global DeferredException

        self.sys_path_save = sys.path

        # Setting up the config module
        from xosconfig import Config
        config = os.path.join(test_path, "../test_config.yaml")
        Config.clear()
        Config.init(config, "synchronizer-config-schema.yaml")
        # END Setting up the config module

        # Mock the kafka producer
        self.mockxoskafka = MagicMock()
        modules = {
            'xoskafka': self.mockxoskafka,
            'xoskafka.XOSKafkaProducer': self.mockxoskafka.XOSKafkaProducer,
        }
        self.module_patcher = patch.dict('sys.modules', modules)
        self.module_patcher.start()

        from xossynchronizer.mock_modelaccessor_build import mock_modelaccessor_config
        mock_modelaccessor_config(test_path, [("fabric", "fabric.xproto"),
                                              ("onos-service", "onos.xproto")])

        import xossynchronizer.modelaccessor
        import mock_modelaccessor
        imp.reload(
            mock_modelaccessor)  # in case nose2 loaded it in a previous test
        imp.reload(xossynchronizer.modelaccessor
                   )  # in case nose2 loaded it in a previous test

        from xossynchronizer.modelaccessor import model_accessor
        self.model_accessor = model_accessor

        from mock_modelaccessor import MockObjectList

        # necessary to reset XOSKafkaProducer's call_count
        import onos_event
        reload(onos_event)

        from onos_event import OnosPortEventStep, XOSKafkaProducer
        self.XOSKafkaProducer = XOSKafkaProducer

        # import all class names to globals
        for (k, v) in model_accessor.all_model_classes.items():
            globals()[k] = v

        self.event_step = OnosPortEventStep

        self.fabric_service = FabricService(name="fabric",
                                            id=1112,
                                            backend_code=1,
                                            backend_status="succeeded")

        self.switch = Switch(name="switch1",
                             ofId="of:0000000000000001",
                             backend_code=1,
                             backend_status="succeeded")

        self.port1 = SwitchPort(name="switch1port1",
                                switch=self.switch,
                                switch_id=self.switch.id,
                                portId="1",
                                oper_status=None,
                                backend_code=1,
                                backend_status="succeeded")

        self.port2 = SwitchPort(name="switch1port2",
                                kind="access",
                                switch=self.switch,
                                switch_id=self.switch.id,
                                portId="2",
                                oper_status=None,
                                backend_code=1,
                                backend_status="succeeded")

        self.switch.ports = MockObjectList([self.port1, self.port2])

        self.log = Mock()
Ejemplo n.º 14
0
    def test_find_or_make_instance_for_s_tag(self):
        with patch.object(NetworkParameterType.objects, "get_items") as npt_objects, \
             patch.object(Node.objects, "get_items") as node_objects, \
             patch.object(Flavor.objects, "get_items") as flavor_objects, \
             patch.object(VEGService.objects, "get_items") as vegservice_objects, \
             patch.object(VEGTenant, "volt") as volt, \
             patch.object(VEGTenant, "save") as tenant_save, \
             patch.object(VEGTenantPolicy, "get_image") as get_image, \
             patch.object(VEGTenantPolicy, "allocate_public_service_instance") as get_psi, \
             patch.object(LeastLoadedNodeScheduler, "pick") as pick, \
             patch.object(Node, "site_deployment") as site_deployment, \
             patch.object(Instance, "save") as instance_save, \
             patch.object(Instance, "delete") as instance_delete, \
             patch.object(VEGTenantPolicy, "port_set_parameter") as port_set_parameter:
            # setup mocks
            vrtenant = AddressManagerServiceInstance(
                public_ip="1.2.3.4", public_mac="01:02:03:04:05:06")
            vegservice = VEGService(
                name="myvegservice",
                id=1,
                slices=MockObjectList(initial=[self.slice]))
            vegservice_objects.return_value = [vegservice]
            self.tenant.owner = vegservice
            volt.s_tag = 222
            volt.c_tag = 111
            get_image.return_value = self.image
            get_psi.return_value = vrtenant
            pick.return_value = (self.node, None)
            site_deployment.deployment = self.deployment
            flavor_objects.return_value = [self.flavor]
            node_objects.return_value = [self.node]
            npt_objects.return_value = [
                self.npt_stag, self.npt_ctag, self.npt_neutron_port_name
            ]
            self.slice.networks = MockObjectList([self.priv_network])
            # done setup mocks

            # call the function under test
            instance = self.policy.find_or_make_instance_for_s_tag(
                self.tenant, volt.s_tag)

            # make sure Instance was created
            self.assertNotEqual(instance, None)
            self.assertEqual(instance.creator.email, "*****@*****.**")
            self.assertEqual(instance.image.name, "trusty-server-multi-nic")
            self.assertEqual(instance.flavor.name, "m1.small")
            self.assertEqual(instance.isolation, "vm")
            self.assertEqual(instance.node.hostname, "my.node.com")
            self.assertEqual(instance.slice.name, "mysite_test1")
            self.assertEqual(instance.parent, None)
            instance_save.assert_called()
            instance_delete.assert_not_called()

            # Access Network Port should have tags to c-tag and s-tag
            port = Port.objects.first()
            self.assertEqual(port.instance, instance)
            self.assertEqual(port.network, self.priv_network)
            port_set_parameter.assert_has_calls([
                mock.call(port, "c_tag", 111),
                mock.call(port, "s_tag", 222),
                mock.call(port, "neutron_port_name", "stag-222")
            ])

            # The instance should be tagged with the s-tag
            tag = Tag.objects.get(name="s_tag")
            self.assertEqual(tag.value, "222")
            self.assertEqual(tag.object_id, instance.id)

            # The instance should have a tag pointing to its address_service_instance
            tag = Tag.objects.get(name="vm_vrouter_tenant")
            self.assertNotEqual(tag.value, vrtenant.id)
            self.assertEqual(tag.object_id, instance.id)

            # Allocate_public_service_instance should have been called
            get_psi.assert_called()
Ejemplo n.º 15
0
    def setUp(self):
        global DeferredException

        self.sys_path_save = sys.path
        sys.path.append(xos_dir)
        sys.path.append(os.path.join(xos_dir, 'synchronizers', 'new_base'))

        # Setting up the config module
        from xosconfig import Config
        config = os.path.join(test_path,
                              "../test_fabric_crossconnect_config.yaml")
        Config.clear()
        Config.init(config, "synchronizer-config-schema.yaml")
        # END Setting up the config module

        from synchronizers.new_base.mock_modelaccessor_build import build_mock_modelaccessor
        build_mock_modelaccessor(xos_dir, services_dir, [
            get_models_fn("fabric-crossconnect", "fabric-crossconnect.xproto"),
            get_models_fn("onos-service", "onos.xproto"),
        ])
        import synchronizers.new_base.mock_modelaccessor
        reload(synchronizers.new_base.mock_modelaccessor
               )  # in case nose2 loaded it in a previous test
        import synchronizers.new_base.modelaccessor
        reload(synchronizers.new_base.modelaccessor
               )  # in case nose2 loaded it in a previous test
        from synchronizers.new_base.modelaccessor import model_accessor
        from mock_modelaccessor import MockObjectList

        from kubernetes_event import KubernetesPodDetailsEventStep

        # import all class names to globals
        for (k, v) in model_accessor.all_model_classes.items():
            globals()[k] = v

        self.event_step = KubernetesPodDetailsEventStep

        self.onos = ONOSService(name="myonos",
                                id=1111,
                                rest_hostname="onos-url",
                                rest_port="8181",
                                rest_username="******",
                                rest_password="******",
                                backend_code=1,
                                backend_status="succeeded")

        self.fcservice = FabricCrossconnectService(
            name="myfcservice",
            id=1112,
            backend_code=1,
            backend_status="succeeded",
            provider_services=[self.onos])

        self.fcsi1 = FabricCrossconnectServiceInstance(
            name="myfcsi1",
            owner=self.fcservice,
            backend_code=1,
            backend_status="succeeded")

        self.fcsi2 = FabricCrossconnectServiceInstance(
            name="myfcsi2",
            owner=self.fcservice,
            backend_code=1,
            backend_status="succeeded")

        self.fcservice.service_instances = MockObjectList(
            [self.fcsi1, self.fcsi2])

        self.log = Mock()