def test_initialize_tables_dse(self):
        """Test performance of initializing data with DSE and Engine.

        This test populates the tables exported by a datasource driver,
        and then invokes the poll() method to send that data to the
        policy engine.  It tests the amount of time to send tables
        across the DSE and load them into the policy engine.
        """
        MAX_TUPLES = 700
        # install datasource driver we can control
        kwds = {}
        kwds['name'] = 'data'
        kwds['args'] = helper.datasource_openstack_args()
        kwds['driver'] = 'performance'
        driver = self.cage.create_datasource_service(kwds)
        self.cage.register_service(driver)
        driver.poll_time = 0
        self.engine.create_policy('data')

        # set return value for datasource driver
        facts = [(1, 2.3, 'foo', 'bar', i, 'a'*100 + str(i))
                 for i in range(MAX_TUPLES)]
        driver.state = {'p': facts}

        # Send formula to engine (so engine subscribes to data:p)
        policy = self.engine.DEFAULT_THEORY
        formula = compile.parse1(
            'q(1) :- data:p(1, 2.3, "foo", "bar", 1, %s)' % ('a'*100 + '1'))
        self.engine.process_policy_update(
            [compile.Event(formula, target=policy)])

        # Poll data and wait til it arrives at engine
        driver.poll()
        self.wait_til_query_nonempty('q(1)', policy)
Example #2
0
 def setUp(self):
     super(TestMistralDriver, self).setUp()
     args = helper.datasource_openstack_args()
     args['poll_time'] = 0
     args['client'] = mock.MagicMock()
     self.driver = mistral_driver.MistralDriver(name='testmistral',
                                                args=args)
    def test_initialize_tables_dse(self):
        """Test performance of initializing data with DSE and Engine.

        This test populates the tables exported by a datasource driver,
        and then invokes the poll() method to send that data to the
        policy engine.  It tests the amount of time to send tables
        across the DSE and load them into the policy engine.
        """
        MAX_TUPLES = 700
        # install datasource driver we can control
        kwds = {}
        kwds['name'] = 'data'
        kwds['args'] = helper.datasource_openstack_args()
        kwds['driver'] = 'performance'
        driver = self.cage.create_datasource_service(kwds)
        self.cage.register_service(driver)
        driver.poll_time = 0
        self.engine.create_policy('data')

        # set return value for datasource driver
        facts = [(1, 2.3, 'foo', 'bar', i, 'a' * 100 + str(i))
                 for i in range(MAX_TUPLES)]
        driver.state = {'p': facts}

        # Send formula to engine (so engine subscribes to data:p)
        policy = self.engine.DEFAULT_THEORY
        formula = compile.parse1(
            'q(1) :- data:p(1, 2.3, "foo", "bar", 1, %s)' % ('a' * 100 + '1'))
        self.engine.process_policy_update(
            [compile.Event(formula, target=policy)])

        # Poll data and wait til it arrives at engine
        driver.poll()
        self.wait_til_query_nonempty('q(1)', policy)
Example #4
0
 def test_policy_data(self):
     """Test policy properly inserts data and processes it normally."""
     cage = congress.dse.d6cage.d6Cage()
     cage.loadModule(
         "TestDriver",
         helper.data_module_path("../tests/datasources/test_driver.py"))
     cage.loadModule("TestPolicy", helper.policy_module_path())
     cage.createservice(name="data",
                        moduleName="TestDriver",
                        args=helper.datasource_openstack_args())
     cage.createservice(name="policy",
                        moduleName="TestPolicy",
                        args={
                            'd6cage': cage,
                            'rootdir': ''
                        })
     data = cage.services['data']['object']
     policy = cage.services['policy']['object']
     # turn off module-schema syntax checking
     policy.create_policy('data')
     policy.set_schema('data', compile.Schema({'p': (1, )}))
     policy.subscribe('data', 'p', callback=policy.receive_data)
     formula = policy.parse1('p(1)')
     # sending a single Insert.  (Default for Event is Insert.)
     data.publish('p', [runtime.Event(formula)])
     helper.retry_check_db_equal(policy, 'data:p(x)', 'data:p(1)')
Example #5
0
    def setUp(self):
        super(TestCloudFoundryV2Driver, self).setUp()

        args = helper.datasource_openstack_args()
        args['poll_time'] = 0
        args['client'] = mock.MagicMock()
        self.driver = cloudfoundryv2_driver.CloudFoundryV2Driver(args=args)
Example #6
0
    def test_initialize_tables_dse(self):
        """Test performance of initializing data with DSE and Engine.

        This test populates the tables exported by a datasource driver,
        and then invokes the poll() method to send that data to the
        policy engine.  It tests the amount of time to send tables
        across the DSE and load them into the policy engine.
        """
        MAX_TUPLES = 700
        # install datasource driver we can control
        self.cage.loadModule(
            "TestDriver",
            helper.data_module_path("../tests/datasources/test_driver.py"))
        self.cage.createservice(name="data",
                                moduleName="TestDriver",
                                args=helper.datasource_openstack_args())
        driver = self.cage.service_object('data')
        driver.poll_time = 0
        self.engine.create_policy('data')

        # set return value for datasource driver
        facts = [(1, 2.3, 'foo', 'bar', i, 'a' * 100 + str(i))
                 for i in range(MAX_TUPLES)]
        driver.state = {'p': facts}

        # Send formula to engine (so engine subscribes to data:p)
        policy = self.engine.DEFAULT_THEORY
        formula = compile.parse1(
            'q(1) :- data:p(1, 2.3, "foo", "bar", 1, %s)' % ('a' * 100 + '1'))
        self.api['rule'].publish('policy-update',
                                 [agnostic.Event(formula, target=policy)])

        # Poll data and wait til it arrives at engine
        driver.poll()
        self.wait_til_query_nonempty('q(1)', policy)
    def setUp(self):
        super(TestCloudFoundryV2Driver, self).setUp()

        args = helper.datasource_openstack_args()
        args['poll_time'] = 0
        args['client'] = mock.MagicMock()
        self.driver = cloudfoundryv2_driver.CloudFoundryV2Driver(args=args)
Example #8
0
 def test_policy_tables(self):
     """Test basic DSE functionality with policy engine and the API."""
     cage = congress.dse.d6cage.d6Cage()
     cage.loadModule(
         "TestDriver",
         helper.data_module_path("../tests/datasources/test_driver.py"))
     cage.loadModule("TestPolicy", helper.policy_module_path())
     cage.createservice(name="data",
                        moduleName="TestDriver",
                        args=helper.datasource_openstack_args())
     # using regular testdriver as API for now
     cage.createservice(name="api",
                        moduleName="TestDriver",
                        args=helper.datasource_openstack_args())
     cage.createservice(name="policy",
                        moduleName="TestPolicy",
                        args={
                            'd6cage': cage,
                            'rootdir': ''
                        })
     data = cage.services['data']['object']
     api = cage.services['api']['object']
     policy = cage.services['policy']['object']
     policy.create_policy('data')
     policy.set_schema('data', compile.Schema({'q': (1, )}))
     policy.subscribe('api',
                      'policy-update',
                      callback=policy.receive_policy_update)
     # simulate API call for insertion of policy statements
     formula = policy.parse1('p(x) :- data:q(x)')
     api.publish('policy-update', [runtime.Event(formula)])
     helper.retry_check_nonempty_last_policy_change(policy)
     # simulate data source publishing to q
     formula = policy.parse1('q(1)')
     data.publish('q', [runtime.Event(formula)])
     helper.retry_check_db_equal(policy, 'data:q(x)', 'data:q(1)')
     # check that policy did the right thing with data
     e = helper.db_equal(policy.select('p(x)'), 'p(1)')
     self.assertTrue(e, 'Policy insert')
     # check that publishing into 'p' does not work
     formula = policy.parse1('p(3)')
     data.publish('p', [runtime.Event(formula)])
     # can't actually check that the update for p does not arrive
     # so instead wait a bit and check
     helper.pause()
     e = helper.db_equal(policy.select('p(x)'), 'p(1)')
     self.assertTrue(e, 'Policy non-insert')
