示例#1
0
 def push(self, context, resource, event_type):
     resource_obj = obj_base.NeutronObject.clean_obj_from_primitive(
         resource)
     LOG.debug("Resources notification (%(event_type)s): %(resource)s",
               {'event_type': event_type, 'resource': repr(resource_obj)})
     resource_type = resources.get_resource_type(resource_obj)
     cons_registry.push(resource_type, resource_obj, event_type)
示例#2
0
 def push(self, context, resource, event_type):
     resource_obj = obj_base.NeutronObject.clean_obj_from_primitive(
         resource)
     LOG.debug("Resources notification (%(event_type)s): %(resource)s",
               {'event_type': event_type, 'resource': repr(resource_obj)})
     resource_type = resources.get_resource_type(resource_obj)
     cons_registry.push(resource_type, resource_obj, event_type)
    def test_policy_rule_delete(self):
        port_dict = self._create_port_with_qos()

        policy_copy = copy.deepcopy(self.qos_policies[TEST_POLICY_ID1])
        policy_copy.rules = list()
        consumer_reg.push(resources.QOS_POLICY, policy_copy, events.UPDATED)

        self.wait_until_bandwidth_limit_rule_applied(port_dict, None)
示例#4
0
    def test_policy_rule_delete(self):
        port_dict = self._create_port_with_qos()

        policy_copy = copy.deepcopy(self.qos_policies[TEST_POLICY_ID1])
        policy_copy.rules = list()
        consumer_reg.push(resources.QOS_POLICY, policy_copy, events.UPDATED)

        self.wait_until_bandwidth_limit_rule_applied(port_dict, None)
示例#5
0
    def push(self, context, **kwargs):
        """Push receiver, will always receive resources of the same type."""
        resource_list = kwargs['resource_list']
        event_type = kwargs['event_type']

        resource_objs = [
            obj_base.NeutronObject.clean_obj_from_primitive(resource)
            for resource in resource_list]

        resource_type = resources.get_resource_type(resource_objs[0])
        cons_registry.push(context, resource_type, resource_objs, event_type)
示例#6
0
    def test_push(self, manager_mock):
        resource_type_ = object()
        resource_ = object()
        event_type_ = object()

        callback1 = mock.Mock()
        callback2 = mock.Mock()
        callbacks = {callback1, callback2}
        manager_mock().get_callbacks.return_value = callbacks
        registry.push(resource_type_, [resource_], event_type_)
        for callback in callbacks:
            callback.assert_called_with([resource_], event_type_)
示例#7
0
 def test_simple_port_policy_update(self):
     self.setup_agent_and_ports(port_dicts=self.create_test_ports(
         amount=1, policy_id=TEST_POLICY_ID1))
     self.wait_until_ports_state(self.ports, up=True)
     policy_copy = copy.deepcopy(self.qos_policies[TEST_POLICY_ID1])
     policy_copy.rules[0].max_kbps = 500
     policy_copy.rules[0].max_burst_kbps = 5
     consumer_reg.push(resources.QOS_POLICY, policy_copy, events.UPDATED)
     self.wait_until_bandwidth_limit_rule_applied(self.ports[0],
                                                  policy_copy.rules[0])
     self._assert_bandwidth_limit_rule_is_set(self.ports[0],
                                              policy_copy.rules[0])
示例#8
0
    def test_push(self, manager_mock):
        resource_type_ = object()
        resource_ = object()
        event_type_ = object()

        callback1 = mock.Mock()
        callback2 = mock.Mock()
        callbacks = {callback1, callback2}
        manager_mock().get_callbacks.return_value = callbacks
        registry.push(resource_type_, resource_, event_type_)
        for callback in callbacks:
            callback.assert_called_with(resource_, event_type_)
