def __init__(self, ser_name, pqueue, c_pri, d_pri):
self._service = None
self._service_name = ser_name
self._clients = {}
self._pq = pqueue
self._create_pri = c_pri
self._update_pri = c_pri
self._delete_pri = d_pri
self._cfg = config.CiscoDFAConfig(ser_name).cfg
self._q_agent = constants.DFA_AGENT_QUEUE
self._url = self._cfg.dfa_rpc.transport_url
dfaq = self._cfg.dfa_notify.cisco_dfa_notify_queue % (
{'service_name': ser_name})
notify_queue = self._cfg.DEFAULT.notification_topics.split(',')
self._notify_queue = dfaq if dfaq in notify_queue else None
self._token = self._cfg.DEFAULT.admin_token
if self._service_name == 'keystone':
endpoint = self._cfg.DEFAULT.admin_endpoint
admin_port = self._cfg.DEFAULT.admin_port
if endpoint:
self._endpoint_url = (endpoint + 'v3/') % (
{'admin_port': admin_port if admin_port else '35357'})
else:
host = self._cfg.DEFAULT.admin_bind_host
proto = self._cfg.DEFAULT.auth_protocol
self._endpoint_url = '%(proto)s://%(host)s:%(port)s/v3/' % (
{'proto': proto if proto else 'http',
'host': host if host else 'localhost',
'port': admin_port if admin_port else '35357'})
self._service = client.Client(token=self._cfg.DEFAULT.admin_token,
endpoint=self._endpoint_url)
# Setup notification listener for the events.
self._setup_notification_listener(self._notify_queue, self._url)
def __init__(self, host, rpc_qn):
self._my_host = host
self._qn = '_'.join((rpc_qn, self._my_host))
self._cfg = config.CiscoDFAConfig('neutron').cfg
LOG.debug('Starting DFA Agent on %s', self._my_host)
# List of task in the agent
self.agent_task_list = []
# This flag indicates the agent started for the first time.
self._need_uplink_info = True
# Initialize iptables driver. This will be used to update the ip
# rules in iptables, after launching an instance.
self._iptd = iptd.IptablesDriver(self._cfg)
# Setup RPC client for sending heartbeat to controller
self._url = self._cfg.dfa_rpc.transport_url
self.setup_client_rpc()
# Initialize VPD manager.
br_int = 'br-int'
br_ext = 'br-ethd'
root_helper = self._cfg.sys.root_helper
self._vdpm = vdpm.VdpMgr(br_int, br_ext, root_helper, self.clnt,
thishost)
self.pool = eventlet.GreenPool()
self.setup_rpc()
def __init__(self):
self.ctl_host = platform.node()
cmd.Cmd.__init__(self)
self._cfg = config.CiscoDFAConfig().cfg
self.dcnm_client = cdr.DFARESTClient(self._cfg)
self.setup_client_rpc()
self.clnt = None
def __init__(self):
self._cfg = config.CiscoDFAConfig('nova').cfg
self._tenant_name = self._cfg.keystone_authtoken.admin_tenant_name
self._user_name = self._cfg.keystone_authtoken.admin_user
self._admin_password = self._cfg.keystone_authtoken.admin_password
self._timeout_respoonse = 10
self._token = None
self._project_id = None
self._auth_url = None
self._token_id = None
self._token = None
self._novaclnt = None
self._url = self._cfg.keystone_authtoken.auth_uri
if not self._url:
proto = self._cfg.keystone_authtoken.auth_protocol
auth_host = self._cfg.keystone_authtoken.auth_host
auth_port = self._cfg.keystone_authtoken.auth_port
self._url = '%(proto)s://%(host)s:%(port)s/v2.0' % (
{
'proto': proto if proto else 'http',
'host': auth_host if auth_host else 'localhost',
'port': auth_port if auth_port else '5000'
})
else:
self._url += '/v2.0'
self._inst_info_cache = {}
LOG.debug('DFAInstanceAPI: initialization done...')
def setUp(self):
# Declare the test resource.
super(TestCiscoDFAClient, self).setUp()
# Setting DCNM parameters.
cfg.CONF.set_override('dcnm_ip', FAKE_DCNM_IP, group='dcnm')
cfg.CONF.set_override('dcnm_user', FAKE_DCNM_USERNAME, group='dcnm')
cfg.CONF.set_override('dcnm_password', FAKE_DCNM_PASSWD, group='dcnm')
cfg.CONF.set_override('timeout_resp', 0.01, group='dcnm')
self.cfg = config.CiscoDFAConfig().cfg
self.send_req = mock.patch.object(dc.DFARESTClient,
'_send_request').start()
self.get_vers = mock.patch.object(dc.DFARESTClient,
'get_version').start()
self.login = mock.patch.object(dc.DFARESTClient,
'_login_request').start()
self.logout = mock.patch.object(dc.DFARESTClient,
'_logout_request').start()
self.send_req.return_value = mock.Mock()
self.send_req.return_value.status_code = 200
self.send_req.return_value.json.return_value = {}
self.get_vers.return_value = '7.0(1)'
self.dcnm_client = dc.DFARESTClient(self.cfg)
self.testnetwork = TestNetwork()
def setUp(self):
super(TestDFAServer, self).setUp()
# Mocking some modules
self.dcnmpatcher = mock.patch(cdr.__name__ + '.DFARESTClient')
self.mdcnm = self.dcnmpatcher.start()
self.keys_patcher = mock.patch(deh.__name__ + '.EventsHandler')
self.mkeys = self.keys_patcher.start()
self.inst_api_patcher = mock.patch(dia.__name__ + '.DFAInstanceAPI')
self.m_inst_api = self.inst_api_patcher.start()
self.module_patcher = mock.patch.dict('sys.modules',
{'pika': mock.Mock()})
self.module_patcher.start()
from networking_cisco.apps.saf.server import dfa_listen_dcnm as dld
from networking_cisco.apps.saf.server import dfa_server as ds
self.dld_patcher = mock.patch(dld.__name__ + '.DCNMListener')
self.dld = self.dld_patcher.start()
ds.DfaServer.__bases__ = (FakeClass.imitate(
dfr.DfaFailureRecovery, dbm.DfaDBMixin, fw_native.FwMgr),)
ds.DfaServer.get_all_projects.return_value = []
ds.DfaServer.get_all_networks.return_value = []
ds.DfaServer._setup_rpc = mock.Mock()
# TODO(padkrish) Have UT for this function. This may mean over-riding
# the mocking of get_segmentid_range of DCNM client to return a range.
ds.DfaServer.register_segment_dcnm = mock.Mock()
# Setting DCNM parameters.
config.default_dcnm_opts['dcnm']['dcnm_ip'] = FAKE_DCNM_IP
config.default_dcnm_opts['dcnm']['dcnm_user'] = FAKE_DCNM_USERNAME
config.default_dcnm_opts['dcnm']['dcnm_password'] = FAKE_DCNM_PASSWD
config.default_dcnm_opts['dcnm']['timeout_resp'] = 0.01
config.default_dcnm_opts['dcnm']['segmentation_id_min'] = 10000
config.default_dcnm_opts['dcnm']['segmentation_id_max'] = 20000
config.default_dcnm_opts['dcnm']['orchestrator_id'] = FAKE_ORCH_ID
self.cfg = config.CiscoDFAConfig().cfg
self.segid = int(self.cfg.dcnm.segmentation_id_min) + 10
self.seg_Drvr = mock.patch(
'networking_cisco.apps.saf.db.dfa_db_models.'
'DfaSegmentTypeDriver').start()
self.dfa_server = ds.DfaServer(self.cfg)
mock.patch.object(self.dfa_server, '_get_segmentation_id',
return_value=12345).start()
mock.patch.object(self.dfa_server.seg_drvr,
'allocate_segmentation_id',
return_value=12345).start()
self.dciid = str(123)
self.proj_desc = 'Unit Test Project'
projs = [
FakeProject(FAKE_PROJECT_ID, FAKE_PROJECT_NAME,
self.dciid, self.proj_desc)]
self.dfa_server.get_all_projects.return_value = projs
self.dfa_server._load_project_info_cache()
self.part_name = self.cfg.dcnm.default_partition_name
def __init__(self):
"""Class init. """
LOG.debug("Initializing Native Firewall")
super(NativeFirewall, self).__init__()
self.tenant_dict = {}
self.os_helper = OsHelper.DfaNeutronHelper()
self.cfg = config.CiscoDFAConfig().cfg
self.mgmt_ip_addr = None
self.dcnm_obj = None
self.que_obj = None
def read_vdp_cfg(self):
self._cfg = config.CiscoDFAConfig().cfg
self.vdp_opts = dict()
self.vdp_opts['mgrid'] = self._cfg.vdp.mgrid2
self.vdp_opts['typeid'] = self._cfg.vdp.typeid
self.vdp_opts['typeidver'] = self._cfg.vdp.typeidver
self.vdp_opts['vsiidfrmt'] = self._cfg.vdp.vsiidfrmt
self.vdp_opts['hints'] = self._cfg.vdp.hints
self.vdp_opts['filter'] = self._cfg.vdp.filter
self.vdp_opts['vdp_sync_timeout'] = self._cfg.vdp.vdp_sync_timeout
def setUp(self):
super(TestDFAServer, self).setUp()
# Mocking some modules
self.dcnmpatcher = mock.patch(cdr.__name__ + '.DFARESTClient')
self.mdcnm = self.dcnmpatcher.start()
self.addCleanup(self.dcnmpatcher.stop)
self.keys_patcher = mock.patch(deh.__name__ + '.EventsHandler')
self.mkeys = self.keys_patcher.start()
self.addCleanup(self.mkeys.stop)
self.inst_api_patcher = mock.patch(dia.__name__ + '.DFAInstanceAPI')
self.m_inst_api = self.inst_api_patcher.start()
self.addCleanup(self.inst_api_patcher.stop)
self.module_patcher = mock.patch.dict('sys.modules',
{'pika': mock.Mock()})
self.module_patcher.start()
self.addCleanup(self.module_patcher.stop)
from networking_cisco.apps.saf.server import dfa_listen_dcnm as dld
from networking_cisco.apps.saf.server import dfa_server as ds
self.dld_patcher = mock.patch(dld.__name__ + '.DCNMListener')
self.dld = self.dld_patcher.start()
self.addCleanup(self.dld_patcher.stop)
ds.DfaServer.__bases__ = (FakeClass.imitate(
dfr.DfaFailureRecovery, dbm.DfaDBMixin),)
ds.DfaServer.get_all_projects.return_value = []
ds.DfaServer.get_all_networks.return_value = []
ds.DfaServer._setup_rpc = mock.Mock()
# Setting DCNM parameters.
config.default_dcnm_opts['dcnm']['dcnm_ip'] = FAKE_DCNM_IP
config.default_dcnm_opts['dcnm']['dcnm_user'] = FAKE_DCNM_USERNAME
config.default_dcnm_opts['dcnm']['dcnm_password'] = FAKE_DCNM_PASSWD
config.default_dcnm_opts['dcnm']['timeout_resp'] = 0.01
config.default_dcnm_opts['dcnm']['segmentation_id_min'] = 10000
config.default_dcnm_opts['dcnm']['segmentation_id_max'] = 20000
self.cfg = config.CiscoDFAConfig().cfg
self.segid = int(self.cfg.dcnm.segmentation_id_min) + 10
self.dfa_server = ds.DfaServer(self.cfg)
self.dciid = str(123)
self.proj_desc = 'Unit Test Project'
projs = [
FakeProject(FAKE_PROJECT_ID, FAKE_PROJECT_NAME,
self.dciid, self.proj_desc)]
self.dfa_server.get_all_projects.return_value = projs
self.dfa_server._load_project_info_cache()
self.part_name = self.cfg.dcnm.default_partition_name
def __init__(self):
self._cfg = config.CiscoDFAConfig('neutron').cfg
self._tenant_name = self._cfg.nova.project_name
self._user_name = self._cfg.nova.username
self._admin_password = self._cfg.nova.password
self._timeout_respoonse = 10
self._token = None
self._project_id = None
self._auth_url = None
self._token_id = None
self._token = None
self._novaclnt = None
self._url = self._cfg.nova.auth_url + '/v2.0'
self._inst_info_cache = {}
LOG.debug('DFAInstanceAPI: initialization done...')
def main():
# Setup logger
cfg = config.CiscoDFAConfig().cfg
logging.setup_logger('dfa_enabler', cfg)
# Get pid of the process and save it.
save_my_pid(cfg)
# Create DFA agent object
dfa_agent = DfaAgent(thishost, constants.DFA_AGENT_QUEUE)
LOG.debug('Starting tasks in agent...')
try:
# Start all task in the agent.
dfa_agent.start_tasks()
# Endless loop
while True:
start = time.time()
# Send heartbeat to controller, data includes:
# - timestamp
# - host name
dfa_agent.send_heartbeat()
# If the agent comes up for the fist time (could be after crash),
# ask for the uplink info.
if dfa_agent._need_uplink_info or (
not dfa_agent.is_uplink_received()):
dfa_agent.request_uplink_info()
for trd in dfa_agent.agent_task_list:
if not trd.am_i_active:
LOG.info("Thread %s is not active.", trd.name)
end = time.time()
delta = end - start
eventlet.sleep(constants.HB_INTERVAL - delta)
except Exception as e:
dfa_agent.stop_rpc()
LOG.exception('Exception %s is received', str(e))
LOG.error('Exception %s is received', str(e))
sys.exit("ERROR: %s" % str(e))
def __init__(self, host, rpc_qn):
self._host_name = host
self._cfg = config.CiscoDFAConfig('neutron').cfg
self._my_host = self._cfg.DEFAULT.host if self._cfg.DEFAULT.host else (
utils.find_agent_host_id(host))
self._qn = '_'.join((rpc_qn, self._my_host))
LOG.debug('Starting DFA Agent on %s', self._my_host)
# List of task in the agent
self.agent_task_list = []
# This flag indicates the agent started for the first time.
self._need_uplink_info = True
# Initialize iptables driver. This will be used to update the ip
# rules in iptables, after launching an instance.
if (self._cfg.dcnm.dcnm_dhcp.lower() == 'true'):
self._iptd = iptd.IptablesDriver(self._cfg)
else:
self._iptd = None
LOG.debug("Using native dhcp, iptable driver is not needed")
# Setup RPC client for sending heartbeat to controller
self._url = self._cfg.dfa_rpc.transport_url
self.setup_client_rpc()
# Initialize VPD manager.
br_int = self._cfg.dfa_agent.integration_bridge
br_ext = self._cfg.dfa_agent.external_dfa_bridge
config_dict = {
'integration_bridge': br_int,
'external_bridge': br_ext,
'host_id': self._my_host,
'root_helper': self._cfg.sys.root_helper,
'node_list': self._cfg.general.node,
'node_uplink_list': self._cfg.general.node_uplink
}
self._vdpm = vdpm.VdpMgr(config_dict, self.clnt, self._host_name)
self.pool = eventlet.GreenPool()
self.setup_rpc()
def setUp(self):
"""Setup for the test scripts. """
super(FwMgrTest, self).setUp()
self._init_values()
config = self._fill_cfg()
self.cfg = config.CiscoDFAConfig().cfg
fw_mgr.FwMgr.__bases__ = (FakeClass.imitate(dev_mgr.DeviceMgr,
dbm.DfaDBMixin),)
FakeClass.set_return(dbm.DfaDBMixin, 'get_all_fw_db', dict())
mock.patch('networking_cisco.apps.saf.server.services.firewall.'
'native.fabric_setup_base.FabricBase').start()
mock.patch('networking_cisco.apps.saf.server.dfa_openstack_helper.'
'DfaNeutronHelper').start()
fw_mgr.FwMgr.events = mock.Mock()
self.fw_mgr = fw_mgr.FwMgr(self.cfg)
self.update_fw_db_mock = mock.patch.object(
self.fw_mgr, 'update_fw_db_final_result').start()
self.create_fw_dev_mock = mock.patch.object(
self.fw_mgr, 'create_fw_device').start()
self.update_fw_dev_mock = mock.patch.object(
self.fw_mgr, 'update_fw_db_dev_status').start()
def __init__(self):
self._cfg = config.CiscoDFAConfig().cfg
self._inst_info_cache = {}
user = self._cfg.nova.username
project = self._cfg.nova.project_name
passwd = self._cfg.nova.password
url = self._cfg.nova.auth_url
region = self._cfg.nova.region_name
u_domain = self._cfg.nova.user_domain_name
p_domain = self._cfg.nova.project_domain_name
api_v = self._cfg.nova.api_version
auth = generic.Password(auth_url=url,
username=user,
password=passwd,
project_name=project,
project_domain_name=p_domain,
user_domain_name=u_domain)
sess = session.Session(auth=auth)
self._novaclnt = nova_client.Client(api_versions.APIVersion(api_v),
session=sess,
region_name=region)
LOG.debug('DFAInstanceAPI: initialization done...')
def __init__(self, ser_name, pqueue, c_pri, d_pri):
self._service = None
self._service_name = ser_name
self._clients = {}
self._nclient = None
self._pq = pqueue
self._create_pri = c_pri
self._update_pri = c_pri
self._delete_pri = d_pri
self._cfg = config.CiscoDFAConfig().cfg
self._q_agent = constants.DFA_AGENT_QUEUE
self._url = self._cfg.dfa_rpc.transport_url
dfaq = self._cfg.dfa_notify.cisco_dfa_notify_queue % (
{'service_name': ser_name})
notify_queue = dfaq
self._notify_queue = dfaq if dfaq in notify_queue else None
# Setup notification listener for the events.
self._setup_notification_listener(self._notify_queue, self._url)
if ser_name != 'keystone':
return
user = self._cfg.keystone_authtoken.username
project = self._cfg.keystone_authtoken.project_name
passwd = self._cfg.keystone_authtoken.password
url = self._cfg.keystone_authtoken.auth_url
u_domain = self._cfg.keystone_authtoken.user_domain_name
p_domain = self._cfg.keystone_authtoken.project_domain_name
auth = generic.Password(auth_url=url,
username=user,
password=passwd,
project_name=project,
project_domain_name=p_domain,
user_domain_name=u_domain)
sess = session.Session(auth=auth)
self._service = k_client.Client(session=sess)
def setUp(self):
# Declare the test resource.
super(TestCiscoDFAClient, self).setUp()
# Setting DCNM parameters.
config.default_dcnm_opts['dcnm']['dcnm_ip'] = FAKE_DCNM_IP
config.default_dcnm_opts['dcnm']['dcnm_user'] = FAKE_DCNM_USERNAME
config.default_dcnm_opts['dcnm']['dcnm_password'] = FAKE_DCNM_PASSWD
config.default_dcnm_opts['dcnm']['timeout_resp'] = 0.01
self.cfg = config.CiscoDFAConfig().cfg
self.send_req = mock.patch.object(dc.DFARESTClient,
'_send_request').start()
self.get_vers = mock.patch.object(dc.DFARESTClient,
'get_version').start()
self.login = mock.patch.object(dc.DFARESTClient, '_login').start()
self.logout = mock.patch.object(dc.DFARESTClient, '_logout').start()
self.send_req.return_value = mock.Mock()
self.send_req.return_value.status_code = 200
self.send_req.return_value.json.return_value = {}
self.get_vers.return_value = ""
self.dcnm_client = dc.DFARESTClient(self.cfg)
self.testnetwork = TestNetwork()
def __init__(self):
"""Initialization. """
self.neutron_help = deh.EventsHandler('neutron', None, 20, 25)
cfg = config.CiscoDFAConfig('neutron').cfg
self.root_helper = cfg.sys.root_helper