Example #9
0
 def _register_test_datasource(self, name):
     args = helper.datasource_openstack_args()
     if name == 'nova':
         ds = nova_driver.NovaDriver('nova', args=args)
     if name == 'neutron':
         ds = neutronv2_driver.NeutronV2Driver('neutron', args=args)
     ds.update_from_datasource = mock.MagicMock()
     return ds
Example #10
0
    def setUp(self):
        super(TestCeilometerDriver, self).setUp()
        self.ceilometer_client = mock.MagicMock()

        args = helper.datasource_openstack_args()
        args['poll_time'] = 0
        self.driver = ceilometer_driver.CeilometerDriver(name='testceilometer',
                                                         args=args)
Example #11
0
    def setUp(self):
        super(TestCeilometerDriver, self).setUp()
        self.ceilometer_client = mock.MagicMock()

        args = helper.datasource_openstack_args()
        args['poll_time'] = 0
        with mock.patch.object(client.Client, '__init__', return_value=None):
            self.driver = ceilometer_driver.CeilometerDriver(
                name='testceilometer', args=args)
Example #12
0
 def setUp(self):
     super(TestNovaDriver, self).setUp()
     nova_client = mock.MagicMock()
     self.nova = fakes.NovaFakeClient()
     with mock.patch.object(novaclient.client.Client, '__init__',
                            return_value=nova_client):
         self.driver = nova_driver.NovaDriver(
             name='nova',
             args=helper.datasource_openstack_args())
    def setUp(self):
        super(TestGlanceV2Driver, self).setUp()
        self.keystone_client_p = mock.patch(
            "keystoneclient.v2_0.client.Client")
        self.keystone_client_p.start()
        self.glance_client_p = mock.patch("glanceclient.v2.client.Client")
        self.glance_client_p.start()

        args = helper.datasource_openstack_args()
        args['poll_time'] = 0
        args['client'] = mock.MagicMock()
        self.driver = glancev2_driver.GlanceV2Driver(args=args)

        self.mock_images = {
            'images': [{
                u'checksum': u'9e486c3bf76219a6a37add392e425b36',
                u'container_format': u'bare',
                u'created_at': u'2014-10-01T20:28:08Z',
                u'disk_format': u'qcow2',
                u'file':
                u'/v2/images/c42736e7-8b09-4906-abd2-d6dc8673c297/file',
                u'id': u'c42736e7-8b09-4906-abd2-d6dc8673c297',
                u'min_disk': 0,
                u'min_ram': 0,
                u'name': u'Fedora-x86_64-20-20140618-sda',
                u'owner': u'4dfdcf14a20940799d89c7a5e7345978',
                u'protected': False,
                u'schema': u'/v2/schemas/image',
                u'size': 209649664,
                u'status': u'active',
                u'tags': ['type=xen2', 'type=xen'],
                u'updated_at': u'2014-10-01T20:28:09Z',
                u'visibility': u'public'
            }, {
                u'checksum': u'4eada48c2843d2a262c814ddc92ecf2c',
                u'container_format': u'ami',
                u'created_at': u'2014-10-01T20:28:06Z',
                u'disk_format': u'ami',
                u'file':
                u'/v2/images/6934941f-3eef-43f7-9198-9b3c188e4aab/file',
                u'id': u'6934941f-3eef-43f7-9198-9b3c188e4aab',
                u'kernel_id': u'15ed89b8-588d-47ad-8ee0-207ed8010569',
                u'min_disk': 0,
                u'min_ram': 0,
                u'name': u'cirros-0.3.2-x86_64-uec',
                u'owner': u'4dfdcf14a20940799d89c7a5e7345978',
                u'protected': False,
                u'ramdisk_id': u'c244d5c7-1c83-414c-a90d-af7cea1dd3b5',
                u'schema': u'/v2/schemas/image',
                u'size': 25165824,
                u'status': u'active',
                u'tags': [],
                u'updated_at': u'2014-10-01T20:28:07Z',
                u'visibility': u'public'
            }]
        }
Example #14
0
 def setUp(self):
     super(TestNeutronDriver, self).setUp()
     self.neutron_client = mock.MagicMock()
     self.neutron_client.list_networks.return_value = network_response
     self.neutron_client.list_ports.return_value = port_response
     self.neutron_client.list_routers.return_value = router_response
     self.neutron_client.list_security_groups.return_value = (
         security_group_response)
     args = helper.datasource_openstack_args()
     self.driver = neutron_driver.NeutronDriver(args=args)
     self.driver.neutron = self.neutron_client
Example #15
0
    def setUp(self):
        super(TestPlexxiDriver, self).setUp()
        args = helper.datasource_openstack_args()
        args['unique_names'] = 'False'
        session = MockCoreSession()
        self.driver = plexxi_driver.PlexxiDriver(args=args, session=session)
        self.driver.exchange = True
        vnic1 = MockNIC(uuid='f318ac0a-9255-4af0-8a41-6f3fbc06c8aa',
                        mac='B8:ED:0A:4D:82:91')
        vnic2 = MockNIC(uuid='f318ac0a-9255-4af0-8a41-6f3fbc06c8a2',
                        mac='B8:ED:0A:4D:82:99')
        pnic1 = MockNIC(uuid='f318ac0a-9255-4af0-8a41-6f3fbc06c8ab',
                        mac='B8:ED:0A:4D:82:92')
        pnic2 = MockNIC(uuid='f318ac0a-9255-4af0-8a41-6f3fbc06c8ac',
                        mac='B8:ED:0A:4D:82:93')
        host1 = MockHost('eed4ebfc-25e5-4a65-9f37-b70b8e8219d3',
                         'mock1',
                         1,
                         [pnic1])
        vm1 = MockVM('2ca924f6-90aa-4ce8-a986-f62f8f64d14b',
                     '192.168.90.2',
                     'namevm',
                     host1,
                     [vnic1])
        host1.addvm(vm1)
        switch1 = MockSwitch('12da13e3-ecb2-4c26-98a0-26cb07f9c33d',
                             '192.168.90.3',
                             'switch1',
                             'HEALTHY',
                             [pnic2])
        affinity = MockAffinity('fd487ecf-5279-4d3c-9378-7fb214f5dd5a',
                                'Testfinnity')
        affinity2 = MockAffinity('fd487ecf-5279-4d3c-9378-7fb214f5dd5b',
                                 'Testfinnity2')
        vswitch = MockVSwitch('fd487ecf-5279-4d3c-9378-7fb214f5dd5c',
                              [host1],
                              [vnic2])
        link1 = MockNetworkLink('fd487ecf-5279-4d3c-9378-7fb214f5dd5f',
                                'Link1',
                                host1,
                                switch1)
        port = MockPort('fd487ecf-5279-4d3c-9378-7fb214f5dd5d',
                        'Port1',
                        [link1])
        port2 = MockPort('fd487ecf-5279-4d3c-9378-7fb214f5dd5e',
                         'Port2',
                         None)

        self.hosts = [host1]
        self.pswitches = [switch1]
        self.affinites = [affinity, affinity2]
        self.vswitches = [vswitch]
        self.vms = [vm1]
        self.ports = [port, port2]
