Exemple #1
0
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()
Exemple #2
0
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)
Exemple #4
0
    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())
Exemple #6
0
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()
Exemple #7
0
def run():
    t = Thread(target=test1)
    t.start()
    t.join(2)

    print t.isAlive()
    t.join()

    print "over"
Exemple #8
0
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)
Exemple #9
0
 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'])
Exemple #10
0
    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]
Exemple #11
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
Exemple #12
0
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
Exemple #13
0
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]]
Exemple #15
0
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"))
Exemple #17
0
    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"])
Exemple #19
0
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
Exemple #20
0
 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)
Exemple #21
0
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")
Exemple #22
0
  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()
Exemple #23
0
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)
Exemple #24
0
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()
Exemple #25
0
    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
Exemple #26
0
  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.")
Exemple #28
0
 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()
Exemple #31
0
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)
Exemple #32
0
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
Exemple #33
0
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))
Exemple #34
0
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")
Exemple #35
0
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)
Exemple #36
0
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, {})
Exemple #37
0
def wait_for_update_trakt():
    logger.info()
    t = Thread(update_all)
    t.setDaemon(True)
    t.start()
    t.isAlive()
Exemple #38
0
    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")
Exemple #39
0
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
Exemple #40
0
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.')
Exemple #41
0
</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()
Exemple #42
0
    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
Exemple #43
0
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.')
Exemple #44
0
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()
Exemple #45
0
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())
Exemple #47
0
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
Exemple #48
0
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
Exemple #49
0
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)
Exemple #50
0
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
Exemple #52
0
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()
Exemple #53
0
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
Exemple #54
0
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 ''
Exemple #55
0
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)
Exemple #56
0
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')
Exemple #58
0
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))
Exemple #59
0
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.
Exemple #60
0
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