def setup_rpc(self):
# print("cfarquhar: in setup_rpc")
self.plugin_rpc = agent_rpc.PluginApi(topics.PLUGIN)
self.sg_plugin_rpc = sg_rpc.SecurityGroupServerRpcApi(topics.PLUGIN)
self.sg_agent = agent_sg_rpc.SecurityGroupAgentRpc(
self.context, self.sg_plugin_rpc, defer_refresh_firewall=True)
# LOG.info("cfarquhar: vars(plugin_rpc): {}".format(vars(self.plugin_rpc)))
# LOG.info("cfarquhar: vars(sg_plugin_rpc): {}".format(vars(self.sg_plugin_rpc)))
# LOG.info("cfarquhar: vars(sg_agent.plugin_rpc): {}".format(vars(self.sg_agent.plugin_rpc)))
self.agent_id = self.mgr.get_agent_id()
LOG.info("RPC agent_id: %s", self.agent_id)
self.topic = topics.AGENT
self.state_rpc = agent_rpc.PluginReportStateAPI(topics.REPORTS)
# RPC network init
# Handle updates from service
self.rpc_callbacks = self.mgr.get_rpc_callbacks(
self.context, self, self.sg_agent)
self.endpoints = [self.rpc_callbacks]
self._validate_rpc_endpoints()
# Define the listening consumers for the agent
consumers = self.mgr.get_rpc_consumers()
self.connection = agent_rpc.create_consumers(self.endpoints,
self.topic,
consumers,
start_listening=False)
def _setup(self):
"""Setup the layer two agent."""
super(HyperVNeutronAgent, self)._setup()
self._sg_plugin_rpc = sg_rpc.SecurityGroupServerRpcApi(topics.PLUGIN)
self._sec_groups_agent = HyperVSecurityAgent(self._context,
self._sg_plugin_rpc)
self._vlan_driver = trunk_driver.HyperVTrunkDriver(self._context)
if CONF.NVGRE.enable_support:
self._consumers.append([h_constant.TUNNEL, topics.UPDATE])
self._consumers.append([h_constant.LOOKUP, h_constant.UPDATE])
def __init__(self, vsphere_hostname, vsphere_login, vsphere_password,
bridge_mappings, polling_interval):
super(DVSAgent, self).__init__()
self.agent_state = {
'binary': 'neutron-dvs-agent',
'host': cfg.CONF.host,
'topic': n_const.L2_AGENT_TOPIC,
'configurations': {
'bridge_mappings': bridge_mappings,
'vsphere_hostname': vsphere_hostname
},
'agent_type': 'DVS agent',
'start_flag': True
}
report_interval = cfg.CONF.AGENT.report_interval
self.polling_interval = polling_interval
# Security group agent support
self.context = context.get_admin_context_without_session()
self.sg_plugin_rpc = sg_rpc.SecurityGroupServerRpcApi(topics.PLUGIN)
self.sg_agent = dvs_rpc.DVSSecurityGroupRpc(
self.context, self.sg_plugin_rpc, defer_refresh_firewall=True)
self.setup_rpc()
self.run_daemon_loop = True
self.iter_num = 0
self.network_map = dvs_util.create_network_map_from_config(
cfg.CONF.ML2_VMWARE, pg_cache=True)
uplink_map = dvs_util.create_uplink_map_from_config(
cfg.CONF.ML2_VMWARE, self.network_map)
for phys, dvs in six.iteritems(self.network_map):
if phys in uplink_map:
dvs.load_uplinks(phys, uplink_map[phys])
self.updated_ports = set()
self.deleted_ports = set()
self.known_ports = set()
self.added_ports = set()
self.booked_ports = set()
LOG.info(_LI("Agent out of sync with plugin!"))
connected_ports = self._get_dvs_ports()
self.added_ports = connected_ports
if cfg.CONF.DVS.clean_on_restart:
self._clean_up_vsphere_extra_resources(connected_ports)
self.fullsync = False
# The initialization is complete; we can start receiving messages
self.connection.consume_in_threads()
if report_interval:
heartbeat = loopingcall.FixedIntervalLoopingCall(
self._report_state)
heartbeat.start(interval=report_interval)
def test_security_group_rules_for_devices(self):
rpcapi = securitygroups_rpc.SecurityGroupServerRpcApi('fake_topic')
with mock.patch.object(rpcapi.client, 'call') as rpc_mock,\
mock.patch.object(rpcapi.client, 'prepare') as prepare_mock:
prepare_mock.return_value = rpcapi.client
rpcapi.security_group_rules_for_devices('context', ['fake_device'])
rpc_mock.assert_called_once_with(
'context',
'security_group_rules_for_devices',
devices=['fake_device'])
def __init__(self, physical_devices_mappings, exclude_devices,
polling_interval, rp_bandwidths, rp_inventory_defaults,
rp_hypervisors):
self.polling_interval = polling_interval
self.network_ports = collections.defaultdict(list)
self.conf = cfg.CONF
self.device_mappings = physical_devices_mappings
self.exclude_devices = exclude_devices
self.setup_eswitch_mgr(physical_devices_mappings, exclude_devices)
# Stores port update notifications for processing in the main loop
self.updated_devices = set()
# Stores <mac, pci_slot> pairs for ports whose binding has been
# activated.
self.activated_bindings = set()
self.context = context.get_admin_context_without_session()
self.plugin_rpc = agent_rpc.PluginApi(topics.PLUGIN)
self.sg_plugin_rpc = sg_rpc.SecurityGroupServerRpcApi(topics.PLUGIN)
self.sg_agent = agent_sg_rpc.SecurityGroupAgentRpc(
self.context, self.sg_plugin_rpc)
self._setup_rpc()
self.ext_manager = self._create_agent_extension_manager(
self.connection)
configurations = {
'device_mappings': physical_devices_mappings,
n_constants.RP_BANDWIDTHS: rp_bandwidths,
n_constants.RP_INVENTORY_DEFAULTS: rp_inventory_defaults,
'resource_provider_hypervisors': rp_hypervisors,
'extensions': self.ext_manager.names()
}
# TODO(mangelajo): optimize resource_versions (see ovs agent)
self.agent_state = {
'binary': n_constants.AGENT_PROCESS_NIC_SWITCH,
'host': self.conf.host,
'topic': n_constants.L2_AGENT_TOPIC,
'configurations': configurations,
'agent_type': n_constants.AGENT_TYPE_NIC_SWITCH,
'resource_versions': resources.LOCAL_RESOURCE_VERSIONS,
'start_flag': True
}
# The initialization is complete; we can start receiving messages
self.connection.consume_in_threads()
# Initialize iteration counter
self.iter_num = 0
def _setup_rpc(self):
self.topic = topics.AGENT
self.plugin_rpc = agent_rpc.PluginApi(topics.PLUGIN)
self.sg_plugin_rpc = api_sg_rpc.SecurityGroupServerRpcApi(
topics.PLUGIN)
self.context = q_context.get_admin_context_without_session()
self.endpoints = [self]
consumers = [[topics.PORT, topics.UPDATE],
[topics.SECURITY_GROUP, topics.UPDATE]]
self.connection = agent_rpc.create_consumers(self.endpoints,
self.topic, consumers)
self.state_rpc = agent_rpc.PluginReportStateAPI(topics.PLUGIN)
report_interval = cfg.CONF.AGENT.report_interval
if report_interval:
heartbeat = loopingcall.FixedIntervalLoopingCall(
self._report_state)
heartbeat.start(interval=report_interval)
def __init__(self, physical_devices_mappings, exclude_devices,
polling_interval):
self.polling_interval = polling_interval
self.network_ports = collections.defaultdict(list)
self.conf = cfg.CONF
self.device_mappings = physical_devices_mappings
self.exclude_devices = exclude_devices
self.setup_eswitch_mgr(physical_devices_mappings, exclude_devices)
# Stores port update notifications for processing in the main loop
self.updated_devices = set()
self.context = context.get_admin_context_without_session()
self.plugin_rpc = agent_rpc.PluginApi(topics.PLUGIN)
self.sg_plugin_rpc = sg_rpc.SecurityGroupServerRpcApi(topics.PLUGIN)
self.sg_agent = agent_sg_rpc.SecurityGroupAgentRpc(
self.context, self.sg_plugin_rpc)
self._setup_rpc()
self.ext_manager = self._create_agent_extension_manager(
self.connection)
configurations = {
'device_mappings': physical_devices_mappings,
'extensions': self.ext_manager.names()
}
#TODO(mangelajo): optimize resource_versions (see ovs agent)
self.agent_state = {
'binary': 'neutron-sriov-nic-agent',
'host': self.conf.host,
'topic': n_constants.L2_AGENT_TOPIC,
'configurations': configurations,
'agent_type': n_constants.AGENT_TYPE_NIC_SWITCH,
'resource_versions': resources.LOCAL_RESOURCE_VERSIONS,
'start_flag': True
}
# The initialization is complete; we can start receiving messages
self.connection.consume_in_threads()
# Initialize iteration counter
self.iter_num = 0
def setup_rpc(self):
self.agent_id = 'opflex-agent-%s' % cfg.CONF.host
self.context = context.get_admin_context_without_session()
# Set GBP rpc API
self.of_rpc = rpc.GBPServerRpcApi(rpc.TOPIC_OPFLEX)
self.plugin_rpc = ovs.OVSPluginApi(topics.PLUGIN)
self.sg_plugin_rpc = sg_rpc.SecurityGroupServerRpcApi(topics.PLUGIN)
self.sg_agent = agent_sg_rpc.SecurityGroupAgentRpc(
self.context, self.sg_plugin_rpc, defer_refresh_firewall=True)
self.state_rpc = agent_rpc.PluginReportStateAPI(topics.PLUGIN)
self.topic = topics.AGENT
self.endpoints = [self]
consumers = [[topics.PORT, topics.UPDATE],
[topics.PORT, topics.DELETE],
[topics.SECURITY_GROUP, topics.UPDATE],
[topics.SUBNET, topics.UPDATE],
[rpc.TOPIC_OPFLEX, rpc.NOTIFY_VRF, topics.UPDATE],
[rpc.TOPIC_OPFLEX, rpc.VRF, topics.UPDATE]]
self.connection = agent_rpc.create_consumers(self.endpoints,
self.topic,
consumers,
start_listening=False)
def neutron_dvs_cli():
"""
CLI command for retrieving a port from Neutron by id;
Comparing the retrieved port to a port in the linked portgroup from vSphere;
The port from vSphere is fetched by the Neutron port MAC address and the portgroup key;
If --correct opt is set a reconfigure task on the port will be started which will apply the rules from the Neutron port to the DVS port
:return:
"""
common_config.init(sys.argv[1:])
port_id = CONF.port_id
correct = CONF.correct
profiler.setup('neutron-dvs-agent-cli', cfg.CONF.host)
agent = DvsNeutronAgent()
neutron_ports = agent.plugin_rpc.get_devices_details_list(
agent.context,
devices=[port_id],
agent_id=agent.agent_id,
host=agent.conf.host)
if neutron_ports[0].has_key('mac_address'):
mac_addr = neutron_ports[0]['mac_address']
else:
raise Exception('Neutron port not found!')
sg_api = securitygroups_rpc.SecurityGroupServerRpcApi(topics.PLUGIN)
sg_info = sg_api.security_group_info_for_devices(
agent.context, [neutron_ports[0]['port_id']])
rules = sg_api.security_group_rules_for_devices(agent.context, [port_id])
patched_sg_rules = sg_util._patch_sg_rules(
rules[port_id]['security_group_rules'])
sg_set = sg_util.security_group_set(sg_info)
dvs = agent.api.network_dvs_map.get(neutron_ports[0]['physical_network'],
None)
sg_aggr_obj = defaultdict(lambda: defaultdict(sg_util.SgAggr))
sg_aggr = sg_aggr_obj[dvs.uuid][sg_set]
sg_util.apply_rules(patched_sg_rules, sg_aggr)
sg_set_rules = sg_util.get_rules(sg_aggr)
port_config = sg_util.port_configuration(None, sg_set_rules, {}, None,
None).setting
neutron_vlan_id = neutron_ports[0]['segmentation_id']
dvpg_name = dvs_util.dvportgroup_name(dvs.uuid, sg_set)
"""
Retrieving the DVS portgroup and properties
"""
port_group = dvs.get_port_group_for_security_group_set(sg_set)
portgroup_key = port_group['ref']['value']
dvs_vlan_id = port_group['defaultPortConfig'].vlan.vlanId
dvs_port = agent.api.fetch_ports_by_mac(portgroup_key, mac_addr)
neutron_port_rules = port_config.filterPolicy.filterConfig[
0].trafficRuleset.rules
dvs_port_rules = dvs_port.config.setting.filterPolicy.filterConfig[
0].trafficRuleset.rules
match = False
for i in range(len(dvs_port_rules)):
config_match = dvs_util._config_differs(dvs_port_rules[i],
neutron_port_rules[i])
if config_match:
match = True
print("Neutron Port configuration rule not matched for : ",
neutron_port_rules[i])
print("DVS Port configuraiton rule: ", dvs_port_rules[i])
if match == False:
print("Neutron port config matches DVS port config")
else:
if correct == 'True':
print("Updating port configuration")
if neutron_vlan_id != dvs_vlan_id:
port_config.vlan = builder.vlan(neutron_vlan_id)
dv_port_config_spec = builder.port_config_spec(
key=dvs_port.key,
version=dvs_port.config.configVersion,
setting=port_config)
dvs.update_ports([dv_port_config_spec])