Example #16
0
    def test_communication(self):
        """Test for communication.

        Test the module's ability to be loaded into the DSE
        by checking its ability to communicate on the message bus.
        """
        cage = d6cage.d6Cage()

        # Create modules.
        # Turn off polling so we don't need to deal with real data.
        args = helper.datasource_openstack_args()
        args['poll_time'] = 0
        cage.loadModule("NovaDriver",
                        helper.data_module_path("nova_driver.py"))
        cage.loadModule("PolicyDriver", helper.policy_module_path())
        cage.createservice(name="policy",
                           moduleName="PolicyDriver",
                           args={
                               'd6cage': cage,
                               'rootdir': helper.data_module_path('')
                           })
        cage.createservice(name="nova", moduleName="NovaDriver", args=args)

        # Check that data gets sent from nova to policy as expected
        nova = cage.service_object('nova')
        policy = cage.service_object('policy')
        policy.debug_mode()
        policy.create_policy('nova')
        policy.set_schema('nova', compile.Schema({'server': (1, )}))
        policy.subscribe('nova', 'server', callback=policy.receive_data)

        # publishing is slightly convoluted b/c deltas are computed
        #  automatically.  (Not just convenient--useful so that DSE
        #  properly handles the initial state problem.)
        # Need to set nova.state and nova.prior_state and then publish
        #  anything.

        # publish server(1), server(2), server(3)
        helper.retry_check_subscribers(nova, [(policy.name, 'server')])
        nova.prior_state = {}
        nova.state['server'] = set([(1, ), (2, ), (3, )])
        nova.publish('server', None)
        helper.retry_check_db_equal(
            policy, 'nova:server(x)',
            'nova:server(1) nova:server(2) nova:server(3)')

        # publish server(1), server(4), server(5)
        nova.prior_state['server'] = nova.state['server']
        nova.state['server'] = set([(1, ), (4, ), (5, )])
        nova.publish('server', None)
        helper.retry_check_db_equal(
            policy, 'nova:server(x)',
            'nova:server(1) nova:server(4) nova:server(5)')
 def setUp(self):
     super(TestMuranoDriver, self).setUp()
     self.keystone_client_p = mock.patch(
         "keystoneclient.v2_0.client.Client")
     self.keystone_client_p.start()
     self.murano_client = mock.MagicMock()
     self.murano_client.environments.list.return_value = env_response
     self.murano_client.services.list.return_value = service_response
     self.murano_client.deployments.list.return_value = deployment_response
     self.murano_client.packages.list.return_value = package_response
     args = helper.datasource_openstack_args()
     self.driver = murano_driver.MuranoDriver(args=args)
     self.driver.murano_client = self.murano_client
def create_network_group(tablename, full_neutron_tablename=None):
    driver = neutron_driver.NeutronDriver(
        args=helper.datasource_openstack_args())
    if full_neutron_tablename is None:
        full_neutron_tablename = 'neutron:networks'
    network_key_to_index = driver.get_column_map(
        neutron_driver.NeutronDriver.NETWORKS)
    network_id_index = network_key_to_index['id']
    network_max_index = max(network_key_to_index.values())
    network_args = ['x' + str(i) for i in xrange(0, network_max_index + 1)]
    formula = compile.parse1('{}({}) :- {}({})'.format(
        tablename, 'x' + str(network_id_index), full_neutron_tablename,
        ",".join(network_args)))
    return formula
Example #19
0
    def setUp(self):
        super(TestMonascaDriver, self).setUp()
        self.keystone_client_p = mock.patch("keystoneclient.v3.client.Client")
        self.keystone_client_p.start()
        self.monasca_client_p = mock.patch("monascaclient.client.Client")
        self.monasca_client_p.start()

        args = helper.datasource_openstack_args()
        args['poll_time'] = 0
        args['client'] = mock.MagicMock()
        self.driver = monasca_driver.MonascaDriver(args=args)

        self.mock_metrics = {
            "links": [{
                "rel": "self",
                "href": "http://192.168.10.4:8070/v2.0/metrics"
            }],
            "elements": [{
                "id": "0",
                "name": "mem.used_buffers",
                "dimensions": {
                    "component": "monasca-persister",
                    "service": "monitoring",
                    "hostname": "ceilosca",
                    "url": "http://localhost:8091/metrics"
                }
            }]
        }

        self.mock_statistics = {
            "links": [{
                "rel":
                "self",
                "href":
                "http://192.168.10.4:8070/v2.0/metrics/statistics"
            }],
            "elements": [{
                "id":
                "2015-11-30T18:00:00Z",
                "name":
                "mem.used_buffers",
                "dimensions": {},
                "columns": ["timestamp", "avg"],
                "statistics": [["2015-11-24T00:00:00Z", 56],
                               ["2015-11-24T06:00:00Z", 46],
                               ["2015-11-24T12:00:00Z", 70],
                               ["2015-11-24T18:00:00Z", 60]]
            }]
        }
Example #20
0
 def test_cage(self):
     """Test basic DSE functionality."""
     cage = congress.dse.d6cage.d6Cage()
     cage.loadModule(
         "TestDriver",
         helper.data_module_path("../tests/datasources/test_driver.py"))
     args = helper.datasource_openstack_args()
     args['poll_time'] = 0
     cage.createservice(name="test1", moduleName="TestDriver", args=args)
     cage.createservice(name="test2", moduleName="TestDriver", args=args)
     test1 = cage.service_object('test1')
     test2 = cage.service_object('test2')
     test1.subscribe('test2', 'p', callback=test1.receive_msg)
     test2.publish('p', 42)
     helper.retry_check_for_message_to_arrive(test1)
     self.assertTrue(test1.msg.body, 42)
Example #21
0
    def test_datasource_pub(self, nova_mock):
        node = helper.make_dsenode_new_partition('testnode')
        nova = nova_driver.NovaDriver(name='nova',
                                      args=helper.datasource_openstack_args())
        test = fake_datasource.FakeDataSource('test')
        node.register_service(nova)
        node.register_service(test)

        test.subscribe('nova', 'p')
        helper.retry_check_function_return_value(
            lambda: hasattr(test, 'last_msg'), True)
        nova.publish('p', 42, use_snapshot=True)
        helper.retry_check_function_return_value(lambda: test.last_msg['data'],
                                                 42)
        self.assertFalse(hasattr(nova, "last_msg"))
        node.stop()
Example #22
0
    def test_initialize_tables_full(self):
        """Test performance of initializing data with Datasource, DSE, Engine.

        This test gives a datasource driver the Python data that would
        have resulted from making an API call and parsing it into Python
        and then polls that datasource, waiting until the data arrives
        in the policy engine.  It tests the amount of time required to
        translate Python data into tables, send those tables over the DSE,
        and load them into the policy engine.
        """
        MAX_TUPLES = 700
        # install datasource driver we can control
        self.cage.loadModule(
            "PerformanceTestDriver",
            helper.data_module_path(
                "../tests/datasources/performance_datasource_driver.py"))
        self.cage.createservice(name="data",
                                moduleName="PerformanceTestDriver",
                                args=helper.datasource_openstack_args())
        driver = self.cage.service_object('data')
        driver.poll_time = 0
        self.engine.create_policy('data')

        # set return value for datasource driver
        facts = [{
            'field1': 1,
            'field2': 2.3,
            'field3': 'foo',
            'field4': 'bar',
            'field5': i,
            'field6': 'a' * 100 + str(i)
        } for i in range(MAX_TUPLES)]
        driver.client_data = facts

        # Send formula to engine (so engine subscribes to data:p)
        policy = self.engine.DEFAULT_THEORY
        formula = compile.parse1(
            'q(1) :- data:p(1, 2.3, "foo", "bar", 1, %s)' % ('a' * 100 + '1'))
        LOG.info("publishing rule")
        self.api['rule'].publish('policy-update',
                                 [agnostic.Event(formula, target=policy)])

        # Poll data and wait til it arrives at engine
        driver.poll()
        self.wait_til_query_nonempty('q(1)', policy)
