Python _i18n._LI函数代码示例

    def login(self):
        """Get session based login"""
        login_obj = {"username": self.username, "password": self.password}

        msg = "NetScaler driver login:" + repr(login_obj)
        LOG.info(msg)
        resp_status, result = self.create_resource("login", NITRO_LOGIN_URI,
                                                   "login", login_obj)
        LOG.info(_LI("Response: status : %(status)s %result(result)s"), {
                 "status": resp_status, "result": result['body']})
        result_body = jsonutils.loads(result['body'])

        session_id = None
        if result_body and "login" in result_body:
            logins = result_body["login"]
            if isinstance(logins, list):
                login = logins[0]
            else:
                login = logins
            if login and "sessionid" in login:
                session_id = login["sessionid"]

        if session_id:
            LOG.info(_LI("Response: %(result)s"), {"result": result['body']})
            LOG.info(
                _LI("Session_id = %(session_id)s") %
                {"session_id": session_id})
            # Update sessin_id in auth
            self.auth = "SessId=%s" % session_id
        else:
            raise NCCException(NCCException.RESPONSE_ERROR)

 def stop(self, graceful=False):
     if self.server:
         LOG.info(_LI('Stopping consumer...'))
         self.server.stop()
         if graceful:
             LOG.info(
                 _LI('Consumer successfully stopped.  Waiting for final '
                     'messages to be processed...'))
             self.server.wait()
     super(OctaviaConsumer, self).stop(graceful=graceful)

 def _create_snatport_for_subnet_if_not_exists(self, context, tenant_id,
                                               subnet_id, network_info):
     port = self._get_snatport_for_subnet(context, tenant_id, subnet_id)
     if not port:
         LOG.info(_LI("No SNAT port found for subnet %s. Creating one..."),
                  subnet_id)
         port = self._create_snatport_for_subnet(context, tenant_id,
                                                 subnet_id,
                                                 ip_address=None)
     network_info['port_id'] = port['id']
     network_info['snat_ip'] = port['fixed_ips'][0]['ip_address']
     LOG.info(_LI("SNAT port: %r"), port)

 def agent_updated(self, context, payload):
     """Handle the agent_updated notification event."""
     if payload["admin_state_up"] != self.admin_state_up:
         self.admin_state_up = payload["admin_state_up"]
         if self.admin_state_up:
             self.needs_resync = True
         else:
             # Copy keys since the dictionary is modified in the loop body
             for loadbalancer_id in list(self.instance_mapping.keys()):
                 LOG.info(_LI("Destroying loadbalancer %s due to agent " "disabling"), loadbalancer_id)
                 self._destroy_loadbalancer(loadbalancer_id)
         LOG.info(_LI("Agent_updated by server side %s!"), payload)

 def agent_updated(self, context, payload):
     """Handle the agent_updated notification event."""
     if payload['admin_state_up'] != self.admin_state_up:
         self.admin_state_up = payload['admin_state_up']
         if self.admin_state_up:
             self.needs_resync = True
         else:
             for loadbalancer_id in self.instance_mapping.keys():
                 LOG.info(_LI("Destroying loadbalancer %s due to agent "
                              "disabling"), loadbalancer_id)
                 self._destroy_loadbalancer(loadbalancer_id)
         LOG.info(_LI("Agent_updated by server side %s!"), payload)

 def agent_updated(self, context, payload):
     """Handle the agent_updated notification event."""
     if payload['admin_state_up'] != self.admin_state_up:
         self.admin_state_up = payload['admin_state_up']
         if self.admin_state_up:
             self.needs_resync = True
         else:
             # Copy keys because the dict is modified in the loop body
             for pool_id in list(self.instance_mapping.keys()):
                 LOG.info(_LI("Destroying pool %s due to agent disabling"),
                          pool_id)
                 self._destroy_pool(pool_id)
         LOG.info(_LI("Agent_updated by server side %s!"), payload)

 def start(self):
     super(OctaviaConsumer, self).start()
     LOG.info(_LI("Starting octavia consumer..."))
     self.server = messaging.get_rpc_server(self.transport, self.target,
                                            self.endpoints,
                                            executor='eventlet')
     self.server.start()

    def delete_cert(self, project_id, cert_ref, resource_ref, **kwargs):
        """Deletes the specified cert.

        :param project_id: Project ID for the owner of the certificate
        :param cert_ref: the UUID of the cert to delete
        :param resource_ref: Full HATEOAS reference to the consuming resource

        :raises CertificateStorageException: if certificate deletion fails
        """
        LOG.info(_LI(
            "Deleting certificate {0} from the local filesystem."
        ).format(cert_ref))

        filename_base = os.path.join(CONF.certificates.storage_path, cert_ref)

        filename_certificate = "{0}.crt".format(filename_base)
        filename_private_key = "{0}.key".format(filename_base)
        filename_intermediates = "{0}.int".format(filename_base)
        filename_pkp = "{0}.pass".format(filename_base)

        try:
            os.remove(filename_certificate)
            os.remove(filename_private_key)
            os.remove(filename_intermediates)
            os.remove(filename_pkp)
        except IOError as ioe:
            LOG.error(_LE(
                "Failed to delete certificate {0}."
            ).format(cert_ref))
            raise exceptions.CertificateStorageException(message=ioe.message)

    def _actually_delete_cert(cert_ref):
        """Deletes the specified cert. Very dangerous. Do not recommend.

        :param cert_ref: the UUID of the cert to delete
        :raises Exception: if certificate deletion fails
        """
        connection = BarbicanKeystoneAuth.get_barbican_client()

        LOG.info(_LI(
            "Recursively deleting certificate container {0} from Barbican."
        ).format(cert_ref))
        try:
            certificate_container = connection.containers.get(cert_ref)
            certificate_container.certificate.delete()
            if certificate_container.intermediates:
                certificate_container.intermediates.delete()
            if certificate_container.private_key_passphrase:
                certificate_container.private_key_passphrase.delete()
            certificate_container.private_key.delete()
            certificate_container.delete()
        except Exception:
            with excutils.save_and_reraise_exception():
                LOG.exception(_LE(
                    "Error recursively deleting certificate container {0}"
                ).format(cert_ref))

    def delete_cert(cert_ref, lb_id, service_name='lbaas', **kwargs):
        """Deregister as a consumer for the specified cert.

        :param cert_ref: the UUID of the cert to retrieve
        :param service_name: Friendly name for the consuming service
        :param lb_id: Loadbalancer id for building resource consumer URL

        :raises Exception: if deregistration fails
        """
        connection = BarbicanKeystoneAuth.get_barbican_client()

        LOG.info(_LI(
            "Deregistering as a consumer of {0} in Barbican."
        ).format(cert_ref))
        try:
            connection.containers.remove_consumer(
                container_ref=cert_ref,
                name=service_name,
                url=CertManager._get_service_url(lb_id)
            )
        except Exception:
            with excutils.save_and_reraise_exception():
                LOG.exception(_LE(
                    "Error deregistering as a consumer of {0}"
                ).format(cert_ref))

    def get_cert(cert_ref, service_name='lbaas',
                 lb_id=None,
                 check_only=False, **kwargs):
        """Retrieves the specified cert and registers as a consumer.

        :param cert_ref: the UUID of the cert to retrieve
        :param service_name: Friendly name for the consuming service
        :param lb_id: Loadbalancer id for building resource consumer URL
        :param check_only: Read Certificate data without registering

        :returns: octavia.certificates.common.Cert representation of the
                 certificate data
        :raises Exception: if certificate retrieval fails
        """
        connection = BarbicanKeystoneAuth.get_barbican_client()

        LOG.info(_LI(
            "Loading certificate container {0} from Barbican."
        ).format(cert_ref))
        try:
            if check_only:
                cert_container = connection.containers.get(
                    container_ref=cert_ref
                )
            else:
                cert_container = connection.containers.register_consumer(
                    container_ref=cert_ref,
                    name=service_name,
                    url=CertManager._get_service_url(lb_id)
                )
            return Cert(cert_container)
        except Exception:
            with excutils.save_and_reraise_exception():
                LOG.exception(_LE("Error getting {0}").format(cert_ref))

    def get_cert(self, project_id, cert_ref, resource_ref,
                 check_only=False, service_name='lbaas'):
        """Retrieves the specified cert and registers as a consumer.

        :param cert_ref: the UUID of the cert to retrieve
        :param resource_ref: Full HATEOAS reference to the consuming resource
        :param check_only: Read Certificate data without registering
        :param service_name: Friendly name for the consuming service

        :returns: octavia.certificates.common.Cert representation of the
                 certificate data
        :raises Exception: if certificate retrieval fails
        """
        connection = self.auth.get_barbican_client(project_id)

        LOG.info(_LI(
            "Loading certificate container {0} from Barbican."
        ).format(cert_ref))
        try:
            if check_only:
                cert_container = connection.containers.get(
                    container_ref=cert_ref
                )
            else:
                cert_container = connection.containers.register_consumer(
                    container_ref=cert_ref,
                    name=service_name,
                    url=resource_ref
                )
            return Cert(cert_container)
        except Exception:
            with excutils.save_and_reraise_exception():
                LOG.exception(_LE("Error getting {0}").format(cert_ref))

    def get_cert(self, project_id, cert_ref, resource_ref, **kwargs):
        """Retrieves the specified cert.

        :param project_id: Project ID for the owner of the certificate
        :param cert_ref: the UUID of the cert to retrieve
        :param resource_ref: Full HATEOAS reference to the consuming resource

        :returns: neutron_lbaas.common.cert_manager.cert_manager.Cert
                 representation of the certificate data
        :raises CertificateStorageException: if certificate retrieval fails
        """
        LOG.info(_LI(
            "Loading certificate {0} from the local filesystem."
        ).format(cert_ref))

        filename_base = os.path.join(CONF.certificates.storage_path, cert_ref)

        filename_certificate = "{0}.crt".format(filename_base)
        filename_private_key = "{0}.key".format(filename_base)
        filename_intermediates = "{0}.int".format(filename_base)
        filename_pkp = "{0}.pass".format(filename_base)

        cert_data = dict()

        try:
            with open(filename_certificate, 'r') as cert_file:
                cert_data['certificate'] = cert_file.read()
        except IOError:
            LOG.error(_LE(
                "Failed to read certificate for {0}."
            ).format(cert_ref))
            raise exceptions.CertificateStorageException(
                msg="Certificate could not be read."
            )
        try:
            with open(filename_private_key, 'r') as key_file:
                cert_data['private_key'] = key_file.read()
        except IOError:
            LOG.error(_LE(
                "Failed to read private key for {0}."
            ).format(cert_ref))
            raise exceptions.CertificateStorageException(
                msg="Private Key could not be read."
            )

        try:
            with open(filename_intermediates, 'r') as int_file:
                cert_data['intermediates'] = int_file.read()
        except IOError:
            pass

        try:
            with open(filename_pkp, 'r') as pass_file:
                cert_data['private_key_passphrase'] = pass_file.read()
        except IOError:
            pass

        return Cert(**cert_data)

 def _remove_snatport_for_subnet_if_not_used(self, context, tenant_id,
                                             subnet_id):
     pools = self._get_pools_on_subnet(context, tenant_id, subnet_id)
     if not pools:
         #No pools left on the old subnet.
         #We can remove the SNAT port/ipaddress
         self._remove_snatport_for_subnet(context, tenant_id, subnet_id)
         LOG.info(_LI("Removing SNAT port for subnet %s "
                      "as this is the last pool using it..."),
                  subnet_id)

 def _get_snatport_for_subnet(self, context, tenant_id, subnet_id):
     device_id = '_lb-snatport-' + subnet_id
     subnet = self.plugin._core_plugin.get_subnet(context, subnet_id)
     network_id = subnet['network_id']
     LOG.debug("Filtering ports based on network_id=%(network_id)s, "
               "tenant_id=%(tenant_id)s, device_id=%(device_id)s",
               {'network_id': network_id,
                'tenant_id': tenant_id,
                'device_id': device_id})
     filter_dict = {
         'network_id': [network_id],
         'tenant_id': [tenant_id],
         'device_id': [device_id],
         'device-owner': [DRIVER_NAME]
     }
     ports = self.plugin._core_plugin.get_ports(context,
                                                filters=filter_dict)
     if ports:
         LOG.info(_LI("Found an existing SNAT port for subnet %s"),
                  subnet_id)
         return ports[0]
     LOG.info(_LI("Found no SNAT ports for subnet %s"), subnet_id)