def __init__(self, host, port, user_id, password, virt_host, exchange_name,
routing_key, consumer_queue_name):
super(RPCListener, self).__init__()
self._exit = threading.Event()
self._exchange_name = exchange_name
self._routing_key = routing_key
self._consumer_queue_name = consumer_queue_name
self._exchange = Exchange(self._exchange_name,
type='topic',
durable=False)
self._connection = Connection(host, user_id, password, virt_host, port)
self._rpc_receive_queue = Queue(self._consumer_queue_name,
durable=True,
exchange=self._exchange,
routing_key=self._routing_key)
self._consumer = Consumer(self._connection, self._rpc_receive_queue)
self._consumer.register_callback(self._callback)
self._message_queue = selectable.ThreadQueue(consumer_queue_name)
self._message_filters_lock = threading.RLock()
self._message_filters = dict()
self._message_handlers = dict()
selobj.selobj_add_read_obj(self._message_queue.selobj,
self._dispatch_messages)
def schedule_task_work(self, task_work=None):
"""
Schedule task work to one of the task workers if available
"""
if task_work is not None:
self._wait_queue.appendleft(task_work)
if 0 == len(self._wait_queue):
return False
worker = self._task_worker_pool.claim_worker()
if worker is not None:
task_work = self._wait_queue.pop()
DLOG.verbose("Pool %s: Task worker available to run TaskWork, "
"name=%s." %
(self._task_worker_pool.name, task_work.name))
selobj.selobj_add_read_obj(worker.selobj, self.task_work_complete)
self._workers_selobj[worker.selobj] = worker
worker.submit_task_work(task_work)
if task_work.timeout_in_secs is not None:
timer_id = timers.timers_create_timer(
task_work.name, task_work.timeout_in_secs,
task_work.timeout_in_secs, self.task_work_timeout)
self._task_work_timers[timer_id] = task_work
self._workers_timer[timer_id] = worker
return True
else:
DLOG.verbose("Pool %s: No task worker available to run TaskWork." %
self._task_worker_pool.name)
return False
def schedule_initialize():
"""
Initialize the schedule module
"""
global _send_socket, _receive_socket, _pending_function_calls
_send_socket, _receive_socket = socket.socketpair()
_receive_socket.setblocking(False)
selobj.selobj_add_read_obj(_receive_socket.fileno(), _schedule_dispatch)
del _pending_function_calls
_pending_function_calls = list() # noqa: F841
def dispatch(self):
while True:
select_obj = (yield)
if select_obj == self._connection.selobj:
# Client Connect
client_socket, client_address = self._socket.accept()
client_ip = client_address[0]
client_port = client_address[1]
client_connection = TCPConnection(client_ip, client_port,
client_socket, False, self,
self._auth_key)
selobj.selobj_add_read_obj(client_connection.selobj,
self.dispatch)
selobj.selobj_add_error_callback(client_connection.selobj,
self.selobj_error_callback)
self._client_connections[client_connection.selobj] \
= client_connection
DLOG.verbose("Client connected from %s, port=%s." %
(client_ip, client_port))
else:
# Client Data
client_connection = self._client_connections.get(
select_obj, None)
if client_connection is not None:
msg = client_connection.receive(blocking=False)
if msg is not None:
DLOG.verbose("Message received from %s, port=%s, "
"select_obj=%s." %
(client_connection.ip,
client_connection.port, select_obj))
self._message_handler(client_connection, msg)
client_connection = self._client_connections.get(
select_obj, None)
if client_connection is not None:
if client_connection.is_shutdown():
selobj.selobj_del_read_obj(select_obj)
selobj.selobj_del_error_callback(select_obj)
del self._client_connections[select_obj]
DLOG.verbose(
"Client connection closed, ip=%s, port=%s, "
"select_obj=%s." %
(client_connection.ip, client_connection.port,
select_obj))
else:
selobj.selobj_del_read_obj(select_obj)
selobj.selobj_del_error_callback(select_obj)
def __init__(self,
ip,
port,
msg_handler,
max_connections=5,
auth_key=None):
"""
Create a TCP Server
"""
self._auth_key = auth_key
self._connection = TCPConnection(ip, port)
self._socket = self._connection.sock
self._socket.listen(max_connections)
selobj.selobj_add_read_obj(self._connection.selobj, self.dispatch)
self._client_connections = dict()
self._message_handler = msg_handler
def process_initialize():
"""
Virtual Infrastructure Manager API - Initialize
"""
debug.debug_initialize(config.CONF['debug'], 'VIM-API')
selobj.selobj_initialize()
timers.timers_initialize(PROCESS_TICK_INTERVAL_IN_MS,
PROCESS_TICK_MAX_DELAY_IN_MS,
PROCESS_TICK_DELAY_DEBOUNCE_IN_MS)
ip = config.CONF['vim-api']['host']
port = int(config.CONF['vim-api']['port'])
# In order to support IPv6, set the address family before creating the server.
simple_server.WSGIServer.address_family = get_address_family(ip)
wsgi = simple_server.make_server(ip,
port,
Application(),
handler_class=get_handler_cls())
selobj.selobj_add_read_obj(wsgi, process_event_handler, wsgi)
def __init__(self, ip, port):
"""
Create the Rest-API Server
"""
l_on_off = 1
l_linger = 0
self._ip = ip
self._port = port
self._http_handler = RestAPIRequestDispatcher
self._http_handler.protocol = "HTTP/1.1"
SocketServer.TCPServer.__init__(self, (ip, int(port)),
self._http_handler,
bind_and_activate=False)
self.request_queue_size = 64
self.allow_reuse_address = True
self.socket.setblocking(False)
self.socket.setsockopt(socket.SOL_SOCKET, socket.SO_LINGER,
struct.pack('ii', l_on_off, l_linger))
self.server_bind()
self.server_activate()
selobj.selobj_add_read_obj(self.fileno(), self.dispatch_rest_api)
def __init__(self, name, task_worker_pool):
"""
Create a task scheduler
"""
self._name = name
self._task_worker_pool = task_worker_pool
self._workers_selobj = dict()
self._workers_timer = dict()
self._tasks = dict()
self._task_timers = dict()
self._task_work_timers = dict()
self._task_read_selobjs = dict()
self._task_write_selobjs = dict()
self._running_task = None
self._tasks_scheduled = False
self._wait_queue = collections.deque()
self._ready_queue = list()
self._ready_dequeues = list()
for _ in TASK_PRIORITY:
self._ready_queue.append(collections.deque())
self._ready_dequeues.append(0)
self._run_queue = selectable.MultiprocessQueue()
selobj.selobj_add_read_obj(self._run_queue.selobj, self.run_tasks)
def _thread_main(thread_name, progress_marker, debug_config, thread_worker,
work_queue):
"""
Main loop for the thread
"""
from ctypes import util
PR_SET_PDEATHSIG = 1
PR_SET_NAME = 15
PR_SIGKILL = 9
libc = ctypes.cdll.LoadLibrary(util.find_library("c"))
result = libc.prctl(PR_SET_NAME, thread_name)
if 0 != result:
DLOG.error("PRCTL set-name failed with error=%s." % result)
sys.exit(200)
result = libc.prctl(PR_SET_PDEATHSIG, PR_SIGKILL)
if 0 != result:
DLOG.error("PRCTL set-parent-death-signal failed with error=%s." %
result)
sys.exit(201)
signal.signal(signal.SIGTERM, signal.SIG_IGN)
signal.signal(signal.SIGINT, signal.SIG_IGN)
signal.signal(signal.SIGHUP, signal.SIG_IGN)
signal.signal(signal.SIGUSR1, signal.SIG_IGN)
signal.signal(signal.SIGUSR2, signal.SIG_IGN)
try:
thread_state = ThreadState()
debug.debug_initialize(debug_config, thread_name=thread_name)
selobj.selobj_initialize()
timers.timers_initialize(thread_worker.tick_interval_in_ms,
thread_worker.tick_max_delay_in_ms,
thread_worker.tick_delay_debounce_in_ms)
DLOG.debug("Thread %s: initializing." % thread_name)
thread_worker.initialize()
selobj.selobj_add_read_obj(work_queue.selobj, _thread_dispatch_work,
thread_state, thread_worker, work_queue)
DLOG.debug("Thread %s: started." % thread_name)
while thread_state.stay_on:
progress_marker.increment()
selobj.selobj_dispatch(thread_worker.tick_interval_in_ms)
timers.timers_schedule()
if not timers.timers_scheduling_on_time():
DLOG.info("Thread %s: not scheduling on time" % thread_name)
if thread_state.debug_reload:
debug.debug_reload_config()
thread_state.debug_reload = False
except KeyboardInterrupt:
print("Keyboard Interrupt received.")
pass
except Exception as e:
DLOG.exception("%s" % e)
sys.exit(202)
finally:
DLOG.info("Thread %s: shutting down." % thread_name)
thread_worker.finalize()
timers.timers_finalize()
selobj.selobj_finalize()
DLOG.info("Thread %s: shutdown." % thread_name)
debug.debug_finalize()
def add_task_io_read_wait(self, select_obj, task):
"""
Add a task read selection object to wait on
"""
selobj.selobj_add_read_obj(select_obj, self.task_io_wait_complete)
self._task_read_selobjs[select_obj] = task
