class SessionManager(GenericSessionManager): """ In memory session manager implementation class """ def __init__(self, timeout, **kwargs): GenericSessionManager.__init__(self, timeout) self._sessions = {} self._list = [] self._is_active = True self._expire_thread = Thread(target=self._expire_sessions, name='Session expriration thread') def init_expiration_mechanism(self): if not self._expire_thread.isAlive(): self._expire_thread.start() def _expire_sessions(self): from porcupine.core.runtime import logger while self._is_active: expire_threshold = time.time() - self.timeout - \ self.revive_threshold for sessionid in self._list: session = self.get_session(sessionid) if session._last_accessed < expire_threshold: logger.debug('Expiring Session: %s' % sessionid) session.terminate() logger.debug('Total active sessions: %s' % \ str(len(self._list))) else: break time.sleep(3.0) def create_session(self, userid): session = Session(userid, {}) self._sessions[session.sessionid] = session self._list.append(session.sessionid) return session def get_session(self, sessionid): session = self._sessions.get(sessionid, None) return session def remove_session(self, sessionid): self._list.remove(sessionid) del self._sessions[sessionid] def revive_session(self, session): # move sessionid at the end of the list self._list.append(session.sessionid) self._list.remove(session.sessionid) # update last access time session._last_accessed = time.time() def close(self): self._is_active = False if self._expire_thread.isAlive(): self._expire_thread.join() # remove temporary files for sessionid in self._list: self._sessions.get(sessionid).remove_temp_files()
class Cam(object): def __init__(self, url, bubbler, user=None, password=None, upload_interval_seconds=60): self.user=user self.password=password self.bubbler=bubbler self.upload_interval_seconds = upload_interval_seconds if user is not None and password is not None: self.stream = requests.get(url, auth=(self.user,self.password), stream=True) else: self.stream = requests.get(url, stream=True) self.thread_cancelled = False self.thread = Thread(target=self.run) print "camera initialized" def start(self): self.thread.start() print "camera stream started" def run(self): bytes='' polling_start = time.time() prev_img = None diff_df = pd.DataFrame() while not self.thread_cancelled: try: cur_time = time.time() if cur_time - polling_start > self.upload_interval_seconds: polling_start = cur_time self.bubbler.process_buffer(diff_df) diff_df = pd.DataFrame() bytes+=self.stream.raw.read(1024) a = bytes.find('\xff\xd8') b = bytes.find('\xff\xd9') if a!=-1 and b!=-1: jpg = bytes[a:b+2] bytes= bytes[b+2:] img = cv2.imdecode(np.fromstring(jpg, dtype=np.uint8),cv2.IMREAD_GRAYSCALE) if prev_img is not None: diff = self.bubbler.imgdiff(img, prev_img) diff_df = diff_df.append(pd.Series({'t':time.time(), 'ctime':time.ctime(), 'diff':diff}), ignore_index=True) prev_img = img except ThreadError: print 'Caught thread error...' self.thread_cancelled = True def is_running(self): return self.thread.isAlive() def shut_down(self): self.thread_cancelled = True print 'Shutting down' #block while waiting for thread to terminate while self.thread.isAlive(): time.sleep(100) return True
def run(): conf = get_config() day = Thread(target=daily) hour = Thread(target=hourly) while True: if not day.isAlive(): # Restart the VPN once per day print("Daily restart of VPN at {}".format(datetime.now())) restart_vpn(conf) day = Thread(target=daily) day.start() if not hour.isAlive(): # do port_update every 10 min, unless connection problems, then try # every 30 seconds. try: port_update(conf) except URLError: print("Port update failed: restarting " "VPN at {}".format(datetime.now())) restart_vpn(conf) sleep(30) else: hour = Thread(target=hourly) hour.start() sleep(10) if not check_running(conf): restart_vpn(conf)
def ssh_run(self, cmd, checkRC=True, waitForCompletion=True): def target(p): p.wait() [t.join() for t in ts] self.print_write("launching subprocess: %s" % cmd) p = Popen(SSH_CMD + "%s %s" % (self.host, cmd), shell=True, stdout=PIPE, stderr=PIPE, preexec_fn=self.preexec) ts = [Thread(target=self.std_listen, args=(p.stdout, self.out))] ts += [Thread(target=self.std_listen, args=(p.stderr, self.out))] [t.start() for t in ts] t = Thread(target=target, args=(p,)) t.start() while waitForCompletion or self.goOnEvent.isSet(): t.join(1) if not t.isAlive(): break if t.isAlive(): os.kill(p.pid, signal.SIGTERM) self.print_write("finished running subprocess: %s" % cmd) if checkRC and self.goOnEvent.isSet(): rc = p.returncode if rc is not 0: c = SSH_CMD + "%s %s" % (self.host, cmd) raise Exception( "subprocess.CalledProcessError: Command '%s'" "returned non-zero exit status %s" % (c, rc) )
def testMainLoopStops(self): t = Thread(target = self.connection.main_loop) t.start() self.assertTrue(t.isAlive()) self.connection.sock.put("") # End of data signal # Wait for the shutdown. sleep(0.001) self.assertFalse(t.isAlive())
def main(args): syslog.openlog("config-manager", syslog.LOG_PID) pdlogs.STARTUP.log() try: arguments = docopt(__doc__, argv=args) except DocoptExit: pdlogs.EXITING_BAD_CONFIG.log() raise local_ip = arguments['--local-ip'] local_site = arguments['--local-site'] log_dir = arguments['--log-directory'] log_level = LOG_LEVELS.get(arguments['--log-level'], logging.DEBUG) stdout_err_log = os.path.join(log_dir, "config-manager.output.log") if not arguments['--foreground']: utils.daemonize(stdout_err_log) logging_config.configure_logging(log_level, log_dir, "config-manager", show_thread=True) # urllib3 logs a WARNING log whenever it recreates a connection, but our # etcd usage does this frequently (to allow watch timeouts), so deliberately # ignore this log urllib_logger = logging.getLogger('urllib3') urllib_logger.setLevel(logging.ERROR) utils.install_sigusr1_handler("config-manager") # Drop a pidfile. pid = os.getpid() with open(arguments['--pidfile'], "w") as pidfile: pidfile.write(str(pid) + "\n") plugins_dir = "/usr/share/clearwater/clearwater-config-manager/plugins/" plugins = load_plugins_in_dir(plugins_dir) plugins.sort(key=lambda x: x.key()) threads = [] files = [p.file() for p in plugins] alarm = ConfigAlarm(files) for plugin in plugins: syncer = EtcdSynchronizer(plugin, local_ip, local_site, alarm) thread = Thread(target=syncer.main, name=plugin.__class__.__name__) thread.start() threads.append(thread) _log.info("Loaded plugin %s" % plugin) while any([thread.isAlive() for thread in threads]): for thread in threads: if thread.isAlive(): thread.join(1) _log.info("Clearwater Configuration Manager shutting down") pdlogs.EXITING.log() syslog.closelog()
def run(): t = Thread(target=test1) t.start() t.join(2) print t.isAlive() t.join() print "over"
class TimeoutProcess(): '''Runs an external command until timeout is reached Assumes that Popen uses PIPE for stdin, stdout and stderr Data for stdin may be supplied on instantiation, stdout and stderr will be returned from the call.''' def __init__(self): self.argv = None self.timeout = None self.stdin = None self.stdout = '' self.stderr = '' self.p = None self.t = None self.returncode = -127 def __call__(self, argv, timeout, stdin=None, **kwargs): '''Run external command argv until timeout is reached If stdin is not none the data will be supplied to the processes stdin. Remaining kwargs will be passed to Popen. stderr and stdout are always strings, returncode is -1 if timeout occured''' self.argv = argv self.timeout = timeout self.stdin = stdin def target(): self.p = Popen(self.argv, stdin=PIPE, stdout=PIPE, stderr=PIPE, **kwargs) (self.stdout, self.stderr) = self.p.communicate(self.stdin) self.returncode = self.p.returncode self.t = Thread(target=target) self.t.start() self.t.join(self.timeout) if self.t.isAlive(): # In strange cases, there is no subprocess... if self.p: log.debug("Terminating process %d in thread %s" % (self.p.pid, self.t.name)) self.p.terminate() self.t.join(THREADKILLTIMEOUT) if self.t.isAlive(): log.debug("Killing process %d in thread %s" % (self.p.pid, self.t.name)) self.p.kill() self.stderr += '\nTimeout occured\n' self.returncode = -1 else: log.warn('No subprocess found :-/') return process(self.returncode, self.stdout, self.stderr)
def test4_MaxConnections(self): from DBUtils.PooledPg import TooManyConnections pool = PooledPg(1, 2, 3) self.assertEqual(pool._cache.qsize(), 1) cache = [] for i in range(3): cache.append(pool.connection()) self.assertEqual(pool._cache.qsize(), 0) self.assertRaises(TooManyConnections, pool.connection) pool = PooledPg(0, 1, 1, False) self.assertEqual(pool._blocking, 0) self.assertEqual(pool._cache.qsize(), 0) db = pool.connection() self.assertEqual(pool._cache.qsize(), 0) self.assertRaises(TooManyConnections, pool.connection) pool = PooledPg(1, 2, 1) self.assertEqual(pool._cache.qsize(), 1) cache = [] cache.append(pool.connection()) self.assertEqual(pool._cache.qsize(), 0) cache.append(pool.connection()) self.assertEqual(pool._cache.qsize(), 0) self.assertRaises(TooManyConnections, pool.connection) pool = PooledPg(3, 2, 1, False) self.assertEqual(pool._cache.qsize(), 3) cache = [] for i in range(3): cache.append(pool.connection()) self.assertEqual(pool._cache.qsize(), 0) self.assertRaises(TooManyConnections, pool.connection) pool = PooledPg(1, 1, 1, True) self.assertEqual(pool._blocking, 1) self.assertEqual(pool._cache.qsize(), 1) db = pool.connection() self.assertEqual(pool._cache.qsize(), 0) def connection(): pool.connection().query('set thread') from threading import Thread thread = Thread(target=connection) thread.start() thread.join(0.1) self.assert_(thread.isAlive()) self.assertEqual(pool._cache.qsize(), 0) session = db._con.session self.assertEqual(session, []) del db thread.join(0.1) self.assert_(not thread.isAlive()) self.assertEqual(pool._cache.qsize(), 1) db = pool.connection() self.assertEqual(pool._cache.qsize(), 0) self.assertEqual(session, ['thread'])
def run(self, **kwargs): super(MultiProcessingDependencyGraphRunner, self).run(**kwargs) import multiprocessing # Set up pool of evaluation workers. self.evaluation_pool = multiprocessing.Pool(processes=self.pool_size) # Set up a 'shared memory' dependency graph. self.manager = multiprocessing.Manager() self.execution_queue = self.manager.Queue() self.result_queue = self.manager.Queue() self.results_repo = self.manager.dict() self.calls_dict = self.manager.dict() self.calls_dict.update(self.dependency_graph.call_requirements) self.dependencies = self.manager.dict() self.dependencies.update(self.dependency_graph.dependencies) self.dependents = self.manager.dict() self.dependents.update(self.dependency_graph.dependents) self.errors = [] # if 'all_market_prices' in self.run_kwds: # all_market_prices = self.run_kwds.pop('all_market_prices') # all_market_prices_dict = self.manager.dict() # for market_name, market_prices in all_market_prices.items(): # all_market_prices_dict[market_name] = market_prices.copy() # # market_prices_dict = self.manager.dict() # # all_market_prices_dict[market_name] = market_prices_dict # # for fixing_date, market_price in market_prices.items(): # # market_prices_dict[fixing_date] = market_price # self.run_kwds['all_market_prices'] = all_market_prices_dict evaluation_thread = Thread(target=self.evaluate_calls) evaluation_thread.daemon = True evaluation_thread.start() results_thread = Thread(target=self.handle_results) results_thread.daemon = True results_thread.start() # Put the leaves on the execution queue. for call_requirement_id in self.dependency_graph.leaf_ids: self.execution_queue.put(call_requirement_id) while results_thread.isAlive() and evaluation_thread.isAlive(): sleep(1) if evaluation_thread.isAlive(): self.execution_queue.put(None) evaluation_thread.join() if results_thread.isAlive(): self.result_queue.put(None) results_thread.join() if self.errors: raise self.errors[0]
class PSTracker(object): """ Tracker module for PS """ def __init__(self, hostIP, cmd, port=9091, port_end=9999, envs=None): """ Starts the PS scheduler """ self.cmd = cmd if cmd is None: return envs = {} if envs is None else envs self.hostIP = hostIP sock = socket.socket(get_family(hostIP), socket.SOCK_STREAM) for port in range(port, port_end): try: sock.bind(('', port)) self.port = port sock.close() break except socket.error: continue env = os.environ.copy() env['DMLC_ROLE'] = 'scheduler' env['DMLC_PS_ROOT_URI'] = str(self.hostIP) env['DMLC_PS_ROOT_PORT'] = str(self.port) for k, v in envs.items(): env[k] = str(v) self.thread = Thread( target=(lambda: subprocess.check_call(self.cmd, env=env, shell=True)), args=()) self.thread.setDaemon(True) self.thread.start() def join(self): if self.cmd is not None: while self.thread.isAlive(): self.thread.join(100) def slave_envs(self): if self.cmd is None: return {} else: return {'DMLC_PS_ROOT_URI': self.hostIP, 'DMLC_PS_ROOT_PORT': self.port} def alive(self): if self.cmd is not None: return self.thread.isAlive() else: return False
def reindex_all(types = None, delete_all_first=False): """ Called from `paster run` to totally re-index everything in the database. Spawns a thread to connect to Solr, and sends it tokenised Things """ global indexed_types start_t = datetime.now() if not types: types = indexed_types # We don't want the default thread-local cache (which is just a # dict) to grow un-bounded (normally, we'd use # utils.set_emptying_cache, except that that preserves memcached, # and we don't even want to get memcached for total indexing, # because it would dump out more recent stuff) g.cache.caches = (SelfEmptyingCache(),) # + g.cache.caches[1:] count = 0 q=Queue(100) indexer=Thread(target=indexer_worker, args=(q,delete_all_first)) indexer.start() try: for cls in types: for batch in fetch_batches(cls,1000, timeago("50 years"), start_t): r = tokenize_things([ x for x in batch if not x._spam and not x._deleted ]) count += len(r) print ("Processing %s #%d(%s): %s" % (cls.__name__, count, q.qsize(), r[0]['contents'])) if indexer.isAlive(): q.put(r) else: raise Exception("'tis a shame that I have but one thread to give") q.put("done") indexer.join() except object,e: if indexer.isAlive(): q.put(e,timeout=30) raise e
def controller(): global kontroll t1 = Thread(target=kaamerapilt) t2 = Thread(target=loogika2) katse = "STOP" while True: if katse == "START": kontroll = True if not t1.isAlive() and not t2.isAlive(): t2.start() t1.start() if katse == "STOP": kontroll = False print (t1.isAlive())
def play(self, position, graph, goal, time): startTime=clock() self.timeout=False # Search only on pertinent edges interestingGraph=getInterestingGraph(position, graph, goal) # At least, always try with a level 1 search thread = Thread(target = self.blockerThread, args=(position,interestingGraph,goal)) thread.start() thread.join(startTime-clock()+time) self.move=self.blockerPlay(position,interestingGraph,goal, 0, -10000, 10000) if thread.isAlive(): self.timeout=True self.maxLevel-=1 writeIntoFile('timeout level 0') r=RandomBlocker() r.randomSearch(position,graph,interestingGraph,goal,time) return # Loop for trying differents depths if clock()-startTime<time: while self.move[0]!=10000 and self.maxLevel<10 and not self.timeout: self.maxLevel+=1 thread = Thread(target = self.blockerThread, args=(position,interestingGraph,goal)) thread.start() thread.join(startTime-clock()+time) if thread.isAlive(): self.timeout=True self.maxLevel-=1 writeIntoFile('timeout level '+str(self.maxLevel)) if self.move[0]==10000: self.maxLevel-=2 else: self.maxLevel-=1 # If not move is found, remove the first edge if(self.move[1]==(-1,-1)): for (a,b) in enumerate(interestingGraph): for (c,d) in enumerate(b): if d>0: self.move=(-10000,(a,c)) writeIntoFile('removed'+str(self.move[1])) graph[self.move[1][0]][self.move[1][1]]-=1 if self.move[0]>self.bestScore: self.bestScore=self.move[0] return graph[self.move[1][0]][self.move[1][1]]
def testScapyThread(): import socket_scapy,select from threading import Thread port=22 sshfilter="tcp and port %d"%(port) soscapy=socket_scapy.socket_scapy(sshfilter,packetCount=100) log.info('Please make some ssh traffic') sniffer = Thread(target=soscapy.run) sniffer.start() # sniffer is strted, let's consume nbblocks=0 data='' readso=soscapy.getInboundSocket() while sniffer.isAlive(): r,w,oo=select.select([readso],[],[],1) if len(r)>0: data+=readso.recv(16) nbblocks+=1 # try to finish socket print 'sniffer is finished' r,w,oo=select.select([readso],[],[],0) while len(r)>0: data+=readso.recv(16) nbblocks+=1 r,w,oo=select.select([readso],[],[],0) #end print "received %d blocks/ %d bytes"%(nbblocks,len(data)) print 'sniffer captured : ',soscapy
def describeBoard(self, copyToClipboard=False): selectedText = self.getSelection() if selectedText: # Search a valid code into selected text description = None c = 0 l = len(selectedText) timeForSearching = Thread(target=sleep, args=(0.2,)) timeForSearching.start() while not description and c < l-16: if not timeForSearching.isAlive(): ui.message(_("Too much text has been selected")) return() description = fen.decode(selectedText[c:], fen.notations[fen.notationLanguage][1]) c = c+1 if description: if copyToClipboard: win32clipboard.OpenClipboard() win32clipboard.EmptyClipboard() win32clipboard.SetClipboardText(description) win32clipboard.CloseClipboard() ui.message(_("Copied to clipboard")) ui.message(description) else: ui.message(_("Selected text doesn't contains a valid FEN code")) else: ui.message(_("There is not selected text"))
def sign_up(self, username): def confirm(login): return message_box( self.res["confirm_text"].format(login), QtGui.QMessageBox.Yes | QtGui.QMessageBox.No, QtGui.QMessageBox.Question, self.res["confirm_title"], self.icon_wnd ) pattern = r"[0-9A-Za-z]{4,}" result = match(pattern, username) if not result or len(result.group()) != len(username): return False if self.db.check_user(username) and confirm(username): result = [None] t1 = Thread(target=self.get_keys, args=(result,)) t1.start() self.label.setText(self.res["msg_gen_start"]) # wait thread self.setEnabled(False) while t1.isAlive(): self.app.processEvents() self.setEnabled(True) if result[0]: return self.db.insert_users( [self.pubkey_in_md5, username] ) else: return False else: return False
def test_multiple_simultaneous_hits(self): # Given results = Queue() def run_code(): """Run an infinite loop.""" testdata = {"user_answer": "while True: pass", "test_case_data": [{"test_case": "assert 1==2"}]} result = self.code_server.run_code("python", "standardtestcase", json.dumps(testdata), "") results.put(json.loads(result)) N = 10 # When import time threads = [] for i in range(N): t = Thread(target=run_code) threads.append(t) t.start() for t in threads: if t.isAlive(): t.join() # Then self.assertEqual(results.qsize(), N) for i in range(N): data = results.get() self.assertFalse(data["success"]) self.assertTrue("infinite loop" in data["error"])
class Dali(object): CONNECTION_TIMEOUT = 5 # in seconds def __init__(self, driver): """ :type driver: Remote """ port = get_free_port() self.server = Thread(target=run, args=(port,)) self.server.daemon = True self.server.start() ### @todo add returncode managment if not self.server.isAlive(): raise Exception("Server didn't start") else: pass t = time.time() while not is_connectable(port) and time.time() - t < self.CONNECTION_TIMEOUT: time.sleep(0.1) if not is_connectable(port): raise DaliServerConnectionError("Couldn't connect to Dali server on port %s", port) try: self.transport = TSocket.TSocket("localhost", port) self.transport = TTransport.TBufferedTransport(self.transport) protocol = TBinaryProtocol.TBinaryProtocol(self.transport) self.client = TDali.Client(protocol) self.transport.open() self.client.init(driver.command_executor._url, json.dumps(driver.capabilities)) self.transport.close() except TException, e: ### @todo error handling print "%s" % e.message
def load_images(image_url_list, dir_, failed_image_urls_file, delay=5): """ Loading list of images :param image_url_list: list of image urls :param dir_: destination dir :param failed_image_urls_file: name of file with unsuccessful urls :param delay: delay for thread :return:None """ abs_failed_image_urls_file = os.path.join(dir_, failed_image_urls_file) if not os.path.exists(abs_failed_image_urls_file): with open(abs_failed_image_urls_file, 'w') as _: pass for index, image in enumerate(image_url_list): f = os.path.join(dir_, image.split('/')[-1]) if os.path.exists(f): print("file ", f, " exist now") else: print('downloading {}: {}...'.format(index, f)) t = Thread(target=Internet.load_image_chunk, args=(image, f, dir_)) t.start() t.join(delay) if t.isAlive(): print('Bad, bad thread!') if abs_failed_image_urls_file is not None: Internet.write_to_failed_image_urls_file(f, image, abs_failed_image_urls_file)
class TestFrame(wx.Frame): def __init__(self): wx.Frame.__init__(self, None, -1, "Test") panel = wx.Panel(self, -1) sizer = wx.BoxSizer(wx.VERTICAL) panel.SetSizer(sizer) self.button = wx.Button(panel, 0, "Start") sizer.Add(self.button, 0, wx.ALIGN_LEFT) self.button.Bind(wx.EVT_BUTTON, self.OnButton) self.text = wx.StaticText(panel, 0, "No test is running") sizer.Add(self.text, 0, wx.ALIGN_LEFT) self.timer = wx.Timer(self) def OnButton(self, event): self.text.SetLabel("Running") self.button.Disable() self.Bind(wx.EVT_TIMER, self.PollThread) self.timer.Start(20, oneShot=True) self.testThread = Thread(target=test1) self.testThread.start() event.Skip() def PollThread(self, event): if self.testThread.isAlive(): self.Bind(wx.EVT_TIMER, self.PollThread) self.timer.Start(200, oneShot=True) self.text.SetLabel(self.text.GetLabel() + ".") else: self.button.Enable() self.text.SetLabel("Test completed")
def run(self, tasks): import time from Queue import Queue from threading import Thread def _job_core(tasks): while tasks.qsize() > 0: if self.lock.acquire(): task = tasks.get() self.lock.release() code, msg = task() log(">> [%s] : %s" % (task.name, msg)) if isinstance(code, int): exit(code) if tasks.qsize() != 0: log(" Reaming %d." % (tasks.qsize())) tasks.task_done() JOBS_SIZE = 5 runningTasks = Queue() # Run tasks with job size for task in tasks: runningTasks.put(task) runners = [] for i in xrange(JOBS_SIZE): runner = Thread(target = _job_core, args = (runningTasks,)) runner.daemon = True runner.start() runners.append(runner) # Wait all tasks complete, It can response Ctrl + C interrupt. while any(runner.isAlive() for runner in runners): time.sleep(1) runningTasks.join()
def chat(): StrangerID = Omegle.startSession() if StrangerID == "": print("Error, network is down or nobody wanted to chat.\n") else: print("Started session with the ID: {0}\n".format(StrangerID) ) EventsThread = Thread(target=pollEvents, args=[StrangerID]) EventsThread.start() while EventsThread.isAlive(): Message = input("> ") # We "start typing" after we get our message because omeglers will think we've been typing for a long time # when infact we've been waiting for their message (learned this the hard way, lost lots of potential friends ;_;) Omegle.startTyping(StrangerID) time.sleep(len(Message) / 8) # Typing at eight characters a second Omegle.say(Message, StrangerID) Omegle.stopTyping(StrangerID) Omegle.endSession(StrangerID)
def run_in_background(target, *args, **kwargs): event = Event() future = Future() def extended_target(*args, **kwargs): try: future.set_result(target(*args, **kwargs)) except Exception as ex: future.set_exception(ex) finally: event.set() thread = Thread(target=extended_target, args=args, kwargs=kwargs) thread.start() exception = None try: yield event except Exception as ex: exception = ex finally: if not exception: future.result(timeout=5) else: raise thread.join(timeout=5) assert not thread.isAlive()
def wait_for_tools_with_timeout(self, timeout, error_fname): """Wait for VMWare Tools to start. Returns True on success and False when the VMWare tools did not start properly in the given timeout. Writes error messages to `error_fname`. """ if timeout > 0: _logger.info('Waiting for VMWare Tools with a timeout of %d seconds' % timeout) tools_thd = Thread(target = self._wait_for_tools) tools_thd.start() # normally the thread will end before the timeout expires, so a high timeout tools_thd.join(timeout) if not tools_thd.isAlive(): return True _logger.error('Timeout waiting for VMWare Tools to start. ' + 'Make sure your virtual machine boots up correctly ' + 'and that you have VMWare Tools installed.') with open(error_fname, 'a') as handler: print >> handler, 'Timeout waiting for VMWare Tools to start.\n' + \ 'Make sure your virtual machine boots up corectly\n' + \ 'and that you have VMWare Tools installed.\n' return False
def runElection(self): if not self.frame.breakTiesRandomly: self.e.strongTieBreakMethod = "manual" self.e.breakTieRequestQueue = Queue(1) self.e.breakTieResponseQueue = Queue(1) countThread = Thread(target=self.e.runElection) countThread.start() # Display a progress dialog dlg = wx.ProgressDialog(\ "Counting votes", "Counting votes using %s\nInitializing..." % self.e.longMethodName, parent=self.frame, style = wx.PD_APP_MODAL | wx.PD_ELAPSED_TIME ) while countThread.isAlive(): sleep(0.1) if not self.e.breakTieRequestQueue.empty(): [tiedCandidates, names, what] = self.e.breakTieRequestQueue.get() c = self.askUserToBreakTie(tiedCandidates, names, what) self.e.breakTieResponseQueue.put(c) if "R" in vars(self.e): status = "Counting votes using %s\nRound: %d" % \ (self.e.longMethodName, self.e.R+1) else: status = "Counting votes using %s\nInitializing..." % \ self.e.longMethodName dlg.Pulse(status) dlg.Destroy()
def test_monitor_log(self): """Tests log monitoring by writing to a log in the background thread""" node = self.account_service.nodes[0] # Make sure we start the log with some data, including the value we're going to grep for self.account_service.write_to_log("foo\nbar\nbaz") # Background thread that simulates a process writing to the log self.wrote_log_line = False def background_logging_thread(): # This needs to be large enough that we can verify we've actually # waited some time for the data to be written, but not too long that # the test takes a long time time.sleep(3) self.wrote_log_line = True self.account_service.write_to_log("foo\nbar\nbaz") with node.account.monitor_log(self.account_service.log_file) as monitor: logging_thread = Thread(target=background_logging_thread) logging_thread.start() monitor.wait_until('foo', timeout_sec=10, err_msg="Never saw expected log") assert self.wrote_log_line logging_thread.join(5.0) if logging_thread.isAlive(): raise Exception("Timed out waiting for background thread.")
def deadlocks(f, t): th = Thread(target = f) th.setName("Thread") th.setDaemon(1) th.start() th.join(t) return th.isAlive()
class threadWrapper(object): def __init__(self, func): self.func = func self.results = queue.Queue() def run(self, *args, **kwargs): # create a thread to run the function in self.thread = Thread(target=self.f, args=args, kwargs=kwargs) # start the thread self.thread.start() def f(self, *args, **kwargs): res = self.func(*args, **kwargs) self.results.put(res) def close(self): self.thread.join() def result(self): results = None if not self.results.empty(): results = self.results.get() return results def isAlive(self): return self.thread.isAlive() def join(self): self.thread.join()
def test_cbcollectinfo_memory_usuage(self): """ Test to make sure cbcollectinfo did not use a lot of memory. We run test with 200K items with size 128 bytes """ gen_load = BlobGenerator('cbcollect', 'cbcollect-', self.value_size, end=200000) self._load_all_buckets(self.master, gen_load, "create", 0) self._wait_for_stats_all_buckets(self.servers[:self.num_servers]) self.log.info("Delete old logs files") self.shell.delete_files("%s.zip" % (self.log_filename)) self.log.info("Delete old logs directory") self.shell.delete_files("cbcollect_info*") options = "" if self.collect_all_option: options = "--multi-node-diag" self.log.info("Run collect log with --multi-node-diag option") collect_threads = [] col_thread = Thread(target=self.shell.execute_cbcollect_info, args=("%s.zip" % (self.log_filename), options)) collect_threads.append(col_thread) col_thread.start() monitor_mem_thread = Thread(target=self._monitor_collect_log_mem_process) collect_threads.append(monitor_mem_thread) monitor_mem_thread.start() self.thred_end = False while not self.thred_end: if not col_thread.isAlive(): self.thred_end = True for t in collect_threads: t.join()
class _ReverseForwarder(object): """ Runs reverse forwarding of a port on a node to a local port. This allows you to setup a server on the test driver that only assumes we have basic SSH access that ducktape guarantees is available for worker nodes. """ def __init__(self, logger, node, remote_port, local_port): self.logger = logger self._node = node self._local_port = local_port self._remote_port = remote_port self.logger.debug('Forwarding %s port %d to driver port %d', node, remote_port, local_port) self._stopping = False self._transport = node.account.ssh_client.get_transport() self._transport.request_port_forward('', remote_port) self._accept_thread = Thread(target=self._accept) self._accept_thread.start() def stop(self): self._stopping = True self._accept_thread.join(30) if self._accept_thread.isAlive(): raise RuntimeError("Failed to stop reverse forwarder on %s", self._node) self._transport.cancel_port_forward('', self._remote_port) def _accept(self): while not self._stopping: chan = self._transport.accept(1) if chan is None: continue thr = Thread(target=self._handler, args=(chan, )) thr.setDaemon(True) thr.start() def _handler(self, chan): sock = socket.socket() try: sock.connect(("localhost", self._local_port)) except Exception as e: self.logger.error('Forwarding request to port %d failed: %r', self._local_port, e) return self.logger.log(TRACE, 'Connected! Tunnel open %r -> %r -> %d', chan.origin_addr, chan.getpeername(), self._local_port) while True: r, w, x = select([sock, chan], [], []) if sock in r: data = sock.recv(1024) if len(data) == 0: break chan.send(data) if chan in r: data = chan.recv(1024) if len(data) == 0: break sock.send(data) chan.close() sock.close() self.logger.log(TRACE, 'Tunnel closed from %r', chan.origin_addr)
class Scene(object): def __init__(self, path, msize=1000.0, nx=5, nz=5): '''class for managing scenery objects in the background of a 1st person navigation game. ''' self.scenery_list = {} self.texture_list = {} self.draw_list = [] self.models = {} self.path = path self.msize = msize self.nx = nx self.nz = nz self.thr = Thread(target=load_scenery) self.thr.daemon = True self.thr.start() def do_pickle(self, fog=((0.3, 0.3, 0.4, 0.95), 450.0)): '''run once to save pkl files from ElevationMaps and Models combined as MergeShapes as defined in the SceneryItem objects listed in scenery_list ''' for key in self.scenery_list: s_item = self.scenery_list[key] if s_item.put_on is None: #this is a map - do all these first pass LOGGER.debug('pickling %s', key) mymap = pi3d.ElevationMap(mapfile='{}/{}.png'.format( self.path, key), name=key, width=(self.msize + 0.001), depth=(self.msize + 0.001), height=s_item.height, x=s_item.x, y=s_item.y, z=s_item.z, divx=32, divy=32) mymap.set_fog(*fog) mymap.set_alpha(s_item.alpha) with open('{}/{}.pkl'.format(self.path, key), 'wb') as f: pickle.dump(mymap, f) s_item.shape = mymap # temp store all these for the sake of make_pickle for key in self.scenery_list: s_item = self.scenery_list[key] if s_item.put_on is not None: #model so need to put on map LOGGER.debug('pickling %s', key) md = s_item.model_details if not md['model'] in self.models: self.models[md['model']] = pi3d.Model( file_string='{}/{}.obj'.format(self.path, md['model'])) m_item = self.scenery_list[s_item.put_on] xpos = s_item.x - m_item.x # relative to map it's put on zpos = s_item.z - m_item.z mymerge = pi3d.MergeShape(name=key, x=s_item.x, z=s_item.z) mymerge.cluster(self.models[md['model']], m_item.shape, 0.0, 0.0, md['w'], md['d'], md['n'], key, md['maxs'], md['mins']) mymerge.set_fog(*fog) with open('{}/{}.pkl'.format(self.path, key), 'wb') as f: pickle.dump(mymerge, f) for key in self.scenery_list: #tidy up memory usage s_item = self.scenery_list[key] s_item.shape = None def _key_draw_list(self, s_item): '''function used by sorted to make drawing follow priority order ''' return s_item.priority def _key_age_list(self, key): '''function used by sorted to clear oldest unused items from draw_list ''' return self.scenery_list[key].last_drawn def check_scenery(self, xm, zm): '''checks the scenery_list for anything that needs to be loaded using a background thread. It wraps the x and z values as they go over the edge of the end tiles and returns a tuple of their values plus the key to the current elevation map to be used for ground following (defined as 'mapXY' where X and Y are the coordinates) ''' xsize = self.msize * self.nx zsize = self.msize * self.nz if xm > xsize: xm -= xsize if xm < 0.0: xm += xsize if zm > zsize: zm -= zsize if zm < 0.0: zm += zsize cmap_id = 'map{}{}'.format(int(xm / self.msize), int(zm / self.msize)) self.draw_list = [] for key in self.scenery_list: s_item = self.scenery_list[key] dx = s_item.x - xm offsetx = 0.0 if dx > xsize / 2.0: offsetx = -xsize if dx < -xsize / 2.0: offsetx = xsize dx += offsetx dz = s_item.z - zm offsetz = 0.0 if dz > zsize / 2.0: offsetz = -zsize if dz < -zsize / 2.0: offsetz = zsize dz += offsetz if (dx * dx + dz * dz) < s_item.threshold_sq: if s_item.status == 0: if not self.thr.isAlive(): self.thr = Thread(target=load_scenery) self.thr.daemon = True self.thr.start() s_item.status = 1 item = (key, self.path, s_item, self.texture_list, self.draw_list, offsetx, offsetz) QDOWN.put(item) elif s_item.status == 2: s_item.shape.position(s_item.x + offsetx, s_item.y, s_item.z + offsetz) s_item.last_drawn = time.time() self.draw_list.append(s_item) self.draw_list = sorted(self.draw_list, key=self._key_draw_list) cmap = self.scenery_list[cmap_id].shape return xm, zm, cmap #################### clear out unused scenery TODO clear unused textures too def clear_scenery(self, threshold): clear_list = sorted(self.scenery_list, key=self._key_age_list, reverse=True)[:-30] for key in clear_list: s_item = self.scenery_list[key] if s_item.last_drawn < threshold: s_item.status = 0 s_item.shape = None
class BitmexWebsocketApiWithHeartbeat(object): HEARTBEAT_INTERVAL = 5 HEARTBEAT_TIMEOUT = 10 RECONNECT_TIMEOUT = 5 def __init__(self, testnet=False): """Constructor""" self.ws = None self.wsThread = None self.active = False self.testnet = testnet self.heartbeatCount = 0 self.heartbeatCheckCount = 0 self.heartbeatThread = None self.heartbeatReceived = True self.connectEvent = Event() self.reconnecting = False self.reconnectTimer = None def get_host(self): return TESTNET_WEBSOCKET_HOST if self.testnet else WEBSOCKET_HOST def start(self, trace=False): """连接""" websocket.enableTrace(trace) self.initWebsocket() self.active = True self.heartbeatReceived = True def initWebsocket(self): """""" self.ws = websocket.WebSocketApp( self.get_host(), on_message=self.onMessageCallback, on_error=self.onErrorCallback, on_close=self.onCloseCallback, on_open=self.onOpenCallback, ) self.wsThread = Thread(target=self.ws.run_forever, kwargs=dict(sslopt={ "cert_reqs": ssl.CERT_NONE, "check_hostname": False }, )) self.wsThread.start() def doHeartbeat(self): d = "ping" self.ws.send(d) def heartbeat(self): while self.active: self.connectEvent.wait() self.heartbeatCount += 1 self.heartbeatCheckCount += 1 if self.heartbeatCount >= self.HEARTBEAT_INTERVAL: self.heartbeatCount = 0 try: self.doHeartbeat() except: msg = traceback.format_exc() self.onError(msg) self.reconnect() if self.heartbeatCheckCount >= self.HEARTBEAT_TIMEOUT: self.heartbeatCheckCount = 0 if not self.heartbeatReceived: self.reconnect() else: self.heartbeatReceived = False sleep(1) def reconnect(self): """重新连接""" if not self.reconnecting: self.reconnecting = True self.closeWebsocket() # 首先关闭之前的连接 # print('API断线重连') self.reconnectTimer = Timer(self.RECONNECT_TIMEOUT, self.connectEvent.set) self.connectEvent.clear() # 设置未连接上 self.initWebsocket() self.reconnectTimer.start() self.heartbeatReceived = True # avoid too frequent reconnect self.reconnecting = False def closeHeartbeat(self): """关闭接口""" if self.heartbeatThread and self.heartbeatThread.isAlive(): self.active = False self.heartbeatThread.join() self.heartbeatThread = None def closeWebsocket(self): """关闭WS""" if self.wsThread and self.wsThread.isAlive(): self.ws.close() if current_thread() != self.wsThread: self.wsThread.join(2) def close(self): """""" self.closeHeartbeat() self.closeWebsocket() def readData(self, evt): """解码推送收到的数据""" data = json.loads(evt) return data def onMessageCallback(self, ws, evt): """""" self.heartbeatReceived = True if evt != "pong": data = self.readData(evt) self.onData(data) #---------------------------------------------------------------------- def onErrorCallback(self, ws, evt): """""" if isinstance(evt, Exception): msg = traceback.format_exc() else: msg = str(evt) self.onError(msg) #---------------------------------------------------------------------- def onCloseCallback(self, ws): """""" self.onClose() #---------------------------------------------------------------------- def onOpenCallback(self, ws): """""" self.connectEvent.set() # 设置为连接上 if self.reconnectTimer: self.reconnectTimer.cancel() self.heartbeatReceived = True if not self.heartbeatThread: self.heartbeatThread = Thread(target=self.heartbeat) self.heartbeatThread.start() self.onConnect() def onData(self, data): """信息推送""" print('onData') def onError(self, data): """错误推送""" print('onError') def onClose(self): """接口断开""" print('onClose') def onConnect(self): """接口打开""" print('onConnect') def sendReq(self, req): """发出请求""" self.ws.send(json.dumps(req))
def trainNS(name,test,cside,start,canvas, device,font, fontT): print ("in the function") #to debug from time import time as getsecs from time import sleep #%%#####################################################################%%# #-------------------------------DEFINITIONS-------------------------------# ########################################################################### ##** LOGFILE **## print ("after import") logname = 'subjs/'+name+'/logs/'+name+'_test_'+test+'.csv' time = (datetime.datetime.now()-start).total_seconds() date = str(datetime.datetime.now()) with open(logname,'w') as log: log.write('datetime,time,event\n') log.write(date+','+str(time)+',TestStart\n') print ("after logfile") #start the video cam = picamera.PiCamera() cam.resolution = (1296,972) cam.framerate = 5 cam.start_recording('subjs/'+name+'/video/'+name+'_test_'+test+'.h264') epd = epd2in9.EPD() epd.init(epd.lut_partial_update) image = Image.open('screenImages/W.bmp') epd.set_frame_memory(image, 0, 0) epd.display_frame() #%%#####################################################################%%# #------------------------------STARTING PROGRAM---------------------------# # #definition of state variables c=0 w=0 # killing = False Cpressed = False Wpressed = False pos = 0 #current motor position # delivering = False # dropPresent = False # stepsnum = 33 #number of steps for a drop # # #-------------------------------------------------------------------------# ########################################################################### ################################################################### #-|-|-|-|-|-|-|-|-PRIME SCREEN AND BUTTONS|-|-|-|-|-|-|-|-|-|-|-|-# # # #make sure the screen is white W = Image.open('screenImages/W.bmp') B = Image.open('screenImages/B.bmp') if cside == 'left': photoCORRECT = pin.photoL photoWRONG = pin.photoR else: photoCORRECT = pin.photoR photoWRONG = pin.photoL epd.set_frame_memory(B, 0, 0) epd.display_frame() epd.set_frame_memory(B, 0, 0) epd.display_frame() epd.set_frame_memory(W, 0, 0) epd.display_frame() epd.set_frame_memory(W, 0, 0) epd.display_frame() # # #-|-|-|-|-|-|-|-|-|-|-|-|-|-|-|-|-|-|-|-|-|-|-|-|-|-|-|-|-|-|-|-|-# #%%######################################################################## #--------------------------------MAIN LOOP--------------------------------# while (True): now = getsecs() #%%/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/%%# #-------------------------FOR CORRECT RESISTOR------------------------# # # if not Cpressed: #if currently the correct button was not being pressed if GPIO.input(photoCORRECT): #but now it is print ("Cpressed") Cpressed = True #change state #logging # time = (datetime.datetime.now()-start).total_seconds() # date = str(datetime.datetime.now()) # with open(logname,'a') as log: log.write(date+','+str(time)+',Cpressed\n') # c+=1 # # # # # # # # # # # # # # # # correct button has become pressed # # # # # if not delivering and not dropPresent: # # delivering = True # delivering state # # #deliver the drop # # deliverer=Thread(name='Perist',target=drop.stepmove, # args=(pin.stp,pin.clk,0,stepsnum,pos)) # deliverer.start() # deliver a drop # # pos = drop.postrack(stepsnum,pos) # # # end # # # # # # # # # # # # # # # # # if Cpressed: #if is being pressed # if not GPIO.input(photoCORRECT): #but then is not print ("Crelease") Cpressed=False #logging # time = (datetime.datetime.now()-start).total_seconds() # date = str(datetime.datetime.now()) # with open(logname,'a') as log: log.write(date+','+str(time)+',Crelease\n') # waitforRetract = getsecs() #start waiting for retraction # # # #---------------------------------------------------------------------# #/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/# #%%/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/%%# #--------------------------FOR WRONG RESISTOR-------------------------# # # #if the wrong is pressed you need to do nothing but remove the drop if is currently present if not Wpressed: # if GPIO.input(photoWRONG): # Wpressed=True # print ("Wpressed") # time = (datetime.datetime.now()-start).total_seconds() # date = str(datetime.datetime.now()) # with open(logname,'a') as log: # log.write(date+','+str(time)+',Wpressed\n') # w+=1 # # # # # # # # # # # # # # # # wrong button has become pressed # # # # # if dropPresent: #if drop is present, remove retracter=Thread(name='suck',target=drop.dcmove,args=(pin.dc,3)) retracter.start() # dropPresent = False # #logging # time = (datetime.datetime.now()-start).total_seconds() # date = str(datetime.datetime.now()) # with open(logname,'a') as log: log.write(date+','+str(time)+',DropRetract\n') # # # # # end # # # # # # # # # # # # # # # # # if Wpressed: #if is being pressed # if not GPIO.input(photoWRONG): #and then is not Wpressed=False #change state print ("Wrelease") # #logging # time = (datetime.datetime.now()-start).total_seconds() # date = str(datetime.datetime.now()) # with open(logname,'a') as log: log.write(date+','+str(time)+',Wrelease\n') # # # #---------------------------------------------------------------------# #/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/# #%%=================================================================%%# #--------------------if I am delivering the drop----------------------# # # if delivering: # if not deliverer.isAlive(): #when i have finished delivering # print ("delivered") #logging # time = (datetime.datetime.now()-start).total_seconds() # date = str(datetime.datetime.now()) # with open(logname,'a') as log: log.write(date+','+str(time)+',DropDeliv\n') # dropPresent = True # delivering = False # waitforRetract = getsecs() #start waiting for retraction # # # #---------------------------------------------------------------------# #=====================================================================# #%%*****************************************************************%%# #------------------------if the drop is present-----------------------# # # if dropPresent: # now = getsecs() #now time # nodrank = now-waitforRetract >= 30 # if nodrank and not Cpressed: #if time is over # retracter=Thread(name='suck',target=drop.dcmove, # args=(pin.dc,3)) # retracter.start() # dropPresent = False #logging # time = (datetime.datetime.now()-start).total_seconds() # date = str(datetime.datetime.now()) # with open(logname,'a') as log: log.write(date+','+str(time)+',DropRetract\n') # # # #---------------------------------------------------------------------# #*********************************************************************# #see habituation file for an explanation of the following lines. they control the turning off routine if not killing: elapsed = str(datetime.datetime.now()-start) elapsed = elapsed.split('.')[0] with canvas(device) as draw: draw.text((30,0), 'testing', font=fontT, fill="white") draw.text((23,48), str(elapsed), font=font, fill="white") draw.text((23,24), 'c: '+str(c)+' w: '+str(w),font=font, fill="white") if not GPIO.input(pin.ok): killing=True waittoclose = getsecs() with canvas(device) as draw: draw.text((30,0), 'testing', font=fontT, fill="white") draw.text((0,26), 'press again to quit', font=font, fill="white") sleep(0.5) if killing: if getsecs()-waittoclose<15: if not GPIO.input(pin.ok): time = (datetime.datetime.now()-start).total_seconds() date = str(datetime.datetime.now()) with open(logname,'a') as log: log.write(date+','+str(time)+',TestOver\n') cam.stop_recording() cam.close() with canvas(device) as draw: draw.text((30,0), 'testing', font=fontT, fill="white") draw.text((0,26), 'cleanup...', font=font, fill="white") draw.text((0,42), 'do not unplug', font=font, fill="white") sleep(5) break else: killing=False with canvas(device) as draw: draw.text((0,26), 'rebooting', font=font, fill="white") draw.text((0,42), 'do not unplug', font=font, fill="white") os.system("sudo reboot")
class Display(ttkFrame): ''' Displays the drone state on a graphical interface ''' REFRESH_PERIOD = 0.2 #5Hz by default ARM_LENGTH = 23 #pixels PIXELS_METER = 100.0 #pixels/meter _instance = None @staticmethod def getInstance(): if Display._instance == None: root = Tk() root.geometry() Display._instance = Display(root) return Display._instance def __init__(self, parent): ''' Constructor ''' ttkFrame.__init__(self, parent) self._refreshTime = Display.REFRESH_PERIOD self._stateProvider = None self._launcherMethod = None self._isRunning = False self._droneThread = None self._parent = parent self._initUI() def setStateProvider(self, stateProvider): ''' Set the flight state provider ''' self._stateProvider = stateProvider return self def setLauncherMethod(self, launcherMethod): ''' Set the method which controlls the process. It is required since the main thread (main loop) is used by the GUI. Therefore, the process for the business logic must be executed within another thread. ''' self._launcherMethod = launcherMethod return self def setRefreshTime(self, refreshTime): self._refreshTime = refreshTime return self def start(self): if self._launcherMethod and not self._droneThread: self._droneThread = Thread(target=self._launcherMethod) self._droneThread.start() self._isRunning = True if self._stateProvider: self._refresh() self._parent.mainloop() def stop(self): self._isRunning = False if self._droneThread and self._droneThread.isAlive(): self._droneThread.join(5.0) def quit(self): self.stop() ttkFrame.quit(self) def _initUI(self): self._parent.title("Drone Flight Emulator") self.style = Style() self.style.theme_use("default") self.pack(fill=BOTH, expand=1) #Draw frame drawFrame = tkFrame(self) drawFrame.grid(column=0, row=0, sticky="W") self._canvasYZ = Canvas(drawFrame, bg="white", height=200, width=200) self._canvasYZ.grid(column=0, row=0, sticky="W", padx=(2,0), pady=(2,0)) self._canvasXZ = Canvas(drawFrame, bg="white", height=200, width=200) self._canvasXZ.grid(column=1, row=0, sticky="E", padx=(2,2), pady=(2,0)) self._canvasXY = Canvas(drawFrame, bg="white", height=200, width=400) self._canvasXY.grid(column=0, row=1, columnspan=2, sticky="S", padx=(2,2), pady=(0,2)) self._linesXY = [self._canvasXY.create_line(200,100, 200, 90, fill="#ff0000"), \ self._canvasXY.create_line(200,100, 210, 100, fill="#0000ff"), \ self._canvasXY.create_line(200,100, 200, 110, fill="#0000ff"), \ self._canvasXY.create_line(200,100, 190, 100, fill="#0000ff")] self._linesYZ = [self._canvasYZ.create_line(100,200, 90, 200, fill="#0000ff"), \ self._canvasYZ.create_line(100,200, 110, 200, fill="#0000ff")] self._linesXZ = [self._canvasXZ.create_line(100,200, 90, 200, fill="#0000ff"), \ self._canvasXZ.create_line(100,200, 110, 200, fill="#0000ff")] #Info frame infoFrame = tkFrame(self) infoFrame.grid(column=1, row=0, sticky="NE", padx=4) #Angles Label(infoFrame, text="Coords").grid(column=0, row=0, sticky="WE") self._coordTexts = [StringVar(),StringVar(),StringVar()] for index in range(3): Entry(infoFrame, textvariable=self._coordTexts[index], state=DISABLED, width=5).grid(column=index, row=1) #Angles Label(infoFrame, text="Angles").grid(column=0, row=2, sticky="WE") self._angleTexts = [StringVar(),StringVar(),StringVar()] for index in range(3): Entry(infoFrame, textvariable=self._angleTexts[index], state=DISABLED, width=5).grid(column=index, row=3) #Accels Label(infoFrame, text="Accels").grid(column=0, row=4, sticky="WE") self._accelTexts = [StringVar(),StringVar(),StringVar()] for index in range(3): Entry(infoFrame, textvariable=self._accelTexts[index], state=DISABLED, width=5).grid(column=index, row=5) #Speeds Label(infoFrame, text="Speeds").grid(column=0, row=6, sticky="WE") self._speedTexts = [StringVar(),StringVar(),StringVar()] for index in range(3): Entry(infoFrame, textvariable=self._speedTexts[index], state=DISABLED, width=5).grid(column=index, row=7) def _plotXY(self, coord, angles): x = int((coord[0]*Display.PIXELS_METER + 200.0) % 400.0) y = int((100.0 - coord[1]*Display.PIXELS_METER) % 200.0) sinz = sin(angles[2]) cosz = cos(angles[2]) lines = [Vector.rotateVector(line, sinz, cosz) \ for line in [ [0, Display.ARM_LENGTH], \ [Display.ARM_LENGTH, 0], \ [0, -Display.ARM_LENGTH], \ [-Display.ARM_LENGTH, 0]] ] for index in range(4): self._canvasXY.coords(self._linesXY[index], x, y, x+lines[index][0], y-lines[index][1]) def _plotHeight(self, x, y, angle, canvas, lines): cosine = cos(angle) sine = sin(angle) vectors = [Vector.rotateVector(vector, sine, cosine) \ for vector in [[-Display.ARM_LENGTH, 0], \ [Display.ARM_LENGTH, 0]] ] for index in range(2): canvas.coords(lines[index], x, y, x+vectors[index][0], y+vectors[index][1]) def _plotXZ(self, coord, angles): x = 100 y = int(200.0 - (coord[2]*Display.PIXELS_METER%200.0)) self._plotHeight(x, y, angles[1], self._canvasXZ, self._linesXZ) def _plotYZ(self, coord, angles): x = 100 y = int(200.0 - (coord[2]*Display.PIXELS_METER%200.0)) self._plotHeight(x, y, -angles[0], self._canvasYZ, self._linesYZ) def _refresh(self): if self._isRunning: state = self._stateProvider.getState() if not state._crashed: angles = [radians(angle) for angle in state._angles] self._plotXY(state._coords, angles) self._plotXZ(state._coords, angles) self._plotYZ(state._coords, angles) for index in range(3): self._coordTexts[index].set("{0:.3f}".format(state._coords[index])) self._angleTexts[index].set("{0:.3f}".format(state._angles[index])) self._accelTexts[index].set("{0:.3f}".format(state._accels[index])) self._speedTexts[index].set("{0:.3f}".format(state._speeds[index])) else: self._canvasXY.create_text((200,100), text="CRASHED!", fill="#ff0000") self._canvasXZ.create_text((100,100), text="CRASHED!", fill="#ff0000") self._canvasYZ.create_text((100,100), text="CRASHED!", fill="#ff0000") self.update_idletasks() self.after(int(self._refreshTime * 1000.0), self._refresh)
class WsFuturesApi(object): # ---------------------------------------------------------------------- def __init__(self): """Constructor""" self.apiKey = '' # 用户名 self.secretKey = '' # 密码 self.ws = None # websocket应用对象 期货对象 self.active = False # 还存活 self.use_lever_rate = 10 self.trace = False # ----------------------------------------------------------------------- def connect(self, apiKey, secretKey, trace=False): self.host = OKEX_USD_CONTRACT self.apiKey = apiKey self.secretKey = secretKey self.trace = trace websocket.enableTrace(trace) self.ws = websocket.WebSocketApp(self.host, on_message=self.onMessage, on_error=self.onError, on_close=self.onClose, on_open=self.onOpen) self.thread = Thread(target=self.ws.run_forever, args=(None, None, 60, 30)) self.thread.start() # ---------------------------------------------------------------------- def http_get_request(self, url, params, add_to_headers=None, TIMEOUT=5): headers = { "Content-type": "application/x-www-form-urlencoded", 'User-Agent': 'Mozilla/5.0 (Windows NT 6.1; WOW64; rv:53.0) Gecko/20100101 Firefox/53.0' } if add_to_headers: headers.update(add_to_headers) #postdata = urllib.urlencode(params) try: # response = requests.get(url, postdata, headers=headers, timeout=TIMEOUT) response = requests.get(url, headers=headers, timeout=TIMEOUT) if response.status_code == 200: return response.json() else: return {"status": "fail"} except Exception as e: print(u'httpGet failed :{}'.format(str(e)), file=sys.stderr) return {"status": "fail", "msg": e} # ---------------------------------------------------------------------- def getContractName(self, symbol_no_usd, contract_type): try: url = OKEX_CONTRACT_HOST % (symbol_no_usd, contract_type) data = self.http_get_request(url, {}) if type(data) == type([]) and len(data) > 0: d1 = data[0] contract_name = d1["contract_name"] return contract_name except Exception as ex: print(u'OkexContractApi.getContractName exception:{},{}'.format( str(ex), traceback.format_exc()), file=sys.stderr) return None def sendHeartBeat(self): """ 发送心跳 :return: """ d = {'event': 'ping'} # 若触发异常则重连 try: print(u'vnokex.futuresApi.sendHeartBeat') j = json.dumps(d) self.ws.send(j) except websocket.WebSocketConnectionClosedException as ex: print(u'vnokex.futuresApi.sendHeartBeat Exception:{}'.format( str(ex)), file=sys.stderr) # ---------------------------------------------------------------------- def close(self): """关闭接口""" if self.thread and self.thread.isAlive(): self.ws.close() self.thread.join() # ---------------------------------------------------------------------- def inflate(self, data): """解压数据流""" decompress = zlib.decompressobj(-zlib.MAX_WBITS # see above ) inflated = decompress.decompress(data) inflated += decompress.flush() # bytes=>string if isinstance(inflated, bytes): inflated = inflated.decode('utf-8') return inflated # ---------------------------------------------------------------------- def readData(self, evt): """解压缩推送收到的数据""" # # 创建解压器 # decompress = zlib.decompressobj(-zlib.MAX_WBITS) # # 将原始数据解压成字符串 # inflated = decompress.decompress(evt) + decompress.flush() # 通过json解析字符串 # data = json.loads(inflated) data = json.loads(evt) return data # ---------------------------------------------------------------------- def onMessage(self, ws, evt): """信息推送""" print(evt) # ---------------------------------------------------------------------- def onError(self, ws, evt): """错误推送""" print('OkexContractApi.onError:{}'.format(evt)) # ---------------------------------------------------------------------- def onClose(self, ws): """接口断开""" print('OkexContractApi.onClose') # ---------------------------------------------------------------------- def onOpen(self, ws): """接口打开""" print('OkexContractApi.onOpen') def subsribeFutureTicker(self, symbol, contract_type): req = "{'event':'addChannel','channel':'ok_sub_futureusd_%s_ticker_%s'}" % ( symbol, contract_type) self.ws.send(req) def subscribeFutureKline(self, symbol, contract_type, time_period): req = "{'event':'addChannel','channel':'ok_sub_futureusd_%s_kline_%s_%s'}" % ( symbol, contract_type, time_period) self.ws.send(req) def subscribeFutureDepth(self, symbol, contract_type): req = "{'event':'addChannel','channel':'ok_sub_future_%s_depth_%s_usd'}" % ( symbol, contract_type) self.ws.send(req) def subscribeFutureDepth20(self, symbol, contract_type): req = "{'event':'addChannel','channel':'ok_sub_futureusd_%s_depth_%s_20'}" % ( symbol, contract_type) self.ws.send(req) def subscribeFutureTrades(self, symbol, contract_type): req = "{'event':'addChannel','channel':'ok_sub_futureusd_%s_trade_%s'}" % ( symbol, contract_type) self.ws.send(req) def subscribeFutureIndex(self, symbol): req = "{'event':'addChannel','channel':'ok_sub_futureusd_%s_index'}" % ( symbol) self.ws.send(req) # ---------------------------------------------------------------------- def generateSign(self, params): """生成签名""" l = [] for key in sorted(params.keys()): l.append('%s=%s' % (key, params[key])) l.append('secret_key=%s' % self.secretKey) sign = '&'.join(l) return hashlib.md5(sign.encode('utf-8')).hexdigest().upper() # ---------------------------------------------------------------------- def sendTradingRequest(self, channel, params): """发送交易请求""" # 在参数字典中加上api_key和签名字段 params['api_key'] = self.apiKey params['sign'] = self.generateSign(params) # 生成请求 d = {} d['event'] = 'addChannel' d['channel'] = channel d['parameters'] = params # 使用json打包并发送 j = json.dumps(d) # 若触发异常则重连 try: self.ws.send(j) except websocket.WebSocketConnectionClosedException as ex: print(u'OkexContractApi.sendTradingRequest exception:{},{}'.format( str(ex), traceback.format_exc()), file=sys.stderr) except Exception as ex: print(u'OkexContractApi.sendTradingRequest exception:{},{}'.format( str(ex), traceback.format_exc()), file=sys.stderr) # ---------------------------------------------------------------------- def login(self): """ 登录 :return: """ params = {} params['api_key'] = self.apiKey params['sign'] = self.generateSign(params) # 生成请求 d = {} d['event'] = 'login' d['parameters'] = params # 使用json打包并发送 j = json.dumps(d) # 若触发异常则重连 try: self.ws.send(j) except websocket.WebSocketConnectionClosedException as ex: print(u'OkexContractApi.login exception:{},{}'.format( str(ex), traceback.format_exc()), file=sys.stderr) except Exception as ex: print(u'OkexContractApi.login exception:{},{}'.format( str(ex), traceback.format_exc()), file=sys.stderr) # ---------------------------------------------------------------------- def futureSubscribeIndex(self, symbol): """ 订阅期货合约指数行情 :param symbol: 合约 :return: """ channel = 'ok_sub_futureusd_%s_index' % symbol self.sendTradingRequest(channel, {}) # ---------------------------------------------------------------------- def futureAllIndexSymbol(self): """ 订阅所有的期货合约指数行情 :return: """ for symbol in CONTRACT_SYMBOL: self.futureSubscribeIndex(symbol) # ---------------------------------------------------------------------- def futureTrade(self, symbol_pair, contract_type, type_, price, amount, _match_price='0', _lever_rate=None): """期货委托""" params = {} params['symbol'] = str(symbol_pair) params['contract_type'] = str(contract_type) params['price'] = str(price) params['amount'] = str(amount) params['type'] = type_ # 1:开多 2:开空 3:平多 4:平空 params['match_price'] = _match_price # 是否为对手价: 0:不是 1:是 当取值为1时,price无效 if _lever_rate != None: params['lever_rate'] = _lever_rate else: params['lever_rate'] = str(self.use_lever_rate) channel = 'ok_futureusd_trade' self.sendTradingRequest(channel, params) # ---------------------------------------------------------------------- def futureCancelOrder(self, symbol_pair, orderid, contract_type): """ 期货撤单指令 :param symbol_pair: 合约对 :param orderid: 委托单编号 :param contract_type: 合约类型 :return: """ params = {} params['symbol'] = str(symbol_pair) params['order_id'] = str(orderid) params['contract_type'] = str(contract_type) channel = 'ok_futureusd_cancel_order' self.sendTradingRequest(channel, params) # ---------------------------------------------------------------------- def futureUserInfo(self): """查询期货账户""" channel = 'ok_futureusd_userinfo' self.sendTradingRequest(channel, {}) # ---------------------------------------------------------------------- # def futureSubUserInfo(self): # channel = 'ok_sub_futureusd_userinfo' # self.sendTradingRequest(channel, {}) # ---------------------------------------------------------------------- def futureOrderInfo(self, symbol_pair, order_id, contract_type, status, current_page, page_length=50): """ 发出查询期货委托 :param symbol_pair: 合约对 :param order_id: 委托单编号 :param contract_type: 合约类型 :param status: 状态 :param current_page:当前页 :param page_length: 每页长度 :return: """ params = {} params['symbol'] = str(symbol_pair) params['order_id'] = str(order_id) params['contract_type'] = str(contract_type) params['status'] = str(status) params['current_page'] = str(current_page) params['page_length'] = str(page_length) channel = 'ok_futureusd_orderinfo' self.sendTradingRequest(channel, params) # ---------------------------------------------------------------------- def futureAllUnfinishedOrderInfo(self): """ 订阅所有未完成的委托单信息 :return: """ for symbol in CONTRACT_SYMBOL: symbol_usd = symbol + "_usd" for contract_type in CONTRACT_TYPE: # orderid = -1, self.futureOrderInfo(symbol_usd, -1, contract_type, 1, 1, 50) # ---------------------------------------------------------------------- def subscribeFutureTrades(self): """ 订阅期货成交回报 :return: """ channel = 'ok_sub_futureusd_trades' self.sendTradingRequest(channel, {}) # ---------------------------------------------------------------------- def subscribeFutureUserInfo(self): """订阅期货账户信息""" channel = 'ok_sub_futureusd_userinfo' self.sendTradingRequest(channel, {}) # ---------------------------------------------------------------------- def subscribeFuturePositions(self): """订阅期货持仓信息""" channel = 'ok_sub_futureusd_positions' self.sendTradingRequest(channel, {})
def wait_for_update_trakt(): logger.info() t = Thread(update_all) t.setDaemon(True) t.start() t.isAlive()
check_update(laspB, ipB, update, logger_2) exec_cmd(laspB, "lasp_peer_service:stop().", ipB, 'b') laspB.sendline("exit") logger_2.info("Execition ended for " + node) #logger_2.handlers.clear() #logger_2.shutdown() laspB.logfile.close() lfileB.close() def bw_log(bw): os.system('docker exec laspvinA bash -c "date > /tmp/bwLogs"') os.system('docker exec laspvinA bash -c "iftop -t >> /tmp/bwLogs"') #Start main here if __name__ == "__main__": tA = Thread(target=laspA_s, args=('Node A', )) tB = Thread(target=laspB_s, args=('Node B', )) tA.start() tB.start() pBW = multiprocessing.Process(target=bw_log, args=('bw', )) pBW.start() while tA.isAlive() or tB.isAlive(): pass pBW.terminate() os.system("mkdir results/" + run_name) os.system("mv logs/* results/" + run_name) os.system("docker cp laspvinA:/tmp/bwLogs results/" + run_name) print("Execution Ended")
class OkexApi(object): """交易接口""" #---------------------------------------------------------------------- def __init__(self): """Constructor""" self.host = '' # 服务器 self.apiKey = '' # 用户名 self.secretKey = '' # 密码 self.active = False # 工作状态 self.ws = None # websocket应用对象 self.wsThread = None # websocket工作线程 self.heartbeatCount = 0 # 心跳计数 self.heartbeatThread = None # 心跳线程 self.heartbeatReceived = True # 心跳是否收到 self.reconnecting = False # 重新连接中 #---------------------------------------------------------------------- def heartbeat(self): """""" while self.active: self.heartbeatCount += 1 if self.heartbeatCount < 10: sleep(1) else: self.heartbeatCount = 0 if not self.heartbeatReceived: self.reconnect() else: self.heartbeatReceived = False d = {'event': 'ping'} j = json.dumps(d) try: self.ws.send(j) except: msg = traceback.format_exc() self.onError(msg) self.reconnect() #---------------------------------------------------------------------- def reconnect(self): """重新连接""" if not self.reconnecting: self.reconnecting = True self.closeWebsocket() # 首先关闭之前的连接 self.initWebsocket() print('我是重连') self.reconnecting = False #---------------------------------------------------------------------- def connect(self, host, apiKey, secretKey, trace=False): """连接""" self.host = host self.apiKey = apiKey self.secretKey = secretKey websocket.enableTrace(trace) self.initWebsocket() self.active = True print('第一次连接') #---------------------------------------------------------------------- def initWebsocket(self): """""" self.ws = websocket.WebSocketApp(self.host, on_message=self.onMessageCallback, on_error=self.onErrorCallback, on_close=self.onCloseCallback, on_open=self.onOpenCallback) self.wsThread = Thread(target=self.ws.run_forever) self.wsThread.start() #---------------------------------------------------------------------- def readData(self, evt): """解码推送收到的数据""" data = json.loads(evt) print(data) return data #---------------------------------------------------------------------- def closeHeartbeat(self): """关闭接口""" if self.heartbeatThread and self.heartbeatThread.isAlive(): self.active = False self.heartbeatThread.join() #---------------------------------------------------------------------- def closeWebsocket(self): """关闭WS""" if self.wsThread and self.wsThread.isAlive(): self.ws.close() self.wsThread.join() #---------------------------------------------------------------------- def close(self): """""" self.closeHeartbeat() self.closeWebsocket() #---------------------------------------------------------------------- def onMessage(self, data): """信息推送""" print('onMessage') # print(evt) #---------------------------------------------------------------------- def onError(self, data): """错误推送""" print('onError') # print(evt) #---------------------------------------------------------------------- def onClose(self): """接口断开""" print('onClose') #---------------------------------------------------------------------- def onOpen(self): """接口打开""" print('onOpen') #---------------------------------------------------------------------- def onMessageCallback(self, ws, evt): """""" data = self.readData(evt) if 'event' in data: self.heartbeatReceived = True else: self.onMessage(data[0]) #---------------------------------------------------------------------- def onErrorCallback(self, ws, evt): """""" self.onError(evt) #---------------------------------------------------------------------- def onCloseCallback(self, ws): """""" self.onClose() #---------------------------------------------------------------------- def onOpenCallback(self, ws): """""" if not self.heartbeatThread: self.heartbeatThread = Thread(target=self.heartbeat) self.heartbeatThread.start() self.onOpen() #---------------------------------------------------------------------- def generateSign(self, params): """生成签名""" l = [] for key in sorted(params.keys()): l.append('%s=%s' %(key, params[key])) l.append('secret_key=%s' %self.secretKey) sign = '&'.join(l) return hashlib.md5(sign.encode('utf-8')).hexdigest().upper() #---------------------------------------------------------------------- def sendRequest(self, channel, params=None): """发送请求""" # 生成请求 d = {} d['event'] = 'addChannel' d['channel'] = channel # 如果有参数,在参数字典中加上api_key和签名字段 if params is not None: params['api_key'] = self.apiKey params['sign'] = self.generateSign(params) d['parameters'] = params # 使用json打包并发送 j = json.dumps(d) # 若触发异常则重连 try: self.ws.send(j) return True except websocket.WebSocketConnectionClosedException: self.reconnect() return False #---------------------------------------------------------------------- def login(self): params = {} params['api_key'] = self.apiKey params['sign'] = self.generateSign(params) # 生成请求 d = {} d['event'] = 'login' d['parameters'] = params j = json.dumps(d) # 若触发异常则重连 try: self.ws.send(j) return True except websocket.WebSocketConnectionClosedException: self.reconnect() return False
class OOP(): def __init__(self): # Create instance self.win = tk.Tk() #Create a Queue self.guiQueue = Queue() #Start TCP/IP Server svrT = Thread(target=startServer, daemon=True) svrT.start() tt.createToolTip(self.win, 'Hello GUI.') # Add a title self.win.title("Python GUI") self.createWidgets() self.defaultFileEntries() def createThread(self): self.runT = Thread(target=self.useQue) self.runT.setDaemon(True) self.runT.start() print(runT) print('createThread():', self.runT.isAlive()) def useQue(self): # guiQue = Queue() # creating que instance .. # print(guiQue) # for idx in range(10): # guiQue.put('Message in a que: ' + str(idx)) while True: print(self.guiQue.get()) def defaultFileEntries(self): self.fileEntry.delete(0, tk.END) self.fileEntry.insert(0, fDir) if len(fDir) > self.entryLen: self.fileEntry.config(width=len(fDir) + 3) self.fileEntry.config(state='readonly') self.netEntry.delete(0, tk.END) self.netEntry.insert(0, netDir) if len(netDir) > self.endryLen: self.netwEntry.config(width=len(netDir) + 3) # Button callback def clickMe(self): self.action.configure(text='Hello ' + self.name.get()) # for idx in range(10): # time.sleep(5) # self.scr.insert(tk.INSERT, str(idx) + '\n') # self.createThread() print(self) bq.writeToScrol(self) # Spinbox callback def _spin(self): value = self.spin.get() print(value) self.scr.insert(tk.INSERT, value + '\n') # Checkbox callback def checkCallback(self, *ignoredArgs): # only enable one checkbutton if self.chVarUn.get(): self.check3.configure(state='disabled') else: self.check3.configure(state='normal') if self.chVarEn.get(): self.check2.configure(state='disabled') else: self.check2.configure(state='normal') # Radiobutton callback function def radCall(self): radSel = self.radVar.get() if radSel == 0: self.monty2.configure(text='Blue') elif radSel == 1: self.monty2.configure(text='Gold') elif radSel == 2: self.monty2.configure(text='Red') # Exit GUI cleanly def _quit(self): self.win.quit() self.win.destroy() exit() def methodInAThread(self, numOfLoops=10): print('supprise motherfcker ...') for idx in range(numOfLoops): time.sleep(1) self.scr.insert(tk.INSERT, str(idx) + '\n') print('methodInAThread():', self.runT.isAlive()) time.sleep(1) print('methodInAThread:', self.runT.isAlive()) def usingGlobal(self): GLOBAL_CONST = 777 print(GLOBAL_CONST) ##################################################################################### def createWidgets(self): # Tab Control introduced here -------------------------------------- tabControl = ttk.Notebook(self.win) # Create Tab Control tab1 = ttk.Frame(tabControl) # Create a tab tabControl.add(tab1, text='Tab 1') # Add the tab tab2 = ttk.Frame(tabControl) # Add a second tab tabControl.add(tab2, text='Tab 2') # Make second tab visible tabControl.pack(expand=1, fill="both") # Pack to make visible # ~ Tab Control introduced here ----------------------------------------- # We are creating a container frame to hold all other widgets self.monty = ttk.LabelFrame(tab1, text=' Monty Python ') self.monty.grid(column=0, row=0, padx=8, pady=4) # Changing our Label ttk.Label(self.monty, text="Enter a name:").grid(column=0, row=0, sticky='W') # Adding a Textbox Entry widget self.name = tk.StringVar() nameEntered = ttk.Entry(self.monty, width=24, textvariable=self.name) nameEntered.grid(column=0, row=1, sticky='W') nameEntered.delete(0, tk.END) nameEntered.insert(0, '<default name>') # Adding a Button self.action = ttk.Button(self.monty, text="Click Me!", command=self.clickMe) self.action.grid(column=2, row=1) ttk.Label(self.monty, text="Choose a number:").grid(column=1, row=0) number = tk.StringVar() numberChosen = ttk.Combobox(self.monty, width=14, textvariable=number) numberChosen['values'] = (1, 2, 4, 42, 100) numberChosen.grid(column=1, row=1) numberChosen.current(0) # Adding a Spinbox widget using a set of values self.spin = Spinbox(self.monty, values=(1, 2, 4, 42, 100), width=5, bd=8, command=self._spin) self.spin.grid(column=0, row=2, sticky='W') # Using a scrolled Text control scrolW = 40 scrolH = 10 self.scr = scrolledtext.ScrolledText(self.monty, width=scrolW, height=scrolH, wrap=tk.WORD) self.scr.grid(column=0, row=3, sticky='WE', columnspan=3) # Tab Control 2 refactoring ----------------------------------------- # We are creating a container frame to hold all other widgets -- Tab2 self.monty2 = ttk.LabelFrame(tab2, text=' The Snake ') self.monty2.grid(column=0, row=0, padx=8, pady=4) # Creating three checkbuttons chVarDis = tk.IntVar() check1 = tk.Checkbutton(self.monty2, text="Disabled", variable=chVarDis, state='disabled') check1.select() check1.grid(column=0, row=0, sticky=tk.W) self.chVarUn = tk.IntVar() self.check2 = tk.Checkbutton(self.monty2, text="UnChecked", variable=self.chVarUn) self.check2.deselect() self.check2.grid(column=1, row=0, sticky=tk.W) self.chVarEn = tk.IntVar() self.check3 = tk.Checkbutton(self.monty2, text="Toggle", variable=self.chVarEn) self.check3.deselect() self.check3.grid(column=2, row=0, sticky=tk.W) # trace the state of the two checkbuttons self.chVarUn.trace( 'w', lambda unused0, unused1, unused2: self.checkCallback()) self.chVarEn.trace( 'w', lambda unused0, unused1, unused2: self.checkCallback()) # ~ Tab Control 2 refactoring ----------------------------------------- # Radiobutton list colors = ["Blue", "Gold", "Red"] self.radVar = tk.IntVar() # Selecting a non-existing index value for radVar self.radVar.set(99) # Creating all three Radiobutton widgets within one loop for col in range(3): curRad = 'rad' + str(col) curRad = tk.Radiobutton(self.monty2, text=colors[col], variable=self.radVar, value=col, command=self.radCall) curRad.grid(column=col, row=6, sticky=tk.W, columnspan=3) # And now adding tooltips tt.createToolTip(curRad, 'This is a Radiobutton control.') # Create a container to hold labels labelsFrame = ttk.LabelFrame(self.monty2, text=' Labels in a Frame ') labelsFrame.grid(column=0, row=7) # Place labels into the container element - vertically ttk.Label(labelsFrame, text="Label1").grid(column=0, row=0) ttk.Label(labelsFrame, text="Label2").grid(column=0, row=1) # Add some space around each label for child in labelsFrame.winfo_children(): child.grid_configure(padx=8) mngFilesFrame = ttk.LabelFrame(tab2, text='Managa Files: ') mngFilesFrame.grid(column=0, row=1, sticky='WE', padx=10, pady=5) def getFileName(): print('hello from getFileName') fDir = path.dirname(__file__) fName = fd.askopenfilename(parent=self.win, initialdir=fDir) lb = ttk.Button(mngFilesFrame, text='Browse to File...', command=getFileName) lb.grid(column=0, row=0, sticky=tk.W) def copyFile(): import shutil src = self.fileEntry.get() file = src.split('/')[-1] dst = self.netwEntry.get() + '\\' + file try: shutil.copy(src, dst) mBox.showinfo('Copy File to Network', 'Succes: File copied.') except FileNotFoundError as err: mBox.showerror('Copy File to Network', '*** Failed to copy file! *** ') except Exception as ex: mBox.showerror('Copy file to network', '*** Failed *** ') cb = ttk.Button(mngFilesFrame, text='Copy file to: ', command=copyFile) cb.grid(column=0, row=1, sticky=tk.E) for child in mngFilesFrame.winfo_children(): child.grid_configure(padx=6, pady=6) # Creating a Menu Bar menuBar = Menu(tab1) self.win.config(menu=menuBar) # Add menu items fileMenu = Menu(menuBar, tearoff=0) fileMenu.add_command(label="New") fileMenu.add_separator() fileMenu.add_command(label="Exit", command=self._quit) menuBar.add_cascade(label="File", menu=fileMenu) # Add another Menu to the Menu Bar and an item helpMenu = Menu(menuBar, tearoff=0) helpMenu.add_command(label="About") menuBar.add_cascade(label="Help", menu=helpMenu) # Change the main windows icon #self.win.iconbitmap(r'C:\Python34\DLLs\pyc.ico') # Using tkinter Variable Classes strData = tk.StringVar() strData.set('Hello StringVar') print(strData.get()) # Default tkinter Variable Classes intData = tk.IntVar() print(intData.get()) print(tk.DoubleVar()) print(tk.BooleanVar()) # It is not necessary to create a tk.StringVar() strData = tk.StringVar() strData = self.spin.get() # Printing the Global works # call method self.usingGlobal() tabControl.select(1) # Place cursor into name Entry # nameEntered.focus() # Add a Tooltip to the Spinbox tt.createToolTip(self.spin, 'This is a Spin control.') # Add Tooltips to more widgets tt.createToolTip(nameEntered, 'This is an Entry control.') tt.createToolTip(self.action, 'This is a Button control.') tt.createToolTip(self.scr, 'This is a ScrolledText control.')
</html> """ def info2tr(info): return """<tr class="%s" class="%s" class="%s"><td>%s</td><td>%s</td><td>%s</td><td>%s</td><td>%s</td></tr>""" % ( info["clsdate"], info["clsprogram"], info["user"], info["user"], "", info["program"], all_owner_info[info["owner"]][0], info["date"]) def save_me(signum, frame): print 'Signal handler called with signal : ', signum for r in all_receives: print info2tr(all_receives[r]) if "__main__" == __name__: getset_owner_info() t = Thread(target=listen_update) t.start() signal.signal(signal.SIGALRM, save_me) while (t.isAlive()): # Set the signal handler and a 5-second alarm signal.alarm(2) signal.pause() t.join()
def run(self, timeout): """Called by worker thread to begin actual command run. This function launches a subprocess that runs the command line set for the object. If the command contains a file-label variable, it also sets up files for STDERR and STDOUT and tells subprocess to pipe to those files. This function creates a thread to handle the running of the subprocess in order to deal with timeouts despite the lack of subprocess timeout functionality in the Python bundled with NexentaStor 3.0. The function will wait the specified timeout and if the subprocess is still running, SIGKILL will be sent to it.""" global cmd_success global cmd_terminate def target(): """Function invoked by run() as a thread.""" global cmd_run # for pipes we don't want the output from DEVNULL = os.open(os.devnull, os.O_RDWR) if silent == False and verbose == True: print "Started \"" + str(self.cmd_line) + "\" via run()." if self.args.has_key("file-label"): filestub = output_dir + self.group + "/" + \ self.args["file-label"] # if we're gzipping, we don't care about stdout as it's # being piped around already - can still capture stderr # so we do if self.args.has_key("gzip") and self.args["gzip"] == True: self.cmd_line = self.cmd_line + " | gzip -c > " + \ filestub + ".out.gz" self.err_f = open(filestub + ".err", "w") self.process = subprocess.Popen(self.cmd_line, stdout=DEVNULL, stderr=self.err_f, shell=True) # regular run -- capture stdout and stderr to file else: self.out_f = open(filestub + ".out", "w") self.err_f = open(filestub + ".err", "w") self.process = subprocess.Popen(self.cmd_line, stdout=self.out_f, stderr=self.err_f, shell=True) # pipe stdout and stderr to /dev/null as this is a # cp command and nobody cares (we know success or failure # implicitly by rather it ends up in the result data or not) else: self.process = subprocess.Popen(self.cmd_line, stdout=DEVNULL, stderr=DEVNULL, shell=True) self.status = "running" self.started_at = time.time() # accounting cmd_run = cmd_run + 1 # this is where we actually DO the command we set up above self.output = self.process.communicate() # deal with file closure if self.args.has_key("file-label"): if self.args.has_key("gzip") and self.args["gzip"] == True: self.err_f.close() else: self.out_f.close() self.err_f.close() self.status = "completed" self.ended_at = time.time() # this is where we actually DO all the stuff we did above - we defined # a target function but it is only at this point that it is called # in execution worker_thread = Thread(target=target) worker_thread.start() # now we block-wait this thread for 'timeout' seconds, waiting on # the "sub"-thread we just launched with the subprocess inside worker_thread.join(timeout) # if we're here, the join() has let us get here - we are either # here because 'timeout' was met, or because the thread terminated # on its own successfully -- let's find out if worker_thread.isAlive(): # if we're here, we got here because the join() above met # its timeout and the "sub"-thread is still alive - we need # to get rid of it # self.process.terminate() # can't use the above function, as our Python in NexentaStor3.x # does not yet support this flag, so we must do the dirtier method # below - could be fixed by verifying Python version at some # future date, but right now only Python 2.5.5 is out there anyway self.terminated = True self.terminated_at = time.time() os.kill(self.process.pid, signal.SIGKILL) # we just potentially tried to os.kill the worker thread - let's # rejoin it again until it's gone; so far this has never caused # an issue but if we should ever have a hung Collector, I'd start # by looking here -- and potentially improving this to do another # timeout wait followed by a global panic because we can't seem # to get rid of our "sub"-thread worker_thread.join() # accounting details if self.terminated == True: self.status = "terminated" self.ended_at = self.terminated_at cmd_terminate = cmd_terminate + 1 # deal with file closures if self.args.has_key("file-label"): if self.args.has_key("gzip") and self.args["gzip"] == True: self.err_f.close() else: self.out_f.close() self.err_f.close() else: cmd_success = cmd_success + 1 self.ended_at = time.time() if silent == False and verbose == True: print "Completed \"" + str(self.cmd_line) + "\" with status " + \ str(self.status) + " in " + \ str(self.ended_at - self.started_at) + " seconds." if self.args.has_key("file-label"): # file label should only exist for COMMANDS -- files and logs # will just skip this since they never have file-label set filestub = output_dir + self.group + "/" + \ self.args["file-label"] # make sure we cleaned up file handles if self.args.has_key("gzip") and self.args["gzip"] == True: if not self.err_f.closed: self.err_f.close() else: if not self.out_f.closed: self.out_f.close() if not self.err_f.closed: self.err_f.close() # write out the statistics gathered for this command run f = open(filestub + ".stats", "w") ofile = "Command line run: " + self.cmd_line + "\n" ofile = ofile + "Command completion status: " + self.status + "\n" if self.status == "completed": ofile = ofile + "Command return code: " + \ str(self.process.returncode) + "\n" else: ofile = ofile + "Command return code: unavailable\n" ofile = ofile + "Started at: " + \ time.ctime(self.started_at) + "\n" ofile = ofile + "Ended at: " + \ time.ctime(self.ended_at) + "\n" ofile = ofile + "Elapsed (s): " + \ str(self.ended_at - self.started_at) + "\n" ofile = ofile + "License Key: " + license + " [" + app_ver + "]\n" f.write(ofile) f.close() else: # no file label? should be a file or log type, so do nothing a = 1 # sigh Python
class OOP(): def __init__(self): # Create instance self.win = tk.Tk() self.i18n = I18N('en') self.i18n = I18N('de') # Add a title self.win.title(self.i18n.title) # Disable resizing the window self.win.resizable(0, 0) # Create a Queue self.guiQueue = Queue() self.createWidgets() # populate Tab 2 Entries self.defaultFileEntries() # create MySQL instance #self.mySQL = MySQL() def defaultFileEntries(self): self.fileEntry.delete(0, tk.END) self.fileEntry.insert(0, 'Z:\\') # bogus path self.fileEntry.config(state='readonly') self.netwEntry.delete(0, tk.END) self.netwEntry.insert(0, 'Z:\\Backup') # bogus path # Combobox callback def _combo(self, val=0): value = self.combo.get() self.scr.insert(tk.INSERT, value + '\n') # Spinbox callback def _spin(self): value = self.spin.get() self.scr.insert(tk.INSERT, value + '\n') # Checkbox callback def checkCallback(self, *ignoredArgs): # only enable one checkbutton if self.chVarUn.get(): self.check3.configure(state='disabled') else: self.check3.configure(state='normal') if self.chVarEn.get(): self.check2.configure(state='disabled') else: self.check2.configure(state='normal') # Radiobutton callback function def radCall(self): radSel = self.radVar.get() if radSel == 0: self.widgetFrame.configure(text=self.i18n.WIDGET_LABEL + self.i18n.colorsIn[0]) elif radSel == 1: self.widgetFrame.configure(text=self.i18n.WIDGET_LABEL + self.i18n.colorsIn[1]) elif radSel == 2: self.widgetFrame.configure(text=self.i18n.WIDGET_LABEL + self.i18n.colorsIn[2]) # Exit GUI cleanly def _quit(self): self.win.quit() self.win.destroy() exit() def methodInAThread(self, numOfLoops=10): for idx in range(numOfLoops): sleep(1) self.scr.insert(tk.INSERT, str(idx) + '\n') sleep(1) print('methodInAThread():', self.runT.isAlive()) # Running methods in Threads def createThread(self, num): self.runT = Thread(target=self.methodInAThread, args=[num]) self.runT.setDaemon(True) self.runT.start() print(self.runT) print('createThread():', self.runT.isAlive()) # textBoxes are the Consumers of Queue data writeT = Thread(target=self.useQueues, daemon=True) writeT.start() # Create Queue instance def useQueues(self): # Now using a class member Queue while True: qItem = self.guiQueue.get() print(qItem) self.scr.insert(tk.INSERT, qItem + '\n') # Button callback def insertQuote(self): title = self.bookTitle.get() page = self.pageNumber.get() quote = self.quote.get(1.0, tk.END) print(title) print(quote) self.mySQL.insertBooks(title, page, quote) # Button callback def getQuote(self): allBooks = self.mySQL.showBooks() print(allBooks) self.quote.insert(tk.INSERT, allBooks) # Button callback def modifyQuote(self): raise NotImplementedError( "This still needs to be implemented for the SQL command.") # TZ Button callback def allTimeZones(self): for tz in all_timezones: self.scr.insert(tk.INSERT, tz + '\n') # TZ Local Button callback def localZone(self): from tzlocal import get_localzone self.scr.insert(tk.INSERT, get_localzone()) # Format local US time with TimeZone info def getDateTime(self): fmtStrZone = "%Y-%m-%d %H:%M:%S %Z%z" # Get Coordinated Universal Time utc = datetime.now(timezone('UTC')) print(utc.strftime(fmtStrZone)) # Convert UTC datetime object to Los Angeles TimeZone la = utc.astimezone(timezone('America/Los_Angeles')) print(la.strftime(fmtStrZone)) # Convert UTC datetime object to New York TimeZone ny = utc.astimezone(timezone('America/New_York')) print(ny.strftime(fmtStrZone)) # update GUI label with NY Time and Zone self.lbl2.set(ny.strftime(fmtStrZone)) ##################################################################################### def createWidgets(self): # Tab Control introduced here -------------------------------------- tabControl = ttk.Notebook(self.win) # Create Tab Control tab1 = ttk.Frame(tabControl) # Create a tab # tabControl.add(tab1, text='MySQL') # Add the tab -- COMMENTED OUT FOR CH08 tab2 = ttk.Frame(tabControl) # Add a second tab tabControl.add(tab2, text='Widgets') # Make second tab visible tabControl.pack(expand=1, fill="both") # Pack to make visible # ~ Tab Control introduced here ----------------------------------------- # We are creating a container frame to hold all other widgets self.mySQL = ttk.LabelFrame(tab1, text=' Python Database ') self.mySQL.grid(column=0, row=0, padx=8, pady=4) # Creating a Label ttk.Label(self.mySQL, text="Book Title:").grid(column=0, row=0, sticky='W') # Adding a Textbox Entry widget book = tk.StringVar() self.bookTitle = ttk.Entry(self.mySQL, width=34, textvariable=book) self.bookTitle.grid(column=0, row=1, sticky='W') # Adding a Textbox Entry widget book1 = tk.StringVar() self.bookTitle1 = ttk.Entry(self.mySQL, width=34, textvariable=book1) self.bookTitle1.grid(column=0, row=2, sticky='W') # Adding a Textbox Entry widget book2 = tk.StringVar() self.bookTitle2 = ttk.Entry(self.mySQL, width=34, textvariable=book2) self.bookTitle2.grid(column=0, row=3, sticky='W') # Creating a Label ttk.Label(self.mySQL, text="Page:").grid(column=1, row=0, sticky='W') # Adding a Textbox Entry widget page = tk.StringVar() self.pageNumber = ttk.Entry(self.mySQL, width=6, textvariable=page) self.pageNumber.grid(column=1, row=1, sticky='W') # Adding a Textbox Entry widget page = tk.StringVar() self.pageNumber1 = ttk.Entry(self.mySQL, width=6, textvariable=page) self.pageNumber1.grid(column=1, row=2, sticky='W') # Adding a Textbox Entry widget page = tk.StringVar() self.pageNumber2 = ttk.Entry(self.mySQL, width=6, textvariable=page) self.pageNumber2.grid(column=1, row=3, sticky='W') # Adding a Button self.action = ttk.Button(self.mySQL, text="Insert Quote", command=self.insertQuote) self.action.grid(column=2, row=1) # Adding a Button self.action1 = ttk.Button(self.mySQL, text="Get Quotes", command=self.getQuote) self.action1.grid(column=2, row=2) # Adding a Button self.action2 = ttk.Button(self.mySQL, text="Mody Quote", command=self.modifyQuote) self.action2.grid(column=2, row=3) # Add some space around each widget for child in self.mySQL.winfo_children(): child.grid_configure(padx=2, pady=4) quoteFrame = ttk.LabelFrame(tab1, text=' Book Quotation ') quoteFrame.grid(column=0, row=1, padx=8, pady=4) # Using a scrolled Text control quoteW = 40 quoteH = 6 self.quote = scrolledtext.ScrolledText(quoteFrame, width=quoteW, height=quoteH, wrap=tk.WORD) self.quote.grid(column=0, row=8, sticky='WE', columnspan=3) # Add some space around each widget for child in quoteFrame.winfo_children(): child.grid_configure(padx=2, pady=4) #====================================================================================================== # Tab Control 2 #====================================================================================================== # We are creating a container frame to hold all other widgets -- Tab2 self.widgetFrame = ttk.LabelFrame(tab2, text=self.i18n.WIDGET_LABEL) self.widgetFrame.grid(column=0, row=0, padx=8, pady=4) # Creating three checkbuttons self.chVarDis = tk.IntVar() self.check1 = tk.Checkbutton(self.widgetFrame, text=self.i18n.disabled, variable=self.chVarDis, state='disabled') self.check1.select() self.check1.grid(column=0, row=0, sticky=tk.W) self.chVarUn = tk.IntVar() self.check2 = tk.Checkbutton(self.widgetFrame, text=self.i18n.unChecked, variable=self.chVarUn) self.check2.deselect() self.check2.grid(column=1, row=0, sticky=tk.W) self.chVarEn = tk.IntVar() self.check3 = tk.Checkbutton(self.widgetFrame, text=self.i18n.toggle, variable=self.chVarEn) self.check3.deselect() self.check3.grid(column=2, row=0, sticky=tk.W) # trace the state of the two checkbuttons self.chVarUn.trace( 'w', lambda unused0, unused1, unused2: self.checkCallback()) self.chVarEn.trace( 'w', lambda unused0, unused1, unused2: self.checkCallback()) # Radiobutton list colors = self.i18n.colors self.radVar = tk.IntVar() # Selecting a non-existing index value for radVar self.radVar.set(99) # Creating all three Radiobutton widgets within one loop for col in range(3): curRad = 'rad' + str(col) curRad = tk.Radiobutton(self.widgetFrame, text=colors[col], variable=self.radVar, value=col, command=self.radCall) curRad.grid(column=col, row=6, sticky=tk.W, columnspan=3) # And now adding tooltips tt.createToolTip(curRad, 'This is a Radiobutton control.') # Create a container to hold labels labelsFrame = ttk.LabelFrame(self.widgetFrame, text=self.i18n.labelsFrame) labelsFrame.grid(column=0, row=7, pady=6) # Place labels into the container element - vertically ttk.Label(labelsFrame, text=self.i18n.chooseNumber).grid(column=0, row=0) self.lbl2 = tk.StringVar() self.lbl2.set(self.i18n.label2) ttk.Label(labelsFrame, textvariable=self.lbl2).grid(column=0, row=1) # Add some space around each label for child in labelsFrame.winfo_children(): child.grid_configure(padx=6, pady=1) number = tk.StringVar() self.combo = ttk.Combobox(self.widgetFrame, width=12, textvariable=number) self.combo['values'] = (1, 2, 4, 42, 100) self.combo.grid(column=1, row=7, sticky=tk.W) self.combo.current(0) self.combo.bind('<<ComboboxSelected>>', self._combo) # Adding a Spinbox widget using a set of values self.spin = Spinbox(self.widgetFrame, values=(1, 2, 4, 42, 100), width=5, bd=8, command=self._spin) self.spin.grid(column=2, row=7, sticky='W,', padx=6, pady=1) # Using a scrolled Text control scrolW = 40 scrolH = 1 self.scr = scrolledtext.ScrolledText(self.widgetFrame, width=scrolW, height=scrolH, wrap=tk.WORD) self.scr.grid(column=0, row=8, sticky='WE', columnspan=3) # Adding a TZ Button self.allTZs = ttk.Button(self.widgetFrame, text=self.i18n.timeZones, command=self.allTimeZones) self.allTZs.grid(column=0, row=9, sticky='WE') # Adding local TZ Button self.localTZ = ttk.Button(self.widgetFrame, text=self.i18n.localZone, command=self.localZone) self.localTZ.grid(column=1, row=9, sticky='WE') # Adding getTime TZ Button self.dt = ttk.Button(self.widgetFrame, text=self.i18n.getTime, command=self.getDateTime) self.dt.grid(column=2, row=9, sticky='WE') # Create Manage Files Frame ------------------------------------------------ mngFilesFrame = ttk.LabelFrame(tab2, text=self.i18n.mgrFiles) mngFilesFrame.grid(column=0, row=1, sticky='WE', padx=10, pady=5) # Button Callback def getFileName(): print('hello from getFileName') fDir = path.dirname(__file__) fName = fd.askopenfilename(parent=self.win, initialdir=fDir) print(fName) self.fileEntry.config(state='enabled') self.fileEntry.delete(0, tk.END) self.fileEntry.insert(0, fName) if len(fName) > self.entryLen: self.fileEntry.config(width=len(fName) + 3) # Add Widgets to Manage Files Frame lb = ttk.Button(mngFilesFrame, text=self.i18n.browseTo, command=getFileName) lb.grid(column=0, row=0, sticky=tk.W) #----------------------------------------------------- file = tk.StringVar() self.entryLen = scrolW - 4 self.fileEntry = ttk.Entry(mngFilesFrame, width=self.entryLen, textvariable=file) self.fileEntry.grid(column=1, row=0, sticky=tk.W) #----------------------------------------------------- logDir = tk.StringVar() self.netwEntry = ttk.Entry(mngFilesFrame, width=self.entryLen, textvariable=logDir) self.netwEntry.grid(column=1, row=1, sticky=tk.W) def copyFile(): import shutil src = self.fileEntry.get() file = src.split('/')[-1] dst = self.netwEntry.get() + '\\' + file try: shutil.copy(src, dst) mBox.showinfo('Copy File to Network', 'Succes: File copied.') except FileNotFoundError as err: mBox.showerror('Copy File to Network', '*** Failed to copy file! ***\n\n' + str(err)) except Exception as ex: mBox.showerror('Copy File to Network', '*** Failed to copy file! ***\n\n' + str(ex)) cb = ttk.Button(mngFilesFrame, text=self.i18n.copyTo, command=copyFile) cb.grid(column=0, row=1, sticky=tk.E) # Add some space around each label for child in mngFilesFrame.winfo_children(): child.grid_configure(padx=6, pady=6) # Creating a Menu Bar ========================================================== menuBar = Menu(tab1) self.win.config(menu=menuBar) # Add menu items fileMenu = Menu(menuBar, tearoff=0) fileMenu.add_command(label=self.i18n.new) fileMenu.add_separator() fileMenu.add_command(label=self.i18n.exit, command=self._quit) menuBar.add_cascade(label=self.i18n.file, menu=fileMenu) # Add another Menu to the Menu Bar and an item helpMenu = Menu(menuBar, tearoff=0) helpMenu.add_command(label=self.i18n.about) menuBar.add_cascade(label=self.i18n.help, menu=helpMenu) # Change the main windows icon self.win.iconbitmap(r'C:\Python34\DLLs\pyc.ico') # Using tkinter Variable Classes strData = tk.StringVar() strData.set('Hello StringVar') # It is not necessary to create a tk.StringVar() strData = tk.StringVar() strData = self.spin.get() # Place cursor into name Entry self.bookTitle.focus() # Add a Tooltip to the Spinbox tt.createToolTip(self.spin, 'This is a Spin control.') # Add Tooltips to more widgets tt.createToolTip(self.bookTitle, 'This is an Entry control.') tt.createToolTip(self.action, 'This is a Button control.') tt.createToolTip(self.scr, 'This is a ScrolledText control.')
class RabitTracker(object): """ tracker for rabit """ def __init__(self, hostIP, nslave, port=9091, port_end=9999): sock = socket.socket(get_family(hostIP), socket.SOCK_STREAM) for _port in range(port, port_end): try: sock.bind((hostIP, _port)) self.port = _port break except socket.error as e: if e.errno in [98, 48]: continue else: raise sock.listen(256) self.sock = sock self.hostIP = hostIP self.thread = None self.start_time = None self.end_time = None self.nslave = nslave logging.info('start listen on %s:%d', hostIP, self.port) def __del__(self): self.sock.close() @staticmethod def get_neighbor(rank, nslave): rank = rank + 1 ret = [] if rank > 1: ret.append(rank // 2 - 1) if rank * 2 - 1 < nslave: ret.append(rank * 2 - 1) if rank * 2 < nslave: ret.append(rank * 2) return ret def slave_envs(self): """ get enviroment variables for slaves can be passed in as args or envs """ return { 'DMLC_TRACKER_URI': self.hostIP, 'DMLC_TRACKER_PORT': self.port } def get_tree(self, nslave): tree_map = {} parent_map = {} for r in range(nslave): tree_map[r] = self.get_neighbor(r, nslave) parent_map[r] = (r + 1) // 2 - 1 return tree_map, parent_map def find_share_ring(self, tree_map, parent_map, r): """ get a ring structure that tends to share nodes with the tree return a list starting from r """ nset = set(tree_map[r]) cset = nset - set([parent_map[r]]) if not cset: return [r] rlst = [r] cnt = 0 for v in cset: vlst = self.find_share_ring(tree_map, parent_map, v) cnt += 1 if cnt == len(cset): vlst.reverse() rlst += vlst return rlst def get_ring(self, tree_map, parent_map): """ get a ring connection used to recover local data """ assert parent_map[0] == -1 rlst = self.find_share_ring(tree_map, parent_map, 0) assert len(rlst) == len(tree_map) ring_map = {} nslave = len(tree_map) for r in range(nslave): rprev = (r + nslave - 1) % nslave rnext = (r + 1) % nslave ring_map[rlst[r]] = (rlst[rprev], rlst[rnext]) return ring_map def get_link_map(self, nslave): """ get the link map, this is a bit hacky, call for better algorithm to place similar nodes together """ tree_map, parent_map = self.get_tree(nslave) ring_map = self.get_ring(tree_map, parent_map) rmap = {0: 0} k = 0 for i in range(nslave - 1): k = ring_map[k][1] rmap[k] = i + 1 ring_map_ = {} tree_map_ = {} parent_map_ = {} for k, v in ring_map.items(): ring_map_[rmap[k]] = (rmap[v[0]], rmap[v[1]]) for k, v in tree_map.items(): tree_map_[rmap[k]] = [rmap[x] for x in v] for k, v in parent_map.items(): if k != 0: parent_map_[rmap[k]] = rmap[v] else: parent_map_[rmap[k]] = -1 return tree_map_, parent_map_, ring_map_ def accept_slaves(self, nslave): # set of nodes that finishs the job shutdown = {} # set of nodes that is waiting for connections wait_conn = {} # maps job id to rank job_map = {} # list of workers that is pending to be assigned rank pending = [] # lazy initialize tree_map tree_map = None while len(shutdown) != nslave: fd, s_addr = self.sock.accept() s = SlaveEntry(fd, s_addr) if s.cmd == 'print': msg = s.sock.recvstr() logging.info(msg.strip()) continue if s.cmd == 'shutdown': assert s.rank >= 0 and s.rank not in shutdown assert s.rank not in wait_conn shutdown[s.rank] = s logging.debug('Recieve %s signal from %d', s.cmd, s.rank) continue assert s.cmd == 'start' or s.cmd == 'recover' # lazily initialize the slaves if tree_map is None: assert s.cmd == 'start' if s.world_size > 0: nslave = s.world_size tree_map, parent_map, ring_map = self.get_link_map(nslave) # set of nodes that is pending for getting up todo_nodes = list(range(nslave)) else: assert s.world_size == -1 or s.world_size == nslave if s.cmd == 'recover': assert s.rank >= 0 rank = s.decide_rank(job_map) # batch assignment of ranks if rank == -1: assert todo_nodes pending.append(s) if len(pending) == len(todo_nodes): pending.sort(key=lambda x: x.host) for s in pending: rank = todo_nodes.pop(0) if s.jobid != 'NULL': job_map[s.jobid] = rank s.assign_rank(rank, wait_conn, tree_map, parent_map, ring_map) if s.wait_accept > 0: wait_conn[rank] = s logging.debug( 'Recieve %s signal from %s; assign rank %d', s.cmd, s.host, s.rank) if not todo_nodes: logging.info('@tracker All of %d nodes getting started', nslave) self.start_time = time.time() else: s.assign_rank(rank, wait_conn, tree_map, parent_map, ring_map) logging.debug('Recieve %s signal from %d', s.cmd, s.rank) if s.wait_accept > 0: wait_conn[rank] = s logging.info('@tracker All nodes finishes job') self.end_time = time.time() logging.info('@tracker %s secs between node start and job finish', str(self.end_time - self.start_time)) def start(self, nslave): def run(): self.accept_slaves(nslave) self.thread = Thread(target=run, args=()) self.thread.setDaemon(True) self.thread.start() def join(self): while self.thread.isAlive(): self.thread.join(100) def alive(self): return self.thread.isAlive()
def generic_handler(event, context_dict): """ context_dict is generic infromation about the context that we are running in, provided by the scheduler """ try: response_status = {'exception': None} s3 = boto3.resource('s3') logger.info("invocation started") # download the input status_key = event['status_key'] func_key = event['func_key'] data_key = event['data_key'] data_byte_range = event['data_byte_range'] output_key = event['output_key'] if version.__version__ != event['pywren_version']: raise Exception("WRONGVERSION", "Pywren version mismatch", version.__version__, event['pywren_version']) start_time = time.time() response_status['start_time'] = start_time func_filename = "/tmp/func.pickle" data_filename = "/tmp/data.pickle" output_filename = "/tmp/output.pickle" runtime_s3_bucket = event['runtime_s3_bucket'] runtime_s3_key = event['runtime_s3_key'] if event.get('runtime_url'): # NOTE(shivaram): Right now we only support S3 urls. runtime_s3_bucket_used, runtime_s3_key_used = wrenutil.split_s3_url( event['runtime_url']) else: runtime_s3_bucket_used = runtime_s3_bucket runtime_s3_key_used = runtime_s3_key job_max_runtime = event.get("job_max_runtime", 290) # default for lambda response_status['func_key'] = func_key response_status['data_key'] = data_key response_status['output_key'] = output_key response_status['status_key'] = status_key b, k = data_key KS = s3util.key_size(b, k) #logger.info("bucket=", b, "key=", k, "status: ", KS, "bytes" ) while KS is None: logger.warn("WARNING COULD NOT GET FIRST KEY") KS = s3util.key_size(b, k) if not event['use_cached_runtime']: subprocess.check_output("rm -Rf {}/*".format(RUNTIME_LOC), shell=True) # get the input and save to disk # FIXME here is we where we would attach the "canceled" metadata s3.meta.client.download_file(func_key[0], func_key[1], func_filename) func_download_time = time.time() - start_time response_status['func_download_time'] = func_download_time logger.info("func download complete, took {:3.2f} sec".format( func_download_time)) if data_byte_range is None: s3.meta.client.download_file(data_key[0], data_key[1], data_filename) else: range_str = 'bytes={}-{}'.format(*data_byte_range) dres = s3.meta.client.get_object(Bucket=data_key[0], Key=data_key[1], Range=range_str) data_fid = open(data_filename, 'wb') data_fid.write(dres['Body'].read()) data_fid.close() data_download_time = time.time() - start_time logger.info("data data download complete, took {:3.2f} sec".format( data_download_time)) response_status['data_download_time'] = data_download_time # now split d = json.load(open(func_filename, 'r')) shutil.rmtree(PYTHON_MODULE_PATH, True) # delete old modules os.mkdir(PYTHON_MODULE_PATH) # get modules and save for m_filename, m_text in d['module_data'].items(): m_path = os.path.dirname(m_filename) if len(m_path) > 0 and m_path[0] == "/": m_path = m_path[1:] to_make = os.path.join(PYTHON_MODULE_PATH, m_path) #print "to_make=", to_make, "m_path=", m_path try: os.makedirs(to_make) except OSError as e: if e.errno == 17: pass else: raise e full_filename = os.path.join(to_make, os.path.basename(m_filename)) #print "creating", full_filename fid = open(full_filename, 'wb') fid.write(m_text.encode('utf-8')) fid.close() logger.info("Finished writing {} module files".format( len(d['module_data']))) logger.debug( subprocess.check_output("find {}".format(PYTHON_MODULE_PATH), shell=True)) logger.debug( subprocess.check_output("find {}".format(os.getcwd()), shell=True)) response_status['runtime_s3_key_used'] = runtime_s3_key_used response_status['runtime_s3_bucket_used'] = runtime_s3_bucket_used runtime_cached = download_runtime_if_necessary(s3, runtime_s3_bucket_used, runtime_s3_key_used) logger.info("Runtime ready, cached={}".format(runtime_cached)) response_status['runtime_cached'] = runtime_cached cwd = os.getcwd() jobrunner_path = os.path.join(cwd, "jobrunner.py") extra_env = event.get('extra_env', {}) extra_env['PYTHONPATH'] = "{}:{}".format(os.getcwd(), PYTHON_MODULE_PATH) call_id = event['call_id'] callset_id = event['callset_id'] response_status['call_id'] = call_id response_status['callset_id'] = callset_id CONDA_PYTHON_RUNTIME = "/tmp/condaruntime/bin/python" cmdstr = "{} {} {} {} {}".format(CONDA_PYTHON_RUNTIME, jobrunner_path, func_filename, data_filename, output_filename) setup_time = time.time() response_status['setup_time'] = setup_time - start_time local_env = os.environ.copy() local_env["OMP_NUM_THREADS"] = "1" local_env.update(extra_env) logger.debug("command str=%s", cmdstr) # This is copied from http://stackoverflow.com/a/17698359/4577954 # reasons for setting process group: http://stackoverflow.com/a/4791612 process = subprocess.Popen(cmdstr, shell=True, env=local_env, bufsize=1, stdout=subprocess.PIPE, preexec_fn=os.setsid) logger.info("launched process") def consume_stdout(stdout, queue): with stdout: for line in iter(stdout.readline, b''): queue.put(line) q = Queue() t = Thread(target=consume_stdout, args=(process.stdout, q)) t.daemon = True t.start() stdout = b"" while t.isAlive(): try: line = q.get_nowait() stdout += line logger.info(line) except Empty: time.sleep(PROCESS_STDOUT_SLEEP_SECS) total_runtime = time.time() - start_time if total_runtime > job_max_runtime: logger.warn( "Process exceeded maximum runtime of {} sec".format( job_max_runtime)) # Send the signal to all the process groups os.killpg(os.getpgid(process.pid), signal.SIGTERM) raise Exception( "OUTATIME", "Process executed for too long and was killed") logger.info("command execution finished") s3.meta.client.upload_file(output_filename, output_key[0], output_key[1]) logger.debug("output uploaded to %s %s", output_key[0], output_key[1]) end_time = time.time() response_status['stdout'] = stdout.decode("ascii") response_status['exec_time'] = time.time() - setup_time response_status['end_time'] = end_time response_status['host_submit_time'] = event['host_submit_time'] response_status['server_info'] = get_server_info() response_status.update(context_dict) except Exception as e: # internal runtime exceptions response_status['exception'] = str(e) response_status['exception_args'] = e.args response_status['exception_traceback'] = traceback.format_exc() finally: s3.meta.client.put_object(Bucket=status_key[0], Key=status_key[1], Body=json.dumps(response_status))
def tryRunInThread(): runT = Thread(target=wxPythonApp) runT.setDaemon(True) runT.start() print(runT) print('createThread():', runT.isAlive())
class OkexApi(object): """交易接口""" #---------------------------------------------------------------------- def __init__(self): """Constructor""" self.host = '' # 服务器 self.apiKey = '' # 用户名 self.secretKey = '' # 密码 self.ws = None # websocket应用对象 现货对象 self.thread = None # 初始化线程 #---------------------------------------------------------------------- def reconnect(self): """重新连接""" # 首先关闭之前的连接 self.close() # 再执行重连任务 self.ws = websocket.WebSocketApp(self.host, on_message=self.onMessage, on_error=self.onError, on_close=self.onClose, on_open=self.onOpen) self.thread = Thread(target=self.ws.run_forever) self.thread.start() #---------------------------------------------------------------------- def connect(self, apiKey, secretKey, trace=False): """ 连接网关 :param apiKey : 申请的API key :param secretKey: 签名key :param trace : 是否开启websocket的日志跟踪功能,输出到StreamHandler :return: """ # 更新websocket服务器地址/API key/ self.host = OKEX_USD_SPOT self.apiKey = apiKey self.secretKey = secretKey # 是否开启日志 websocket.enableTrace(trace) # 创建websocket,绑定本地回调函数 onMessage/onError/onClose/onOpen self.ws = websocket.WebSocketApp(self.host, on_message=self.onMessage, on_error=self.onError, on_close=self.onClose, on_open=self.onOpen) self.thread = Thread(target=self.ws.run_forever) self.thread.start() #---------------------------------------------------------------------- def readData(self, evt): """ 解码推送收到的数据 :param evt: :return: """ if isinstance(evt, bytes): evt = evt.decode('utf-8') data = json.loads(evt) return data #---------------------------------------------------------------------- def close(self): """ 关闭接口 :return: """ if self.thread and self.thread.isAlive(): print(u'vnokex.close') self.ws.close() self.thread.join() #---------------------------------------------------------------------- def onMessage(self, ws, evt): """ 信息推送事件 :param ws: 接口 :param evt: 事件 :return: """ print(u'vnokex.onMessage:{}'.format(evt)) #---------------------------------------------------------------------- def onError(self, ws, evt): """ 接口错误推送事件 :param ws: :param evt: :return: """ print(u'vnokex.onApiError:{}'.format(evt)) #---------------------------------------------------------------------- def onClose(self, ws): """ 接口断开事件 :param ws: :return: """ print(u'vnokex.onClose') # ---------------------------------------------------------------------- def onOpen(self, ws): """ 接口打开事件 :param ws: :return: """ print(u'vnokex.onOpen') # ---------------------------------------------------------------------- def inflate(self, data): """解压数据流""" decompress = zlib.decompressobj(-zlib.MAX_WBITS # see above ) inflated = decompress.decompress(data) inflated += decompress.flush() # bytes=>string if isinstance(inflated, bytes): inflated = inflated.decode('utf-8') return inflated #---------------------------------------------------------------------- def generateSign(self, params): """生成签名""" #print(u'vnokex.generateSign') l = [] for key in sorted(params.keys()): l.append('%s=%s' % (key, params[key])) l.append('secret_key=%s' % self.secretKey) sign = '&'.join(l) return hashlib.md5(sign.encode('utf-8')).hexdigest().upper() #---------------------------------------------------------------------- def sendRequest(self, channel, params): """发送指令请求""" #print(u'vnokex.sendRequest:{}'.format(channel)) # 在参数字典中加上api_key和签名字段 params['api_key'] = self.apiKey params['sign'] = self.generateSign(params) # 生成请求 d = {} d['event'] = 'addChannel' d['channel'] = channel d['parameters'] = params # 使用json打包并发送 j = json.dumps(d) # 若触发异常则重连 try: self.ws.send(j) except websocket.WebSocketConnectionClosedException as ex: print(u'vnokex.sendTradingRequest Exception:{}'.format(str(ex)), file=sys.stderr) #---------------------------------------------------------------------- def sendDataRequest(self, channel): """发送数据请求""" #print(u'vnokex.sendDataRequest:{}'.format(channel)) d = {} d['event'] = 'addChannel' d['channel'] = channel j = json.dumps(d) # 若触发异常则重连 try: self.ws.send(j) except websocket.WebSocketConnectionClosedException as ex: print(u'vnokex.sendDataRequest Exception:{},{}'.format( str(ex), traceback.format_exc()), file=sys.stderr) except Exception as ex: print(u'vnokex.sendDataRequest Exception:{},{}'.format( str(ex), traceback.format_exc()), file=sys.stderr) def sendHeartBeat(self): """ 发送心跳 :return: """ d = {'event': 'ping'} # 若触发异常则重连 try: #print(u'vnokex.sendHeartBeat') j = json.dumps(d) self.ws.send(j) except websocket.WebSocketConnectionClosedException as ex: print(u'vnokex.sendHeartBeat Exception:{}'.format(str(ex)), file=sys.stderr) #---------------------------------------------------------------------- def login(self): """ 登录 :return: True/False """ print(u'vnokex.login()') params = {} params['api_key'] = self.apiKey params['sign'] = self.generateSign(params) # 生成请求 d = {} d['event'] = 'login' d['parameters'] = params # 使用json打包并发送 j = json.dumps(d) # 若触发异常则重连 try: self.ws.send(j) return True except websocket.WebSocketConnectionClosedException as ex: print(u'vnokex.login exception:{},{}'.format( str(ex), traceback.format_exc()), file=sys.stderr) return False
class ProgressDownloadThreadedTask(Task): """ Download a resource given its URL using urllib2.urlopen with an optional opener (urllib2.Request object) and some HTTP headers (dictionary), and return the downloaded data. The task calls 'elapsed_cb' every time a chunk of data has been downloaded, the argument being (elapsed, total). Note that the total bytes field will only be set if the response contains a valid 'Content-Length' header, otherwise it default to None. """ def __init__(self, url, opener=None, headers=None, elapsed_cb=None, chunk_size=1024): self.url = url self.opener = opener self.headers = headers self.elapsed_cb = elapsed_cb self.chunk_size = chunk_size self.data = BytesIO() def run(self): self.queue = Queue() self.pause_event = Event() self.cancel_event = Event() self.thread = Thread(target=self._thread_manager) self.thread.setDaemon(True) self.thread.start() self.current_size = 0 self._thread_id = gobject.timeout_add(50, self._thread_receiver) def pause(self): self.pause_event.set() def resume(self): self.pause_event.clear() def cancel(self): self.cancel_event.set() gobject.source_remove(self._thread_id) @propagate_exceptions def _thread_receiver(self): if self.pause_event.isSet(): return True elif not self.thread.isAlive() and self.queue.empty(): self.exception_cb( TaskError("thread is dead but the queue is empty")) return False while not self.queue.empty(): result = self.queue.get() if not result: return False key = result["key"] if key == "restart": self.current_size = 0 if self.elapsed_cb: self.elapsed_cb(self.current_size, result["size"]) self.data = BytesIO() elif key == "exception": self.exception_cb(result["exception"]) return False elif key == "data": self.current_size += len(result["data"]) if self.elapsed_cb: self.elapsed_cb(self.current_size, result["size"]) if result["data"]: self.data.write(result["data"]) else: self.return_cb(self.data.getvalue()) return False else: raise ValueError("Unexpected message in queue") return True def _thread_manager(self): try: request, size = connect_opener(self.url, self.opener, self.headers) while 1: data = request.read(self.chunk_size) if self.cancel_event.isSet(): self.queue.put(None) return elif self.pause_event.isSet(): # on pause, close current request and re-connect later request.close() while self.pause_event.isSet(): if self.cancel_event.isSet(): self.queue.put(None) return time.sleep(0.1) self.queue.put(dict(key="restart", size=size)) request, size = connect_opener(self.url, self.opener, self.headers) continue self.queue.put(dict(key="data", data=data, size=size)) if not data: break except Exception, exc: self.queue.put(dict(key="exception", exception=exc)) raise
class Controller(object): def __init__(self): rospy.loginfo("Initializing Controller") self.known_obj = {"ball", "cup", "object", "arrow"} # Initializing Threads self.mutator_thread = Thread() self.observer_thread = Thread() # initialize node rospy.init_node("control") rospy.on_shutdown(self.shutdown) # Sound handler self.soundhandle = SoundClient() self.voice = 'voice_kal_diphone' self.volume = 1.0 # Modules self.cam = Camera() self.nav = Nav() self.arm = Arm() # Subscribe to speech commands self.sub = rospy.Subscriber("/botty/speech/commands", Command, self.process_command) rospy.loginfo("Controller initialized") rospy.sleep(2) self.say("I am Botty McTurtleface") def process_command(self, cmd): print("Incoming command ...") if cmd.action == Action.STOP: self.stop_all() return if not self.mutator_thread.isAlive(): if cmd.action == Action.GO: self.go(cmd.obj) return if cmd.action == Action.GRAB: self.mutator_thread = Thread(target=self.grab) self.mutator_thread.start() return if not self.observer_thread.isAlive(): if cmd.action == Action.SEARCH: #self.observer_thread = Thread(target=self.search, args=(cmd.obj,)) self.observer_thread = Thread(target=self.search_at, args=(cmd.obj, int(cmd.obj.attr[0]), int(cmd.obj.attr[1]))) self.observer_thread.start() return self.say("I'm already doing something") def stop_all(self): self.say('Canceling actions') self.nav.cancel() self.arm.home() print('Waiting for threads') if self.mutator_thread.isAlive(): self.mutator_thread.join() if self.observer_thread.isAlive(): self.observer_thread.join() self.say('Stopped all Actions') self.nav.resume() def search(self, obj): if obj.name == "all": self.say("I know: " + ', '.join(self.known_obj)) else: found = self.cam.find() if found: if obj.name in found: if obj.attr[0] in found: self.say("Found " + found) else: self.say("Found similar object: " + found) else: self.say("Not found, but found: " + found) return True else: self.say("Couldn't find object") return False def search_at(self, obj, x, y): self.say("Going to Position " + str(x) + ", " + str(y)) if not self.nav.go_to(x, y): return #if not self.nav.drive(x, 1): # return #if not self.nav.turn(90): # return #if not self.nav.drive(y, 1): # return self.say("Searching for " + obj.name) for x in range(4): rospy.sleep(0.5) tmp = self.cam.findObj(obj) rospy.sleep(0.5) if tmp != None: self.say("I found: " + tmp) return elif not self.nav.turn(87): return self.say("I didn't find " + obj.name) def go(self, obj): if obj.name == "forward": self.mutator_thread = Thread(target=self.nav.drive, args=( 2, 1, )) elif obj.name == "right": self.mutator_thread = Thread(target=self.nav.turn, args=(90, )) elif obj.name == "left": self.mutator_thread = Thread(target=self.nav.turn, args=(-90, )) elif obj.name == "docking station" and self.nav.enable_dock: self.mutator_thread = Thread(target=self.nav.dock) elif obj.name == "position": self.mutator_thread = Thread(target=self.nav.go_to, args=( int(obj.attr[0]), int(obj.attr[1]), )) else: self.say("Unknown place or direction") return self.say('Moving ' + obj.name + " ...") self.mutator_thread.start() def grab(self): self.say("Grabbing object") self.arm.push() self.say("oops") self.arm.home() def say(self, txt): print('Saying: %s' % txt) self.soundhandle.stopAll() self.soundhandle.say(txt, self.voice, self.volume) def shutdown(self): rospy.loginfo("Stopping Controller") self.stop_all() rospy.sleep(1)
class ReInstall(Install): """ AWS provider for destroy command Attributes: executed_with_error (boolean): this is set to True if any error occurs FOLDER_EXISTS_ERROR_NO (int): Error number of folder creation failure install_statuses (dict): Available destroy statuses terraform_thread (thread): Install python thread terraform_outputs (dict): Terraform output dict current_install_status (int): Current install status """ destroy = False def run_tf_execution_and_status_threads(self, resources, terraform_with_targets, dry_run): """ Creates 2 thread 1. For actualy installation 2. For displaying the status of installation Since python is interpreted language we need to create threads to display the status in one and actual process in another Args: resources (list): Resources to be installed terraform_with_targets (boolean): If partial install is to be done (if --tags is supplied) dry_run (boolean): Decides whether original install should be done """ self.terraform_thread = Thread(target=self.re_create_resources, args=(list(resources), terraform_with_targets, dry_run)) progressbar_thread = Thread(target=self.show_progress_status, args=(list(resources), terraform_with_targets, dry_run)) self.terraform_thread.start() progressbar_thread.start() self.terraform_thread.join() progressbar_thread.join() def re_create_resources(self, resources, terraform_with_targets, dry_run): """ Start installing the resources by calling PyTerraform class destroy Args: resources (list): Resources to be created terraform_with_targets (boolean): If partial install is to be done (if --tags is supplied) dry_run (boolean): Decides whether original install should be done """ try: if not dry_run: PyTerraform().terraform_destroy(resources) self.destroy = True self.terraform_apply(resources, terraform_with_targets, dry_run) except Exception as e: self.executed_with_error = True self.exception = e self._cleanup_installation_process(dry_run) def show_progress_status(self, resources, terraform_with_targets, dry_run): """ Show the status of installation continously in this thread Args: resources (list): Resources to be created terraform_with_targets (boolean): If partial install is to be done (if --tags is supplied) dry_run (boolean): Decides whether original install should be done """ self.render_terraform_destroy_progress() super().show_progress_status(resources, terraform_with_targets, dry_run) def render_terraform_destroy_progress(self): """Show the status of terraform init command execution""" start_time = datetime.now() self.show_step_heading(K.TERRAFORM_DESTROY_STARTED, write_log=False) while self.destroy is False and self.terraform_thread.isAlive(): self.show_progress_message(K.TERRAFORM_DESTROY_STARTED, 0.5)
def _pms_list_from_plex_tv(token): """ get Plex media Server List from plex.tv/pms/resources """ xml = DU().downloadUrl('https://plex.tv/api/resources', authenticate=False, parameters={'includeHttps': 1}, headerOptions={'X-Plex-Token': token}) try: xml.attrib except AttributeError: LOG.error('Could not get list of PMS from plex.tv') return from Queue import Queue queue = Queue() thread_queue = [] max_age_in_seconds = 2*60*60*24 for device in xml.findall('Device'): if 'server' not in device.get('provides'): # No PMS - skip continue if device.find('Connection') is None: # no valid connection - skip continue # check MyPlex data age - skip if >2 days info_age = time() - int(device.get('lastSeenAt')) if info_age > max_age_in_seconds: LOG.debug("Skip server %s not seen for 2 days", device.get('name')) continue pms = { 'machineIdentifier': device.get('clientIdentifier'), 'name': device.get('name'), 'token': device.get('accessToken'), 'ownername': device.get('sourceTitle'), 'product': device.get('product'), # e.g. 'Plex Media Server' 'version': device.get('productVersion'), # e.g. '1.11.2.4772-3e...' 'device': device.get('device'), # e.g. 'PC' or 'Windows' 'platform': device.get('platform'), # e.g. 'Windows', 'Android' 'local': device.get('publicAddressMatches') == '1', 'owned': device.get('owned') == '1', 'relay': device.get('relay') == '1', 'presence': device.get('presence') == '1', 'httpsRequired': device.get('httpsRequired') == '1', 'connections': [] } # Try a local connection first, no matter what plex.tv tells us for connection in device.findall('Connection'): if connection.get('local') == '1': pms['connections'].append(connection) # Then try non-local for connection in device.findall('Connection'): if connection.get('local') != '1': pms['connections'].append(connection) # Spawn threads to ping each PMS simultaneously thread = Thread(target=_poke_pms, args=(pms, queue)) thread_queue.append(thread) max_threads = 5 threads = [] # poke PMS, own thread for each PMS while True: # Remove finished threads for thread in threads: if not thread.isAlive(): threads.remove(thread) if len(threads) < max_threads: try: thread = thread_queue.pop() except IndexError: # We have done our work break else: thread.start() threads.append(thread) else: sleep(50) # wait for requests being answered for thread in threads: thread.join() # declare new PMSs pms_list = [] while not queue.empty(): pms = queue.get() del pms['connections'] pms_list.append(pms) queue.task_done() return pms_list
def loading(sleep=None, function=None, speed=None, method=None, argument=None, output=None): # show error function ... def error(problem): print('tekrar module - error | python file : ' + python_file_name + ' | line : ' + line_python_file + ' | problem : ' + problem) # colored stars animate functions ... class star: BLUE = '{blue}*'.format(blue='\033[94m') GREEN = '{green}*'.format(green='\033[92m') RED = '{red}*'.format(red='\033[91m') YELLOW = '{yellow}*'.format(yellow='\033[33m') # find (filename or line) python file ... x = stack()[1] x = x[0] get_python_file_name_or_line = getframeinfo(x) # set valur for find line in python file ... line_python_file = str(get_python_file_name_or_line.lineno) # set value for find python file name ... python_file_name = str(get_python_file_name_or_line.filename) # ------------------------------------------------------------------------------------------------------------------------------------------------------------------ # all argument is None ... list_argument = [sleep, function, speed, method, argument, output] if list_argument == [None, None, None, None, None, None]: error('please use arguments ...') return # function has value ... if function is not None: # set method , default 1 ... if method is None: method = 1 elif type(method) is not int: error('\'method\' argument must be number range of 1 to 2 ...') return elif method == 0: error('\'method\' argument must be number range of 1 to 2 ...') return elif method > 2: error('\'method\' argument must be number range of 1 to 2 ...') return # set value for speed ... if speed is None: speed = 0.040 elif speed is not None: if type(speed) is not int: error('\'speed\' argument must be number range of 1 to 10 ...') return elif speed == 1: speed = 0.020 elif speed == 2: speed = 0.030 elif speed == 3: speed = 0.040 elif speed == 4: speed = 0.050 elif speed == 5: speed = 0.060 elif speed == 6: speed = 0.070 elif speed == 7: speed = 0.080 elif speed == 8: speed = 0.090 elif speed == 9: speed = 0.200 elif speed == 10: speed = 0.350 elif speed > 10: error('\'speed\' argument must be number range of 1 to 10 ...') return # cannot use simultaneously 'sleep' and 'function' argument ... if sleep is not None: error( 'if use \'sleep\' argument , cannot use \'function\' argument and vice versa ...' ) return # argument has value ... if argument is not None: if type(argument) is not list: error('argument \'argument\' must be a list type ...') return # output no value ... if output is None: output = True # output has value ... elif output is not None: if type(output) is not bool: error('argument \'output\' must be boolean type ...') return # function no value ... elif function is None: # sleep no value ... if sleep is None: # sleep has value ... if speed is not None: error( 'need \'sleep\' or \'function\' argument to use the \'speed\' argument ...' ) return # method has value ... elif method is not None: error( 'need \'sleep\' or \'function\' argument to use the \'method\' argument ...' ) return # argument has value ... if argument is not None: error( 'need \'function\' argument to use the \'argument\' argument ...' ) return # output has value ... if output is not None: error( 'need \'function\' argument to use the \'output\' argument ...' ) return # output has value ... if output is not None: error( 'need \'function\' argument to use the \'output\' argument ...' ) return # sleep has value ... if sleep is not None: if type(sleep) is not int: error('argument \'sleep\' must be a int type ...') return # set method , default 1 ... if method is None: method = 1 elif type(method) is not int: error('\'method\' argument must be number range of 1 to 2 ...') return elif method == 0: error('\'method\' argument must be number range of 1 to 2 ...') elif method > 2: error('\'method\' argument must be number range of 1 to 2 ...') return # set value for speed ... if speed is None: speed = 0.040 elif speed is not None: if type(speed) is not int: error('\'speed\' argument must be number range of 1 to 10 ...') return elif speed == 1: speed = 0.020 elif speed == 2: speed = 0.030 elif speed == 3: speed = 0.040 elif speed == 4: speed = 0.050 elif speed == 5: speed = 0.060 elif speed == 6: speed = 0.070 elif speed == 7: speed = 0.080 elif speed == 8: speed = 0.090 elif speed == 9: speed = 0.200 elif speed == 10: speed = 0.350 elif speed > 10: error('\'speed\' argument must be number range of 1 to 10 ...') return # ----------------------------------------------------------------------------------------------------------------------------------------------------------- # fix show text color ... system('') # if finished is True break animate function ... finished = False # check command prompet columns size if ostype().upper() == 'WINDOWS': resize = str(check_output("mode con:", shell=True)) resize = resize.split('\\r\\n K', 1)[0] a = resize[-3] b = resize[-2] c = resize[-1] resize = a + b + c resize = resize.replace(' ', '') elif ostype().upper() == 'LINUX': resize = str(check_output("resize", shell=True)) resize = resize[10], resize[11], resize[12] resize = str(resize) resize = resize.replace(' ', '') resize = resize.replace(',', '') resize = resize.replace('\'', '') resize = resize.replace(')', '') resize = resize.replace('(', '') resize = resize.replace(';', '') # command prompet size method 1 ... command_line_size_method_1 = int(resize) # command prompet half size method 2 ... half_command_line_size_method_1 = (command_line_size_method_1 - 3) // 2 # command prompet size method 2 ... command_line_size_method_2 = int(resize) - 4 # -------------------------------------------------------------------------------------------------------------------------------------------------------------------- # b is blue , g is green , r is red , y is yellow in animate method 1 comment ... # animate method 1 function ... def animate_method_1(speed): # hide command line cursor ... hide() # infinite repetition until forced exit ... while True: # show loading ... for space in range(half_command_line_size_method_1): # end color ... stdout.write('\033[0m') # exit from animate function method 2 , if runtime ended ... if (not thread.isAlive()) or (finished): # show command line cursor ... show() # delete line and close animate function ... stdout.write('\r\b \b' * int(resize)) stdout.write(' ' * int(resize) + '\r') return # delete line ... stdout.flush() stdout.write('\b \b' * int(resize)) zzz(speed) stdout.write(' ' * command_line_size_method_1 + '\r') # show loading , | bgy r | stdout.write(' ' * half_command_line_size_method_1 + star.BLUE + star.GREEN + star.YELLOW + ' ' * space + star.RED) # show loading ... for space in range(half_command_line_size_method_1): # end color ... stdout.write('\033[0m') # exit from animate function method 2 , if runtime ended ... if (not thread.isAlive()) or (finished): # show command line cursor ... show() # delete line and close animate function ... stdout.write('\r\b \b' * int(resize)) stdout.write(' ' * int(resize) + '\r') return # add star to 3 stars from left varable reverse = (half_command_line_size_method_1 - 1) - space # delete line ... stdout.flush() stdout.write('\b \b' * int(resize)) zzz(speed) stdout.write(' ' * command_line_size_method_1 + '\r') # show loading , | r bgy | stdout.write(' ' * space + star.RED + ' ' * reverse + star.BLUE + star.GREEN + star.YELLOW) # show loading ... for space in range(half_command_line_size_method_1): # end color ... stdout.write('\033[0m') # exit from animate function method 2 , if runtime ended ... if (not thread.isAlive()) or (finished): # show command line cursor ... show() # delete line and close animate function ... stdout.write('\r\b \b' * int(resize)) stdout.write(' ' * int(resize) + '\r') return # delete line ... stdout.flush() stdout.write('\b \b' * int(resize)) zzz(speed) stdout.write(' ' * command_line_size_method_1 + '\r') # show loading , | rbg y | stdout.write(' ' * half_command_line_size_method_1 + star.RED + star.BLUE + star.GREEN + ' ' * space + star.YELLOW) # show loading ... for space in range(half_command_line_size_method_1): # end color ... stdout.write('\033[0m') # exit from animate function method 2 , if runtime ended ... if (not thread.isAlive()) or (finished): # show command line cursor ... show() # delete line and close animate function ... stdout.write('\r\b \b' * int(resize)) stdout.write(' ' * int(resize) + '\r') return # add star to 3 stars from left varable reverse = (half_command_line_size_method_1 - 1) - space # delete line ... stdout.flush() stdout.write('\b \b' * int(resize)) zzz(speed) stdout.write(' ' * command_line_size_method_1 + '\r') # show loading , | y rgbg | stdout.write(' ' * space + star.YELLOW + ' ' * reverse + star.RED + star.BLUE + star.GREEN) # show loading ... for space in range(half_command_line_size_method_1): # end color ... stdout.write('\033[0m') # exit from animate function method 2 , if runtime ended ... if (not thread.isAlive()) or (finished): # show command line cursor ... show() # delete line and close animate function ... stdout.write('\r\b \b' * int(resize)) stdout.write(' ' * int(resize) + '\r') return # delete line ... stdout.flush() stdout.write('\b \b' * int(resize)) zzz(speed) stdout.write(' ' * command_line_size_method_1 + '\r') # show loading , | yrb g | stdout.write(' ' * half_command_line_size_method_1 + star.YELLOW + star.RED + star.BLUE + ' ' * space + star.GREEN) # show loading ... for space in range(half_command_line_size_method_1): # end color ... stdout.write('\033[0m') # exit from animate function method 2 , if runtime ended ... if (not thread.isAlive()) or (finished): # show command line cursor ... show() # delete line and close animate function ... stdout.write('\r\b \b' * int(resize)) stdout.write(' ' * int(resize) + '\r') return # add star to 3 stars from left varable ... reverse = (half_command_line_size_method_1 - 1) - space # delete line ... stdout.flush() stdout.write('\b \b' * int(resize)) zzz(speed) stdout.write(' ' * command_line_size_method_1 + '\r') # show loading , | g yrb | stdout.write(' ' * space + star.GREEN + ' ' * reverse + star.YELLOW + star.RED + star.BLUE) # show loading ... for space in range(half_command_line_size_method_1): # exit from animate function method 2 , if runtime ended ... if (not thread.isAlive()) or (finished): # show command line cursor ... show() # delete line and close animate function ... stdout.write('\r\b \b' * int(resize)) stdout.write(' ' * command_line_size_method_1 + '\033[0m\r') return # end color ... stdout.write('\033[0m') # delete line ... stdout.flush() stdout.write('\b \b' * int(resize)) zzz(speed) stdout.write(' ' * command_line_size_method_1 + '\r') # show loading , | gyr b | stdout.write(' ' * half_command_line_size_method_1 + star.GREEN + star.YELLOW + star.RED + ' ' * space + star.BLUE) # show loading ... for space in range(half_command_line_size_method_1): # exit from animate function method 2 , if runtime ended ... if (not thread.isAlive()) or (finished): # show command line cursor ... show() # delete line and close animate function ... stdout.write('\r\b \b' * int(resize)) stdout.write(' ' * command_line_size_method_1 + '\033[0m\r') return # end color ... stdout.write('\033[0m') # add star to 3 stars from left varable reverse = (half_command_line_size_method_1 - 1) - space # delete line ... stdout.flush() stdout.write('\b \b' * int(resize)) zzz(speed) stdout.write(' ' * command_line_size_method_1 + '\r') # show loading , | b gyr | stdout.write(' ' * space + star.BLUE + ' ' * reverse + star.GREEN + star.YELLOW + star.RED) # --------------------------------------------------------------------------------------------------------------------------------------------------------------------------- # animate method 2 function ... def animate_method_2(speed): # hide command line cursor ... hide() # infinite repetition until forced exit ... while True: # move stars from left to right for space in range(command_line_size_method_2): # end color ... stdout.write('\033[0m') # exit from animate function method 2 , if runtime ended ... if (not thread.isAlive()) or (finished): # show command line cursor ... show() # delete line and close animate function ... stdout.write('\r\033[D \033[D' * int(resize)) stdout.write(' ' * int(resize) + '\r') return # stars variable ... stars = ' ' * space + "***" # set stars random color ... colors = [ '\x1b[34m', '\x1b[36m', '\x1b[32m', '\x1b[90m', '\x1b[94m', '\x1b[96m', '\x1b[92m', '\x1b[95m', '\x1b[91m', '\x1b[97m', '\x1b[93m', '\x1b[35m', '\x1b[31m', '\x1b[39m', '\x1b[37m', '\x1b[33m' ] # delete line ... stdout.flush() stdout.write('\033[D \033[D' * int(resize)) zzz(speed) stdout.write(' ' * int(resize) + '\r') # show stars random color ... stdout.write(''.join([choice(colors) + char for char in stars])) # move stars from right to left for space in range(command_line_size_method_2): # end color ... stdout.write('\033[0m') # exit from animate function method 2 , if runtime ended ... if (not thread.isAlive()) or (finished): # show command line cursor ... show() # delete line and close animate function ... stdout.write('\r\b \b' * int(resize)) stdout.write(' ' * int(resize) + '\r') return # stars variable ... stars = ' ' * (command_line_size_method_2 - space) + "***" # set stars random color ... colors = [ '\x1b[34m', '\x1b[36m', '\x1b[32m', '\x1b[90m', '\x1b[94m', '\x1b[96m', '\x1b[92m', '\x1b[95m', '\x1b[91m', '\x1b[97m', '\x1b[93m', '\x1b[35m', '\x1b[31m', '\x1b[39m', '\x1b[37m', '\x1b[33m' ] # delete line ... stdout.flush() stdout.write('\b \b' * int(resize)) zzz(speed) stdout.write(' ' * int(resize) + '\r') # show stars random color ... stdout.write(''.join([choice(colors) + char for char in stars])) # ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------- # create loading by sleep ... if sleep is not None: # animate method function selection ... if method == 1: # show animate function method 1 ... thread = Thread(target=animate_method_1, args=[speed]) thread.start() # if sleep time ended break animate function ... zzz(sleep) # delete line ... stdout.write('\b \b' * int(resize)) stdout.write(' ' * int(resize) + '\033[0m\r') # if finished is True breaked animate method 1 function ... finished = True elif method == 2: # show animate function method 2 ... thread = Thread(target=animate_method_2, args=[speed]) # start thread ... thread.start() # if sleep time ended break animate function ... zzz(sleep) # delete line ... stdout.write('\b \b' * int(resize)) stdout.write(' ' * int(resize) + '\033[0m\r') # if finished is True breaked animate method 2 function ... finished = True # -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- # create loading by function ... elif function is not None: # check function return value ... return_value = Queue() def storeInQueue(function): def returned(*args): try: return_value.put(function(*args)) except TypeError: error( 'content of the \'argument\' argument does not match the arguments for \'function\' ...' ) return returned # redirect function stdout ... def redirect(f): def wrapper(*args, **kwargs): default_stdout = sys.stdout if ostype().upper() == 'LINUX': sys.stdout = open('/dev/null', 'w') elif ostype().upper() == 'WINDOWS': sys.stdout = open('file', 'w') try: return f(*args, **kwargs) except TypeError: error( 'content of the \'argument\' argument does not match the arguments for \'function\' ...' ) return finally: sys.stdout.close() sys.stdout = default_stdout return wrapper # output is False , redirect function output ... if output is False: # if is arguments ... if argument is not None: # if type 'argument' is not list show error ... if type(argument) is not list: error('argument \'argument\' must be a list type ...') return # create thread ... thread = Thread(target=storeInQueue(redirect(function)), args=argument) # if is not arguments ... elif argument is None: # create thread ... thread = Thread(target=storeInQueue(redirect(function))) # output is True , can't redirect function output ... elif output is True: # if is argument ... if argument is not None: # create thread ... thread = Thread(target=storeInQueue(function), args=argument) # if is not arguments ... elif argument is None: # create thread ... thread = Thread(target=storeInQueue(function)) # start thread and show loading ... thread.start() # if function is running ... while thread.isAlive(): # selection method to show animate ... if method == 1: animate_method_1(speed) elif method == 2: animate_method_2(speed) # return function value ... return return_value.get()
class LhangApi(object): """""" DEBUG = True #---------------------------------------------------------------------- def __init__(self): """Constructor""" self.apiKey = '' self.secretKey = '' self.interval = 1 # 每次请求的间隔等待 self.active = False # API工作状态 self.reqID = 0 # 请求编号 self.reqQueue = Queue() # 请求队列 self.reqThread = Thread(target=self.processQueue) # 请求处理线程 #---------------------------------------------------------------------- def init(self, apiKey, secretKey, interval): """初始化""" self.apiKey = apiKey self.secretKey = secretKey self.interval = interval self.active = True self.reqThread.start() #---------------------------------------------------------------------- def exit(self): """退出""" self.active = False if self.reqThread.isAlive(): self.reqThread.join() #---------------------------------------------------------------------- def processRequest(self, req): """处理请求""" # 读取方法和参数 api, method = req['function'] params = req['params'] url = LHANG_API_ROOT + api # 在参数中增加必须的字段 params['api_key'] = self.apiKey # 添加签名 sign = signature(params, self.secretKey) params['sign'] = sign # 发送请求 payload = urllib.urlencode(params) r = requests.request(method, url, params=payload) if r.status_code == 200: data = r.json() return data else: return None #---------------------------------------------------------------------- def processQueue(self): """处理请求队列中的请求""" while self.active: try: req = self.reqQueue.get(block=True, timeout=1) # 获取请求的阻塞为一秒 callback = req['callback'] reqID = req['reqID'] data = self.processRequest(req) # 请求失败 if data is None: error = u'请求失败' self.onError(error, req, reqID) elif 'error_code' in data: error = u'请求出错,错误代码:%s' % data['error_code'] self.onError(error, req, reqID) # 请求成功 else: if self.DEBUG: print callback.__name__ callback(data, req, reqID) # 流控等待 sleep(self.interval) except Empty: pass #---------------------------------------------------------------------- def sendRequest(self, function, params, callback): """发送请求""" # 请求编号加1 self.reqID += 1 # 生成请求字典并放入队列中 req = {} req['function'] = function req['params'] = params req['callback'] = callback req['reqID'] = self.reqID self.reqQueue.put(req) # 返回请求编号 return self.reqID #---------------------------------------------------------------------- def onError(self, error, req, reqID): """错误推送""" print error, req, reqID ############################################### # 行情接口 ############################################### #---------------------------------------------------------------------- def getTicker(self, symbol): """查询行情""" function = FUNCTION_TICKER params = {'symbol': symbol} callback = self.onGetTicker return self.sendRequest(function, params, callback) # ---------------------------------------------------------------------- def getDepth(self, symbol, size, merge): """查询深度""" function = FUNCTION_DEPTH params = {'symbol': symbol, 'size': size, 'mege': merge} callback = self.onGetDepth return self.sendRequest(function, params, callback) # ---------------------------------------------------------------------- def getTrades(self, symbol, size, time): """查询历史成交""" function = FUNCTION_TRADES params = {'symbol': symbol, 'size': size, 'time': time} callback = self.onGetTrades return self.sendRequest(function, params, callback) # ---------------------------------------------------------------------- def getKline(self, symbol, size, type_, time): """查询K线""" function = FUNCTION_TRADES params = {'symbol': symbol, 'size': size, 'type': type_, 'time': time} callback = self.onGetKline return self.sendRequest(function, params, callback) #---------------------------------------------------------------------- def onGetTicker(self, data, req, reqID): """查询行情回调""" print data, reqID # ---------------------------------------------------------------------- def onGetDepth(self, data, req, reqID): """查询深度回调""" print data, reqID # ---------------------------------------------------------------------- def onGetTrades(self, data, req, reqID): """查询历史成交""" print data, reqID # ---------------------------------------------------------------------- def onGetKline(self, data, req, reqID): """查询K线回报""" print data, reqID ############################################### # 交易接口 ############################################### # ---------------------------------------------------------------------- def getUserInfo(self): """查询K线""" function = FUNCTION_USERINFO params = {} callback = self.onGetUserInfo return self.sendRequest(function, params, callback) # ---------------------------------------------------------------------- def createOrder(self, symbol, type_, price, amount): """发送委托""" function = FUNCTION_CREATEORDER params = { 'symbol': symbol, 'type': type_, 'price': price, 'amount': amount } callback = self.onCreateOrder return self.sendRequest(function, params, callback) # ---------------------------------------------------------------------- def cancelOrder(self, symbol, orderId): """撤单""" function = FUNCTION_CANCELORDER params = {'symbol': symbol, 'order_id': orderId} callback = self.onCancelOrder return self.sendRequest(function, params, callback) # ---------------------------------------------------------------------- def getOrdersInfo(self, symbol, orderId): """查询委托""" function = FUNCTION_ORDERSINFO params = {'symbol': symbol, 'order_id': orderId} callback = self.onGetOrdersInfo return self.sendRequest(function, params, callback) # ---------------------------------------------------------------------- def getOrdersInfoHistory(self, symbol, status, currentPage, pageLength): """撤单""" function = FUNCTION_ORDERSINFOHISTORY params = { 'symbol': symbol, 'status': status, 'current_page': currentPage, 'page_length': pageLength } callback = self.onGetOrdersInfoHistory return self.sendRequest(function, params, callback) # ---------------------------------------------------------------------- def onGetUserInfo(self, data, req, reqID): """查询K线回报""" print data, reqID # ---------------------------------------------------------------------- def onCreateOrder(self, data, req, reqID): """委托回报""" print data, reqID # ---------------------------------------------------------------------- def onCancelOrder(self, data, req, reqID): """撤单回报""" print data, reqID # ---------------------------------------------------------------------- def onGetOrdersInfo(self, data, req, reqID): """查询委托回报""" print data, reqID # ---------------------------------------------------------------------- def onGetOrdersInfoHistory(self, data, req, reqID): """撤单回报""" print data, reqID
class VideoStream: frame = None grabbed = None stream = None stopped = True paused = False src = None net = None def __init__(self, src=0): self.state = 'creating' if type(src) == int: self.src = src log.info('Creating camera %s' % src) self.stream = cv2.VideoCapture(get_cam(src)) self.stream.set(3, 320) self.stream.set(4, 240) try: # self.grabbed, self.frame = self.stream.read() self.grabbed = self.stream.grab() except Exception as e: log.error('Camera %s error: %s' % (self.src, e)) self.stopped = False else: pattern = r"^http:\/\/(?P<ip>[0-9.]+):(?P<port>[0-9]+)\/(?P<fn>.+)\.(?P<ft>.+)$" self.net = re.search(pattern, src).groupdict() self.src = str(src) self.stopped = False self.paused = True self.time = time() self.th = Thread(target=self.update) self.th.start() def netconn(self): stream = None while stream is None: try: stream = urllib.urlopen(self.src, timeout=1) except Exception as e: log.error(self.src + ': ' + str(e)) sleep(1) return stream def update(self): try: if type(self.src) == str: stream = None self.data = bytes() self.state = 'starting' while RUN: if self.stopped: log.warning('cam %s stoping' % str(self.src)) self.state = 'stopped' return if self.paused: self.state = 'paused' continue if stream is None: self.state = 'wait for stream' stream = self.netconn() if len(self.data) == 0: while self.data != b'-': self.state = 'wait for "-"' try: self.data = stream.read(1) except Exception as e: log.error(e) self.data = bytes() stream.close() stream = None continue try: self.state = 'read stream %i' % len(self.data) self.data += stream.read(1) except Exception as e: log.error(e) self.data = bytes() stream.close() stream = None continue b = self.data.find(b'\r\n\r\n') if b == -1: if len(self.data) > 1000: self.state = 'reset' self.data = bytes() continue a = self.data.find(b'--') if a != -1 and b != -1: head = self.data[a:b].split('\r\n') self.data = bytes() for i in head: if 'length' in i: l = int(i[i.find(': ') + 2:]) self.jpg = bytes() while len(self.jpg) < l: try: self.state = 'read jpg' self.jpg += stream.read(l - len(self.jpg)) except Exception as e: log.error(str(e)) stream.close() stream = None self.jpg = bytes() break if len(self.jpg) == l: try: self.state = 'parse jpg' img = cv2.imdecode( np.fromstring(self.jpg, dtype=np.uint8), cv2.IMREAD_COLOR) self.frame = img self.time = time() except Exception as e: log.error(e) else: while RUN: if self.stopped: self.state = 'stopped' log.warning('cam %s stoping' % str(self.src)) return if self.paused: self.state = 'paused' continue try: self.grabbed = self.stream.grab() self.state = 'get frame' _, self.frame = self.stream.retrieve() self.time = time() except Exception as e: log.error('Camera %s error: %s' % (self.src, e)) except Exception as e: log.critical(str(e)) def read(self): if self.paused: log.debug('cam %s -> start' % str(self.src)) self.paused = False if not self.th.isAlive(): log.critical('Thread %s not alive, restarting...' % self.src) self.th = Thread(target=self.update) self.th.start() img = self.frame return img def pause(self): self.paused = True log.debug('cam %s -> pause' % str(self.src)) return self def start(self): self.paused = False log.debug('cam %s -> start' % str(self.src)) return self def stop(self): self.stopped = True log.debug('cam %s -> stop' % str(self.src)) return self def __del__(self): self.stop() self.stream.release() def __str__(self): f = self.read() if f is not None: return cv2.imencode(".png", self.frame)[1].tostring() return ''
class CollectionScanner(GObject.GObject, TagReader): """ Scan user music collection """ __gsignals__ = { 'scan-finished': (GObject.SignalFlags.RUN_FIRST, None, ()), 'artist-updated': (GObject.SignalFlags.RUN_FIRST, None, (int, bool)), 'genre-updated': (GObject.SignalFlags.RUN_FIRST, None, (int, bool)), 'album-updated': (GObject.SignalFlags.RUN_FIRST, None, (int, bool)) } def __init__(self): """ Init collection scanner """ GObject.GObject.__init__(self) TagReader.__init__(self) self.__thread = None self.__history = None if Lp().settings.get_value('auto-update'): self.__inotify = Inotify() else: self.__inotify = None Lp().albums.update_max_count() def update(self): """ Update database """ if not self.is_locked(): uris = Lp().settings.get_music_uris() if not uris: return Lp().window.progress.add(self) Lp().window.progress.set_fraction(0.0, self) if Lp().notify is not None: Lp().notify.send(_("Your music is updating")) self.__thread = Thread(target=self.__scan, args=(uris, )) self.__thread.daemon = True self.__thread.start() def clean_charts(self): """ Clean charts in db """ self.__thread = Thread(target=self.__clean_charts) self.__thread.daemon = True self.__thread.start() def is_locked(self): """ Return True if db locked """ return self.__thread is not None and self.__thread.isAlive() def stop(self): """ Stop scan """ self.__thread = None ####################### # PRIVATE # ####################### def __clean_charts(self): """ Clean charts in db """ track_ids = Lp().tracks.get_charts() Lp().db.del_tracks(track_ids) self.stop() def __get_objects_for_uris(self, uris): """ Return all tracks/dirs for uris @param uris as string @return (track uri as [str], track dirs as [str], ignore dirs as [str]) """ tracks = [] ignore_dirs = [] track_dirs = list(uris) walk_uris = list(uris) while walk_uris: uri = walk_uris.pop(0) empty = True try: d = Lio.File.new_for_uri(uri) infos = d.enumerate_children( 'standard::name,standard::type,standard::is-hidden', Gio.FileQueryInfoFlags.NONE, None) except Exception as e: print("CollectionScanner::__get_objects_for_uris():", e) continue for info in infos: f = infos.get_child(info) child_uri = f.get_uri() empty = False if info.get_is_hidden(): continue elif info.get_file_type() == Gio.FileType.DIRECTORY: track_dirs.append(child_uri) walk_uris.append(child_uri) else: try: f = Lio.File.new_for_uri(child_uri) if is_pls(f): pass elif is_audio(f): tracks.append(child_uri) else: debug("%s not detected as a music file" % uri) except Exception as e: print( "CollectionScanner::" "__get_objects_for_uris():", e) # If a root uri is empty # Ensure user is not doing something bad if empty and uri in uris: ignore_dirs.append(uri) return (tracks, track_dirs, ignore_dirs) def __update_progress(self, current, total): """ Update progress bar status @param scanned items as int, total items as int """ Lp().window.progress.set_fraction(current / total, self) def __finish(self): """ Notify from main thread when scan finished """ Lp().window.progress.set_fraction(1.0, self) self.stop() self.emit("scan-finished") # Update max count value Lp().albums.update_max_count() if Lp().settings.get_value('artist-artwork'): Lp().art.cache_artists_info() def __scan(self, uris): """ Scan music collection for music files @param uris as [string], uris to scan @thread safe """ gst_message = None if self.__history is None: self.__history = History() mtimes = Lp().tracks.get_mtimes() (new_tracks, new_dirs, ignore_dirs) = self.__get_objects_for_uris(uris) orig_tracks = Lp().tracks.get_uris(ignore_dirs) was_empty = len(orig_tracks) == 0 if ignore_dirs: if Lp().notify is not None: Lp().notify.send(_("Lollypop is detecting an empty folder."), _("Check your music settings.")) count = len(new_tracks) + len(orig_tracks) # Add monitors on dirs if self.__inotify is not None: for d in new_dirs: self.__inotify.add_monitor(d) with SqlCursor(Lp().db) as sql: i = 0 # Look for new files/modified files try: to_add = [] for uri in new_tracks: if self.__thread is None: return GLib.idle_add(self.__update_progress, i, count) f = Lio.File.new_for_uri(uri) info = f.query_info('time::modified', Gio.FileQueryInfoFlags.NONE, None) mtime = int(info.get_attribute_as_string('time::modified')) # If songs exists and mtime unchanged, continue, # else rescan if uri in orig_tracks: orig_tracks.remove(uri) i += 1 if mtime <= mtimes[uri]: i += 1 continue else: self.__del_from_db(uri) # On first scan, use modification time # Else, use current time if not was_empty: mtime = int(time()) to_add.append((uri, mtime)) # Clean deleted files # Now because we need to populate history for uri in orig_tracks: i += 1 GLib.idle_add(self.__update_progress, i, count) if uri.startswith('file:'): self.__del_from_db(uri) # Add files to db for (uri, mtime) in to_add: try: debug("Adding file: %s" % uri) i += 1 GLib.idle_add(self.__update_progress, i, count) self.__add2db(uri, mtime) except GLib.GError as e: print("CollectionScanner::__scan:", e) if e.message != gst_message: gst_message = e.message if Lp().notify is not None: Lp().notify.send(gst_message) sql.commit() except Exception as e: print("CollectionScanner::__scan()", e) GLib.idle_add(self.__finish) del self.__history self.__history = None def __add2db(self, uri, mtime): """ Add new file to db with informations @param uri as string @param mtime as int @return track id as int """ f = Lio.File.new_for_uri(uri) debug("CollectionScanner::add2db(): Read tags") info = self.get_info(uri) tags = info.get_tags() name = f.get_basename() title = self.get_title(tags, name) artists = self.get_artists(tags) composers = self.get_composers(tags) performers = self.get_performers(tags) a_sortnames = self.get_artist_sortnames(tags) aa_sortnames = self.get_album_artist_sortnames(tags) album_artists = self.get_album_artist(tags) album_name = self.get_album_name(tags) genres = self.get_genres(tags) discnumber = self.get_discnumber(tags) discname = self.get_discname(tags) tracknumber = self.get_tracknumber(tags, name) year = self.get_year(tags) duration = int(info.get_duration() / 1000000000) # If no artists tag, use album artist if artists == '': artists = album_artists # if artists is always null, no album artists too, # use composer/performer if artists == '': artists = performers album_artists = composers if artists == '': artists = album_artists if artists == '': artists = _("Unknown") debug("CollectionScanner::add2db(): Restore stats") # Restore stats (track_pop, track_ltime, amtime, album_pop) = self.__history.get(name, duration) # If nothing in stats, set mtime if amtime == 0: amtime = mtime debug("CollectionScanner::add2db(): Add artists %s" % artists) artist_ids = self.add_artists(artists, album_artists, a_sortnames) debug("CollectionScanner::add2db(): " "Add album artists %s" % album_artists) album_artist_ids = self.add_album_artists(album_artists, aa_sortnames) new_artist_ids = list(set(album_artist_ids) | set(artist_ids)) debug("CollectionScanner::add2db(): Add album: " "%s, %s" % (album_name, album_artist_ids)) (album_id, new_album) = self.add_album(album_name, album_artist_ids, uri, album_pop, amtime, False) genre_ids = self.add_genres(genres, album_id) # Add track to db debug("CollectionScanner::add2db(): Add track") track_id = Lp().tracks.add(title, uri, duration, tracknumber, discnumber, discname, album_id, year, track_pop, track_ltime, mtime) debug("CollectionScanner::add2db(): Update tracks") self.update_track(track_id, artist_ids, genre_ids) self.update_album(album_id, album_artist_ids, genre_ids, year) if new_album: with SqlCursor(Lp().db) as sql: sql.commit() for genre_id in genre_ids: GLib.idle_add(self.emit, 'genre-updated', genre_id, True) for artist_id in new_artist_ids: GLib.idle_add(self.emit, 'artist-updated', artist_id, True) return track_id def __del_from_db(self, uri): """ Delete track from db @param uri as str """ f = Lio.File.new_for_uri(uri) name = f.get_basename() track_id = Lp().tracks.get_id_by_uri(uri) album_id = Lp().tracks.get_album_id(track_id) genre_ids = Lp().tracks.get_genre_ids(track_id) album_artist_ids = Lp().albums.get_artist_ids(album_id) artist_ids = Lp().tracks.get_artist_ids(track_id) popularity = Lp().tracks.get_popularity(track_id) ltime = Lp().tracks.get_ltime(track_id) mtime = Lp().albums.get_mtime(album_id) duration = Lp().tracks.get_duration(track_id) album_popularity = Lp().albums.get_popularity(album_id) uri = Lp().tracks.get_uri(track_id) self.__history.add(name, duration, popularity, ltime, mtime, album_popularity) Lp().playlists.remove(uri) Lp().tracks.remove(track_id) Lp().tracks.clean(track_id) deleted = Lp().albums.clean(album_id) if deleted: with SqlCursor(Lp().db) as sql: sql.commit() GLib.idle_add(self.emit, 'album-updated', album_id, True) for artist_id in album_artist_ids + artist_ids: Lp().artists.clean(artist_id) GLib.idle_add(self.emit, 'artist-updated', artist_id, False) for genre_id in genre_ids: Lp().genres.clean(genre_id) GLib.idle_add(self.emit, 'genre-updated', genre_id, False)
class MainWindow: def __init__(self): self.controller = None self.logQ = Queue.Queue(maxsize=100) def show(self): self.root = root = Tkinter.Tk() # create a Tk root window root.title("Company Data Parser") parentFrame = Frame(root) parentFrame.configure(borderwidth=3, relief=RAISED) parentFrame.pack(fill=X) w = 800 # width for the Tk root h = 800 # height for the Tk root # get screen width and height ws = root.winfo_screenwidth() # width of the screen hs = root.winfo_screenheight() # height of the screen # calculate x and y coordinates for the Tk root window x = (ws / 2) - (w / 2) y = (hs / 2) - (h / 2) # set the dimensions of the screen # and where it is placed root.geometry('%dx%d+%d+%d' % (w, h, x, y)) root.lift() #bring the window to the front root.attributes("-topmost", True) root.after_idle(root.attributes, '-topmost', False) root.focus_force() frame = Frame(parentFrame) frame.configure(borderwidth=3, bg="#e1ffd6") frame.pack(side=TOP, expand=NO, fill=BOTH) label = Label(frame, text=u'\u8acb\u9078\u64c7\u76ee\u9304', bg="#e1ffd6") label.pack(side=LEFT) self.fileEntry = Entry(frame, width=50) self.fileEntry.pack(side=LEFT) selectFilebutton = Button(frame, text=u'\u700f\u89bd', command=self.load_file, width=10) selectFilebutton.pack(side=LEFT) optionFrame = Frame(parentFrame) optionFrame.configure(borderwidth=3, bg="#e1ffd6") optionFrame.pack(side=TOP, expand=NO, fill=BOTH) optionLabel = Label(optionFrame, text=u'\u9078\u9805\uff1a', bg="#e1ffd6") optionLabel.pack(side=LEFT) optionFrame2 = Frame(parentFrame) optionFrame2.configure(borderwidth=3, bg="#e1ffd6") optionFrame2.pack(side=TOP, fill=BOTH) op1Label = Label(optionFrame2, text=u' \u53d6\u5f97\uff1a', bg="#e1ffd6") op1Label.pack(side=LEFT) self.dataType = StringVar() self.dataType.set("CompanyData") Radiobutton(optionFrame2, text=u'\u57fa\u672c\u8cc7\u6599', variable=self.dataType, value="CompanyData", bg="#e1ffd6").pack(side=LEFT) Radiobutton(optionFrame2, text=u'\u7d44\u7e54\u67b6\u69cb', variable=self.dataType, value="Hierarchy", bg="#e1ffd6").pack(side=LEFT) optionFrame3 = Frame(parentFrame) optionFrame3.configure(borderwidth=3, bg="#e1ffd6") optionFrame3.pack(side=TOP, fill=BOTH) op2Label = Label(optionFrame3, text=u' \u5e74\u4efd\uff1a', bg="#e1ffd6") op2Label.pack(side=LEFT) self.selectYears = StringVar() self.selectYears.set("All") Radiobutton(optionFrame3, text=u'\u5168\u90e8', variable=self.selectYears, value="All", bg="#e1ffd6").pack(side=LEFT) Radiobutton(optionFrame3, text=u'\u6307\u5b9a\u5e74\u4efd', variable=self.selectYears, value="Designated", bg="#e1ffd6").pack(side=LEFT) self.yearEntry = Entry(optionFrame3, width=30) self.yearEntry.pack(side=LEFT) def handleReturn(event): self.selectYears.set("Designated") self.yearEntry.bind("<FocusIn>", handleReturn) Label(optionFrame3, text="(e.g. 2014,2015,Present)", bg="#e1ffd6").pack(side=LEFT) optionFrameFilterCompany = Frame(parentFrame) optionFrameFilterCompany.configure(borderwidth=3, bg="#e1ffd6") optionFrameFilterCompany.pack(side=TOP, fill=BOTH) Label(optionFrameFilterCompany, text=u' \u6307\u5b9a\u516c\u53f8ID\uff1a', bg="#e1ffd6").pack(side=LEFT) self.filter_company_entry = tkst.ScrolledText( master=optionFrameFilterCompany, wrap='word', # wrap text at full words only width=10, # characters height=3, # text lines bg='beige' # background color of edit area ) # self.edit_space.configure(state="disabled") self.filter_company_entry.pack(padx=10, pady=10, fill=BOTH, expand=True) optionFrame5 = Frame(parentFrame) optionFrame5.configure(borderwidth=3, bg="#e1ffd6") optionFrame5.pack(side=TOP, fill=BOTH) Label(optionFrame5, text=u' \u5176\u4ed6\uff1a', bg="#e1ffd6").pack(side=LEFT) Label(optionFrame5, text=u'\u9593\u9694', bg="#e1ffd6").pack(side=LEFT) self.sleepEntry = Entry(optionFrame5, width=3) self.sleepEntry.pack(side=LEFT) self.sleepEntry.insert(END, '1') Label(optionFrame5, text=u'\u79d2\u6293\u4e0b\u4e00\u500b\u516c\u53f8', bg="#e1ffd6").pack(side=LEFT) Label(optionFrame5, text=u' \u5e74\u8207\u5e74\u9593\u9694', bg="#e1ffd6").pack(side=LEFT) self.sleepYearEntry = Entry(optionFrame5, width=3) self.sleepYearEntry.pack(side=LEFT) self.sleepYearEntry.insert(END, '1') Label(optionFrame5, text=u'\u79d2', bg="#e1ffd6").pack(side=LEFT) optionFrame4 = Frame(parentFrame) optionFrame4.configure(borderwidth=3, bg="#e1ffd6") optionFrame4.pack(side=TOP, fill=BOTH) self.start_button = Button(optionFrame4, text=u'\u958b\u59cb', command=self.startCallBack) self.start_button.pack(side=LEFT) Label(optionFrame4, text=" ", bg="#e1ffd6").pack(side=LEFT) self.cancel_button = Button(optionFrame4, text=u'\u53d6\u6d88', command=self.cancelCallBack) self.cancel_button.pack(side=LEFT) separator = Frame(parentFrame) separator.configure(height=2, bd=1, background="#e1ffd6", relief=SUNKEN) # separator.pack(fill=X, padx=5, pady=5) optionFrame6 = Frame(parentFrame) optionFrame6.configure(borderwidth=3, bg="#e1ffd6") # optionFrame6.pack(side=TOP, expand=NO, fill=BOTH) # Label(optionFrame6, text=u'\u5931\u6557\u8655\u7406\uff1a', bg="#e1ffd6").pack(side=LEFT) self.retry_button = Button( optionFrame6, text=u'\u6293\u53d6\u524d\u6b21\u5931\u6557\u7684\u516c\u53f8', command=self.retryCallBack) self.retry_button.pack_forget() # (side=LEFT) self.retry_button.config(state="disabled") # Label(optionFrame6, text=" ", bg="#e1ffd6").pack(side=LEFT) self.save_button = Button( optionFrame6, text=u'\u5c07\u5931\u6557\u516c\u53f8ID\u5b58\u6210\u6a94\u6848', command=self.saveFailedCompanies) self.save_button.pack_forget() # .pack(side=LEFT) self.save_button.config(state="disabled") logFrame = Frame(root) logFrame.configure(borderwidth=3) logFrame.pack(fill=BOTH, expand=True) self.edit_space = tkst.ScrolledText( master=logFrame, wrap='word', # wrap text at full words only width=25, # characters height=10, # text lines bg='beige' # background color of edit area ) # self.edit_space.configure(state="disabled") self.edit_space.pack(padx=10, pady=10, fill=BOTH, expand=True) root.grid_columnconfigure(0, weight=1) root.mainloop() # starts the mainloop def load_file(self): # fname = askopenfilename(filetypes=[("HTML Files", "*.html"), ("HTML Files", "*.htm")]) fname = tkFileDialog.askdirectory() if fname: try: self.set_input_file(fname) except: # <- naked except is a bad idea tkMessageBox.showerror( u'\u932f\u8aa4', u'\u7121\u6cd5\u8b80\u53d6\u6307\u5b9a\u7684\u76ee\u9304') def set_input_file(self, text): self.fileEntry.delete(0, END) self.fileEntry.insert(0, text) def cancelCallBack(self): if self.controller: result = tkMessageBox.askquestion( u'\u53d6\u6d88', u'\u78ba\u5b9a\u53d6\u6d88\u55ce\uff1f', icon='warning') if result == 'yes': self.controller.isRunning = False def startCallBack(self): if not self.fileEntry.get(): tkMessageBox.showerror(u'\u932f\u8aa4', u'\u8acb\u9078\u64c7\u76ee\u9304') return if self.selectYears.get() == "Designated" and not self.yearEntry.get(): tkMessageBox.showerror( u'\u932f\u8aa4', u'\u8acb\u4f9d\u7167\u683c\u5f0f\u8f38\u5165\u6307\u5b9a\u5e74\u4efd\uff0c\u5982 2014,2015,Present' ) return if self.selectYears.get() == "Designated" and self.yearEntry.get(): try: nums = self.yearEntry.get().split(",") except: tkMessageBox.showerror( u'\u8acb\u4f9d\u7167\u683c\u5f0f\u8f38\u5165\u6307\u5b9a\u5e74\u4efd\uff0c\u5982 2014,2015,Present' ) return else: nums = [] result = tkMessageBox.askquestion( u'\u78ba\u5b9a', u'\u78ba\u5b9a\u958b\u59cb\u55ce\uff1f', icon='warning') if result == 'no': return else: self.root.after(0, lambda: self.__run_it__(nums)) def __run_it__(self, nums): self.retry_button.config(state="disabled") self.save_button.config(state="disabled") self.edit_space.configure(state='normal') self.edit_space.delete('1.0', END) self.edit_space.configure(state='disabled') if not self.sleepEntry.get(): sleep = 0 else: sleep = float(self.sleepEntry.get()) if not self.sleepYearEntry.get(): sleepYear = 0 else: sleepYear = float(self.sleepYearEntry.get()) filterCompanies = [] if self.filter_company_entry.get(1.0, END).rstrip(): filterCompanies = self.filter_company_entry.get( 1.0, END).rstrip().split(",") self.controller = controller.ParserController([self.fileEntry.get()], sleep, sleepYear, self.logProgress, self.doNothing, nums, filterCompanies) self.t = Thread(target=self.__startInternal__) self.t.start() self.root.after(100, lambda: self.logProgressAsync()) self.check_thread() def retryCallBack(self): if not self.controller or not self.controller.failed_companies: tkMessageBox.showerror( u'\u932f\u8aa4', u'\u4e26\u672a\u6709\u524d\u6b21\u5931\u6557\u7684\u516c\u53f8' ) return result = tkMessageBox.askquestion( u'\u78ba\u5b9a', u'\u78ba\u5b9a\u91cd\u6293\u524d\u6b21\u5931\u6557\u7684\u516c\u53f8\uff1f', icon='warning') if result == 'no': return else: self.root.after(0, self.__run_retry__) def __run_retry__(self): self.edit_space.configure(state='normal') self.edit_space.delete('1.0', END) self.edit_space.configure(state='disabled') self.t = Thread(target=self.__retryInternal__) self.t.start() self.root.after(100, lambda: self.logProgressAsync()) self.check_thread() def check_thread(self): # Still alive? Check again in half a second if self.t.isAlive(): self.root.after(500, self.check_thread) else: self.isDone() def doNothing(self): pass def __retryInternal__(self): self.start_button.config(state="disabled") self.controller.parseHierarchyDataForFailedCompanies() def __startInternal__(self): self.start_button.config(state="disabled") if self.dataType.get() == "CompanyData": self.controller.parseCompanyData() else: self.controller.parseHierarchyData() def logProgress(self, text): self.logQ.put(text) def logProgressAsync(self): while self.logQ.qsize(): try: msg = self.logQ.get(0) # Check contents of message and do whatever is needed. As a # simple test, print it (in real life, you would # suitably update the GUI's display in a richer fashion). self.__logProgress__(msg) except Queue.Empty: # just on general principles, although we don't # expect this branch to be taken in this case pass self.root.after(100, lambda: self.logProgressAsync()) def __logProgress__(self, text): self.edit_space.configure(state='normal') self.edit_space.insert(INSERT, text + "\n") self.edit_space.see(Tkinter.END) self.edit_space.configure(state='disabled') def isDone(self): self.start_button.config(state="active") if not self.controller.failed_companies: self.retry_button.config(state="disabled") self.save_button.config(state="disabled") tkMessageBox.showinfo(u'\u8a0a\u606f', u'\u5de5\u4f5c\u5b8c\u6210') else: self.retry_button.config(state="active") self.save_button.config(state="active") tkMessageBox.showwarning( u'\u8a0a\u606f', u'\u5de5\u4f5c\u5b8c\u6210\u3002\u4f46\u6709\u672a\u80fd\u6210\u529f\u6293\u53d6\u7684\u516c\u53f8\uff0c\u53ef\u57f7\u884c\u91cd\u6293\u3002' ) # self.controller.saveFailedCompanies() def saveFailedCompanies(self): if self.controller and self.controller.failed_companies: self.controller.saveFailedCompanies() tkMessageBox.showinfo(u'\u8a0a\u606f', u'\u5132\u5b58\u5b8c\u6210')
class Robot(): def __init__(self, robot_ip): self.robot_ip = robot_ip self.commandsocket = socket.socket(socket.AF_INET, socket.SOCK_STREAM) self.commandsocket.connect((self.robot_ip, 40923)) self.commandsocket.sendall('command;'.encode()) commandreply = self.commandsocket.recv(1024) print(f'Command socket: {commandreply.decode("utf-8")}') self.cap = None self.frame = None def _sendcommand(self, cmdstring, echo=True): assert isinstance(cmdstring, str) cmdstring = cmdstring + ';' self.commandsocket.sendall(cmdstring.encode()) commandreply = self.commandsocket.recv(1024) commandreply = commandreply.decode("utf-8") if echo: print(f'\treply for {cmdstring}: {commandreply}') return commandreply def startvideo(self): self._sendcommand('stream on') self.videothread = Thread(target=self._receive_video_thread, daemon=True) self.videothread.start() # updates self.frame if self.videothread.isAlive(): print('videothread started!') def _receive_video_thread(self): """ Listens for video streaming (raw h264). Runs as a thread, sets self.frame to the most recent frame captured. frame processing and imshow should be in main loop """ self.cap = cv2.VideoCapture(f'tcp://@{self.robot_ip}:40921') while self.cap.isOpened(): ret, self.frame = self.cap.read() # ROBOT COMMANDS def move(self, inputstring): ''' input: x dist y dist z angle vxy m/s Vz degree/s moves chassis by distance e.g. move('x 0.5') to move forward by 0.5m ''' command = 'chassis move ' + inputstring return self._sendcommand(command) def rotate(self, inputstring): ''' input: string in degrees rotate CW ''' command = 'chassis move z ' + inputstring return self._sendcommand(command) def right(self, inputstring): ''' input: integer in m/s constantly strafe right ''' command = 'chassis speed y ' + inputstring return self._sendcommand(command) def forward(self, inputstring): ''' input: integer in m per s constantly move forward ''' command = 'chassis speed x ' + inputstring return self._sendcommand(command) def movearm(self, inputstring): """ input: x {val} y {val} """ command = 'robotic_arm move ' + inputstring return self._sendcommand(command) def openarm(self): return self._sendcommand('robotic_gripper open 1') def closearm(self): return self._sendcommand('robotic_gripper close 1') def rotategimbal(self, inputstring): ''' relative to current position p angle y angle vp speed vy speed ''' command = 'gimbal move ' + inputstring return self._sendcommand(command) def rotategimbalto(self): ''' relative to initial position p angle y angle vp speed vy speed ''' command = 'gimbal moveto ' + inputstring return self._sendcommand(command) def stop(self): self._sendcommand('chassis move x 0') self._sendcommand('gimbal speed p 0 y 0' ) # stops if in speed. gimbal move will finish self._sendcommand('robotic_arm stop') def center(self): self._sendcommand('gimbal moveto p 0 y 0') self._sendcommand('robotic_arm recenter') def exit( self ): # call this to stop robot and bring back to center position before exiting print('Exiting...') self.stop() self.center() time.sleep(2) if self.cap is not None: self.cap.release() self._sendcommand('stream off') self._sendcommand('quit') self.commandsocket.close() print('All done')
class BinanceSpotApi(object): """基于Websocket的API对象""" #---------------------------------------------------------------------- def __init__(self): """Constructor""" self.apiKey = '' # 用户名 self.secretKey = '' # 密码 self.client = None # 客户端管理器 self.bm = None # sockets 管理器 self.reqID = 0 # 请求编号 # self.reqQueue = Queue() # 请求队列 self.reqQueue = [] # 请求的队列 self.reqThread = Thread(target=self.processQueue) # 请求处理线程 self.active = False # API工作状态 self.DEBUG = False self.writeLog = None self.writeError = None #---------------------------------------------------------------------- def connect_Subpot(self, apiKey, secretKey): self.apiKey = apiKey self.secretKey = secretKey self.client = Client(apiKey, secretKey, self) self.client.DEBUG = self.DEBUG self.bm = BinanceSocketManager(self.client) self.bm.start_user_socket(self.onMessage) self.bm.start() self.active = True self.reqThread.start() #---------------------------------------------------------------------- def processQueue(self): """处理请求队列中的请求""" while self.active: if len(self.reqQueue) == 0: continue (Type, req) = self.reqQueue[0] if req is None: self.reqQueue.pop(0) continue callback = req.get('callback', None) reqID = req.get('reqID', None) try: data = self.processRequest(req) # 请求成功 if data != None: if self.DEBUG: self.writeLog(callback.__name__) callback(data, req, reqID) except Exception as ex: self.writeError(u'processQueue exception:{},{}'.format( str(ex), traceback.format_exc())) self.reqQueue.pop(0) sleep(0.1) #---------------------------------------------------------------------- def processRequest(self, req): """ 处理各类请求 :param req: :return: """ try: method = req['method'] reqID = req["reqID"] callback = req['callback'] data = None # 请求账号信息 if method == FUNCTIONCODE_GET_ACCOUNT_BINANCE: data = self.client.get_account() # 替换 一些 symbol for b_symbol_dic in data["balances"]: b_symbol_dic["asset"] = symbolFromBinanceToOtherExchanges( b_symbol_dic["asset"]) self.onGetAccount(data, req, reqID) # 请求委托单 elif method == FUNCTIONCODE_GET_OPEN_ORDERS: kwargs = req["kwargs"] symbol = kwargs["symbol"] if symbol != None: data = self.client.get_open_orders(symbol=symbol) # update symbol for dic in data: dic["symbol"] = symbolFromBinanceToOtherExchanges( dic["symbol"]) callback(data, req, reqID) else: data = self.client.get_open_orders() # update symbol for dic in data: dic["symbol"] = symbolFromBinanceToOtherExchanges( dic["symbol"]) callback(data, req, reqID) # 请求所有委托单 elif method == FUNCTIONCODE_GET_ALL_ORDERS: kwargs = req["kwargs"] symbol = kwargs["symbol"] #if '_' not in symbol and len(symbol) in [3,4]: # return None data = self.client.get_all_orders(symbol=symbol) # update symbol for dic in data: dic["symbol"] = symbolFromBinanceToOtherExchanges( dic["symbol"]) callback(data, req, reqID) # 买入现货 elif method == FUNCTIONCODE_BUY_ORDER_BINANCE: kwargs = req["kwargs"] symbol = self.legalSymbolUpper(kwargs["symbol"]) quantity = float(kwargs["quantity"]) price = float(kwargs["price"]) price = str('%.8f' % float(price)) data = self.client.order_limit_buy(symbol=symbol, price=price, quantity=quantity) # update symbol data["symbol"] = symbolFromBinanceToOtherExchanges( data["symbol"]) callback(data, req, reqID) # 卖出现货 elif method == FUNCTIONCODE_SELL_ORDER_BINANCE: kwargs = req["kwargs"] symbol = self.legalSymbolUpper(kwargs["symbol"]) quantity = float(kwargs["quantity"]) price = float(kwargs["price"]) price = str('%.8f' % float(price)) data = self.client.order_limit_sell(symbol=symbol, price=price, quantity=quantity) # update symbol data["symbol"] = symbolFromBinanceToOtherExchanges( data["symbol"]) callback(data, req, reqID) # 取消订单 elif method == FUNCTIONCODE_CANCEL_ORDER_BINANCE: kwargs = req["kwargs"] symbol = self.legalSymbolUpper(kwargs["symbol"]) orderId = int(kwargs["orderId"]) data = self.client.cancel_order(symbol=symbol, orderId=orderId) # update symbol data["symbol"] = symbolFromBinanceToOtherExchanges( data["symbol"]) callback(data, req, reqID) # 获取交易所信息 elif method == FUNCTIONCODE_GET_EXCHANGE_INFO: data = self.client.get_exchange_info() # update symbol for symbol_dic in data["symbols"]: symbol_dic["symbol"] = symbolFromBinanceToOtherExchanges( symbol_dic["symbol"]) symbol_dic[ "baseAsset"] = symbolFromBinanceToOtherExchanges( symbol_dic["baseAsset"]) callback(data, req, reqID) except Exception as ex: if req is not None or reqID is not None: self.onAllError(ex, req, reqID) self.writeError(u'processRequest exception:{},{}'.format( str(ex), traceback.format_exc())) # pass #---------------------------------------------------------------------- def legalSymbolLower(self, symbol): symbol = symbol.lower() symbol = ''.join(symbol.split('_')) return symbol #---------------------------------------------------------------------- def legalSymbolUpper(self, symbol): symbol = symbol.upper() symbol = ''.join(symbol.split('_')) return symbol #---------------------------------------------------------------------- def exit(self): """退出""" self.active = False if self.bm != None: self.bm.close() if self.reqThread.isAlive(): self.reqThread.join() #----------------------------------------------------------------------- def sendTradingRequest(self, method, callback, kwargs=None, optional=None): # 请求编号加1 self.reqID += 1 # 生成请求字典并放入队列中 req = {} req['method'] = method req['callback'] = callback req['optional'] = optional req['kwargs'] = kwargs req['reqID'] = self.reqID if method in [ FUNCTIONCODE_GET_OPEN_ORDERS, FUNCTIONCODE_GET_ACCOUNT_BINANCE ]: flag = False for use_method, r in self.reqQueue: if use_method == method: flag = True break if False == flag: self.reqQueue.append((method, req)) else: self.reqQueue.append((method, req)) # 返回请求编号 return self.reqID #---------------------------------------------------------------------- def spotTrade(self, symbol_pair, type_, price, amount): """现货委托""" symbol_pair = self.legalSymbolUpper(symbol_pair) symbol_pair = symbolFromOtherExchangesToBinance(symbol_pair) if type_ == "buy": return self.sendTradingRequest( method=FUNCTIONCODE_BUY_ORDER_BINANCE, callback=self.onTradeOrder, kwargs={ "symbol": symbol_pair, "price": price, "quantity": amount }, optional=None) elif type_ == "sell": return self.sendTradingRequest( method=FUNCTIONCODE_SELL_ORDER_BINANCE, callback=self.onTradeOrder, kwargs={ "symbol": symbol_pair, "price": price, "quantity": amount }, optional=None) return None #---------------------------------------------------------------------- def spotCancelOrder(self, symbol_pair, orderid): """现货委托撤单""" symbol_pair = self.legalSymbolUpper(symbol_pair) symbol_pair = symbolFromOtherExchangesToBinance(symbol_pair) return self.sendTradingRequest( method=FUNCTIONCODE_CANCEL_ORDER_BINANCE, callback=self.onGetCancelOrder, kwargs={ "symbol": symbol_pair, "orderId": int(orderid) }, optional=None) #---------------------------------------------------------------------- def spotAccountInfo(self): """列出账户""" return self.sendTradingRequest(method=FUNCTIONCODE_GET_ACCOUNT_BINANCE, callback=self.onGetAccount, kwargs={}, optional=None) #---------------------------------------------------------------------- def spotListOpenOrders(self, symbol=None): """列出所有的 orders""" if symbol != None: symbol = self.legalSymbolUpper(symbol) symbol = symbolFromOtherExchangesToBinance(symbol) return self.sendTradingRequest(method=FUNCTIONCODE_GET_OPEN_ORDERS, callback=self.onGetOpenOrders, kwargs={"symbol": symbol}, optional=None) #---------------------------------------------------------------------- def spotListAllOrders(self, symbol): symbol = self.legalSymbolUpper(symbol) symbol = symbolFromOtherExchangesToBinance(symbol) return self.sendTradingRequest(method=FUNCTIONCODE_GET_ALL_ORDERS, callback=self.onGetAllOrders, kwargs={"symbol": symbol}, optional=None) #---------------------------------------------------------------------- def spotExchangeInfo(self): return self.sendTradingRequest(method=FUNCTIONCODE_GET_EXCHANGE_INFO, callback=self.onExchangeInfo, kwargs={}, optional=None) #---------------------------------------------------------------------- # def subcribeSymbol(self , symbol): # symbol = self.legalSymbolLower(symbol) # symbol = symbolFromOtherExchangesToBinance(symbol) # #self.bm.start_symbol_ticker_socket( symbol , self.onTick) # self.bm.start_multiplex_socket([symbol + "@ticker" , symbol + "@depth5" , symbol + "@trade"] , callback=self.onMessage) #---------------------------------------------------------------------- def subscribeAllTicker(self): self.bm.start_ticker_socket(callback=self.onPreDealAllTicker) #---------------------------------------------------------------------- def subscribeSpotTicker(self, symbol): if self.bm != None: # print "self.bm != None:" symbol = self.legalSymbolLower(symbol) symbol = symbolFromOtherExchangesToBinance(symbol) self.bm.start_symbol_ticker_socket(symbol, self.onPreDealTicker) #---------------------------------------------------------------------- def subscribeSpotDepth(self, symbol): if self.bm != None: symbol = self.legalSymbolLower(symbol) symbol = symbolFromOtherExchangesToBinance(symbol) self.bm.start_depth_socket(symbol, self.onPreDealDepth) #---------------------------------------------------------------------- def subscribeSpotTrades(self, symbol): if self.bm != None: symbol = self.legalSymbolLower(symbol) symbol = symbolFromOtherExchangesToBinance(symbol) self.bm.start_trade_socket(symbol, self.onPreDealTrades) #---------------------------------------------------------------------- def http_get_request(self, url, params, add_to_headers=None): headers = { "Content-type": "application/x-www-form-urlencoded", 'User-Agent': 'Mozilla/5.0 (Windows NT 6.1; WOW64; rv:53.0) Gecko/20100101 Firefox/53.0' } if add_to_headers: headers.update(add_to_headers) postdata = urllib.parse.urlencode(params) try: #response = requests.get(url, postdata, headers=headers, timeout=5) response = requests.get(url) if response.status_code == 200: return response.json() else: return {"status": "fail"} except Exception as e: self.writeError('httpGet failed, detail is:{}'.format(str(e))) return {"status": "fail", "msg": e} # limit in [5, 10, 20, 50, 100, 500, 1000] #---------------------------------------------------------------------- def getDepthSymbol(self, symbol, limit=10): symbol = self.legalSymbolUpper(symbol) symbol = symbolFromOtherExchangesToBinance(symbol) url = "https://www.binance.com/api/v1/depth?symbol=%s&limit=%s" % ( symbol, str(limit)) data = self.http_get_request(url, "") return data #---------------------------------------------------------------------- def onMessage(self, msg): if 's' in msg.keys(): msg['s'] = symbolFromBinanceToOtherExchanges(msg["s"]) if "lastUpdateId" in msg.keys(): self.onDepth(msg) else: if msg["e"] == "trade": self.onTrades(msg) elif "ticker" in msg["e"]: self.onTick(msg) #---------------------------------------------------------------------- def onAllError(self, ex, req, reqID): self.writeError("onAllError" + str(ex)) #---------------------------------------------------------------------- def onPreDealAllTicker(self, msg): for dic in msg: dic["s"] = symbolFromBinanceToOtherExchanges(dic["s"]) self.onAllTicker(msg) #---------------------------------------------------------------------- def onAllTicker(self, msg): """币安支持所有 ticker 同时socket过来""" self.writeLog(u'onAllTicker:'.format(msg)) # ---------------------------------------------------------------------- def onPreDealTicker(self, msg): if 's' in msg.keys(): msg['s'] = symbolFromBinanceToOtherExchanges(msg["s"]) self.onTick(msg) #---------------------------------------------------------------------- def onTick(self, msg): self.writeLog(u'onTick:'.format(msg)) # ---------------------------------------------------------------------- def onPreDealDepth(self, msg): if 's' in msg.keys(): msg['s'] = symbolFromBinanceToOtherExchanges(msg["s"]) self.onDepth(msg) #---------------------------------------------------------------------- def onDepth(self, msg): self.writeLog(u'onDepth:'.format(msg)) # ---------------------------------------------------------------------- def onPreDealTrades(self, msg): if 's' in msg.keys(): msg['s'] = symbolFromBinanceToOtherExchanges(msg["s"]) self.onTrades(msg) #---------------------------------------------------------------------- def onTrades(self, msg): self.writeLog(u'onTrades:{}'.format(msg)) #---------------------------------------------------------------------- def onGetAccount(self, data, req, reqID): self.writeLog(u'onGetAccount:'.format(data, req, reqID)) #---------------------------------------------------------------------- def onGetOpenOrders(self, data, req, reqID): self.writeLog(u'onGetOpenOrders:ata:{}, req:{}, reqID:{}'.format( data, req, reqID)) #---------------------------------------------------------------------- def onGetAllOrders(self, data, req, reqID): self.writeLog(u'onGetAllOrders:data:{}, req:{}, reqID:{}'.format( data, req, reqID)) #---------------------------------------------------------------------- def onGetBuyOrder(self, data, req, reqID): self.writeLog(u'onGetBuyOrder:data:{}, req:{}, reqID:{}'.format( data, req, reqID)) #---------------------------------------------------------------------- def onGetSellOrder(self, data, req, reqID): self.writeLog(u'onGetSellOrder:data:{}, req:{}, reqID:{}'.format( data, req, reqID)) #---------------------------------------------------------------------- def onGetCancelOrder(self, data, req, reqID): self.writeLog(u'onGetCancelOrder:data:{},req:{},reqId:{}'.format( data, req, reqID)) #---------------------------------------------------------------------- def onExchangeInfo(self, data, req, reqID): self.writeLog(u'onExchangeInfo:data:{},req:{},reqId:{}'.format( data, req, reqID)) # ---------------------------------------------------------------------- def onTradeOrder(self, data, req, reqID): self.writeLog(u'onTradeOrder:{}'.format(data))
run_login = True attempt_num = 0 login_tried = False all_threads_alive = True while run_login and attempt_num < LOGIN_NUM: attempt_num = attempt_num + 1 # Create timeout thread. login_tried = False timeout_thread = Thread(target=wait_to_login) timeout_thread.start() all_threads_alive = True while all_threads_alive: # Check if 15 seconds passed. if not timeout_thread.isAlive(): if not login_tried: print('15 seconds passed.') run_login = False all_threads_alive = False # Check if the login window is closed. if not login_view_thread.isAlive(): print('Login window is closed.') all_threads_alive = False run_login = False # Sleep for some time and then check again. time.sleep(0.1) # Release resources.
def run_process(cmds, timeout=None): """run a process asynchronously :param cmds: list of commands to invoke on a shell e.g. ['make', 'install'] :param timeout: timeout in seconds (optional) """ # open process as its own session, and with no stdout buffering p = Popen(cmds, stdout=PIPE, stderr=STDOUT, bufsize=1, close_fds=_ON_POSIX, preexec_fn=os.setsid if _ON_POSIX else None) q = Queue() t = Thread(target=enqueue_output, args=(p.stdout, q)) t.daemon = True # thread dies with the program t.start() _time = time.time() e = None try: while t.isAlive(): try: buf = q.get(timeout=.1) except Empty: buf = b'' _log_buf(buf) elapsed = time.time() - _time if timeout and elapsed > timeout: break # Make sure we print all the output from the process. if p.stdout: for line in p.stdout: _log_buf(line) p.wait() except (KeyboardInterrupt, SystemExit) as e: # if user interrupted pass # noinspection PyBroadException try: os.kill(p.pid, signal.SIGINT) except (KeyboardInterrupt, SystemExit) as e: pass except: pass # noinspection PyBroadException try: if e: os.kill(p.pid, signal.SIGKILL) else: p.wait() except (KeyboardInterrupt, SystemExit) as e: # noinspection PyBroadException try: os.kill(p.pid, signal.SIGKILL) except: pass except: pass t.join(timeout=0.1) if e: raise e return p.returncode