示例#9
0
    def push(self, context, **kwargs):
        """Push receiver, will always receive resources of the same type."""
        resource_list = kwargs['resource_list']
        event_type = kwargs['event_type']

        resource_objs = [
            obj_base.NeutronObject.clean_obj_from_primitive(resource)
            for resource in resource_list
        ]

        resource_type = resources.get_resource_type(resource_objs[0])
        cons_registry.push(context, resource_type, resource_objs, event_type)
 def test_simple_port_policy_update(self):
     self.setup_agent_and_ports(
         port_dicts=self.create_test_ports(amount=1,
                                           policy_id=TEST_POLICY_ID1))
     self.wait_until_ports_state(self.ports, up=True)
     policy_copy = copy.deepcopy(self.qos_policies[TEST_POLICY_ID1])
     policy_copy.rules[0].max_kbps = 500
     policy_copy.rules[0].max_burst_kbps = 5
     consumer_reg.push(resources.QOS_POLICY, policy_copy, events.UPDATED)
     self.wait_until_bandwidth_limit_rule_applied(self.ports[0],
                                                  policy_copy.rules[0])
     self._assert_bandwidth_limit_rule_is_set(self.ports[0],
                                              policy_copy.rules[0])
 def test_simple_port_policy_update(self):
     self.setup_agent_and_ports(port_dicts=self.create_test_ports(amount=1, policy_id=TEST_POLICY_ID1))
     self.wait_until_ports_state(self.ports, up=True)
     self._assert_dscp_marking_rule_is_set(self.ports[0], TEST_DSCP_MARKING_RULE_1)
     policy_copy = copy.deepcopy(self.qos_policies[TEST_POLICY_ID1])
     policy_copy.rules[0].max_kbps = 500
     policy_copy.rules[0].max_burst_kbps = 5
     policy_copy.rules[1].dscp_mark = TEST_DSCP_MARK_2
     context = mock.Mock()
     consumer_reg.push(context, resources.QOS_POLICY, [policy_copy], events.UPDATED)
     self.wait_until_bandwidth_limit_rule_applied(self.ports[0], policy_copy.rules[0])
     self._assert_bandwidth_limit_rule_is_set(self.ports[0], policy_copy.rules[0])
     self._assert_dscp_marking_rule_is_set(self.ports[0], TEST_DSCP_MARKING_RULE_2)
示例#12
0
    def push(self, context, **kwargs):
        """Push receiver, will always receive resources of the same type."""
        # TODO(mangelajo): accept single 'resource' parameter for backwards
        #                  compatibility during Newton, remove in Ocata
        resource_list = ([kwargs['resource']] if 'resource' in kwargs else
                         kwargs['resource_list'])
        event_type = kwargs['event_type']

        resource_objs = [
            obj_base.NeutronObject.clean_obj_from_primitive(resource)
            for resource in resource_list]

        resource_type = resources.get_resource_type(resource_objs[0])
        cons_registry.push(resource_type, resource_objs, event_type)
示例#13
0
    def push(self, context, **kwargs):
        """Push receiver, will always receive resources of the same type."""
        # TODO(mangelajo): accept single 'resource' parameter for backwards
        #                  compatibility during Newton, remove in Ocata
        resource_list = ([kwargs['resource']] if 'resource' in kwargs else
                         kwargs['resource_list'])
        event_type = kwargs['event_type']

        resource_objs = [
            obj_base.NeutronObject.clean_obj_from_primitive(resource)
            for resource in resource_list]

        resource_type = resources.get_resource_type(resource_objs[0])
        cons_registry.push(context, resource_type, resource_objs, event_type)
示例#14
0
    def test_push(self, manager_mock):
        resource_type_ = object()
        resource_ = object()
        event_type_ = object()

        context = mock.Mock()
        callback1 = mock.Mock()
        callback2 = mock.Mock()
        registry.register(callback1, 'x')
        registry.register(callback2, 'x')
        callbacks = {callback1, callback2}
        manager_mock().get_callbacks.return_value = callbacks
        registry.push(context, resource_type_, [resource_], event_type_)
        for callback in (callback1, callback2):
            callback.assert_called_with(context, resource_type_,
                                        [resource_], event_type_)
