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