Example #1
0
    def setup_rpc(self, physical_interfaces):
        if physical_interfaces:
            mac = utils.get_interface_mac(physical_interfaces[0])
        else:
            devices = ip_lib.IPWrapper().get_devices(True)
            if devices:
                mac = utils.get_interface_mac(devices[0].name)
            else:
                LOG.error(
                    _LE("Unable to obtain MAC address for unique ID. "
                        "Agent terminated!"))
                exit(1)
        self.agent_id = '%s%s' % ('lb', (mac.replace(":", "")))
        LOG.info(_LI("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.endpoints = [
            LinuxBridgeRpcCallbacks(self.context, self, self.sg_agent)
        ]
        # Define the listening consumers for the agent
        consumers = [[topics.PORT, topics.UPDATE],
                     [topics.NETWORK, topics.DELETE],
                     [topics.SECURITY_GROUP, topics.UPDATE]]
        if cfg.CONF.VXLAN.l2_population:
            consumers.append([topics.L2POPULATION, topics.UPDATE])
        self.connection = agent_rpc.create_consumers(self.endpoints,
                                                     self.topic, consumers)
        report_interval = cfg.CONF.AGENT.report_interval
        if report_interval:
            heartbeat = loopingcall.FixedIntervalLoopingCall(
                self._report_state)
            heartbeat.start(interval=report_interval)
    def setup_rpc(self, physical_interfaces):
        if physical_interfaces:
            mac = utils.get_interface_mac(physical_interfaces[0])
        else:
            devices = ip_lib.IPWrapper().get_devices(True)
            if devices:
                mac = utils.get_interface_mac(devices[0].name)
            else:
                LOG.error(_LE("Unable to obtain MAC address for unique ID. "
                              "Agent terminated!"))
                exit(1)
        self.agent_id = '%s%s' % ('lb', (mac.replace(":", "")))
        LOG.info(_LI("RPC agent_id: %s"), self.agent_id)

        self.topic = topics.AGENT
        self.state_rpc = agent_rpc.PluginReportStateAPI(topics.PLUGIN)
        # RPC network init
        # Handle updates from service
        self.endpoints = [LinuxBridgeRpcCallbacks(self.context, self,
                                                  self.sg_agent)]
        # Define the listening consumers for the agent
        consumers = [[topics.PORT, topics.UPDATE],
                     [topics.NETWORK, topics.DELETE],
                     [topics.SECURITY_GROUP, topics.UPDATE]]
        if cfg.CONF.VXLAN.l2_population:
            consumers.append([topics.L2POPULATION,
                              topics.UPDATE, cfg.CONF.host])
        self.connection = agent_rpc.create_consumers(self.endpoints,
                                                     self.topic,
                                                     consumers)
        report_interval = cfg.CONF.AGENT.report_interval
        if report_interval:
            heartbeat = loopingcall.FixedIntervalLoopingCall(
                self._report_state)
            heartbeat.start(interval=report_interval)
Example #3
0
    def setup_rpc(self, physical_interfaces):
        if physical_interfaces:
            mac = utils.get_interface_mac(physical_interfaces[0])
        else:
            devices = ip_lib.IPWrapper(self.root_helper).get_devices(True)
            if devices:
                mac = utils.get_interface_mac(devices[0].name)
            else:
                LOG.error(
                    _("Unable to obtain MAC address for unique ID. "
                      "Agent terminated!"))
                exit(1)
        self.agent_id = '%s%s' % ('lb', (mac.replace(":", "")))
        LOG.info(_("RPC agent_id: %s"), self.agent_id)

        self.topic = topics.AGENT
        self.plugin_rpc = LinuxBridgePluginApi(topics.PLUGIN)
        self.state_rpc = agent_rpc.PluginReportStateAPI(topics.PLUGIN)
        # RPC network init
        self.context = context.get_admin_context_without_session()
        # Handle updates from service
        self.callbacks = LinuxBridgeRpcCallbacks(self.context, self)
        self.dispatcher = self.callbacks.create_rpc_dispatcher()
        # Define the listening consumers for the agent
        consumers = [[topics.PORT, topics.UPDATE],
                     [topics.NETWORK, topics.DELETE],
                     [topics.SECURITY_GROUP, topics.UPDATE]]
        self.connection = agent_rpc.create_consumers(self.dispatcher,
                                                     self.topic, consumers)
        report_interval = cfg.CONF.AGENT.report_interval
        if report_interval:
            heartbeat = loopingcall.FixedIntervalLoopingCall(
                self._report_state)
            heartbeat.start(interval=report_interval)
    def setup_rpc(self, physical_interfaces):
        if physical_interfaces:
            mac = utils.get_interface_mac(physical_interfaces[0])
        else:
            devices = ip_lib.IPWrapper(self.root_helper).get_devices(True)
            if devices:
                mac = utils.get_interface_mac(devices[0].name)
            else:
                LOG.error(_("Unable to obtain MAC address for unique ID. "
                          "Agent terminated!"))
                exit(1)
        self.agent_id = '%s%s' % ('lb', (mac.replace(":", "")))
        LOG.info(_("RPC agent_id: %s"), self.agent_id)

        self.topic = topics.AGENT
        self.plugin_rpc = LinuxBridgePluginApi(topics.PLUGIN)
        self.state_rpc = agent_rpc.PluginReportStateAPI(topics.PLUGIN)
        # RPC network init
        self.context = context.get_admin_context_without_session()
        # Handle updates from service
        self.callbacks = LinuxBridgeRpcCallbacks(self.context,
                                                 self)
        self.dispatcher = self.callbacks.create_rpc_dispatcher()
        # Define the listening consumers for the agent
        consumers = [[topics.PORT, topics.UPDATE],
                     [topics.NETWORK, topics.DELETE],
                     [topics.SECURITY_GROUP, topics.UPDATE]]
        self.connection = agent_rpc.create_consumers(self.dispatcher,
                                                     self.topic,
                                                     consumers)
        report_interval = cfg.CONF.AGENT.report_interval
        if report_interval:
            heartbeat = loopingcall.FixedIntervalLoopingCall(
                self._report_state)
            heartbeat.start(interval=report_interval)
    def setup_rpc(self, physical_interfaces):
        if physical_interfaces:
            mac = utils.get_interface_mac(physical_interfaces[0])
        else:
            devices = ip_lib.IPWrapper().get_devices(True)
            if devices:
                mac = utils.get_interface_mac(devices[0].name)
            else:
                LOG.error(_LE("Unable to obtain MAC address for unique ID. " "Agent terminated!"))
                exit(1)

        self.plugin_rpc = agent_rpc.PluginApi(topics.PLUGIN)
        self.sg_plugin_rpc = sg_rpc.SecurityGroupServerRpcApi(topics.PLUGIN)
        self.sg_agent = sg_rpc.SecurityGroupAgentRpc(self.context, self.sg_plugin_rpc, defer_refresh_firewall=True)

        self.agent_id = "%s%s" % ("lb", (mac.replace(":", "")))
        LOG.info(_LI("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.endpoints = [LinuxBridgeRpcCallbacks(self.context, self, self.sg_agent)]
        # Define the listening consumers for the agent
        consumers = [
            [topics.PORT, topics.UPDATE],
            [topics.NETWORK, topics.DELETE],
            [topics.NETWORK, topics.UPDATE],
            [topics.SECURITY_GROUP, topics.UPDATE],
        ]

        if cfg.CONF.VXLAN.l2_population:
            consumers.append([topics.L2POPULATION, topics.UPDATE])
        self.connection = agent_rpc.create_consumers(self.endpoints, self.topic, consumers)
 def get_agent_id(self):
     if self.bridge_mappings:
         mac = utils.get_interface_mac(list(self.bridge_mappings.values())[0])
     else:
         devices = ip_lib.IPWrapper().get_devices(True)
         if devices:
             mac = utils.get_interface_mac(devices[0].name)
         else:
             LOG.error(_LE("Unable to obtain MAC address for unique ID. " "Agent terminated!"))
             sys.exit(1)
     return "lb%s" % mac.replace(":", "")
Example #7
0
 def get_agent_id(self):
     if self.bridge_mappings:
         mac = utils.get_interface_mac(
             list(self.bridge_mappings.values())[0])
     else:
         devices = ip_lib.IPWrapper().get_devices(True)
         if devices:
             mac = utils.get_interface_mac(devices[0].name)
         else:
             LOG.error(_LE("Unable to obtain MAC address for unique ID. "
                           "Agent terminated!"))
             sys.exit(1)
     return 'lb%s' % mac.replace(":", "")
Example #8
0
 def test_get_interface_mac(self):
     expect_val = '01:02:03:04:05:06'
     with mock.patch('fcntl.ioctl') as ioctl:
         ioctl.return_value = ''.join(
             ['\x00' * 18, '\x01\x02\x03\x04\x05\x06', '\x00' * 232])
         actual_val = utils.get_interface_mac('eth0')
     self.assertEqual(actual_val, expect_val)
Example #9
0
 def test_get_interface_mac(self):
     expect_val = '01:02:03:04:05:06'
     with mock.patch('fcntl.ioctl') as ioctl:
         ioctl.return_value = ''.join(['\x00' * 18,
                                       '\x01\x02\x03\x04\x05\x06',
                                       '\x00' * 232])
         actual_val = utils.get_interface_mac('eth0')
     self.assertEqual(actual_val, expect_val)
Example #10
0
 def get_agent_id(self):
     devices = ip_lib.IPWrapper().get_devices(True)
     if devices:
         mac = utils.get_interface_mac(devices[0].name)
         return 'macvtap%s' % mac.replace(":", "")
     else:
         LOG.error(_LE("Unable to obtain MAC address for unique ID. "
                       "Agent terminated!"))
         sys.exit(1)
Example #11
0
 def get_agent_id(self):
     devices = ip_lib.IPWrapper().get_devices(True)
     if devices:
         mac = utils.get_interface_mac(devices[0].name)
         return 'macvtap%s' % mac.replace(":", "")
     else:
         LOG.error(_LE("Unable to obtain MAC address for unique ID. "
                       "Agent terminated!"))
         sys.exit(1)
Example #12
0
 def get_all_devices(self):
     devices = set()
     all_device_names = os.listdir(MACVTAP_FS)
     # Refresh the mac_device_name mapping
     self.mac_device_name_mappings = dict()
     for device_name in all_device_names:
         if device_name.startswith(constants.MACVTAP_DEVICE_PREFIX):
             mac = utils.get_interface_mac(device_name)
             self.mac_device_name_mappings[mac] = device_name
             devices.add(mac)
     return devices
Example #13
0
 def get_all_devices(self):
     devices = set()
     all_device_names = os.listdir(MACVTAP_FS)
     # Refresh the mac_device_name mapping
     self.mac_device_name_mappings = dict()
     for device_name in all_device_names:
         if device_name.startswith(constants.MACVTAP_DEVICE_PREFIX):
             mac = utils.get_interface_mac(device_name)
             self.mac_device_name_mappings[mac] = device_name
             devices.add(mac)
     return devices
Example #14
0
 def test_get_interface_mac(self):
     expect_val = "01:02:03:04:05:06"
     with mock.patch("fcntl.ioctl") as ioctl:
         ioctl.return_value = "".join(["\x00" * 18, "\x01\x02\x03\x04\x05\x06", "\x00" * 232])
         actual_val = utils.get_interface_mac("eth0")
     self.assertEqual(actual_val, expect_val)