def create_networkXnetwork_group(tablename):
    """Return rule of the form:

    TABLENAME(x,y) :- neutron:network(...,x,...),neutron:network(...,y,...)
    """
    driver = neutron_driver.NeutronDriver(
        args=helper.datasource_openstack_args())
    network_key_to_index = driver.get_column_map(
        neutron_driver.NeutronDriver.NETWORKS)
    network_id_index = network_key_to_index['id']
    network_max_index = max(network_key_to_index.values())
    net1_args = ['x' + str(i) for i in xrange(0, network_max_index + 1)]
    net2_args = ['y' + str(i) for i in xrange(0, network_max_index + 1)]
    formula = compile.parse1(
        '{}({},{}) :- neutron:networks({}), neutron2:networks({})'.format(
            tablename, 'x' + str(network_id_index),
            'y' + str(network_id_index), ",".join(net1_args),
            ",".join(net2_args)))
    return formula
    def test_initialize_tables_full(self):
        """Test performance of initializing data with Datasource, DSE, Engine.

        This test gives a datasource driver the Python data that would
        have resulted from making an API call and parsing it into Python
        and then polls that datasource, waiting until the data arrives
        in the policy engine.  It tests the amount of time required to
        translate Python data into tables, send those tables over the DSE,
        and load them into the policy engine.
        """
        MAX_TUPLES = 700
        # install datasource driver we can control
        kwds = {}
        kwds['name'] = 'data'
        kwds['args'] = helper.datasource_openstack_args()
        kwds['driver'] = 'performance'
        driver = self.cage.create_datasource_service(kwds)
        self.cage.register_service(driver)
        driver.poll_time = 0
        self.engine.create_policy('data')

        # set return value for datasource driver
        facts = [{
            'field1': 1,
            'field2': 2.3,
            'field3': 'foo',
            'field4': 'bar',
            'field5': i,
            'field6': 'a' * 100 + str(i)
        } for i in range(MAX_TUPLES)]
        driver.client_data = facts

        # Send formula to engine (so engine subscribes to data:p)
        policy = self.engine.DEFAULT_THEORY
        formula = compile.parse1(
            'q(1) :- data:p(1, 2.3, "foo", "bar", 1, %s)' % ('a' * 100 + '1'))
        LOG.info("publishing rule")
        self.engine.process_policy_update(
            [compile.Event(formula, target=policy)])

        # Poll data and wait til it arrives at engine
        driver.poll()
        self.wait_til_query_nonempty('q(1)', policy)
Example #25
0
    def test_datasource_unsub(self, nova_mock):
        node = helper.make_dsenode_new_partition('testnode')
        nova = nova_driver.NovaDriver(name='nova',
                                      args=helper.datasource_openstack_args())
        test = fake_datasource.FakeDataSource('test')
        node.register_service(nova)
        node.register_service(test)

        nova.subscribe('test', 'p')
        helper.retry_check_function_return_value(
            lambda: hasattr(nova, 'last_msg'), True)
        test.publish('p', 42, use_snapshot=True)
        helper.retry_check_function_return_value(lambda: nova.last_msg['data'],
                                                 42)
        self.assertFalse(hasattr(test, "last_msg"))
        nova.unsubscribe('test', 'p')
        test.publish('p', 43, use_snapshot=True)
        # hard to test that the message is never delivered
        time.sleep(0.2)
        self.assertEqual(nova.last_msg['data'], 42)
        node.stop()
Example #26
0
    def _create_neutron_mock(self, name):
        # Register Neutron service
        args = helper.datasource_openstack_args()
        neutronv2 = neutronv2_driver.NeutronV2Driver(name, args=args)
        # FIXME(ekcs): this is a hack to prevent the synchronizer from
        # attempting to delete this DSD because it's not in DB
        neutronv2.type = 'no_sync_datasource_driver'
        neutron_mock = mock.MagicMock(spec=neutronclient.v2_0.client.Client)
        neutronv2.neutron = neutron_mock

        # initialize neutron_mocks
        network1 = test_neutron.network_response
        port_response = test_neutron.port_response
        router_response = test_neutron.router_response
        sg_group_response = test_neutron.security_group_response
        neutron_mock.list_networks.return_value = network1
        neutron_mock.list_ports.return_value = port_response
        neutron_mock.list_routers.return_value = router_response
        neutron_mock.list_security_groups.return_value = sg_group_response
        self.node.register_service(neutronv2)
        return neutronv2
Example #27
0
 def test_policy(self):
     """Test basic DSE functionality with policy engine."""
     cage = congress.dse.d6cage.d6Cage()
     cage.loadModule(
         "TestDriver",
         helper.data_module_path("../tests/datasources/test_driver.py"))
     cage.loadModule("TestPolicy", helper.policy_module_path())
     cage.createservice(name="data",
                        moduleName="TestDriver",
                        args=helper.datasource_openstack_args())
     cage.createservice(name="policy",
                        moduleName="TestPolicy",
                        args={
                            'd6cage': cage,
                            'rootdir': ''
                        })
     data = cage.services['data']['object']
     policy = cage.services['policy']['object']
     policy.subscribe('data', 'p', callback=policy.receive_msg)
     data.publish('p', 42)
     helper.retry_check_for_message_to_arrive(policy)
     self.assertTrue(policy.msg.body, 42)
    def setUp(self):
        super(TestNeutronV2QosDriver, self).setUp()
        self.neutron_client_p = mock.patch(
            "neutronclient.v2_0.client.Client")
        self.neutron_client_p.start()

        args = helper.datasource_openstack_args()
        args['poll_time'] = 0
        args['client'] = mock.MagicMock()
        self.driver = neutronv2_qos_driver.NeutronV2QosDriver(args=args)

        self.mock_ports = {'ports': [
            {u'admin_state_up': True,
             u'allowed_address_pairs': [],
             u'binding:host_id': None,
             u'binding:vif_details': {u'port_filter': True},
             u'binding:vif_type': u'ovs',
             u'binding:vnic_type': u'normal',
             u'device_id': u'f42dc4f1-f371-48cc-95be-cf1b97112ab8',
             u'device_owner': u'network:router_gateway',
             u'fixed_ips': [
                 {u'ip_address': u'1.1.1.2',
                  u'subnet_id': u'10d20df9-e8ba-4756-ba30-d573ceb2e99a'}],
             u'id': u'04627c85-3553-436c-a7c5-0a64f5b87bb9',
             u'mac_address': u'fa:16:3e:f3:19:e5',
             u'name': u'',
             u'network_id': u'ecdea1af-7197-43c8-b3b0-34d90f72a2a8',
             u'port_security_enabled': False,
             u'security_groups': [],
             u'status': u'DOWN',
             u'tenant_id': u''},
            {u'admin_state_up': True,
             u'allowed_address_pairs': [],
             u'binding:host_id': None,
             u'binding:vif_details': {u'port_filter': True},
             u'binding:vif_type': u'ovs',
             u'binding:vnic_type': u'normal',
             u'device_id': u'f42dc4f1-f371-48cc-95be-cf1b97112ab8',
             u'device_owner': u'network:router_interface',
             u'fixed_ips': [
                 {u'ip_address': u'169.254.169.253',
                  u'subnet_id': u'aa9ad4f7-baf0-4a41-85c3-1cc8a3066db6'}],
             u'id': u'87f8933a-9582-48d8-ad16-9abf6e545002',
             u'mac_address': u'fa:16:3e:b7:78:e8',
             u'name': u'',
             u'network_id': u'6743ff85-2cfd-48a7-9d3f-472cd418783e',
             u'port_security_enabled': False,
             u'security_groups': [],
             u'status': u'DOWN',
             u'tenant_id': u''},
            {u'admin_state_up': True,
             u'allowed_address_pairs': [],
             u'binding:host_id': None,
             u'binding:vif_details': {u'port_filter': True},
             u'binding:vif_type': u'ovs',
             u'binding:vnic_type': u'normal',
             u'device_id': u'f42dc4f1-f371-48cc-95be-cf1b97112ab8',
             u'device_owner': u'network:router_interface',
             u'fixed_ips': [
                 {u'ip_address': u'10.0.0.1',
                  u'subnet_id': u'3c0eb3a3-4d16-4b1b-b327-44417182d0bb'}],
             u'id': u'c58c3246-6c2e-490a-b4d9-3b8d5191b465',
             u'mac_address': u'fa:16:3e:08:31:6e',
             u'name': u'',
             u'network_id': u'63ce8fbb-12e9-4ecd-9b56-1bbf8b51217d',
             u'port_security_enabled': False,
             u'security_groups': [],
             u'status': u'DOWN',
             u'tenant_id': u'feee0a965cc34274917fb753623dd57d'},
            {u'admin_state_up': True,
             u'allowed_address_pairs': [],
             u'binding:host_id': None,
             u'binding:vif_details': {u'port_filter': True},
             u'binding:vif_type': u'ovs',
             u'binding:vnic_type': u'normal',
             u'device_id': u'',
             u'device_owner': u'',
             u'fixed_ips': [
                 {u'ip_address': u'10.0.0.2',
                  u'subnet_id': u'3c0eb3a3-4d16-4b1b-b327-44417182d0bb'}],
             u'id': u'eb50003b-a081-4533-92aa-1cbd97f526a8',
             u'mac_address': u'fa:16:3e:af:56:fa',
             u'name': u'',
             u'network_id': u'63ce8fbb-12e9-4ecd-9b56-1bbf8b51217d',
             u'port_security_enabled': True,
             u'security_groups': [u'e0239062-4243-4798-865f-7055f03786d6'],
             u'qos_policies': [u'be50b732-4508-4a94-9c3c-8dc4b96a2b43'],
             u'status': u'DOWN',
             u'tenant_id': u'feee0a965cc34274917fb753623dd57d'}]}

        self.mock_qos_policies = {'policies': [
            {u'name': u'ysm',
             u'rules': [
                 {u'max_kbps': 100,
                  u'direction': u'egress',
                  u'qos_policy_id': u'be50b732-4508-4a94-9c3c-8dc4b96a2b43',
                  u'type': u'bandwidth_limit',
                  u'id': u'9daaa87a-5441-49ef-8f25-2810d37c3a60',
                  u'max_burst_kbps': 500},
                 {u'dscp_mark': 10,
                  u'type': u'dscp_marking',
                  u'id': u'6be91937-b9ec-4209-a430-0c2694df1095',
                  u'qos_policy_id': u'be50b732-4508-4a94-9c3c-8dc4b96a2b43'},
                 {u'id': u'015f3dc8-7d3e-4598-8996-0597328c4db5',
                  u'direction': u'egress',
                  u'type': u'minimum_bandwidth',
                  u'qos_policy_id': u'be50b732-4508-4a94-9c3c-8dc4b96a2b43',
                  u'min_kbps': 100}],
             u'tenant_id': u'feee0a965cc34274917fb753623dd57d',
             u'is_default': False,
             u'shared': False,
             u'project_id': u'feee0a965cc34274917fb753623dd57d',
             u'id': u'be50b732-4508-4a94-9c3c-8dc4b96a2b43',
             u'description': u''}]}

        self.expected_state = {
            'ports': set([(u'04627c85-3553-436c-a7c5-0a64f5b87bb9',),
                          (u'87f8933a-9582-48d8-ad16-9abf6e545002',),
                          (u'c58c3246-6c2e-490a-b4d9-3b8d5191b465',),
                          (u'eb50003b-a081-4533-92aa-1cbd97f526a8',)]),
            'qos_policy_port_bindings':
                set([('eb50003b-a081-4533-92aa-1cbd97f526a8',
                      'be50b732-4508-4a94-9c3c-8dc4b96a2b43')]),
            'policies':
                set([('be50b732-4508-4a94-9c3c-8dc4b96a2b43',
                      'feee0a965cc34274917fb753623dd57d',
                      'ysm',
                      '',
                      'False')]),
            'rules':
                set([('be50b732-4508-4a94-9c3c-8dc4b96a2b43',
                      '015f3dc8-7d3e-4598-8996-0597328c4db5',
                      100,
                      'egress',
                      'minimum_bandwidth',
                      'None',
                      'None',
                      'None'),
                     ('be50b732-4508-4a94-9c3c-8dc4b96a2b43',
                      '6be91937-b9ec-4209-a430-0c2694df1095',
                      'None',
                      'None',
                      'dscp_marking',
                      10,
                      'None',
                      'None'),
                     ('be50b732-4508-4a94-9c3c-8dc4b96a2b43',
                      '9daaa87a-5441-49ef-8f25-2810d37c3a60',
                      'None',
                      'egress',
                      'bandwidth_limit',
                      'None',
                      500,
                      100)])}
