6b20fa8597
1. Use translation marker functions, their argument must just be a string 2. Any message with more than one variable should use named interpolation instead of positional to allow translators to move the variables around in the string to account for differences in grammar and writing direction. 3. String interpolation should be delayed to be handled by the logging code, rather than being done at the point of the logging call. For more details, please refert to oslo.i18n guideline [1] Note: this commit doesn't touch test code. [1] http://docs.openstack.org/developer/oslo.i18n/guidelines.html Change-Id: I5f013d65b20396bbe0e5a2cceaed2a33fad1af23
349 lines
12 KiB
Python
349 lines
12 KiB
Python
# Copyright 2014, Red Hat, Inc.
|
|
#
|
|
# Licensed under the Apache License, Version 2.0 (the "License"); you may
|
|
# not use this file except in compliance with the License. You may obtain
|
|
# a copy of the License at
|
|
#
|
|
# http://www.apache.org/licenses/LICENSE-2.0
|
|
#
|
|
# Unless required by applicable law or agreed to in writing, software
|
|
# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
|
|
# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
|
|
# License for the specific language governing permissions and limitations
|
|
# under the License.
|
|
|
|
"""
|
|
A thread that performs all messaging I/O and protocol event handling.
|
|
|
|
This module provides a background thread that handles messaging operations
|
|
scheduled via the Controller, and performs blocking socket I/O and timer
|
|
processing. This thread is designed to be as simple as possible - all the
|
|
protocol specific intelligence is provided by the Controller and executed on
|
|
the background thread via callables.
|
|
"""
|
|
|
|
import errno
|
|
import heapq
|
|
import logging
|
|
import os
|
|
import select
|
|
import socket
|
|
import sys
|
|
import threading
|
|
import time
|
|
import uuid
|
|
|
|
import pyngus
|
|
from six import moves
|
|
|
|
from oslo_messaging._i18n import _LE, _LI, _LW
|
|
LOG = logging.getLogger(__name__)
|
|
|
|
|
|
class _SocketConnection(object):
|
|
"""Associates a pyngus Connection with a python network socket,
|
|
and handles all connection-related I/O and timer events.
|
|
"""
|
|
|
|
def __init__(self, name, container, properties, handler):
|
|
self.name = name
|
|
self.socket = None
|
|
self._properties = properties or {}
|
|
self._properties["properties"] = self._get_name_and_pid()
|
|
# The handler is a pyngus ConnectionEventHandler, which is invoked by
|
|
# pyngus on connection-related events (active, closed, error, etc).
|
|
# Currently it is the Controller object.
|
|
self._handler = handler
|
|
self._container = container
|
|
self.connection = None
|
|
|
|
def _get_name_and_pid(self):
|
|
# helps identify the process that is using the connection
|
|
return {u'process': os.path.basename(sys.argv[0]), u'pid': os.getpid()}
|
|
|
|
def fileno(self):
|
|
"""Allows use of a _SocketConnection in a select() call.
|
|
"""
|
|
return self.socket.fileno()
|
|
|
|
def read(self):
|
|
"""Called when socket is read-ready."""
|
|
while True:
|
|
try:
|
|
rc = pyngus.read_socket_input(self.connection, self.socket)
|
|
self.connection.process(time.time())
|
|
return rc
|
|
except (socket.timeout, socket.error) as e:
|
|
# pyngus handles EAGAIN/EWOULDBLOCK and EINTER
|
|
self.connection.close_input()
|
|
self.connection.close()
|
|
self._handler.socket_error(str(e))
|
|
return pyngus.Connection.EOS
|
|
|
|
def write(self):
|
|
"""Called when socket is write-ready."""
|
|
while True:
|
|
try:
|
|
rc = pyngus.write_socket_output(self.connection, self.socket)
|
|
self.connection.process(time.time())
|
|
return rc
|
|
except (socket.timeout, socket.error) as e:
|
|
# pyngus handles EAGAIN/EWOULDBLOCK and EINTER
|
|
self.connection.close_output()
|
|
self.connection.close()
|
|
self._handler.socket_error(str(e))
|
|
return pyngus.Connection.EOS
|
|
|
|
def connect(self, host):
|
|
"""Connect to host and start the AMQP protocol."""
|
|
addr = socket.getaddrinfo(host.hostname, host.port,
|
|
socket.AF_INET, socket.SOCK_STREAM)
|
|
if not addr:
|
|
key = "%s:%i" % (host.hostname, host.port)
|
|
error = "Invalid peer address '%s'" % key
|
|
LOG.error(_LE("Invalid peer address '%s'"), key)
|
|
self._handler.socket_error(error)
|
|
return
|
|
my_socket = socket.socket(addr[0][0], addr[0][1], addr[0][2])
|
|
my_socket.setblocking(0) # 0=non-blocking
|
|
my_socket.setsockopt(socket.IPPROTO_TCP, socket.TCP_NODELAY, 1)
|
|
try:
|
|
my_socket.connect(addr[0][4])
|
|
except socket.error as e:
|
|
if e.errno != errno.EINPROGRESS:
|
|
error = "Socket connect failure '%s'" % str(e)
|
|
LOG.error(_LE("Socket connect failure '%s'"), str(e))
|
|
self._handler.socket_error(error)
|
|
return
|
|
self.socket = my_socket
|
|
|
|
props = self._properties.copy()
|
|
if pyngus.VERSION >= (2, 0, 0):
|
|
# configure client authentication
|
|
#
|
|
props['x-server'] = False
|
|
if host.username:
|
|
props['x-username'] = host.username
|
|
props['x-password'] = host.password or ""
|
|
|
|
c = self._container.create_connection(self.name, self._handler, props)
|
|
c.user_context = self
|
|
self.connection = c
|
|
|
|
if pyngus.VERSION < (2, 0, 0):
|
|
# older versions of pyngus requires manual SASL configuration:
|
|
# determine the proper SASL mechanism: PLAIN if a username/password
|
|
# is present, else ANONYMOUS
|
|
pn_sasl = self.connection.pn_sasl
|
|
if host.username:
|
|
password = host.password if host.password else ""
|
|
pn_sasl.plain(host.username, password)
|
|
else:
|
|
pn_sasl.mechanisms("ANONYMOUS")
|
|
# TODO(kgiusti): server if accepting inbound connections
|
|
pn_sasl.client()
|
|
|
|
self.connection.open()
|
|
|
|
def reset(self, name=None):
|
|
"""Clean up the current state, expect 'connect()' to be recalled
|
|
later.
|
|
"""
|
|
# note well: since destroy() is called on the connection, do not invoke
|
|
# this method from a pyngus callback!
|
|
if self.connection:
|
|
self.connection.destroy()
|
|
self.connection = None
|
|
self.close()
|
|
if name:
|
|
self.name = name
|
|
|
|
def close(self):
|
|
if self.socket:
|
|
self.socket.close()
|
|
|
|
|
|
class Schedule(object):
|
|
"""A list of callables (requests). Each callable may have a delay (in
|
|
milliseconds) which causes the callable to be scheduled to run after the
|
|
delay passes.
|
|
"""
|
|
def __init__(self):
|
|
self._entries = []
|
|
|
|
def schedule(self, request, delay):
|
|
"""Request a callable be executed after delay."""
|
|
entry = (time.time() + delay, request)
|
|
heapq.heappush(self._entries, entry)
|
|
|
|
def get_delay(self, max_delay=None):
|
|
"""Get the delay in milliseconds until the next callable needs to be
|
|
run, or 'max_delay' if no outstanding callables or the delay to the
|
|
next callable is > 'max_delay'.
|
|
"""
|
|
due = self._entries[0][0] if self._entries else None
|
|
if due is None:
|
|
return max_delay
|
|
now = time.time()
|
|
if due < now:
|
|
return 0
|
|
else:
|
|
return min(due - now, max_delay) if max_delay else due - now
|
|
|
|
def process(self):
|
|
"""Invoke all expired callables."""
|
|
while self._entries and self._entries[0][0] < time.time():
|
|
heapq.heappop(self._entries)[1]()
|
|
|
|
|
|
class Requests(object):
|
|
"""A queue of callables to execute from the eventloop thread's main
|
|
loop.
|
|
"""
|
|
def __init__(self):
|
|
self._requests = moves.queue.Queue(maxsize=10)
|
|
self._wakeup_pipe = os.pipe()
|
|
|
|
def wakeup(self, request=None):
|
|
"""Enqueue a callable to be executed by the eventloop, and force the
|
|
eventloop thread to wake up from select().
|
|
"""
|
|
if request:
|
|
self._requests.put(request)
|
|
os.write(self._wakeup_pipe[1], b'!')
|
|
|
|
def fileno(self):
|
|
"""Allows this request queue to be used by select()."""
|
|
return self._wakeup_pipe[0]
|
|
|
|
def read(self):
|
|
"""Invoked by the eventloop thread, execute each queued callable."""
|
|
os.read(self._wakeup_pipe[0], 512)
|
|
# first pop of all current tasks
|
|
requests = []
|
|
while not self._requests.empty():
|
|
requests.append(self._requests.get())
|
|
# then process them, this allows callables to re-register themselves to
|
|
# be run on the next iteration of the I/O loop
|
|
for r in requests:
|
|
r()
|
|
|
|
|
|
class Thread(threading.Thread):
|
|
"""Manages socket I/O and executes callables queued up by external
|
|
threads.
|
|
"""
|
|
def __init__(self, container_name=None):
|
|
super(Thread, self).__init__()
|
|
|
|
# callables from other threads:
|
|
self._requests = Requests()
|
|
# delayed callables (only used on this thread for now):
|
|
self._schedule = Schedule()
|
|
|
|
# Configure a container
|
|
if container_name is None:
|
|
container_name = "Container-" + uuid.uuid4().hex
|
|
self._container = pyngus.Container(container_name)
|
|
|
|
self.name = "Thread for Proton container: %s" % self._container.name
|
|
self._shutdown = False
|
|
self.daemon = True
|
|
self.start()
|
|
|
|
def wakeup(self, request=None):
|
|
"""Wake up the eventloop thread, Optionally providing a callable to run
|
|
when the eventloop wakes up. Thread safe.
|
|
"""
|
|
self._requests.wakeup(request)
|
|
|
|
def shutdown(self, wait=True, timeout=None):
|
|
"""Shutdown the eventloop thread. Thread safe.
|
|
"""
|
|
LOG.debug("eventloop shutdown requested")
|
|
self._shutdown = True
|
|
self.wakeup()
|
|
if wait:
|
|
self.join(timeout=timeout)
|
|
LOG.debug("eventloop shutdown complete")
|
|
|
|
# the following methods are not thread safe - they must be run from the
|
|
# eventloop thread
|
|
|
|
def schedule(self, request, delay):
|
|
"""Invoke request after delay seconds."""
|
|
self._schedule.schedule(request, delay)
|
|
|
|
def connect(self, host, handler, properties=None, name=None):
|
|
"""Get a _SocketConnection to a peer represented by url."""
|
|
key = name or "%s:%i" % (host.hostname, host.port)
|
|
# return pre-existing
|
|
conn = self._container.get_connection(key)
|
|
if conn:
|
|
return conn.user_context
|
|
|
|
# create a new connection - this will be stored in the
|
|
# container, using the specified name as the lookup key, or if
|
|
# no name was provided, the host:port combination
|
|
sc = _SocketConnection(key, self._container,
|
|
properties, handler=handler)
|
|
sc.connect(host)
|
|
return sc
|
|
|
|
def run(self):
|
|
"""Run the proton event/timer loop."""
|
|
LOG.debug("Starting Proton thread, container=%s",
|
|
self._container.name)
|
|
|
|
while not self._shutdown:
|
|
readers, writers, timers = self._container.need_processing()
|
|
|
|
readfds = [c.user_context for c in readers]
|
|
# additionally, always check for readability of pipe we
|
|
# are using to wakeup processing thread by other threads
|
|
readfds.append(self._requests)
|
|
writefds = [c.user_context for c in writers]
|
|
|
|
timeout = None
|
|
if timers:
|
|
deadline = timers[0].deadline # 0 == next expiring timer
|
|
now = time.time()
|
|
timeout = 0 if deadline <= now else deadline - now
|
|
|
|
# adjust timeout for any deferred requests
|
|
timeout = self._schedule.get_delay(timeout)
|
|
|
|
try:
|
|
results = select.select(readfds, writefds, [], timeout)
|
|
except select.error as serror:
|
|
if serror[0] == errno.EINTR:
|
|
LOG.warning(_LW("ignoring interrupt from select(): %s"),
|
|
str(serror))
|
|
continue
|
|
raise # assuming fatal...
|
|
|
|
# don't process any I/O or timers if woken up by a shutdown:
|
|
# if we've been forked we don't want to do I/O on the parent's
|
|
# sockets
|
|
if self._shutdown:
|
|
break
|
|
|
|
readable, writable, ignore = results
|
|
|
|
for r in readable:
|
|
r.read()
|
|
|
|
for t in timers:
|
|
if t.deadline > time.time():
|
|
break
|
|
t.process(time.time())
|
|
|
|
for w in writable:
|
|
w.write()
|
|
|
|
self._schedule.process() # run any deferred requests
|
|
|
|
LOG.info(_LI("eventloop thread exiting, container=%s"),
|
|
self._container.name)
|
|
self._container.destroy()
|