"neutron/plugins/ml2",
"neutron/plugins/openvswitch",
"neutron/plugins/linuxbridge",
- "neutron/plugins/vmware"]
+ "neutron/plugins/vmware",
+ "neutron/plugins/mlnx"]
return any([dir in filename for dir in dirs])
from neutron.common import topics
from neutron.common import utils as q_utils
from neutron import context
-from neutron.i18n import _LE, _LI
+from neutron.i18n import _LE, _LI, _LW
from neutron.openstack.common import log as logging
from neutron.openstack.common import loopingcall
from neutron.plugins.common import constants as p_const
for port in data['ports']:
if port['port_mac'] == port_mac:
return port['port_id']
- err_msg = _("Agent cache inconsistency - port id "
- "is not stored for %s") % port_mac
- LOG.error(err_msg)
- raise exceptions.MlnxException(err_msg=err_msg)
+ LOG.error(_LE("Agent cache inconsistency - port id "
+ "is not stored for %s"), port_mac)
+ raise exceptions.MlnxException(err_msg=("Agent cache inconsistency, "
+ "check logs"))
def get_vnics_mac(self):
return set(self.utils.get_attached_vnics().keys())
if network_id in self.network_map:
del self.network_map[network_id]
else:
- LOG.debug(_("Network %s not defined on Agent."), network_id)
+ LOG.debug("Network %s not defined on Agent.", network_id)
def port_down(self, network_id, physical_network, port_mac):
"""Sets port to down.
if port['port_mac'] == port_mac:
self.utils.port_down(physical_network, port_mac)
return
- LOG.info(_('Network %s is not available on this agent'), network_id)
+ LOG.info(_LI('Network %s is not available on this agent'), network_id)
def port_up(self, network_id, network_type,
physical_network, seg_id, port_id, port_mac):
- configure eswitch vport
- set port to Up
"""
- LOG.debug(_("Connecting port %s"), port_id)
+ LOG.debug("Connecting port %s", port_id)
if network_id not in self.network_map:
self.provision_network(port_id, port_mac,
net_map['ports'].append({'port_id': port_id, 'port_mac': port_mac})
if network_type == p_const.TYPE_VLAN:
- LOG.info(_('Binding Segmentation ID %(seg_id)s'
- 'to eSwitch for vNIC mac_address %(mac)s'),
+ LOG.info(_LI('Binding Segmentation ID %(seg_id)s '
+ 'to eSwitch for vNIC mac_address %(mac)s'),
{'seg_id': seg_id,
'mac': port_mac})
self.utils.set_port_vlan_id(physical_network,
port_mac)
self.utils.port_up(physical_network, port_mac)
else:
- LOG.error(_('Unsupported network type %s'), network_type)
+ LOG.error(_LE('Unsupported network type %s'), network_type)
def port_release(self, port_mac):
"""Clear port configuration from eSwitch."""
self.utils.port_release(net_data['physical_network'],
port['port_mac'])
return
- LOG.info(_('Port_mac %s is not available on this agent'), port_mac)
+ LOG.info(_LI('Port_mac %s is not available on this agent'), port_mac)
def provision_network(self, port_id, port_mac,
network_id, network_type,
physical_network, segmentation_id):
- LOG.info(_("Provisioning network %s"), network_id)
+ LOG.info(_LI("Provisioning network %s"), network_id)
if network_type == p_const.TYPE_VLAN:
- LOG.debug(_("Creating VLAN Network"))
+ LOG.debug("Creating VLAN Network")
else:
- LOG.error(_("Unknown network type %(network_type)s "
- "for network %(network_id)s"),
+ LOG.error(_LE("Unknown network type %(network_type)s "
+ "for network %(network_id)s"),
{'network_type': network_type,
'network_id': network_id})
return
self.sg_agent = agent
def network_delete(self, context, **kwargs):
- LOG.debug(_("network_delete received"))
+ LOG.debug("network_delete received")
network_id = kwargs.get('network_id')
if not network_id:
- LOG.warning(_("Invalid Network ID, cannot remove Network"))
+ LOG.warning(_LW("Invalid Network ID, cannot remove Network"))
else:
- LOG.debug(_("Delete network %s"), network_id)
+ LOG.debug("Delete network %s", network_id)
self.eswitch.remove_network(network_id)
def port_update(self, context, **kwargs):
self.agent_state)
self.agent_state.pop('start_flag', None)
except Exception:
- LOG.exception(_("Failed reporting state!"))
+ LOG.exception(_LE("Failed reporting state!"))
def _setup_rpc(self):
self.agent_id = 'mlnx-agent.%s' % socket.gethostname()
- LOG.info(_("RPC agent_id: %s"), self.agent_id)
+ LOG.info(_LI("RPC agent_id: %s"), self.agent_id)
self.topic = topics.AGENT
self.plugin_rpc = MlnxEswitchPluginApi(topics.PLUGIN)
else:
self.eswitch.port_down(network_id, physical_network, port_mac)
else:
- LOG.debug(_("No port %s defined on agent."), port_id)
+ LOG.debug("No port %s defined on agent.", port_id)
def treat_devices_added_or_updated(self, devices):
try:
for dev_details in devs_details_list:
device = dev_details['device']
- LOG.info(_("Adding or updating port with mac %s"), device)
+ LOG.info(_LI("Adding or updating port with mac %s"), device)
if 'port_id' in dev_details:
- LOG.info(_("Port %s updated"), device)
+ LOG.info(_LI("Port %s updated"), device)
LOG.debug("Device details %s", str(dev_details))
self.treat_vif_port(dev_details['port_id'],
dev_details['device'],
def treat_devices_removed(self, devices):
resync = False
for device in devices:
- LOG.info(_("Removing device with mac_address %s"), device)
+ LOG.info(_LI("Removing device with mac_address %s"), device)
try:
port_id = self.eswitch.get_port_id_by_mac(device)
dev_details = self.plugin_rpc.update_device_down(self.context,
self.agent_id,
cfg.CONF.host)
except Exception as e:
- LOG.debug(_("Removing port failed for device %(device)s "
- "due to %(exc)s"), {'device': device, 'exc': e})
+ LOG.debug("Removing port failed for device %(device)s "
+ "due to %(exc)s", {'device': device, 'exc': e})
resync = True
continue
if dev_details['exists']:
- LOG.info(_("Port %s updated."), device)
+ LOG.info(_LI("Port %s updated."), device)
else:
- LOG.debug(_("Device %s not defined on plugin"), device)
+ LOG.debug("Device %s not defined on plugin", device)
self.eswitch.port_release(device)
return resync
port_info['updated'])
def daemon_loop(self):
- LOG.info(_("eSwitch Agent Started!"))
+ LOG.info(_LI("eSwitch Agent Started!"))
sync = True
port_info = {'current': set(),
'added': set(),
try:
port_info = self.scan_ports(previous=port_info, sync=sync)
except exceptions.RequestTimeout:
- LOG.exception(_("Request timeout in agent event loop "
- "eSwitchD is not responding - exiting..."))
+ LOG.exception(_LE("Request timeout in agent event loop "
+ "eSwitchD is not responding - exiting..."))
raise SystemExit(1)
if sync:
LOG.info(_LI("Agent out of sync with plugin!"))
if (elapsed < self._polling_interval):
time.sleep(self._polling_interval - elapsed)
else:
- LOG.debug(_("Loop iteration exceeded interval "
- "(%(polling_interval)s vs. %(elapsed)s)"),
+ LOG.debug("Loop iteration exceeded interval "
+ "(%(polling_interval)s vs. %(elapsed)s)",
{'polling_interval': self._polling_interval,
'elapsed': elapsed})
interface_mappings = q_utils.parse_mappings(
cfg.CONF.ESWITCH.physical_interface_mappings)
except ValueError as e:
- LOG.error(_("Parsing physical_interface_mappings failed: %s."
- " Agent terminated!"), e)
+ LOG.error(_LE("Parsing physical_interface_mappings failed: %s. "
+ "Agent terminated!"), e)
sys.exit(1)
- LOG.info(_("Interface mappings: %s"), interface_mappings)
+ LOG.info(_LI("Interface mappings: %s"), interface_mappings)
try:
agent = MlnxEswitchNeutronAgent(interface_mappings)
except Exception as e:
- LOG.error(_("Failed on Agent initialisation : %s."
- " Agent terminated!"), e)
+ LOG.error(_LE("Failed on Agent initialisation : %s. "
+ "Agent terminated!"), e)
sys.exit(1)
# Start everything.
- LOG.info(_("Agent initialised successfully, now running... "))
+ LOG.info(_LI("Agent initialised successfully, now running... "))
agent.daemon_loop()
sys.exit(0)
from oslo.serialization import jsonutils
from oslo.utils import importutils
+from neutron.i18n import _LE
from neutron.openstack.common import log as logging
from neutron.plugins.mlnx.common import comm_utils
from neutron.plugins.mlnx.common import exceptions
class EswitchUtils(object):
def __init__(self, daemon_endpoint, timeout):
if not zmq:
- msg = _("Failed to import eventlet.green.zmq. "
- "Won't connect to eSwitchD - exiting...")
- LOG.error(msg)
+ LOG.error(_LE("Failed to import eventlet.green.zmq. "
+ "Won't connect to eSwitchD - exiting..."))
raise SystemExit(1)
self.__conn = None
self.daemon = daemon_endpoint
return
elif msg['status'] == 'FAIL':
msg_dict = dict(action=msg['action'], reason=msg['reason'])
- error_msg = _("Action %(action)s failed: %(reason)s") % msg_dict
+ error_msg = _LE("Action %(action)s failed: %(reason)s") % msg_dict
else:
- error_msg = _("Unknown operation status %s") % msg['status']
+ error_msg = _LE("Unknown operation status %s") % msg['status']
LOG.error(error_msg)
raise exceptions.OperationFailed(err_msg=error_msg)
def get_attached_vnics(self):
- LOG.debug(_("get_attached_vnics"))
+ LOG.debug("get_attached_vnics")
msg = jsonutils.dumps({'action': 'get_vnics', 'fabric': '*'})
vnics = self.send_msg(msg)
return vnics
def set_port_vlan_id(self, physical_network,
segmentation_id, port_mac):
- LOG.debug(_("Set Vlan %(segmentation_id)s on Port %(port_mac)s "
- "on Fabric %(physical_network)s"),
+ LOG.debug("Set Vlan %(segmentation_id)s on Port %(port_mac)s "
+ "on Fabric %(physical_network)s",
{'port_mac': port_mac,
'segmentation_id': segmentation_id,
'physical_network': physical_network})
def define_fabric_mappings(self, interface_mapping):
for fabric, phy_interface in interface_mapping.iteritems():
- LOG.debug(_("Define Fabric %(fabric)s on interface %(ifc)s"),
+ LOG.debug("Define Fabric %(fabric)s on interface %(ifc)s",
{'fabric': fabric,
'ifc': phy_interface})
msg = jsonutils.dumps({'action': 'define_fabric_mapping',
self.send_msg(msg)
def port_up(self, fabric, port_mac):
- LOG.debug(_("Port Up for %(port_mac)s on fabric %(fabric)s"),
+ LOG.debug("Port Up for %(port_mac)s on fabric %(fabric)s",
{'port_mac': port_mac, 'fabric': fabric})
msg = jsonutils.dumps({'action': 'port_up',
'fabric': fabric,
self.send_msg(msg)
def port_down(self, fabric, port_mac):
- LOG.debug(_("Port Down for %(port_mac)s on fabric %(fabric)s"),
+ LOG.debug("Port Down for %(port_mac)s on fabric %(fabric)s",
{'port_mac': port_mac, 'fabric': fabric})
msg = jsonutils.dumps({'action': 'port_down',
'fabric': fabric,
self.send_msg(msg)
def port_release(self, fabric, port_mac):
- LOG.debug(_("Port Release for %(port_mac)s on fabric %(fabric)s"),
+ LOG.debug("Port Release for %(port_mac)s on fabric %(fabric)s",
{'port_mac': port_mac, 'fabric': fabric})
msg = jsonutils.dumps({'action': 'port_release',
'fabric': fabric,
self.client = n_rpc.get_client(target)
def network_delete(self, context, network_id):
- LOG.debug(_("Sending delete network message"))
+ LOG.debug("Sending delete network message")
cctxt = self.client.prepare(topic=self.topic_network_delete,
fanout=True)
cctxt.cast(context, 'network_delete', network_id=network_id)
def port_update(self, context, port, physical_network,
network_type, vlan_id):
- LOG.debug(_("Sending update port message"))
+ LOG.debug("Sending update port message")
kwargs = {'port': port,
'network_type': network_type,
'physical_network': physical_network,
try:
return original_func(*args, **kwargs)
except self.exc:
- LOG.debug(_("Request timeout - call again after "
- "%s seconds"), sleep_interval)
+ LOG.debug("Request timeout - call again after "
+ "%s seconds", sleep_interval)
time.sleep(sleep_interval)
num_of_iter -= 1
sleep_interval *= self.backoff_rate
import neutron.db.api as db
from neutron.db import models_v2
from neutron.db import securitygroups_db as sg_db
+from neutron.i18n import _LW
from neutron import manager
from neutron.openstack.common import log as logging
from neutron.plugins.mlnx.common import config # noqa
# it's not allocatable, so check if its allocated
if not entry.allocated:
# it's not, so remove it from table
- LOG.debug(_(
+ LOG.debug(
"Removing vlan %(seg_id)s on "
"physical network "
- "%(net)s from pool"),
+ "%(net)s from pool",
{'seg_id': entry.segmentation_id,
'net': physical_network})
session.delete(entry)
for entries in allocations.itervalues():
for entry in entries:
if not entry.allocated:
- LOG.debug(_("Removing vlan %(seg_id)s on physical "
- "network %(net)s from pool"),
+ LOG.debug("Removing vlan %(seg_id)s on physical "
+ "network %(net)s from pool",
{'seg_id': entry.segmentation_id,
'net': entry.physical_network})
session.delete(entry)
first())
if not entry:
raise n_exc.NoNetworkAvailable()
- LOG.debug(_("Reserving vlan %(seg_id)s on physical network "
- "%(net)s from pool"),
+ LOG.debug("Reserving vlan %(seg_id)s on physical network "
+ "%(net)s from pool",
{'seg_id': entry.segmentation_id,
'net': entry.physical_network})
entry.allocated = True
if entry.allocated:
raise n_exc.VlanIdInUse(vlan_id=segmentation_id,
physical_network=physical_network)
- LOG.debug(_("Reserving specific vlan %(seg_id)s "
- "on physical network %(phy_net)s from pool"),
+ LOG.debug("Reserving specific vlan %(seg_id)s "
+ "on physical network %(phy_net)s from pool",
log_args)
entry.allocated = True
except exc.NoResultFound:
- LOG.debug(_("Reserving specific vlan %(seg_id)s on "
- "physical network %(phy_net)s outside pool"),
+ LOG.debug("Reserving specific vlan %(seg_id)s on "
+ "physical network %(phy_net)s outside pool",
log_args)
entry = mlnx_models_v2.SegmentationIdAllocation(physical_network,
segmentation_id)
inside = True
break
if inside:
- LOG.debug(_("Releasing vlan %(seg_id)s "
- "on physical network "
- "%(phy_net)s to pool"),
+ LOG.debug("Releasing vlan %(seg_id)s "
+ "on physical network "
+ "%(phy_net)s to pool",
log_args)
else:
- LOG.debug(_("Releasing vlan %(seg_id)s "
- "on physical network "
- "%(phy_net)s outside pool"),
+ LOG.debug("Releasing vlan %(seg_id)s "
+ "on physical network "
+ "%(phy_net)s outside pool",
log_args)
session.delete(state)
except exc.NoResultFound:
- LOG.warning(_("vlan_id %(seg_id)s on physical network "
- "%(phy_net)s not found"),
+ LOG.warning(_LW("vlan_id %(seg_id)s on physical network "
+ "%(phy_net)s not found"),
log_args)
def get_port_from_device(device):
"""Get port from database."""
- LOG.debug(_("get_port_from_device() called"))
+ LOG.debug("get_port_from_device() called")
session = db.get_session()
sg_binding_port = sg_db.SecurityGroupPortBinding.port_id
def get_port_from_device_mac(device_mac):
"""Get port from database."""
- LOG.debug(_("Get_port_from_device_mac() called"))
+ LOG.debug("Get_port_from_device_mac() called")
session = db.get_session()
qry = session.query(models_v2.Port).filter_by(mac_address=device_mac)
return qry.first()
def set_port_status(port_id, status):
"""Set the port status."""
- LOG.debug(_("Set_port_status as %s called"), status)
+ LOG.debug("Set_port_status as %s called", status)
session = db.get_session()
try:
port = session.query(models_v2.Port).filter_by(id=port_id).one()
from neutron.db import securitygroups_rpc_base as sg_db_rpc
from neutron.extensions import portbindings
from neutron.extensions import providernet as provider
+from neutron.i18n import _LE, _LI
from neutron.openstack.common import log as logging
from neutron.plugins.common import constants as svc_constants
from neutron.plugins.common import utils as plugin_utils
self.router_scheduler = importutils.import_object(
cfg.CONF.router_scheduler_driver
)
- LOG.debug(_("Mellanox Embedded Switch Plugin initialisation complete"))
+ LOG.debug("Mellanox Embedded Switch Plugin initialisation complete")
def _setup_rpc(self):
# RPC support
self.physical_net_type = cfg.CONF.MLNX.physical_network_type
if self.physical_net_type not in (constants.TYPE_ETH,
constants.TYPE_IB):
- LOG.error(_("Invalid physical network type %(type)s."
- "Server terminated!"), {'type': self.physical_net_type})
+ LOG.error(_LE("Invalid physical network type %(type)s. "
+ "Server terminated!"),
+ {'type': self.physical_net_type})
raise SystemExit(1)
try:
self.phys_network_type_maps = utils.parse_mappings(
cfg.CONF.MLNX.physical_network_type_mappings)
except ValueError as e:
- LOG.error(_("Parsing physical_network_type failed: %s."
- " Server terminated!"), e)
+ LOG.error(_LE("Parsing physical_network_type failed: %s. "
+ "Server terminated!"), e)
raise SystemExit(1)
for network, type in self.phys_network_type_maps.iteritems():
if type not in (constants.TYPE_ETH, constants.TYPE_IB):
- LOG.error(_("Invalid physical network type %(type)s "
- " for network %(net)s. Server terminated!"),
+ LOG.error(_LE("Invalid physical network type %(type)s "
+ "for network %(net)s. Server terminated!"),
{'net': network, 'type': type})
raise SystemExit(1)
- LOG.info(_("Physical Network type mappings: %s"),
+ LOG.info(_LI("Physical Network type mappings: %s"),
self.phys_network_type_maps)
def _parse_network_vlan_ranges(self):
self.network_vlan_ranges = plugin_utils.parse_network_vlan_ranges(
cfg.CONF.MLNX.network_vlan_ranges)
except Exception as ex:
- LOG.error(_("%s. Server terminated!"), ex)
+ LOG.error(_LE("%s. Server terminated!"), ex)
sys.exit(1)
- LOG.info(_("Network VLAN ranges: %s"), self.network_vlan_ranges)
+ LOG.info(_LI("Network VLAN ranges: %s"), self.network_vlan_ranges)
def _extend_network_dict_provider(self, context, network):
binding = db.get_network_binding(context.session, network['id'])
if self.tenant_network_type not in [svc_constants.TYPE_VLAN,
svc_constants.TYPE_LOCAL,
svc_constants.TYPE_NONE]:
- LOG.error(_("Invalid tenant_network_type: %s. "
- "Service terminated!"),
+ LOG.error(_LE("Invalid tenant_network_type: %s. "
+ "Service terminated!"),
self.tenant_network_type)
sys.exit(1)
physical_network = None
else:
- msg = _("provider:network_type %s not supported") % network_type
+ msg = _LE("provider:network_type %s not supported") % network_type
raise n_exc.InvalidInput(error_message=msg)
physical_network = self._process_net_type(network_type,
physical_network,
def _process_flat_net(self, segmentation_id_set):
if segmentation_id_set:
- msg = _("provider:segmentation_id specified for flat network")
+ msg = _LE("provider:segmentation_id specified for flat network")
raise n_exc.InvalidInput(error_message=msg)
def _process_vlan_net(self, segmentation_id, segmentation_id_set):
if not segmentation_id_set:
- msg = _("provider:segmentation_id required")
+ msg = _LE("provider:segmentation_id required")
raise n_exc.InvalidInput(error_message=msg)
if not utils.is_valid_vlan_tag(segmentation_id):
- msg = (_("provider:segmentation_id out of range "
- "(%(min_id)s through %(max_id)s)") %
+ msg = (_LE("provider:segmentation_id out of range "
+ "(%(min_id)s through %(max_id)s)") %
{'min_id': q_const.MIN_VLAN_TAG,
'max_id': q_const.MAX_VLAN_TAG})
raise n_exc.InvalidInput(error_message=msg)
def _process_local_net(self, physical_network_set, segmentation_id_set):
if physical_network_set:
- msg = _("provider:physical_network specified for local "
- "network")
+ msg = _LE("provider:physical_network specified for local "
+ "network")
raise n_exc.InvalidInput(error_message=msg)
if segmentation_id_set:
- msg = _("provider:segmentation_id specified for local "
- "network")
+ msg = _LE("provider:segmentation_id specified for local "
+ "network")
raise n_exc.InvalidInput(error_message=msg)
def _process_net_type(self, network_type,
svc_constants.TYPE_FLAT]:
if physical_network_set:
if physical_network not in self.network_vlan_ranges:
- msg = _("Unknown provider:physical_network "
- "%s") % physical_network
+ msg = _LE("Unknown provider:physical_network "
+ "%s") % physical_network
raise n_exc.InvalidInput(error_message=msg)
elif 'default' in self.network_vlan_ranges:
physical_network = 'default'
else:
- msg = _("provider:physical_network required")
+ msg = _LE("provider:physical_network required")
raise n_exc.InvalidInput(error_message=msg)
return physical_network
self.base_binding_dict[portbindings.VIF_TYPE] = vnic_type
return vnic_type
else:
- msg = (_("Unsupported vnic type %(vnic_type)s "
- "for physical network type %(net_type)s") %
+ msg = (_LE("Unsupported vnic type %(vnic_type)s "
+ "for physical network type %(net_type)s") %
{'vnic_type': vnic_type, 'net_type': phy_net_type})
else:
- msg = _("Invalid vnic_type on port_create")
+ msg = _LE("Invalid vnic_type on port_create")
else:
- msg = _("vnic_type is not defined in port profile")
+ msg = _LE("vnic_type is not defined in port profile")
raise n_exc.InvalidInput(error_message=msg)
def create_network(self, context, network):
self._process_l3_create(context, net, network['network'])
self._extend_network_dict_provider(context, net)
# note - exception will rollback entire transaction
- LOG.debug(_("Created network: %s"), net['id'])
+ LOG.debug("Created network: %s", net['id'])
return net
def update_network(self, context, net_id, network):
- LOG.debug(_("Update network"))
+ LOG.debug("Update network")
provider._raise_if_updates_provider_attributes(network['network'])
session = context.session
return net
def delete_network(self, context, net_id):
- LOG.debug(_("Delete network"))
+ LOG.debug("Delete network")
session = context.session
with session.begin(subtransactions=True):
binding = db.get_network_binding(session, net_id)
return port
def create_port(self, context, port):
- LOG.debug(_("create_port with %s"), port)
+ LOG.debug("create_port with %s", port)
session = context.session
port_data = port['port']
with session.begin(subtransactions=True):
"""Agent requests device details."""
agent_id = kwargs.get('agent_id')
device = kwargs.get('device')
- LOG.debug(_("Device %(device)s details requested from %(agent_id)s"),
+ LOG.debug("Device %(device)s details requested from %(agent_id)s",
{'device': device, 'agent_id': agent_id})
plugin = manager.NeutronManager.get_plugin()
port = plugin.get_port_from_device(device)
db.set_port_status(port['id'], new_status)
else:
entry = {'device': device}
- LOG.debug(_("%s can not be found in database"), device)
+ LOG.debug("%s can not be found in database", device)
return entry
def get_devices_details_list(self, rpc_context, **kwargs):
"""Device no longer exists on agent."""
agent_id = kwargs.get('agent_id')
device = kwargs.get('device')
- LOG.debug(_("Device %(device)s no longer exists on %(agent_id)s"),
+ LOG.debug("Device %(device)s no longer exists on %(agent_id)s",
{'device': device, 'agent_id': agent_id})
plugin = manager.NeutronManager.get_plugin()
port = plugin.get_port_from_device(device)
else:
entry = {'device': device,
'exists': False}
- LOG.debug(_("%s can not be found in database"), device)
+ LOG.debug("%s can not be found in database", device)
return entry
def update_device_up(self, rpc_context, **kwargs):
"""Device is up on agent."""
agent_id = kwargs.get('agent_id')
device = kwargs.get('device')
- LOG.debug(_("Device %(device)s up %(agent_id)s"),
+ LOG.debug("Device %(device)s up %(agent_id)s",
{'device': device, 'agent_id': agent_id})
plugin = manager.NeutronManager.get_plugin()
port = plugin.get_port_from_device(device)
# Set port status to ACTIVE
db.set_port_status(port['id'], q_const.PORT_STATUS_ACTIVE)
else:
- LOG.debug(_("%s can not be found in database"), device)
+ LOG.debug("%s can not be found in database", device)
Code Review / openstack-build / neutron-build.git / commitdiff