def tempControlProcTest(mode, cycle_time, duty_cycle, set_point, k_param, i_param, d_param, conn): p = current_process() print 'Starting:', p.name, p.pid parent_conn_temp, child_conn_temp = Pipe() ptemp = Process(name = "getrandProc", target=getrandProc, args=(child_conn_temp,)) #ptemp.daemon = True ptemp.start() parent_conn_heat, child_conn_heat = Pipe() pheat = Process(name = "heatProctest", target=heatProctest, args=(cycle_time, duty_cycle, child_conn_heat)) #pheat.daemon = True pheat.start() while (True): if parent_conn_temp.poll(): randnum = parent_conn_temp.recv() #non blocking receive conn.send([randnum, mode, cycle_time, duty_cycle, set_point, k_param, i_param, d_param]) if parent_conn_heat.poll(): cycle_time, duty_cycle = parent_conn_heat.recv() #duty_cycle = on_time/offtime*100.0 #cycle_time = on_time + off_time if conn.poll(): mode, cycle_time, duty_cycle, set_point, k_param, i_param, d_param = conn.recv() #conn.send([mode, cycle_time, duty_cycle]) #if mode == "manual": parent_conn_heat.send([cycle_time, duty_cycle])
class CameraProcess(object): END_MESSAGE = 'END' def __init__(self): self._resolution = Camera.RESOLUTION_LO self._main_conn, self._worker_conn = Pipe() self._worker = Process(target=cameraWorker, args=((self._main_conn, self._worker_conn),self._resolution,)) self._worker.daemon = True self._worker.start() def stop(self): self._main_conn.send(CameraProcess.END_MESSAGE) while True: if self._main_conn.poll(0.1): if self._main_conn.recv() == CameraProcess.END_MESSAGE: break self._main_conn.send(CameraProcess.END_MESSAGE) self._worker.join() def update(self): if not self._main_conn.poll(): return data = self._main_conn.recv() self._y_stereo = data EventDispatcher().dispatch_event(YImageEvent(self._y_stereo))
def run_approx(nodes, timeout: int): start_time = time.process_time() # Get current uptime in secconds solution_read, solution_write = Pipe() tracepoint_read, tracepoint_write = Pipe() trace = Trace() # Create a subprocess which will run the algorithm on another core while this process checks time p = Process(target=approx, args=(nodes, tracepoint_write, solution_write)) p.start() # Start the process # Have the thread spin so that it keeps track of time most accurately while ((time.process_time() - start_time) < timeout and p.is_alive()): if solution_read.poll(0) and tracepoint_read.poll(0): # Block until a solution is available or timeout solution = solution_read.recv() # Receive corresponding tracepoint and append trace.add_tracepoint(tracepoint_read.recv()) p.join(0) # Join the subprocess which automatically closes the pipes if p.is_alive(): p.terminate() return solution, trace
def tempControlProcTest(mode, cycle_time, duty_cycle, set_point, k_param, i_param, d_param, conn): p = current_process() print 'Starting:', p.name, p.pid parent_conn_temp, child_conn_temp = Pipe() ptemp = Process(name="getrandProc", target=getrandProc, args=(child_conn_temp, )) #ptemp.daemon = True ptemp.start() parent_conn_heat, child_conn_heat = Pipe() pheat = Process(name="heatProctest", target=heatProctest, args=(cycle_time, duty_cycle, child_conn_heat)) #pheat.daemon = True pheat.start() while (True): if parent_conn_temp.poll(): randnum = parent_conn_temp.recv() #non blocking receive conn.send([ randnum, mode, cycle_time, duty_cycle, set_point, k_param, i_param, d_param ]) if parent_conn_heat.poll(): cycle_time, duty_cycle = parent_conn_heat.recv() #duty_cycle = on_time/offtime*100.0 #cycle_time = on_time + off_time if conn.poll(): mode, cycle_time, duty_cycle, set_point, k_param, i_param, d_param = conn.recv( ) #conn.send([mode, cycle_time, duty_cycle]) #if mode == "manual": parent_conn_heat.send([cycle_time, duty_cycle])
def run(self): if not self.isRunnable(): print "Can't run thread '{}'".format(self.name) print self.target, self.EVT_ID, self.notifyWindow, self.process return try: parentPipe, childPipe = Pipe() #self.process = Process(target = self.target, args = (childPipe, self.args)) self.process = threading.Thread(target = self.target, name = "Serial communication thread", kwargs = {"pipe": childPipe, "args": self.args}) self.process.name = self.name self.process.daemon = True self.process.start() while self.process.isAlive() or parentPipe.poll(0.001): if parentPipe.poll(0.001): out = parentPipe.recv() wx.PostEvent(self.notifyWindow, ResultEvent(out, self.EVT_ID)) if self.stop: if self.stopSignalTime == 0: self.stopSignalTime = time() + 0.5 parentPipe.send([False]) if time() > self.stopSignalTime: self.process._Thread__stop() wx.YieldIfNeeded() #sleep(0.01) except OSError, e: wx.PostEvent(self.notifyWindow, ResultEvent(\ "Execution failed in thread '{}', message: {}".format(\ self.name, e), self.EVT_ID))
def add_gzip_upload_process(self, args, kwargs): """ Create and start a gzip process Keep track of the total size of files we are gzipping :param args: contains info about file :param kwargs: :return: """ parent_conn, child_conn = Pipe(duplex=False) process = Process(name=os.path.basename(args['file']), target=self.gzip_upload_func, args=[child_conn, args['file_part']], kwargs=kwargs) setattr(process, 'process_type', 'GZIP') setattr(process, 'header', args['header']) setattr(process, 'file', args['file']) setattr(process, 'file_size', args['file_size']) process.start() self.gzip_running_size += args['file_size'] logging.debug("Added Gzip process, running size {}".format( self.gzip_running_size)) child_conn.close() try: parent_conn.poll() started = parent_conn.recv() if started: logging.debug("GZIP and upload process started on {}".format( args['file_part'])) except (EOFError, BrokenPipeError): pass return process, parent_conn
class IPCManagerPipes: def __init__(self): self.s2r_conn_r_, self.s2r_conn_w_ = Pipe() self.r2s_conn_r_, self.r2s_conn_w_ = Pipe() # def connect(self): # pass # def start(self): # pass # def shutdown(self): # pass def get_from_sender(self): if not self.s2r_conn_r_.poll(): return None return self.s2r_conn_r_.recv() def get_from_receiver(self): if not self.r2s_conn_r_.poll(): return None return self.r2s_conn_r_.recv() def send_to_receiver(self, msg): self.s2r_conn_w_.send(msg) def send_to_sender(self, msg): self.r2s_conn_w_.send(msg)
def main(): parent_conn, child_conn = Pipe() #sim.reset() #sim.setup() sim_proc = Process(target=Simulation, args=(child_conn,GAIT_STEPS*STEP_REPEAT,1111, 'gui')) sim_proc.start() #joints_seg = parent_conn.recv() #print(joints_seg) #simulation.setup() #stepss = readFile(r'E:\projekty\spider\algorithm\gen\generations-07_18_2018_13_26.txt') sleep(2) while True: for step in stepss: print(len(step)) y = convertToSim(step) logger.debug('converted: %s', str(y)) y = copytoLegs(y) logger.debug('copied: %s', str(y)) y = stepRepeat(y) logger.debug('sent: %s', str(y)) parent_conn.send(y) while True: if parent_conn.poll(): rec = parent_conn.recv() if rec == "simok": logger.debug('simok') break else: logger.debug('wrong data, received %s', str(rec)) #else: #logger.debug('waitinf for simok') while True: if parent_conn.poll(): rec= parent_conn.recv()[-1] logger.debug('data received : size %s %s', len(rec), str(rec)) if len(rec)==4: contact, base_pos, base_angle, diff = rec #if len(contact) == 6 and len(base_pos) == 3 and len(base_angle) == 3: parent_conn.send('dataok') logger.debug('dataok') break else: logger.debug('waitinf for correct data') parent_conn.send('reset') while True: #print('in loop3') if parent_conn.poll(): rec = parent_conn.recv() if rec == "resok": logger.debug('resok') break #else: # logger.debug('waitinf for reset confirm') #parent_conn.send('reset') print("end")
def ls2(nodes, timeout: int, seed_num): #Here we will implement the Simulated Annealing Algorithm start_time = time.process_time() # Get current uptime in secconds solution_read, solution_write = Pipe() tracepoint_read, tracepoint_write = Pipe() solution = Solution() random.seed(seed_num) trace = Trace() p = Process(target=anneal_route, args=(nodes, tracepoint_write, solution_write, seed_num)) p.start() # Start the process # Have the thread spin so that it keeps track of time most accurately while (((time.process_time() - start_time) < timeout) and p.is_alive()): if solution_read.poll(0) and tracepoint_read.poll(0): # Blocking call which shouldn't block since poll conditions ensure data is available solution = solution_read.recv() trace.add_tracepoint(tracepoint_read.recv( )) # Receive corresponding tracepoint and append p.join(0) # Join the subprocess which automatically closes the pipes if p.is_alive(): p.terminate() return solution, trace
def search(processes: list, pipe: Pipe, start: float = None, timeout: float = None) -> tuple: while len(active_children()) > 0 and not istimeout(start, timeout): if pipe.poll(): return pipe.recv() if pipe.poll(timeout=0.0001): return pipe.recv() if istimeout(start, timeout): raise Elliot("Timeout reached")
def main(): Base.metadata.create_all(engine) ready_msg = "ready" logger_queue = Queue(-1) page_parent_conn, page_child_conn = Pipe() logger_parent_conn, logger_child_conn = Pipe() log_process = LogListenerProcess(queue=logger_queue, pipe=logger_child_conn, verifying_message=ready_msg, configure=main_logger_configure) log_process.start() logger_parent_conn.send(ready_msg) get_process = GetKakakuNoteBookPage(lcd_from="10", lcd_to="16", configure=queue_logger_configure, queue=logger_queue, pipe=page_child_conn, verifying_message=ready_msg) get_process.start() page_parent_conn.send(ready_msg) queue_logger_configure(logger_queue) logger = getLogger(current_process().name) logger.info("Preparing PhantomJS ...") logger.info("[Start MainProcess]") if page_parent_conn.poll(timeout=60) and logger_parent_conn.poll( timeout=60): assert page_parent_conn.recv( ) == ready_msg, "GetKakakuNoteBookPage Process can't start." assert logger_parent_conn.recv( ) == ready_msg, "LogListener Process can't start." logger.debug("All processes ready.") else: print("[Process start failed]") sys.exit(1) logger.info("Try to get information from kakaku.com ...") while True: if page_parent_conn.poll(timeout=60): table = GetTable(page_parent_conn.recv()) for tr in table.all_tr: scraped = ScrapeNoteBook(tr) add_to_db(scraped, logger=logger) page_parent_conn.send("Done") else: logger.info("[Complete GetKakakuNoteBook Process]") break logger.info("[End MainProcess]") page_parent_conn.send(None) logger_queue.put(None) log_process.join() get_process.join() sys.exit()
def blocking_run(self): parent_conn, child_conn = Pipe() q = Queue() self.p = Process(target=job_process, args=( self.job_id, self.job_class, self.parameters, q, child_conn, self.server_url, self.log_filename, )) self.p.start() while self.p.is_alive(): while parent_conn.poll(): self.output_received_from_job(parent_conn.recv()) time.sleep(1) self.p.join() try: while parent_conn.poll(): self.output_received_from_job(parent_conn.recv()) except: print('Exception while gathering job process output') try: if self.terminated: # Job was terminated from user request self.result = { 'job_id': self.job_id, 'success': False, 'retcode': 1, 'exception': 'Terminated by server', 'progress': 'terminated' } else: if q.empty(): # Job process error, the job should always place its output in the queue self.result = { 'job_id': self.job_id, 'success': False, 'retcode': 1, 'exception': 'Job process terminated abnormally', 'progress': 'failed' } else: # Job terminated normally self.result = q.get() self.result['progress'] = self.status except: print('Exception while gathering job output') parent_conn.close() return self.result
class Driver(object): def __init__(self): self._driver_process = None self._sig_parent = None self._sig_child = None def start(self, func, *argv): self._sig_parent, self._sig_child = Pipe() self._driver_process = Process(target=Driver.run_driver_func, args=(func, self._sig_child, argv)) self._driver_process.daemon = True self._driver_process.start() def terminate(self, timeout=5): assert self._driver_process is not None, "It's an error to attempt to \ terminate a driver before it has been started." try: self._driver_process.join(timeout) except TimeoutError: logging.error("The driver was not terminated for some reason " "(exitcode: {}), force to terminate it.".format( self._driver_process.exitcode)) self._driver_process.terminate() time.sleep(0.1) finally: self._sig_parent.close() self._sig_parent = None self._sig_child = None self._driver_process = None def poll(self, timeout=None): if self._sig_parent is not None: if timeout is not None: return self._sig_parent.poll(timeout) else: return self._sig_parent.poll() else: return False def send(self, msg): self._sig_parent.send(msg) def recv(self): return self._sig_parent.recv() @staticmethod def run_driver_func(driver_func, signal, *argv): try: driver_func(signal, *argv[0]) finally: signal.close()
def timeout(func, args=(), kwargs={}, timeout_duration=10): """This function will spawn a thread and run the given function using the args, kwargs and return the given default value if the timeout_duration is exceeded. """ class InterruptableProcess(Process): def __init__(self, pipe): Process.__init__(self) self.pipe = pipe def run(self): result = func(*args, **kwargs) self.pipe.send((result.installList, result.uninstallList, result.solvable)) parent_conn, child_conn = Pipe() p = InterruptableProcess(child_conn) p.start() p.join(timeout_duration) if p.is_alive(): p.terminate() pass if parent_conn.poll(): return parent_conn.recv() else: return None
def run(self): print self.obj.name() + " thinks..." parent_conn, child_conn = Pipe() self.process = AsyncRunProcess(self.obj, self.state, child_conn) self.process.start() while not self.stop and not parent_conn.poll(): time.sleep(0.1) if self.stop: self.process.terminate() self.process.join() elif parent_conn.poll(): msg, result = parent_conn.recv() print "Calculation finished" self.process.join() self.emit(QtCore.SIGNAL("success"), result) self.emit(QtCore.SIGNAL("finished"))
class SonicProcess(Process): """ Wrapper class around multiprocessing.Process that would capture the exception thrown if the Process throws an exception when run. This exception (including backtrace) can be logged in test log to provide better info of why a particular Process failed. """ def __init__(self, *args, **kwargs): Process.__init__(self, *args, **kwargs) self._pconn, self._cconn = Pipe() self._exception = None def run(self): try: Process.run(self) self._cconn.send(None) except Exception as e: tb = traceback.format_exc() self._cconn.send((e, tb)) raise e # for wait_procs def wait(self, timeout): return self.join(timeout=timeout) # for wait_procs def is_running(self): return self.is_alive() @property def exception(self): if self._pconn.poll(): self._exception = self._pconn.recv() return self._exception
class ActiveConn(object): """ Talks to the specific backend instance associated with a userid """ def __init__(self, userid, modules): self.userid = userid self.here, self.there = Pipe(duplex=True) self.proc = CoqProc() self.proc.start(modules) self.read() logging.debug("Coqtop Process started %s", self.proc) def read(self): """poll results from the coqtop backend""" res = None self.proc.run(self.there) if self.here.poll(): res = self.here.recv() logging.debug("Received content from process") return {'userid': self.userid, 'response': res} def send(self, data): """send results to our coqtop instance""" if self.proc.alive: logging.debug("sending stuff") self.here.send(data + " ") return True else: return False def quit(self): if self.proc.alive: return self.proc.terminate(True)
class CelRecognizerWorker(QObject): update = Signal(list) def __init__(self): super().__init__() self.process = None self.timer = QTimer() self.timer.timeout.connect(self.check_for_results) self.timer.setInterval(1000) self.timer.start(1000) def submit(self, cel_path, video_path): # Cancel an existing process if it exists self.cancel() # Start a new process to run the CelRecognizer self.pipe, child_conn = Pipe() self.process = Process( target=_recognizer_worker_func, args=(child_conn, cel_path, video_path)) self.process.start() def check_for_results(self): if self.process is not None: while self.pipe.poll(): results = self.pipe.recv() self.update.emit(results) def cancel(self): if self.process is not None: self.process.terminate() self.process.join() self.process.close() self.process = None
def dispatch(self, fcn, timeout=0, params=()): """Start a new subrocess. This function will detach 'fcn' as a process of its own, passing params AND a pipe as arguments to 'fcn'. If 'timeout' > 0 this function will block, waiting for the detached process to send some data over the pipe. If data i written to pipe in time, the pipe will be returned to the calling process. On timeout, the pipe will be closed and 'None' will be returned to the calling process. """ conn, child_conn = Pipe() p = Process(target=fcn, args=params + (child_conn,)) p.start() if timeout > 0: poll_status = conn.poll(timeout) if poll_status == False: print "Dispatched function %s did not send anything within the specified timeout (%d s)" % (fcn, timeout) # FIXME: How to properly handle this case? # - p.terminate() doesn't terminate any subprocesses the p might have spawned # - conn.close(), i.e. closing the control channel, is probably better. Make sure p detects and handle it. # - send a proper control message (set running to False) should work too. # The proper way to implement a client is to handle connection.close() and stop running control message in the same way. conn.close() conn = None return conn
class Simulation: """ Physics simulation """ def __init__(self, team, project): logging.debug("Simulation created for team %d project %s" % (team, project)) self.team = team self.project = project #TODO: Load code from SVN zip = open("robot.zip", "rb").read() self.pipe, otherend = Pipe() self.sim = Sim(zip, otherend) self.sim.start() def step(self, commands): """ Step the simulation """ #Send commands for command in commands: message, args = command[0], command[1:] self.pipe.send((message, args)) #Receive data data = [] while self.pipe.poll(): data.append(self.pipe.recv()) return data def end(self): self.pipe.send(("END", None)) self.sim.join()
class StubExecuteTestsFunc: def __init__(self): self.main_conn, self.func_conn = Pipe() self._called = self._complete = None self.stub_reset() def stub_reset(self): self._called = self._complete = False def stub_complete(self): self._complete = True self.main_conn.send(StubExecuteTestsFuncConnMessages.COMPLETE) def stub_called(self): if not self._called and self.main_conn.poll(): conn_message = self.main_conn.recv() if conn_message == StubExecuteTestsFuncConnMessages.CALLED: self._called = True return self._called def __enter__(self): self.stub_reset() return self def __exit__(self, exc_type, exc_val, exc_tb): self.stub_complete() def __call__(self, *_): self._called = True self.func_conn.send(StubExecuteTestsFuncConnMessages.CALLED) while not self._complete: conn_message = self.func_conn.recv() if conn_message == StubExecuteTestsFuncConnMessages.COMPLETE: self._complete = True
class MMLWorker(object): """Represents the Daemon's connection to the subprocess""" def __init__(self,runner): """Creates and initalizes a subprocess and its connections.""" self.pipe, pipe = Pipe() self.proc = Process(target=worker, args=(pipe,runner)) self.proc.start(); self.pid = self.proc.pid def __del__(self): """Ensures the subprocess is correctly garbage collected.""" self.pipe.close(); self.proc.terminate(); def pump(self,block=False): """Returns a key,val pair from the subprocess, or None,None.""" key,val = None,None if block: (key,val) = self.pipe.recv() elif self.pipe.poll(): (key,val) = self.pipe.recv() return key,val def stop(self): """Sends the stop signal to the subprocess.""" self.pipe.send(('stop',())) def pause(self): """Sends the pause signal to the subprocess.""" self.pipe.send(('pause',())) def start(self,program): """Sends the start signal to the subprocess.""" self.pipe.send(('start',(program,)))
class RPC_Wamp(object): def __init__(self): self.ip = unicode(CONF.wamp.wamp_ip) self.port = unicode(CONF.wamp.wamp_port) self.realm = unicode(CONF.wamp.wamp_realm) self.server = RPCWampServer(self.ip, self.port, self.realm) self.b_a_int, self.b_a_ext = Pipe() server_process = multiprocessing.Process(target=reactor.run, args=()) server_process.start() def rpc_call(self, rpc, *args): res = '' RPCWampClient( self.ip, self.port, self.realm, rpc, args, self.b_a_ext) client_process = multiprocessing.Process(target=reactor.run, args=()) client_process.start() while True: if self.b_a_int.poll(): res = self.b_a_int.recv() client_process.join() break if res['error'] == 0: return res['response'] else: return {'result': 1}
def map(self, function, *function_args): lock = Lock() main_pipe, remote_pipe = Pipe() requests = list(enumerate(function_args)) works_count = len(function_args) results = [self] * works_count workers = self._create_workers(function, function_args, remote_pipe, lock) cursor = 0 while cursor < works_count: if results[cursor] is not self: yield results[cursor] cursor += 1 if main_pipe.poll(): response = main_pipe.recv() if requests: main_pipe.send(requests.pop(0)) if response is not True: index, result = response results[index] = result for worker in workers: worker.join() main_pipe.close() raise StopIteration
class gui: ''' A multithreaded handler for the coincidence-count GUI ''' def __init__(self): ''' Constructor ''' # Start up the GUI process and build the communication network self.pipe, their_pipe = Pipe() self.gui = Process(target=gui_head, name='gui_head', args=(their_pipe, )) self.gui.start() def collect(self): ''' Collect all messages and act upon them ''' messages = [] while self.pipe.poll(0): messages.append(self.pipe.recv()) return messages def send(self, key, value): ''' Send a message to the threaded GUI ''' self.pipe.send((key, value)) def kill(self): ''' Send the message to shut down ''' self.send('kill', None)
class J1708(): def __init__(self,uart=None): self._sport = None if uart is not None: self._sport = serial.Serial(port=uart,baudrate=9600, bytesize=serial.EIGHTBITS, stopbits=serial.STOPBITS_ONE) self.buslock = Lock() self.mypipe, self.otherpipe = Pipe() self.r_proc = Process(target=run, args=(self._sport,self.buslock,self.otherpipe)) self.r_proc.start() def read_message(self,timeout=None): if not self.mypipe.poll(timeout): return None retval = self.mypipe.recv() return retval #currently relying on the read_thread to maintain synchronization def send_message(self,msg): retval = 0 thismsg = bytes(msg) chksum = struct.pack('b',checksum(thismsg)) thismsg += chksum with self.buslock: retval = self._sport.write(thismsg) self._sport.flushInput()#solve "echo" problem return retval def __del__(self): self.r_proc.terminate()
class MPPlugin(object): # this functionality needs to be implemented in the cython parent side def __init__(self): self.plot_pipe, plotter_pipe = Pipe() self.plotter = SimplePlotter(20000.) self.plot_process = Process(target=self.plotter, args=(plotter_pipe, )) self.plot_process.daemon = True self.plot_process.start() def bufferfunction(self, n_arr=None, finished=False): # print "entering plot" send = self.plot_pipe.send if finished: send(None) else: # print "sending data" if not n_arr: n_arr = np.random.random((11, 1000)) send({'data': n_arr}) while 1: if not self.plot_pipe.poll(): break e = self.plot_pipe.recv() print(e) def setparam(self, name, value): self.plot_pipe.send({'param': {name: value}})
class EmulatorProxy(object): width = 128 height = 64 device_mode = "1" char_width = 6 char_height = 8 type = ["char", "b&w-pixel"] def __init__(self): self.device = type("MockDevice", (), {"mode": "1", "size": (128, 64)}) self.parent_conn, self.child_conn = Pipe() self.proc = Process(target=Emulator, args=(self.child_conn, )) self.__base_classes__ = (GraphicalOutputDevice, CharacterOutputDevice) self.current_image = None self.proc.start() def poll_input(self, timeout=1): if self.parent_conn.poll(timeout) is True: return self.parent_conn.recv() return None def quit(self): DummyCallableRPCObject(self.parent_conn, 'quit')() self.proc.join() def __getattr__(self, name): # Raise an exception if the attribute being called # doesn't actually exist on the Emulator object getattr(Emulator, name) # Otherwise, return an object that imitates the requested # attribute of the Emulator - for now, only callables # are supported, and you can't get the result of a # callable. return DummyCallableRPCObject(self.parent_conn, name)
def simulateModel(geometry, model): from multiprocessing import Pipe, Process from time import sleep parent_conn, child_conn = Pipe() p = Process(target=_simulateModel, args=(geometry, model, child_conn)) try: p.start() while not parent_conn.poll(): sleep(0.1) timeTrace, vTraces, textOutput, err, tb = parent_conn.recv() p.join() except BaseException: if p.is_alive(): p.terminate() timeTrace = [] vTraces = [] textOutput = "" err = None tb = "" raise if err is not None: print(tb) raise err return timeTrace, vTraces, textOutput
class gui: """ A multithreaded handler for the coincidence-count GUI """ def __init__(self): """ Constructor """ # Start up the GUI process and build the communication network self.pipe, their_pipe = Pipe() self.gui = Process(target=gui_head, name="gui_head", args=(their_pipe,)) self.gui.start() def collect(self): """ Collect all messages and act upon them """ messages = [] while self.pipe.poll(0): messages.append(self.pipe.recv()) return messages def send(self, key, value): """ Send a message to the threaded GUI """ self.pipe.send((key, value)) def kill(self): """ Send the message to shut down """ self.send("kill", None)
def fn_with_timeout(*args, **kwargs): conn1, conn2 = Pipe() kwargs["_conn"] = conn2 th = Process(target=partial(fn, best_loss=self._best_loss), args=args, kwargs=kwargs) th.start() if conn1.poll(self.trial_timeout): fn_rval = conn1.recv() th.join() else: self.info("TERMINATING DUE TO TIMEOUT") th.terminate() th.join() fn_rval = "return", {"status": hyperopt.STATUS_FAIL, "failure": "TimeOut"} assert fn_rval[0] in ("raise", "return") if fn_rval[0] == "raise": raise fn_rval[1] # -- remove potentially large objects from the rval # so that the Trials() object below stays small # We can recompute them if necessary, and it's usually # not necessary at all. if fn_rval[1]["status"] == hyperopt.STATUS_OK: fn_loss = float(fn_rval[1].get("loss")) fn_preprocs = fn_rval[1].pop("preprocs") fn_classif = fn_rval[1].pop("classifier") fn_iters = fn_rval[1].pop("iterations") if fn_loss < self._best_loss: self._best_preprocs = fn_preprocs self._best_classif = fn_classif self._best_loss = fn_loss self._best_iters = fn_iters return fn_rval[1]
def run(self): logging.info('Visualizer thread started') parent_end, child_end = Pipe() # Sensible default value for max_process max_process = 3 process_count = 0 while not self.stop or not self.job_backlog.empty(): while parent_end.poll(0.1): (name, counter) = parent_end.recv() self.controller.find_trial(name).set_counter_plot(counter) process_count -= 1 if self.job_backlog.empty(): time.sleep(1) elif process_count < max_process: process_count += 1 function, snapshot, trial = self.job_backlog.get_nowait() logging.info('Visualizing {}'.format(trial.get_name())) p = Process(target=self.render_graph, args=(function, snapshot, trial.get_name(), child_end)) p.start() self.job_backlog.task_done() logging.info('Visualizer Finished')
def run_http_server(redirect_uri = None, modify_port = True, port_range = (10000, 10010) ): """Returns (modified) redirect_uri""" from multiprocessing import Process, Pipe from urllib.parse import urlsplit, urlunsplit if redirect_uri is None: redirect_uri = "http://localhost" p = urlsplit(redirect_uri) #Ensure hostname is localhost or 127.0.0.1 if p.hostname != "127.0.0.1" and p.hostname != "localhost": raise ValueError("url must have host of 127.0.0.1 or localhost! Got: {}".format(p.hostname)) if not modify_port: if p.port is not None: port_range = (int(p.port), int(p.port)) else: port_range = (int(80), int(80)) parent_port_pipe, child_port_pipe = Pipe() parent_pipe, child_pipe = Pipe() httpd_p = Process(target = _run_http_server, args = (child_port_pipe, child_pipe, port_range)) httpd_p.start() if parent_port_pipe.poll(3000): final_port = parent_port_pipe.recv() else: raise Exception("Timeout waiting for HTTP server process to start") if final_port == 0: #Could not find a port raise Exception("Could not find open port") netloc = "{0}:{1}".format(p.hostname, final_port) if p.path: path = p.path else: path = '/' p = p._replace(netloc = netloc, path = path) return (urlunsplit(p), parent_pipe, httpd_p)
class ProcessManager(): def __init__(self, client_id, debug=False): self.client_id = client_id self.client_status = Value("i", ClientStatus.IDLE) self.parent_conn, self.child_conn = Pipe() self.pinger = Pinger(client_id, self.child_conn, self.client_status) self.task_worker = TaskWorker(client_id, self.client_status, debug) def _are_processes_alive(self, processes): for process in processes: if not process.is_alive(): other_processes = list( filter(lambda p: p != process, processes)) for other_process in other_processes: other_process.stop() logging.info("Client is exiting...") return False return True def launch(self): self.task_worker.launch() self.pinger.launch() while True: if not self._are_processes_alive([self.task_worker, self.pinger]): return if self.parent_conn.poll(1): self.parent_conn.recv() logging.info("Stopping task...") self.task_worker.stop() self.task_worker.launch()
def evaluate_expression(exp): ''' Evaluates given expression. ''' if not exp: return "No expression supplied." exp = str(exp) # Setup evaluation process if it's not present global eval_process, eval_pipe_parent, eval_pipe_child if not eval_process: eval_pipe_parent, eval_pipe_child = Pipe() eval_process = Process(name = "seejoo_eval", target = _eval_worker, args = (eval_pipe_child,)) eval_process.daemon = True eval_process.start() # Push expression through the pipe and wait for result eval_pipe_parent.send(exp) if eval_pipe_parent.poll(EVAL_TIMEOUT): res = str(eval_pipe_parent.recv()) res = filter(lambda x: ord(x) >= 32, res) # Sanitize result return res # Evaluation timed out; kill the process and return error os.kill(eval_process.pid, 9) os.waitpid(eval_process.pid, os.WUNTRACED) eval_process = None return "Operation timed out."
class MyThread(threading.Thread): def __init__(self): threading.Thread.__init__(self) self.pipe_ext, self.pipe_int = Pipe() def read(self): msgs = [] while self.pipe_ext.poll(): msgs.append(self.pipe_ext.recv()) return msgs def write(self, data): self.pipe_ext.send(data) def internal_read(self): msgs = [] while self.pipe_int.poll(): msgs.append(self.pipe_int.recv()) return msgs def internal_write(self, data): self.pipe_int.send(data)
class Airplay(): def __init__(self, file): self.metadata = AIRPLAY_DEFAULT self.block = '' self.out_pipe, self.in_pipe = Pipe() p = Process(target=read_shairport_pipe, args=(file, self.in_pipe,)) p.start() def __repr__(self): printout = "metadata:\n"+self.metadata # for k,v in self.metadata.items(): # printout += '%12s : %s\n' % (k,v) return printout def grab(self): if self.out_pipe.poll(0): s = True self.metadata = self.out_pipe.recv() # prints "[42, None, 'hello']" else: print "nothing in pipe" s = False return s
def test_contract_manager() -> None: aut = AirspaceManager() stop_ev = Event() conn, manager_conn = Pipe() p = Process(target=run_as_process, kwargs={"aut": aut, "conn": manager_conn, "stop_ev": stop_ev}) p.start() try: uid = 0 for i in range(10): if conn.poll(1.0): act = conn.recv() print(act) elif i % 3 != 2: uid = i % 5 target = Contract.from_stamped_rectangles([ (0.0, Rectangle(mins=[0, 0, 0], maxes=[1, 1, 0.5])), (0.5, Rectangle(mins=[0, 0.5, 0], maxes=[2, 3, 0.5])), (1.0, Rectangle(mins=[0.5, 0.5, 1.0], maxes=[1.5, 1.5, 1.5])) ]) conn.send(("request", {"uid": uid, "target": target})) else: releasable = Contract.from_stamped_rectangles([ (0.0, Rectangle(mins=[0, 0, 0], maxes=[1, 1, 0.5])), (0.5, Rectangle(mins=[0, 0.5, 0], maxes=[2, 2, 0.5])) ]) print("Agent " + str(uid) + " release > " + str(releasable)) conn.send(("release", {"uid": uid, "releasable": releasable})) finally: stop_ev.set() # Stop all automatons p.join() conn.close() manager_conn.close()
def master(): results = [] mcn, scn = Pipe() mon = Thread(target=monitor, args=(mcn, results)) mon.daemon = True mon.start() proc = Process(target=slave, args=(scn,)) proc.start() mcn.send('1') while not results: time.sleep(0.01) pid = results.pop() log.info('pid: %s', pid) mcn.send('die') try: for n in range(7): if mcn.poll(1): break if not proc.is_alive(): raise Exception('stop') except Exception: log.error('slave died', exc_info=True)
class Aby3Process(Process): """ Extends from Process, evaluate the computation party in aby3. """ def __init__(self, *args, **kwargs): Process.__init__(self, *args, **kwargs) self._pconn, self._cconn = Pipe() self._exception = None def run(self): """ Override. Send any exceptions raised in subprocess to main process. """ try: Process.run(self) self._cconn.send(None) except Exception as e: tb = traceback.format_exc() self._cconn.send((e, tb)) @property def exception(self): """ Get exception. """ if self._pconn.poll(): self._exception = self._pconn.recv() return self._exception
def master(): results = [] mcn, scn = Pipe() mon = Thread(target=monitor, args=(mcn, results)) mon.daemon = True mon.start() proc = Process(target=slave, args=(scn, )) proc.start() mcn.send('1') while not results: time.sleep(0.01) pid = results.pop() log.info('pid: %s', pid) mcn.send('die') try: for n in range(7): if mcn.poll(1): break if not proc.is_alive(): raise Exception('stop') except Exception: log.error('slave died', exc_info=True)
class EmulatorProxy(object): width = 128 height = 64 def __init__(self): self.device = type("MockDevice", (), {"mode": "1", "size": (128, 64)}) self.parent_conn, self.child_conn = Pipe() self.proc = Process(target=Emulator, args=(self.child_conn, )) self.proc.start() def poll_input(self, timeout=1): if self.parent_conn.poll(timeout) is True: return self.parent_conn.recv() return None def quit(self): DummyCallableRPCObject(self.parent_conn, 'quit')() self.proc.join() def __getattr__(self, name): # Raise an exception if the attribute being called # Doesn't actually exist on the Emulator object getattr(Emulator, name) return DummyCallableRPCObject(self.parent_conn, name)
def fn_with_timeout(*args, **kwargs): conn1, conn2 = Pipe() kwargs['_conn'] = conn2 th = Process(target=fn, args=args, kwargs=kwargs) th.start() if conn1.poll(self.trial_timeout): fn_rval = conn1.recv() th.join() else: print 'TERMINATING DUE TO TIMEOUT' th.terminate() th.join() fn_rval = 'return', { 'status': hyperopt.STATUS_FAIL, 'failure': 'TimeOut' } assert fn_rval[0] in ('raise', 'return') if fn_rval[0] == 'raise': raise fn_rval[1] # -- remove potentially large objects from the rval # so that the Trials() object below stays small # We can recompute them if necessary, and it's usually # not necessary at all. if fn_rval[1]['status'] == hyperopt.STATUS_OK: fn_loss = float(fn_rval[1].get('loss')) fn_preprocs = fn_rval[1].pop('preprocs') fn_classif = fn_rval[1].pop('classifier') if fn_loss < self._best_loss: self._best_preprocs = fn_preprocs self._best_classif = fn_classif self._best_loss = fn_loss return fn_rval[1]
def run(self): logging.info('Visualizer thread started') parent_end, child_end = Pipe() # Sensible default value for max_process max_process = 2 process_count = 0 while not self.stop or not self.job_backlog.empty(): while parent_end.poll(0.1): parent_end.recv() ## currently not using the info... irrelevant ## TODO - a signal to notify the viewer that visuzaliztion job has been finished... #self.controller.view_update(self) process_count -= 1 if self.job_backlog.empty(): time.sleep(1) elif process_count < max_process: process_count += 1 run_name, function, snapshot = self.job_backlog.get_nowait() if not (run_name in self.remove_run_name): logging.info('Added job to visuzalizer Que: ' + str(run_name)) logging.info('No. of jobs in Que: ' + str(process_count)) p = Process(target=self.render_graph, args=(function, snapshot, run_name, child_end)) p.start() logging.info('Visualizer Finished')
def fork_get_action(game_state, active_player, time_limit): action_queue = Queue() listener, client = Pipe() active_player.queue = action_queue # give the agent instance a threadsafe queue # comment out these lines for debugging mode p = Process(target=_request_action, args=(active_player, game_state, time_limit, client)) p.start() p.join(timeout=PROCESS_TIMEOUT) if p and p.is_alive(): p.terminate() # Uncomment these lines to run in debug mode, which runs the search function in the # main process so that debuggers and profilers work properly. NOTE: calls to your # search methods will NOT timeout in debug mode; you must be very careful to avoid # calls that are not methods of your CustomPlayer class or else your agent may fail # # from copy import deepcopy # active_player.queue = None # active_player = deepcopy(active_player) # active_player.queue = action_queue # _request_action(active_player, game_state, time_limit, client) if listener.poll(): active_player.context = listener.recv() # preserve any internal state while True: # treat the queue as LIFO action = action_queue.get_nowait( ) # raises Empty if agent did not respond if action_queue.empty(): break return action
class NodePair: def __init__(self,txnode,rxnode): self.txNode = txnode self.rxNode = rxnode self.ptx_conn, self.tx_conn = Pipe(True) self.prx_conn, self.rx_conn = Pipe(True) self.ptx = Process(target=self.txNode.runNode, args=(self.tx_conn,)) self.prx = Process(target=self.rxNode.runNode, args=(self.rx_conn,)) self.ptx.start() self.prx.start() def CompareResults(self): self.prx_conn.send(StatusMessage()) passedB = False ba = StatusMessage() if self.prx_conn.poll(1): b = self.prx_conn.recv()#clear buffer print '%s checksums rx %x calc %x'%(self.rxNode.name, b.status[3], b.status[4]) passedB = True if passedB : if b.status[3] == b.status[4]: return True else: return False else: print 'error found' def GetDisplayName(self): return self.txNode.name + ' to ' + self.rxNode.name def StopNodePair(self): self.ptx_conn.send(CloseMessage()) self.prx_conn.send(CloseMessage()) self.ptx.join() self.ptx_conn.close() self.tx_conn.close() self.ptx.terminate() self.prx.join() self.prx_conn.close() self.rx_conn.close() self.prx.terminate() def SetTranmitData(self,txData): self.ptx_conn.send(TxDataMessage(txData)) if self.ptx_conn.poll(2): a = self.ptx_conn.recv()#clear buffer print 'inside checksum %x'%a.checksum
class ProcessIA(): """ Classe qui va lancer une IA en subprocess. Gère aussi la communication avec les IA lancées via un pipe. """ def __init__(self, color_and_robot_list): self.__color = color_and_robot_list[0] if color_and_robot_list[1] is not None: self.__bigrobot = color_and_robot_list[1] if color_and_robot_list[2] is not None: self.__minirobot = color_and_robot_list[2] else: self.__minirobot = None else: self.__bigrobot =None if color_and_robot_list[2] is not None: self.__minirobot = color_and_robot_list[2] else: self.__minirobot = None self.__robots = color_and_robot_list self.__hokuyo = Hokuyo(self.__robots[1:]) self.__communication = Communication(self.__bigrobot, self.__minirobot, self.__hokuyo, self) #communication de data entre l'IA et le simu self.__parent_conn, self.__child_conn = Pipe() #lancement de l'ia if TEST_MODE == False: self.__process = Process(target=main.startIa, args=(self.__child_conn,self.__color)) elif TEST_MODE == True : self.__process = Process(target=test.testIa, args=(self.__child_conn,self.__color)) #pour les tests self.__process.start() time.sleep(0.1) #on démarre le thread de lecture des données IA renvoyées à travers le pipe self.__read_thread = threading.Thread(target=self.__readPipe) self.__read_thread.start() def writePipe(self, addresse, ordre, args): """ Envoie des données à l'IA à travers le Pipe """ self.__parent_conn.send((addresse, ordre, args)) def __readPipe(self): """ Méthode de lecture des données envoyées par l'IA via le pipe. recv est bloquant, donc lancé dans un thread """ while True: if self.__parent_conn.poll(): message = self.__parent_conn.recv() self.__parseDataIa(message) def __parseDataIa(self, data): """ Formate les données IA reçues pour les adapter à la méthode sendOrderAPI de Communication """ self.__communication.orderBalancing(data[0],data[1],data[2])
class Flow: def __init__ (self, debug_mode=False): from multiprocessing import Pipe, Process self.motions = [] self.debug_mode = debug_mode self.parent_conn, self.child_conn = Pipe() self.p = Process(target=self.do_motion_detect, args=(self.child_conn,)) self.p.start() # Send kill command to child process def kill (self): self.parent_conn.send('STOP') #self.parent_conn.recv() self.p.join() def _clear_pipe (self): while (self.parent_conn.poll(0.01) != False): reading = self.parent_conn.recv() self.motions.append(reading) # Checks if pipe has any data # If it does return that # Else return [] def get_motion (self): self._clear_pipe() if len(self.motions) == 0: return None else: copy = self.motions self.motions = [] return copy def do_motion_detect (self, child_conn): import picamera, subprocess, time camera = picamera.PiCamera(framerate=30) output = DetectMotion(camera) output.set_conn(child_conn) while True: try: #camera.resolution = (640, 480) camera.resolution = (200, 150) #camera.resolution = (240, 160) camera.start_recording('/dev/null', format='h264', motion_output=output) camera.wait_recording(0.25) #t = int(time.time()) #name = '{}-image.jpg'.format(t) name = 'image.jpg' os.remove(name) camera.capture(name, use_video_port=True) camera.stop_recording() if child_conn.poll(0.01): s = child_conn.recv() if s == 'STOP': break except KeyboardInterrupt: break camera.close()
def data_handler(spigot_data: SpigotData, lock: threading.Lock): """ Main thread for reading output from spigot IO worker. Also interprets data. spigot_data - shared SpigotData object """ client, child = Pipe() t = Process(target=r_w_worker, args=(child, spigot_data.close_event)) t.start() spigot_data.game.status = SpigotState.RUNNING running = True while running: while t.is_alive(): if client.poll(0.3): buf = client.recv() parse_event(spigot_data, buf) spigot_data.add_message(buf) logging.debug('<<OUTPUT>> {}'.format(buf)) while not spigot_data.commands.empty(): command = spigot_data.commands.get() client.send(command) logging.debug('<<COMMAND>> {}'.format(command)) # After java process is dead spigot_data.status = SpigotState.STOPPED spigot_data.add_message(info_message("""The server has stopped. Type 'start' to start. """ """Type 'quit' to close Spigot Monitor""")) # PEP8ers gonna hate spigot_data.game.players = {} # No players are available on a stopped server... while True and not AUTO_RESTART: command = spigot_data.commands.get().strip() # strip because commands have newline appended if command.lower() == 'start': t = Process(target=r_w_worker, args=(child, spigot_data.close_event)) t.start() logging.debug('Thread created.') break elif command.lower() == 'quit' or command.lower() == 'stop': message = info_message("KTHXBAI") spigot_data.add_message(message) logging.debug('Quitting program.') break if AUTO_RESTART: t = Process(target=r_w_worker, args=(child, spigot_data.close_event)) t.start() logging.debug('Thread created.') if not t.is_alive(): # thread hasn't started again running = False print('exiting data_handler loop')
def _proxy_loop(self, broker, *args): is_debug = partial(log.isEnabledFor, logging.DEBUG) pid = os.getpid() proc = None queue = self.queue def stop(): try: if proc is not None: child.send(STOP) child.close() proc.join() except Exception: log.error('%s failed to stop cleanly', str(self), exc_info=True) raise else: log.debug('terminated %s', str(self)) finally: self.pid = '%s-terminated' % self.pid while True: if proc is None or not proc.is_alive(): # start new worker process child, parent = Pipe() cx = _reduce_connection(parent) # HACK reduce for pickle proc = run_in_subprocess(worker_process, pid, cx, *args) self.pid = proc.pid task, return_to_pool = queue.get() if task == STOP: stop() break try: child.send(task) while not child.poll(task.heartrate): if not proc.is_alive(): broker.task_failed(task) raise Error('unknown cause of death') broker.heartbeat(task) (result, status) = child.recv() broker.set_result(task, result) except Exception: log.error('%s died unexpectedly', str(self), exc_info=True) child.close() proc.stdin.close() proc = None else: if is_debug(): log.debug('%s completed task', str(self)) if status == STOP: child.close() proc.stdin.close() proc = None finally: return_to_pool(self)
def test_multiprocessing_pipe(self): parent_conn, child_conn = Pipe() p = Process(target=f, args=(child_conn,)) p.start() for _ in range(5): while parent_conn.poll(): print("Got from client", parent_conn.recv_bytes()) # prints "[42, None, 'hello']" time.sleep(1) parent_conn.send_bytes(b"stop") p.join()
class ExternalDataManager(Process): def __init__(self, sim, address, port, map_path, free_move_only, hmac_key=HMAC_KEY_DEFAULT): Process.__init__(self, name='ExternalDataManager', sim=sim) self.sim = sim self.conn, child_conn = Pipe() self.service = ConnectionService(address, port, child_conn, map_path, free_move_only, hmac_key) self.service_process = MultiProcess(target=cherrypy.quickstart, args=(self.service, )) #self.service_process.daemon = True self.service_process.start() self.running = True self.free_move_only = free_move_only def run(self): for pers in self.sim.persons: if isinstance(pers, ExternalPerson): pers.current_coords = pers.current_coords_free_move pers.calculate_duration = pers.calculate_duration_free_move if self.free_move_only: self.sim.geo.free_obj.add(pers) while self.running: sim = self.sim geo = self.sim.geo while(self.conn.poll()): person_id, node_id_start, node_id_end, x, y, time_received = self.conn.recv() #person_id, node_id_start, node_id_end, x, y, time_received, lat, lon = self.conn.recv() person = sim.get_person(person_id) if person == None: print 'ExternalDataManager received unknown person id ', person_id, '. Discarded' continue if not isinstance(person, ExternalPerson): print 'Received ID ', person_id, ' does not belong to external person. Discarded' continue person.last_received_coords = [x, y] if node_id_start is not None: if person in self.sim.geo.free_obj: print 'Removing person with ID ', person_id, ' from free objects set!' self.sim.geo.free_obj.remove(person) person.new_next_node = geo.way_nodes_by_id[geo.map_osmnodeid_nodeid[node_id_end]] person.new_last_node = geo.way_nodes_by_id[geo.map_osmnodeid_nodeid[node_id_start]] person.need_next_target = True else: print 'Free move or no match found; free moving!' self.sim.geo.free_obj.add(person) #for m in sim.monitors: # if isinstance(m, SocketPlayerMonitor): # m.add_heatmap_blip(lat, lon, 3, (0.0, 0.0, 1.0, 0.4)) #lon, lat = utm.utm_to_latlong(x, y, sim.geo.zone) #for m in sim.monitors: # if isinstance(m, SocketPlayerMonitor): # m.add_heatmap_blip(lat, lon, 3, (1.0, 0.0, 0.0, 0.4)) self.interrupt(person) yield hold, self, 1 def shutdown(self): self.service_process.terminate()
class DataPump: def __init__(self, fname, t0=0.0): """ """ self.fname = fname self._data_end, self._control_end = Pipe() self.process = Process(target=self._read_data, args=()) self.process.start() self._control_end.send((True, t0)) if self._control_end.poll(5.): self.dt = self._control_end.recv() else: warnings.warn("dt could not be retrived from video, waited 5 s", RuntimeWarning) self.dt = np.nan def _read_data(self): """ """ vr = VideoReader(self.fname, color=False) self._data_end.send(vr.dt_ns * 1e-9) running = True while running: if self._data_end.poll(): # See if msg sent from get_data running, next_t = self._data_end.recv() # get the time of the frame to read (from get_data) if running: data = vr.get_frame(next_t) # Read video frame curr_t = vr.get_current_position(fmt='time') # get time of frame from video, should be very close to self.data_t self._data_end.send((data, curr_t)) # Send data via the pipe to get_data vr.close() def get_data(self, next_t): """ Ask for a future frame and returns the previously asked for. """ # Get previous frame and time of frame via the pipe from self._read_data data, curr_t = self._control_end.recv() # Tell self._read_data to read a new frame at time next_t self._control_end.send((True, next_t)) return data, curr_t def close(self): """ """ self._control_end.send((False, None)) self._control_end.close() self._data_end.close() self.process.join()
class SimpleQueue(object): def __init__(self): self._reader, self._writer = Pipe(duplex=False) self._rlock = Lock() if sys.platform == 'win32': self._wlock = None else: self._wlock = Lock() self._make_methods() return def empty(self): return not self._reader.poll() def __getstate__(self): assert_spawning(self) return (self._reader, self._writer, self._rlock, self._wlock) def __setstate__(self, state): self._reader, self._writer, self._rlock, self._wlock = state self._make_methods() def _make_methods(self): recv = self._reader.recv racquire, rrelease = self._rlock.acquire, self._rlock.release def get(): racquire() try: return recv() finally: rrelease() self.get = get if self._wlock is None: self.put = self._writer.send else: send = self._writer.send wacquire, wrelease = self._wlock.acquire, self._wlock.release def put(obj): wacquire() try: return send(obj) finally: wrelease() self.put = put return
def start_kernel(self, kernel_id=None, config=None, resource_limits=None): """ A function for starting new kernels by forking. :arg str kernel_id: the id of the kernel to be started. If no id is passed, a uuid will be generated. :arg Ipython.config.loader config: kernel configuration. :arg dict resource_limits: a dict with keys resource.RLIMIT_* (see config_default documentation for explanation of valid options) and values of the limit for the given resource to be set in the kernel process :returns: kernel id and connection information which includes the kernel's ip, session key, and shell, heartbeat, stdin, and iopub port numbers :rtype: dict """ kernel_logger.debug("start_kernel with config %s", config) if kernel_id is None: kernel_id = str(uuid.uuid4()) if config is None: config = Config({"ip": self.ip}) if resource_limits is None: resource_limits = {} config.HistoryManager.enabled = False dir = os.path.join(self.dir, kernel_id) try: os.mkdir(dir) except OSError: # TODO: take care of race conditions and other problems with us # using an 'unclean' directory pass currdir = os.getcwd() os.chdir(dir) p, q = Pipe() proc = Process(target=self.fork_kernel, args=(config, q, resource_limits)) proc.start() os.chdir(currdir) # todo: yield back to the message processing while we wait for i in range(5): if p.poll(1): connection = p.recv() p.close() self.kernels[kernel_id] = (proc, connection) return {"kernel_id": kernel_id, "connection": connection} else: kernel_logger.info("Kernel %s did not start after %d seconds." % (kernel_id[:4], i)) p.close() self.kill_process(proc) raise KernelError("Kernel start timeout.")
def start_proc_thread_func(): # start a child process running a pyro server and get the uri parent_conn, child_conn = Pipe() process = Process(target=_start_remote_server, args=(sys.argv, child_conn)) process.daemon = True process.start() timeout = time.clock() + 60 while process.is_alive() and time.clock() < timeout: if parent_conn.poll(1): break else: raise Exception("failed to start sub-process") uri = parent_conn.recv() server = Pyro4.Proxy(uri) server._pyroOneway.add("shutdown") return process, server