示例#15
0
    def test_push(self, manager_mock):
        resource_type_ = object()
        resource_ = object()
        event_type_ = object()

        context = mock.Mock()
        callback1 = mock.Mock()
        callback2 = mock.Mock()
        legacy_callback = mock.Mock()
        registry.register(callback1, 'x')
        registry.register(callback2, 'x')
        registry.subscribe(legacy_callback, 'x')
        callbacks = {callback1, callback2, legacy_callback}
        manager_mock().get_callbacks.return_value = callbacks
        registry.push(context, resource_type_, [resource_], event_type_)
        for callback in (callback1, callback2):
            callback.assert_called_with(context, resource_type_, [resource_],
                                        event_type_)
        legacy_callback.assert_called_with([resource_], event_type_)
 def test_simple_port_policy_update(self):
     self.setup_agent_and_ports(port_dicts=self.create_test_ports(
         amount=1, policy_id=TEST_POLICY_ID1))
     self.wait_until_ports_state(self.ports, up=True)
     self._assert_dscp_marking_rule_is_set(self.ports[0],
                                           self.test_dscp_marking_rule_1)
     policy_copy = copy.deepcopy(self.qos_policies[TEST_POLICY_ID1])
     policy_copy.rules[0].max_kbps = 500
     policy_copy.rules[0].max_burst_kbps = 5
     policy_copy.rules[1].dscp_mark = TEST_DSCP_MARK_2
     context = mock.Mock()
     consumer_reg.push(context, resources.QOS_POLICY, [policy_copy],
                       events.UPDATED)
     self.wait_until_bandwidth_limit_rule_applied(self.ports[0],
                                                  policy_copy.rules[0])
     self._assert_bandwidth_limit_rule_is_set(self.ports[0],
                                              policy_copy.rules[0])
     self._assert_dscp_marking_rule_is_set(self.ports[0],
                                           self.test_dscp_marking_rule_2)
    def test_simple_port_policy_update_change_bw_limit_direction(self):
        self.setup_agent_and_ports(port_dicts=self.create_test_ports(
            amount=1, policy_id=TEST_POLICY_ID1))
        self.wait_until_ports_state(self.ports, up=True)

        self._assert_bandwidth_limit_rule_is_set(self.ports[0],
                                                 self.test_bw_limit_rule_1)
        self._assert_bandwidth_limit_rule_not_set(self.ports[0],
                                                  self.reverse_direction)

        policy_copy = copy.deepcopy(self.qos_policies[TEST_POLICY_ID1])
        policy_copy.rules[0].direction = self.reverse_direction
        context = mock.Mock()
        consumer_reg.push(context, resources.QOS_POLICY, [policy_copy],
                          events.UPDATED)
        self.wait_until_bandwidth_limit_rule_applied(self.ports[0],
                                                     policy_copy.rules[0])

        self._assert_bandwidth_limit_rule_not_set(self.ports[0],
                                                  self.direction)
        self._assert_bandwidth_limit_rule_is_set(self.ports[0],
                                                 policy_copy.rules[0])
    def test_simple_port_policy_update_change_bw_limit_direction(self):
        self.setup_agent_and_ports(
            port_dicts=self.create_test_ports(amount=1,
                                              policy_id=TEST_POLICY_ID1))
        self.wait_until_ports_state(self.ports, up=True)

        self._assert_bandwidth_limit_rule_is_set(self.ports[0],
                                                 self.test_bw_limit_rule_1)
        self._assert_bandwidth_limit_rule_not_set(self.ports[0],
                                                  self.reverse_direction)

        policy_copy = copy.deepcopy(self.qos_policies[TEST_POLICY_ID1])
        policy_copy.rules[0].direction = self.reverse_direction
        context = mock.Mock()
        consumer_reg.push(context, resources.QOS_POLICY,
                          [policy_copy], events.UPDATED)
        self.wait_until_bandwidth_limit_rule_applied(self.ports[0],
                                                     policy_copy.rules[0])

        self._assert_bandwidth_limit_rule_not_set(self.ports[0],
                                                  self.direction)
        self._assert_bandwidth_limit_rule_is_set(self.ports[0],
                                                 policy_copy.rules[0])