def __init__(self):
super(AristaVlanTypeDriver, self).__init__()
ndb = db_lib.NeutronNets()
self.rpc = AristaRPCWrapperEapi(ndb)
self.sync_service = driver_helpers.VlanSyncService(self.rpc)
self.network_vlan_ranges = dict()
self.sync_timeout = cfg.CONF.arista_type_driver['sync_interval']
def test_cleanup_on_start(self):
"""Ensures that the driver cleans up the arista database on startup."""
ndb = db_lib.NeutronNets()
# Create some networks in neutron db
n1_context = self._get_network_context('t1', 'n1', 10)
ndb.create_network(n1_context, {'network': n1_context.current})
n2_context = self._get_network_context('t2', 'n2', 20)
ndb.create_network(n2_context, {'network': n2_context.current})
n3_context = self._get_network_context('', 'ha-network', 100)
ndb.create_network(n3_context, {'network': n3_context.current})
# Create some networks in Arista db
db_lib.remember_network('t1', 'n1', 10)
db_lib.remember_network('t2', 'n2', 20)
db_lib.remember_network('admin', 'ha-network', 100)
db_lib.remember_network('t3', 'n3', 30)
# Initialize the driver which should clean up the extra networks
self.drv.initialize()
adb_networks = db_lib.get_networks(tenant_id='any')
# 'n3' should now be deleted from the Arista DB
assert(set(('n1', 'n2', 'ha-network')) == set(adb_networks.keys()))
def create_port(tenant_id,
net_id,
device_id,
port_id,
network_ctx,
device_owner='compute',
host='ubuntu1',
dynamic_segment=None):
session = db_api.get_writer_session()
ndb = db_lib.NeutronNets()
ndb.set_ipam_backend()
port_ctx = get_port_context(tenant_id,
net_id,
device_id,
network_ctx,
port_id=port_id,
device_owner=device_owner,
host=host,
session=session,
dynamic_segment=dynamic_segment)
ndb.create_port(port_ctx, {'port': port_ctx.current})
for binding_level in port_ctx._binding_levels:
session.add(ml2_models.PortBindingLevel(**binding_level.__dict__))
session.flush()
return port_ctx
def __init__(self, driver=None):
self.driver = driver or arista_l3_driver.AristaL3Driver()
self.ndb = db_lib.NeutronNets()
self.setup_rpc()
self.sync_timeout = cfg.CONF.l3_arista.l3_sync_interval
self.sync_lock = threading.Lock()
self._synchronization_thread()
def setUp(self):
super(SyncServiceTest, self).setUp()
plugin_klass = importutils.import_class(
"neutron.db.db_base_plugin_v2.NeutronDbPluginV2")
directory.add_plugin(plugin_constants.CORE, plugin_klass())
self.rpc = mock.MagicMock()
ndb = db_lib.NeutronNets()
self.sync_service = arista_sync.SyncService(self.rpc, ndb)
self.sync_service._force_sync = False
def test_exception_is_raised_on_json_server_error(self):
ndb = db_lib.NeutronNets()
drv = arista_eapi.AristaRPCWrapperEapi(ndb)
drv._send_api_request = mock.MagicMock(
side_effect=Exception('server error'))
with mock.patch.object(arista_eapi.LOG, 'error') as log_err:
self.assertRaises(arista_exc.AristaRpcError,
drv._run_openstack_cmds, [])
log_err.assert_called_once_with(mock.ANY)
def __init__(self, rpc=None):
self.rpc = rpc or arista_ml2.AristaRPCWrapper()
self.db_nets = db.AristaProvisionedNets()
self.db_vms = db.AristaProvisionedVms()
self.db_tenants = db.AristaProvisionedTenants()
self.ndb = db_lib.NeutronNets()
confg = cfg.CONF.ml2_arista
self.segmentation_type = db_lib.VLAN_SEGMENTATION
self.timer = None
self.eos = arista_ml2.SyncService(self.rpc, self.ndb)
self.sync_timeout = confg['sync_interval']
self.eos_sync_lock = threading.Lock()
def create_network(tenant_id,
net_id,
seg_id,
shared=False,
network_type='vlan',
physical_network='default'):
session = db_api.get_writer_session()
ndb = db_lib.NeutronNets()
net_ctx = get_network_context(tenant_id,
net_id,
seg_id,
shared=shared,
network_type=network_type,
physical_network=physical_network,
session=session)
ndb.create_network(net_ctx, {'network': net_ctx.current})
for segment in net_ctx.network_segments:
session.add(segment_models.NetworkSegment(**segment))
session.flush()
return net_ctx
def __init__(self, rpc=None):
self.ndb = db_lib.NeutronNets()
confg = cfg.CONF.ml2_arista
self.segmentation_type = db_lib.VLAN_SEGMENTATION
self.timer = None
self.managed_physnets = confg['managed_physnets']
self.manage_fabric = confg['manage_fabric']
self.eos_sync_lock = threading.Lock()
self.eapi = None
if rpc is not None:
LOG.info("Using passed in parameter for RPC")
self.rpc = rpc
self.eapi = rpc
else:
self.eapi = AristaRPCWrapperEapi(self.ndb)
self.rpc = AristaRPCWrapperJSON(self.ndb)
def __init__(self, rpc=None):
self.ndb = db_lib.NeutronNets()
self.db_nets = db.AristaProvisionedNets()
self.db_vms = db.AristaProvisionedVms()
self.db_tenants = db.AristaProvisionedTenants()
confg = cfg.CONF.ml2_arista
self.segmentation_type = db_lib.VLAN_SEGMENTATION
self.timer = None
self.sync_timeout = confg['sync_interval']
self.managed_physnets = confg['managed_physnets']
self.eos_sync_lock = threading.Lock()
self.eapi = None
if rpc:
LOG.info("Using passed in parameter for RPC")
self.rpc = rpc
self.eapi = rpc
else:
self.eapi = arista_ml2.AristaRPCWrapperEapi(self.ndb)
api_type = confg['api_type'].upper()
if api_type == 'EAPI':
LOG.info("Using EAPI for RPC")
self.rpc = arista_ml2.AristaRPCWrapperEapi(self.ndb)
elif api_type == 'JSON':
LOG.info("Using JSON for RPC")
self.rpc = arista_ml2.AristaRPCWrapperJSON(self.ndb)
else:
msg = "RPC mechanism %s not recognized" % api_type
LOG.error(msg)
raise arista_exc.AristaRpcError(msg=msg)
self.sync_service = arista_ml2.SyncService(self.rpc, self.ndb)
self.rpc.sync_service = self.sync_service
def setUp(self):
super(SyncServiceTest, self).setUp()
self.rpc = mock.MagicMock()
ndb = db_lib.NeutronNets()
self.sync_service = arista_ml2.SyncService(self.rpc, ndb)
self.sync_service._force_sync = False
def delete_port(context, port_id):
ndb = db_lib.NeutronNets()
ndb.set_ipam_backend()
ndb.delete_port(context, port_id)
context.session.flush()
def delete_network(context, network_id):
ndb = db_lib.NeutronNets()
ndb.delete_network(context, network_id)
context.session.flush()
def test_raises_exception_on_wrong_configuration(self):
ndb = db_lib.NeutronNets()
self.assertRaises(arista_exc.AristaConfigError,
arista_eapi.AristaRPCWrapperEapi, ndb)