Example #29
0
    def setUp(self):
        super(TestKeystoneDriver, self).setUp()

        class FakeClient(object):
            def __init__(self):
                self.users = mock.MagicMock()
                self.roles = mock.MagicMock()
                self.tenants = mock.MagicMock()

        self.users_data = [
            ResponseObj({
                'username': '******',
                'name': 'alice foo',
                'enabled': True,
                'tenantId': '019b18a15f2a44c1880d57704b2c4009',
                'id': '00f2c34a156c40058004ee8eb3320e04',
                'email': '*****@*****.**'
            }),
            ResponseObj({
                'username': '******',
                'name': 'bob bar',
                'enabled': False,
                'tenantId': 'aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa',
                'id': 'bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb',
                'email': '*****@*****.**'
            })
        ]

        self.roles_data = [
            ResponseObj({
                'id': 'cccccccccccccccccccccccccccccccc',
                'name': 'admin'
            }),
            ResponseObj({
                'id': 'dddddddddddddddddddddddddddddddd',
                'name': 'viewer'
            })
        ]

        self.tenants_data = [
            ResponseObj({
                'enabled': True,
                'description': 'accounting team',
                'name': 'accounting',
                'id': '00000000000000000000000000000001'
            }),
            ResponseObj({
                'enabled': False,
                'description': 'eng team',
                'name': 'eng',
                'id': '00000000000000000000000000000002'
            })
        ]

        self.keystone_client = mock.patch("keystoneclient.v2_0.client.Client",
                                          return_value=FakeClient())
        self.keystone_client.start()
        args = helper.datasource_openstack_args()
        args['poll_time'] = 0
        self.driver = keystone_driver.KeystoneDriver(args=args)
        self.driver.client.users.list.return_value = self.users_data
        self.driver.client.roles.list.return_value = self.roles_data
        self.driver.client.tenants.list.return_value = self.tenants_data
    def setUp(self):
        super(TestKeystoneDriver, self).setUp()

        class FakeClient(object):
            def __init__(self):
                self.users = mock.MagicMock()
                self.roles = mock.MagicMock()
                self.projects = mock.MagicMock()
                self.domains = mock.MagicMock()

        self.users_data = [
            ResponseObj({
                'id': '00f2c34a156c40058004ee8eb3320e04',
                'name': 'alice',
                'enabled': True,
                'default_project_id': '019b18a15f2a44c1880d57704b2c4009',
                'domain_id': 'default'
            }),
            ResponseObj({
                'id': 'bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb',
                'name': 'bob',
                'enabled': False,
                'default_project_id': 'aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa',
                'domain_id': 'default'
            })
        ]

        self.roles_data = [
            ResponseObj({
                'id': 'cccccccccccccccccccccccccccccccc',
                'name': 'admin'
            }),
            ResponseObj({
                'id': 'dddddddddddddddddddddddddddddddd',
                'name': 'viewer'
            })
        ]

        self.projects_data = [
            ResponseObj({
                'enabled': True,
                'description': 'accounting team',
                'name': 'accounting',
                'domain_id': 'default',
                'id': '00000000000000000000000000000001'
            }),
            ResponseObj({
                'enabled': False,
                'description': 'eng team',
                'domain_id': 'default',
                'name': 'eng',
                'id': '00000000000000000000000000000002'
            })
        ]

        self.domains_data = [
            ResponseObj({
                'enabled': True,
                'description': 'domain 1',
                'name': 'default',
                'id': '1fbe4e6fedb34050ad56c6e5dd225998'
            }),
            ResponseObj({
                'enabled': False,
                'description': 'domain 2',
                'name': 'test domain',
                'id': 'aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa'
            })
        ]

        self.keystone_client = mock.patch("keystoneclient.v3.client.Client",
                                          return_value=FakeClient())
        self.keystone_client.start()
        args = helper.datasource_openstack_args()
        args['poll_time'] = 0
        self.driver = keystonev3_driver.KeystoneV3Driver(args=args)
        self.driver.client.users.list.return_value = self.users_data
        self.driver.client.roles.list.return_value = self.roles_data
        self.driver.client.projects.list.return_value = self.projects_data
        self.driver.client.domains.list.return_value = self.domains_data
    def setUp(self):
        """Setup polling tests."""
        super(TestDataSourceDriver, self).setUp()
        cage = d6cage.d6Cage()

        # Create mock of Neutron client so we can control data
        mock_factory = mox.Mox()
        neutron_client = mock_factory.CreateMock(
            neutronclient.v2_0.client.Client)
        neutron_client.list_networks().InAnyOrder(1).AndReturn(network1)
        neutron_client.list_ports().InAnyOrder(1).AndReturn(port_response)
        neutron_client.list_routers().InAnyOrder(1).AndReturn(router_response)
        neutron_client.list_security_groups().InAnyOrder(1).AndReturn(
            security_group_response)
        neutron_client.list_networks().InAnyOrder(2).AndReturn(network2)
        neutron_client.list_ports().InAnyOrder(2).AndReturn(port_response)
        neutron_client.list_routers().InAnyOrder(2).AndReturn(router_response)
        neutron_client.list_security_groups().InAnyOrder(2).AndReturn(
            security_group_response)
        mock_factory.ReplayAll()

        # Create modules (without auto-polling)
        cage.loadModule("NeutronDriver",
                        helper.data_module_path("neutron_driver.py"))
        cage.loadModule("PolicyDriver", helper.policy_module_path())
        cage.createservice(name="policy",
                           moduleName="PolicyDriver",
                           args={
                               'd6cage': cage,
                               'rootdir': helper.data_module_path('')
                           })
        args = helper.datasource_openstack_args()
        args['poll_time'] = 0
        args['client'] = neutron_client
        cage.createservice(name="neutron",
                           moduleName="NeutronDriver",
                           args=args)
        policy = cage.service_object('policy')
        policy.create_policy('neutron')
        policy.set_schema('neutron',
                          cage.service_object('neutron').get_schema())
        cage.service_object('neutron').neutron = neutron_client
        policy.debug_mode()

        # insert rule into policy to make testing easier.
        #   (Some of the IDs are auto-generated each time we convert)
        policy.insert(create_network_group('p'))

        # create some garbage data
        args = helper.datasource_openstack_args()
        driver = neutron_driver.NeutronDriver(args=args)
        network_key_to_index = driver.get_column_map(
            neutron_driver.NeutronDriver.NETWORKS)
        network_max_index = max(network_key_to_index.values())
        args1 = ['1'] * (network_max_index + 1)
        args2 = ['2'] * (network_max_index + 1)
        args1 = ",".join(args1)
        args2 = ",".join(args2)
        fake_networks = [
            'neutron:networks({})'.format(args1),
            'neutron:networks({})'.format(args2)
        ]

        # answer to query above for network1
        datalog1 = ('p("240ff9df-df35-43ae-9df5-27fae87f2492") '
                    'p("340ff9df-df35-43ae-9df5-27fae87f2492") '
                    'p("440ff9df-df35-43ae-9df5-27fae87f2492")')

        # answer to query above for network2
        datalog2 = ('p("240ff9df-df35-43ae-9df5-27fae87f2492") '
                    'p("640ff9df-df35-43ae-9df5-27fae87f2492") '
                    'p("540ff9df-df35-43ae-9df5-27fae87f2492")')

        # return value
        self.info = {}
        self.info['cage'] = cage
        self.info['datalog1'] = datalog1
        self.info['datalog2'] = datalog2
        self.info['fake_networks'] = fake_networks
    def setUp(self):
        super(TestNeutronV2Driver, self).setUp()
        self.neutron_client_p = mock.patch(
            "neutronclient.v2_0.client.Client")
        self.neutron_client_p.start()

        args = helper.datasource_openstack_args()
        args['poll_time'] = 0
        args['client'] = mock.MagicMock()
        self.driver = neutronv2_driver.NeutronV2Driver(args=args)

        self.mock_networks = {'networks': [
            {u'admin_state_up': True,
             u'id': u'63ce8fbb-12e9-4ecd-9b56-1bbf8b51217d',
             u'name': u'private',
             u'router:external': False,
             u'shared': False,
             u'status': u'ACTIVE',
             u'subnets': [u'3c0eb3a3-4d16-4b1b-b327-44417182d0bb'],
             u'tenant_id': u'feee0a965cc34274917fb753623dd57d'},
            {u'admin_state_up': True,
             u'id': u'ecdea1af-7197-43c8-b3b0-34d90f72a2a8',
             u'name': u'public',
             u'router:external': True,
             u'shared': False,
             u'status': u'ACTIVE',
             u'subnets': [u'10d20df9-e8ba-4756-ba30-d573ceb2e99a'],
             u'tenant_id': u'feee0a965cc34274917fb753623dd57d'}]}

        self.mock_ports = {'ports': [
            {u'admin_state_up': True,
             u'allowed_address_pairs': [],
             u'binding:host_id': None,
             u'binding:vif_details': {u'port_filter': True},
             u'binding:vif_type': u'ovs',
             u'binding:vnic_type': u'normal',
             u'device_id': u'f42dc4f1-f371-48cc-95be-cf1b97112ab8',
             u'device_owner': u'network:router_gateway',
             u'fixed_ips': [
                 {u'ip_address': u'1.1.1.2',
                  u'subnet_id': u'10d20df9-e8ba-4756-ba30-d573ceb2e99a'}],
             u'id': u'04627c85-3553-436c-a7c5-0a64f5b87bb9',
             u'mac_address': u'fa:16:3e:f3:19:e5',
             u'name': u'',
             u'network_id': u'ecdea1af-7197-43c8-b3b0-34d90f72a2a8',
             u'port_security_enabled': False,
             u'security_groups': [],
             u'status': u'DOWN',
             u'tenant_id': u''},
            {u'admin_state_up': True,
             u'allowed_address_pairs': [],
             u'binding:host_id': None,
             u'binding:vif_details': {u'port_filter': True},
             u'binding:vif_type': u'ovs',
             u'binding:vnic_type': u'normal',
             u'device_id': u'f42dc4f1-f371-48cc-95be-cf1b97112ab8',
             u'device_owner': u'network:router_interface',
             u'fixed_ips': [
                 {u'ip_address': u'169.254.169.253',
                  u'subnet_id': u'aa9ad4f7-baf0-4a41-85c3-1cc8a3066db6'}],
             u'id': u'87f8933a-9582-48d8-ad16-9abf6e545002',
             u'mac_address': u'fa:16:3e:b7:78:e8',
             u'name': u'',
             u'network_id': u'6743ff85-2cfd-48a7-9d3f-472cd418783e',
             u'port_security_enabled': False,
             u'security_groups': [],
             u'status': u'DOWN',
             u'tenant_id': u''},
            {u'admin_state_up': True,
             u'allowed_address_pairs': [],
             u'binding:host_id': None,
             u'binding:vif_details': {u'port_filter': True},
             u'binding:vif_type': u'ovs',
             u'binding:vnic_type': u'normal',
             u'device_id': u'f42dc4f1-f371-48cc-95be-cf1b97112ab8',
             u'device_owner': u'network:router_interface',
             u'fixed_ips': [
                 {u'ip_address': u'10.0.0.1',
                  u'subnet_id': u'3c0eb3a3-4d16-4b1b-b327-44417182d0bb'}],
             u'id': u'c58c3246-6c2e-490a-b4d9-3b8d5191b465',
             u'mac_address': u'fa:16:3e:08:31:6e',
             u'name': u'',
             u'network_id': u'63ce8fbb-12e9-4ecd-9b56-1bbf8b51217d',
             u'port_security_enabled': False,
             u'security_groups': [],
             u'status': u'DOWN',
             u'tenant_id': u'feee0a965cc34274917fb753623dd57d'},
            {u'admin_state_up': True,
             u'allowed_address_pairs': [],
             u'binding:host_id': None,
             u'binding:vif_details': {u'port_filter': True},
             u'binding:vif_type': u'ovs',
             u'binding:vnic_type': u'normal',
             u'device_id': u'',
             u'device_owner': u'',
             u'fixed_ips': [
                 {u'ip_address': u'10.0.0.2',
                  u'subnet_id': u'3c0eb3a3-4d16-4b1b-b327-44417182d0bb'}],
             u'id': u'eb50003b-a081-4533-92aa-1cbd97f526a8',
             u'mac_address': u'fa:16:3e:af:56:fa',
             u'name': u'',
             u'network_id': u'63ce8fbb-12e9-4ecd-9b56-1bbf8b51217d',
             u'port_security_enabled': True,
             u'security_groups': [u'e0239062-4243-4798-865f-7055f03786d6'],
             u'status': u'DOWN',
             u'tenant_id': u'feee0a965cc34274917fb753623dd57d'}]}

        self.mock_subnets = {'subnets': [
            {u'allocation_pools': [{u'end': u'1.1.1.254',
                                    u'start': u'1.1.1.2'}],
             u'cidr': u'1.1.1.0/24',
             u'dns_nameservers': [],
             u'enable_dhcp': True,
             u'gateway_ip': u'1.1.1.1',
             u'host_routes': [],
             u'id': u'10d20df9-e8ba-4756-ba30-d573ceb2e99a',
             u'ip_version': 4,
             u'ipv6_address_mode': None,
             u'ipv6_ra_mode': None,
             u'name': u'',
             u'network_id': u'ecdea1af-7197-43c8-b3b0-34d90f72a2a8',
             u'tenant_id': u'feee0a965cc34274917fb753623dd57d'},
            {u'allocation_pools': [{u'end': u'10.0.0.254',
                                    u'start': u'10.0.0.2'}],
             u'cidr': u'10.0.0.0/24',
             u'dns_nameservers': [u'8.8.8.8'],
             u'enable_dhcp': True,
             u'gateway_ip': u'10.0.0.1',
             u'host_routes': [{u'destination': u'10.10.0.2/32',
                               u'nexthop': u'10.0.0.1'}],
             u'id': u'3c0eb3a3-4d16-4b1b-b327-44417182d0bb',
             u'ip_version': 4,
             u'ipv6_address_mode': None,
             u'ipv6_ra_mode': None,
             u'name': u'private-subnet',
             u'network_id': u'63ce8fbb-12e9-4ecd-9b56-1bbf8b51217d',
             u'tenant_id': u'feee0a965cc34274917fb753623dd57d'},
            {u'allocation_pools': [{u'end': u'169.254.169.254',
                                    u'start': u'169.254.169.254'}],
             u'cidr': u'169.254.169.252/30',
             u'dns_nameservers': [],
             u'enable_dhcp': True,
             u'gateway_ip': u'169.254.169.253',
             u'host_routes': [],
             u'id': u'aa9ad4f7-baf0-4a41-85c3-1cc8a3066db6',
             u'ip_version': 4,
             u'ipv6_address_mode': None,
             u'ipv6_ra_mode': None,
             u'name': u'meta-f42dc4f1-f371-48cc-95be-cf1b97112ab8',
             u'network_id': u'6743ff85-2cfd-48a7-9d3f-472cd418783e',
             u'tenant_id': u''}]}

        self.mock_routers = {'routers': [
            {u'admin_state_up': True,
             u'distributed': False,
             u'external_gateway_info': {
                 u'enable_snat': True,
                 u'external_fixed_ips': [
                     {u'ip_address': u'1.1.1.2',
                      u'subnet_id': u'10d20df9-e8ba-4756-ba30-d573ceb2e99a'}],
                 u'network_id': u'ecdea1af-7197-43c8-b3b0-34d90f72a2a8'},
             u'id': u'f42dc4f1-f371-48cc-95be-cf1b97112ab8',
             u'name': u'myrouter',
             u'routes': [],
             u'status': u'DOWN',
             u'tenant_id': u'feee0a965cc34274917fb753623dd57d'}]}

        self.mock_security_groups = {'security_groups': [
            {u'description': u'Default security group',
             u'id': u'a268fc32-1a59-4154-9a7c-f453ef92560c',
             u'name': u'default',
             u'security_group_rules': [
                 {u'direction': u'egress',
                  u'ethertype': u'IPv4',
                  u'id': u'1d943e83-e4e6-472a-9655-f74eb22f3668',
                  u'port_range_max': None,
                  u'port_range_min': None,
                  u'protocol': None,
                  u'remote_group_id': None,
                  u'remote_ip_prefix': None,
                  u'security_group_id':
                    u'a268fc32-1a59-4154-9a7c-f453ef92560c',
                  u'tenant_id': u''},
                 {u'direction': u'ingress',
                  u'ethertype': u'IPv4',
                  u'id': u'30be5ee1-5b0a-4929-aca5-0c25f1c6b733',
                  u'port_range_max': None,
                  u'port_range_min': None,
                  u'protocol': None,
                  u'remote_group_id': u'a268fc32-1a59-4154-9a7c-f453ef92560c',
                  u'remote_ip_prefix': None,
                  u'security_group_id':
                     u'a268fc32-1a59-4154-9a7c-f453ef92560c',
                  u'tenant_id': u''},
                 {u'direction': u'ingress',
                  u'ethertype': u'IPv6',
                  u'id': u'639995b8-c3ac-44a3-a4f3-c74f9172ad54',
                  u'port_range_max': None,
                  u'port_range_min': None,
                  u'protocol': None,
                  u'remote_group_id': u'a268fc32-1a59-4154-9a7c-f453ef92560c',
                  u'remote_ip_prefix': None,
                  u'security_group_id':
                     u'a268fc32-1a59-4154-9a7c-f453ef92560c',
                  u'tenant_id': u''},
                 {u'direction': u'egress',
                  u'ethertype': u'IPv6',
                  u'id': u'ed7fd9f6-e390-448a-9f5f-8dd4659282f7',
                  u'port_range_max': None,
                  u'port_range_min': None,
                  u'protocol': None,
                  u'remote_group_id': None,
                  u'remote_ip_prefix': None,
                  u'security_group_id':
                     u'a268fc32-1a59-4154-9a7c-f453ef92560c',
                  u'tenant_id': u''}],
             u'tenant_id': u''},
            {u'description': u'Default security group',
             u'id': u'e0239062-4243-4798-865f-7055f03786d6',
             u'name': u'default',
             u'security_group_rules': [
                 {u'direction': u'ingress',
                  u'ethertype': u'IPv6',
                  u'id': u'8a81fecc-ecc7-48ca-bccc-195799667e23',
                  u'port_range_max': None,
                  u'port_range_min': None,
                  u'protocol': None,
                  u'remote_group_id': u'e0239062-4243-4798-865f-7055f03786d6',
                  u'remote_ip_prefix': None,
                  u'security_group_id':
                     u'e0239062-4243-4798-865f-7055f03786d6',
                  u'tenant_id': u'feee0a965cc34274917fb753623dd57d'},
                 {u'direction': u'ingress',
                  u'ethertype': u'IPv4',
                  u'id': u'8f4d9e99-1fe8-4816-9f07-c4ecddea9427',
                  u'port_range_max': None,
                  u'port_range_min': None,
                  u'protocol': None,
                  u'remote_group_id': u'e0239062-4243-4798-865f-7055f03786d6',
                  u'remote_ip_prefix': None,
                  u'security_group_id':
                     u'e0239062-4243-4798-865f-7055f03786d6',
                  u'tenant_id': u'feee0a965cc34274917fb753623dd57d'},
                 {u'direction': u'egress',
                  u'ethertype': u'IPv4',
                  u'id': u'e70cf243-3389-4f80-82dc-92a3ec1f2d2a',
                  u'port_range_max': None,
                  u'port_range_min': None,
                  u'protocol': None,
                  u'remote_group_id': None,
                  u'remote_ip_prefix': None,
                  u'security_group_id':
                     u'e0239062-4243-4798-865f-7055f03786d6',
                  u'tenant_id': u'feee0a965cc34274917fb753623dd57d'},
                 {u'direction': u'egress',
                  u'ethertype': u'IPv6',
                  u'id': u'eca1df0f-b222-4208-8f96-8a8024fd6834',
                  u'port_range_max': None,
                  u'port_range_min': None,
                  u'protocol': None,
                  u'remote_group_id': None,
                  u'remote_ip_prefix': None,
                  u'security_group_id':
                     u'e0239062-4243-4798-865f-7055f03786d6',
                  u'tenant_id': u'feee0a965cc34274917fb753623dd57d'}],
                u'tenant_id': u'feee0a965cc34274917fb753623dd57d'}]}

        self.expected_state = {
            'subnets': set([
                ('3c0eb3a3-4d16-4b1b-b327-44417182d0bb',
                 'feee0a965cc34274917fb753623dd57d', 'private-subnet',
                 '63ce8fbb-12e9-4ecd-9b56-1bbf8b51217d', 4, '10.0.0.0/24',
                 '10.0.0.1', 'True', 'None', 'None'),
                ('aa9ad4f7-baf0-4a41-85c3-1cc8a3066db6', '',
                 'meta-f42dc4f1-f371-48cc-95be-cf1b97112ab8',
                 '6743ff85-2cfd-48a7-9d3f-472cd418783e', 4,
                 '169.254.169.252/30',
                 '169.254.169.253', 'True', 'None', 'None'),
                ('10d20df9-e8ba-4756-ba30-d573ceb2e99a',
                 'feee0a965cc34274917fb753623dd57d', '',
                 'ecdea1af-7197-43c8-b3b0-34d90f72a2a8', 4, '1.1.1.0/24',
                 '1.1.1.1', 'True', 'None', 'None')]),
            'routers':
                set([('f42dc4f1-f371-48cc-95be-cf1b97112ab8',
                      'feee0a965cc34274917fb753623dd57d', 'DOWN', 'True',
                      'myrouter', 'False')]),
            'dns_nameservers':
                set([('3c0eb3a3-4d16-4b1b-b327-44417182d0bb', '8.8.8.8')]),
            'security_group_rules':
                set([('e0239062-4243-4798-865f-7055f03786d6',
                      'e70cf243-3389-4f80-82dc-92a3ec1f2d2a',
                      'feee0a965cc34274917fb753623dd57d', 'None', 'egress',
                      'IPv4', 'None', 'None', 'None', 'None'),
                     ('a268fc32-1a59-4154-9a7c-f453ef92560c',
                      'ed7fd9f6-e390-448a-9f5f-8dd4659282f7', '', 'None',
                      'egress', 'IPv6', 'None', 'None', 'None', 'None'),
                     ('a268fc32-1a59-4154-9a7c-f453ef92560c',
                      '1d943e83-e4e6-472a-9655-f74eb22f3668', '', 'None',
                      'egress', 'IPv4', 'None', 'None', 'None', 'None'),
                     ('a268fc32-1a59-4154-9a7c-f453ef92560c',
                      '30be5ee1-5b0a-4929-aca5-0c25f1c6b733', '',
                      'a268fc32-1a59-4154-9a7c-f453ef92560c', 'ingress',
                      'IPv4', 'None', 'None', 'None', 'None'),
                     ('e0239062-4243-4798-865f-7055f03786d6',
                      '8a81fecc-ecc7-48ca-bccc-195799667e23',
                      'feee0a965cc34274917fb753623dd57d',
                      'e0239062-4243-4798-865f-7055f03786d6', 'ingress',
                      'IPv6', 'None', 'None', 'None', 'None'),
                     ('a268fc32-1a59-4154-9a7c-f453ef92560c',
                      '639995b8-c3ac-44a3-a4f3-c74f9172ad54', '',
                      'a268fc32-1a59-4154-9a7c-f453ef92560c', 'ingress',
                      'IPv6', 'None', 'None', 'None', 'None'),
                     ('e0239062-4243-4798-865f-7055f03786d6',
                      '8f4d9e99-1fe8-4816-9f07-c4ecddea9427',
                      'feee0a965cc34274917fb753623dd57d',
                      'e0239062-4243-4798-865f-7055f03786d6',
                      'ingress', 'IPv4', 'None', 'None', 'None', 'None'),
                     ('e0239062-4243-4798-865f-7055f03786d6',
                      'eca1df0f-b222-4208-8f96-8a8024fd6834',
                      'feee0a965cc34274917fb753623dd57d', 'None', 'egress',
                      'IPv6', 'None', 'None', 'None', 'None')]),
                'ports':
                    set([('c58c3246-6c2e-490a-b4d9-3b8d5191b465',
                          'feee0a965cc34274917fb753623dd57d', '',
                          '63ce8fbb-12e9-4ecd-9b56-1bbf8b51217d',
                          'fa:16:3e:08:31:6e', 'True', 'DOWN',
                          'f42dc4f1-f371-48cc-95be-cf1b97112ab8',
                          'network:router_interface'),
                         ('87f8933a-9582-48d8-ad16-9abf6e545002', '', '',
                          '6743ff85-2cfd-48a7-9d3f-472cd418783e',
                          'fa:16:3e:b7:78:e8', 'True', 'DOWN',
                          'f42dc4f1-f371-48cc-95be-cf1b97112ab8',
                          'network:router_interface'),
                         ('eb50003b-a081-4533-92aa-1cbd97f526a8',
                          'feee0a965cc34274917fb753623dd57d', '',
                          '63ce8fbb-12e9-4ecd-9b56-1bbf8b51217d',
                          'fa:16:3e:af:56:fa', 'True', 'DOWN', '', ''),
                         ('04627c85-3553-436c-a7c5-0a64f5b87bb9', '', '',
                          'ecdea1af-7197-43c8-b3b0-34d90f72a2a8',
                          'fa:16:3e:f3:19:e5', 'True', 'DOWN',
                          'f42dc4f1-f371-48cc-95be-cf1b97112ab8',
                          'network:router_gateway')]),
                'allocation_pools':
                    set([('10d20df9-e8ba-4756-ba30-d573ceb2e99a', '1.1.1.2',
                          '1.1.1.254'),
                         ('3c0eb3a3-4d16-4b1b-b327-44417182d0bb', '10.0.0.2',
                          '10.0.0.254'),
                         ('aa9ad4f7-baf0-4a41-85c3-1cc8a3066db6',
                          '169.254.169.254', '169.254.169.254')]),
                'host_routes':
                    set([('3c0eb3a3-4d16-4b1b-b327-44417182d0bb',
                          '10.10.0.2/32', '10.0.0.1')]),
                'security_group_port_bindings':
                    set([('eb50003b-a081-4533-92aa-1cbd97f526a8',
                          'e0239062-4243-4798-865f-7055f03786d6')]),
                'external_gateway_infos':
                    set([('f42dc4f1-f371-48cc-95be-cf1b97112ab8',
                          'ecdea1af-7197-43c8-b3b0-34d90f72a2a8', 'True')]),
                'fixed_ips':
                    set([('c58c3246-6c2e-490a-b4d9-3b8d5191b465', '10.0.0.1',
                          '3c0eb3a3-4d16-4b1b-b327-44417182d0bb'),
                         ('eb50003b-a081-4533-92aa-1cbd97f526a8', '10.0.0.2',
                          '3c0eb3a3-4d16-4b1b-b327-44417182d0bb'),
                         ('87f8933a-9582-48d8-ad16-9abf6e545002',
                          '169.254.169.253',
                          'aa9ad4f7-baf0-4a41-85c3-1cc8a3066db6'),
                         ('04627c85-3553-436c-a7c5-0a64f5b87bb9', '1.1.1.2',
                          '10d20df9-e8ba-4756-ba30-d573ceb2e99a')]),
                'networks':
                    set([('ecdea1af-7197-43c8-b3b0-34d90f72a2a8',
                          'feee0a965cc34274917fb753623dd57d', 'public',
                          'ACTIVE', 'True', 'False'),
                         ('63ce8fbb-12e9-4ecd-9b56-1bbf8b51217d',
                          'feee0a965cc34274917fb753623dd57d', 'private',
                          'ACTIVE', 'True', 'False')]),
                'security_groups':
                    set([('e0239062-4243-4798-865f-7055f03786d6',
                          'feee0a965cc34274917fb753623dd57d', 'default',
                          'Default security group'),
                         ('a268fc32-1a59-4154-9a7c-f453ef92560c', '',
                          'default', 'Default security group')]),
                'external_fixed_ips':
                    set([('f42dc4f1-f371-48cc-95be-cf1b97112ab8',
                          '10d20df9-e8ba-4756-ba30-d573ceb2e99a', '1.1.1.2')])}