def __init__(self, enabled=True): super(ProcessingQueueNode, self).__init__(enabled) self.read_queue = aioprocessing.AioQueue() self.write_queue = aioprocessing.AioQueue() self.lock = aioprocessing.AioLock() self.exit_event = aioprocessing.AioEvent() self.process = aioprocessing.AioProcess( target=self.processor_heavy_fn, args=(self.exit_event, self.lock, self.write_queue, self.read_queue))
def __init__(self, loop, pool, func, consumer, start_event, terminate_event): self.start_event = start_event self.terminate_event = terminate_event self.pool = pool self.func = func self.queue = aioprocessing.AioQueue() self.lock = aioprocessing.AioLock() self._event = aioprocessing.AioEvent() self.consumer = consumer self.loop = loop self.process = aioprocessing.AioProcess( target=GeneratorWorker.func_run, args=(self.loop, self.queue, self.lock, self._event, self.func))
def fork_and_start(main_function: Callable): """ Forks a child process to run as the docker controller, and keep running the `main_function()` as the main process. When the `main_function()` exits, the child process is notified via `terminate_evt`, which will cause the child process to exit immediately as well. Afterwards, call join() and close() on the child process to ensure all acquired resources are freed up. """ p1, p2 = aioprocessing.AioPipe() terminate_evt: aioprocessing.AioEvent = aioprocessing.AioEvent() docker_process: Process = Process(target=_docker_process_main, args=(p1, p2, terminate_evt)) try: # fork the docker process as child. docker_process.start() # Set the pipe for docker_ipc() functions. set_hummingbot_pipe(p1) # run the main function as parent. main_function() # stop the gateway container. try: asyncio.get_event_loop().run_until_complete( docker_ipc("stop", container=get_gateway_container_name(), timeout=1)) except Exception: pass finally: # close pipes. p1.close() p2.close() # set the terminate event. terminate_evt.set() # wait for Docker controller process to clean up. docker_process.join() docker_process.close()
def __init__(self, app_log=None, config=None, verbose: bool = False, com_backend_class_name: str = 'TornadoBackend'): """Init the node components""" super().__init__(app_log, config, verbose) self.startup_time = time() self.connecting = False # If true, manager tries to initiate outgoing connections to peers self.stop_event = aioprocessing.AioEvent() # load the backend class from the provided name backend_class = getattr( importlib.import_module( f"bismuthcore.{com_backend_class_name.lower()}"), com_backend_class_name) self._com_backend = backend_class(self, app_log=app_log, config=config, verbose=verbose) self._client_commands = ClientCommands(self) self._check() self._clients = {} # outgoing connections
print("Please edit config.txt, set mempool_ram_conf=False and restart node") sys.exit() """ # TODO: print settings if not os.path.isfile(CONFIG.mempool_path): print("mempool.db not found at {}".format(CONFIG.mempool_path)) print( "Please edit node's config.txt, check mempool_ram_conf=False and restart node." ) sys.exit() start_time = time.time() stop_event = aioprocessing.AioEvent() # Event() lock = aioprocessing.AioLock() ch = logging.StreamHandler(sys.stdout) ch.setLevel(logging.INFO) # formatter = logging.Formatter('%(asctime)s %(funcName)s(%(lineno)d) %(message)s') # ch.setFormatter(formatter) app_log = logging.getLogger("tornado.application") tornado.log.enable_pretty_logging() # app_log.addHandler(ch) logfile = os.path.abspath("wallet_app.log") # Rotate log after reaching 512K, keep 5 old copies. rotateHandler = RotatingFileHandler(logfile, "a", 512 * 1024, 10) formatter = logging.Formatter('%(asctime)s %(levelname)s %(message)s') rotateHandler.setFormatter(formatter)
def setUp(self): super().setUp() self.event = aioprocessing.AioEvent()
break print("Got result {}".format(result)) await p.coro_join() async def example2(queue, event, lock): await event.coro_wait() async with lock: await queue.coro_put(78) await queue.coro_put(None) # Shut down the worker if __name__ == "__main__": loop = asyncio.get_event_loop() queue = aioprocessing.AioQueue() lock = aioprocessing.AioLock() event = aioprocessing.AioEvent() tasks = [ asyncio.ensure_future(example(queue, event, lock)), asyncio.ensure_future(example2(queue, event, lock)), ] loop.run_until_complete(asyncio.wait(tasks)) loop.close() # endpoints = [1,2,2,3] # # queue_list = [] # for i, item in enumerate(endpoints): # queue_list.append(aioprocessing.AioQueue) # # print(queue_list)
def __init__(self, width, height, address=("10.76.76.1", 80), enabled=True, enable_images=True): super(WebsiteClient, self).__init__(enabled) # http://user:[email protected]/api/robot/rightcam self.address = address self.requested_width = width self.requested_height = height self.width = width self.height = height self.num_frames = 0 self.reader = None self.writer = None self.enable_images = enable_images self.response_start_header = b'\xbb\x08' self.message_start_header = b'\xde\xad\xbe\xef' self.frame_len = 4 self.timestamp_len = 8 self.width_len = 2 self.height_len = 2 self.endian = 'big' self.chunk_size = int(self.width * self.height / 2) self.fps = 30.0 self.length_sec = 0.0 self.fps_sum = 0.0 self.fps_avg = 30.0 self.prev_t = None self.credentials = base64.b64encode(b'robot:naboris').decode('ascii') # self.manager = aioprocessing.AioSyncManager() self.connection = HTTPConnection("%s:%s" % (self.address[0], self.address[1])) self.headers = { 'Content-type': 'image/jpeg', 'Authorization': 'Basic %s' % self.credentials } if self.enable_images: self.connection.request("GET", "/api/robot/rightcam_meta", headers=self.headers) response = self.connection.getresponse() else: response = None self.image_process = aioprocessing.AioProcess( target=self.retrieve_images, args=(response, )) self.image_queue = aioprocessing.AioQueue() self.connection.request("GET", "/cmd", headers=self.headers) response = self.connection.getresponse() self.command_process = aioprocessing.AioProcess( target=self.retrieve_commands, args=(response, )) self.command_queue = aioprocessing.AioQueue() self.exit_event = aioprocessing.AioEvent() self.command_service_tag = "commands" self.define_service(self.command_service_tag, str)