Python Timeout.cancel方法代码示例

# 需要导入模块: from gevent import Timeout [as 别名]
# 或者: from gevent.Timeout import cancel [as 别名]
    def _get_message_data(self):
        max_size = self.extensions.getparam('SIZE', filter=int)
        reader = DataReader(self.io, max_size)

        err = None
        timeout = Timeout(self.data_timeout)
        timeout.start()
        try:
            data = reader.recv()
        except ConnectionLost:
            raise
        except SmtpError as e:
            data = None
            err = e
        finally:
            timeout.cancel()

        reply = Reply('250', '2.6.0 Message Accepted for Delivery')
        self._call_custom_handler('HAVE_DATA', reply, data, err)

        self.io.send_reply(reply)
        self.io.flush_send()

        self.have_mailfrom = None
        self.have_rcptto = None

# 需要导入模块: from gevent import Timeout [as 别名]
# 或者: from gevent.Timeout import cancel [as 别名]
    def __init__(self, url):
        self.url = url
        self.protocol, self.domain = self.url.split("://")  #e.g. news.bbc.co.uk
        self.domain = self.domain.split('/')[0]
        self.site_data = sites[self.domain]

        self.total_words = {}

        timeout = Timeout(30, TimeoutError)
        timeout.start()
        try:
            self.html = self.read_url()
        except TimeoutError:
            print url + " timed out"
            return 
        finally:
            timeout.cancel()

        self.text = self.boiler_extract()
        self.soup = BeautifulSoup(self.html, 'lxml')
        self.article = self.is_article()

        if self.article:
            self.calc_total_words()
            articles.put(self)

        self.find_links()

# 需要导入模块: from gevent import Timeout [as 别名]
# 或者: from gevent.Timeout import cancel [as 别名]
def main(socket, address):
    global client_mgr
    print "one client", address
    logger.debug("one client %s" % str(address))
    client = Client(socket)
    hbTimer = None
    while True:
        try:
            hbTimer = Timeout(ONE_MOVE_MAX_TIME)
            hbTimer.start()
            client.read_and_deal_cmd()
            hbTimer.cancel()
        except Timeout, t:
            if t == hbTimer:
                print "client lose"
                client.lose_hb()
                client.cancel_timeout()
                if client.latitude != None:
                    client_mgr.remove_client(client)
                client = None
                break
            else:
                print "other timeout"
                hbTimer.cancel()
                client.deal_timeout()

        except:

# 需要导入模块: from gevent import Timeout [as 别名]
# 或者: from gevent.Timeout import cancel [as 别名]
 def _recv_command(self):
     timeout = Timeout(self.command_timeout)
     timeout.start()
     try:
         return self.io.recv_command()
     finally:
         timeout.cancel()

# 需要导入模块: from gevent import Timeout [as 别名]
# 或者: from gevent.Timeout import cancel [as 别名]
def func1():
    
        
    utc = arrow.utcnow()
    local = utc.to('Asia/Shanghai')
    ts = local.timestamp
    print arrow.get(ts)
    #print local.format('YYYY-MM-DD HH:mm:ss ZZ')
    
    """function and heartbeat"""
    
    ex = TimeoutException("timeout ex")
    
    #gevent timeout
    timeout = Timeout(6, ex)
    #start
    timeout.start()
    try:
        
        # exception will be raised here, after *seconds* 
        # passed since start() call
        
        gevent.sleep(3 * random.randint(1,4))
        #print "f1 heart beat"
        heartbeat("f1")

    except TimeoutException as ex:
        print ex
    finally:
        #cancel timeout
        timeout.cancel()

# 需要导入模块: from gevent import Timeout [as 别名]
# 或者: from gevent.Timeout import cancel [as 别名]
 def initial_test(self, address):
     try:
         timeout = Timeout(self.TIMEOUT, TestTimeout('The server timed out on the first command.'))
         timeout.start()
         TestClient(address).put('key', 'value')
     finally:
         timeout.cancel()

# 需要导入模块: from gevent import Timeout [as 别名]
# 或者: from gevent.Timeout import cancel [as 别名]
    def _methodExecute(self, method_, id_="", timeout_=0, **args):  # added the _ to make sure we have no conflicts with the code we execute
        timeoutObj = Timeout(timeout_)
        timeoutObj.start()

        if "lock_" in args:
            lock = args["lock_"]
            if lock != None:
                while not lock.checkCanExecute(id_):
                    # print "sleep for lock:%s for methodid:%s"% (lock,id_)
                    gevent.sleep(0.05)
            args.pop("lock_")

        try:
            result = method_(**args)
        except Exception as e:
            timeoutObj.cancel()
            self.methodError(id_, e)
            return None
        except Timeout as t:
            if t is not timeoutObj:
                raise RuntimeError("not my timeout")
            self.methodTimeout(id_)
            return None
        timeoutObj.cancel()
        if id_ in self.locksActive:
            self.locksActive.pop(id_)
            if lock != None:
                if id_ in lock.greenletsActive:
                    lock.greenletsActive.pop(id_)  # unlock the lock for this greenlet
            else:
                print "Could not find lock for id %s" % id_

        return result

# 需要导入模块: from gevent import Timeout [as 别名]
# 或者: from gevent.Timeout import cancel [as 别名]
def reposts_crawler():
    '''
    greenlet reposts crawler
    '''
    while not reposts_fetch_queue.empty():
        IS_NEED_REFETCH = False #when timeout or errors occur,put the url back into the task queue and the make sure the task is not set to done!
        try:
            wait_time = Timeout(MAX_WAIT_TIME)
            wait_time.start()
            url = reposts_fetch_queue.get()
            gevent.sleep(0.0)
            reposts_time = _http_call(url)
            for status in reposts_time['reposts']:
                if not status.get('deleted'):
                    weibo_created_at = datetime.strptime(status.get('created_at'), '%a %b %d %H:%M:%S +0800 %Y')
                    user_created_at = datetime.strptime(status.get('user').get('created_at'),
                                                        '%a %b %d %H:%M:%S +0800 %Y')
                    reposts_status_id = -1

                    if status.get('retweeted_status') is not None:
                        reposts_status = status['retweeted_status']
                        reposts_status_id = reposts_status['id']

                    weibo_params = (
                        status['id'], status['user']['id'], status['text'], status['source'], weibo_created_at,
                        reposts_status_id)
                    user_params = (
                        status['user']['id'], status['user']['screen_name'], status['user']['name'],
                        status['user']['province'],
                        status['user']['city'], status['user']['location'], status['user']['description'],
                        status['user']['profile_image_url'], status['user']['domain'], status['user']['gender'],
                        status['user']['followers_count'], status['user']['friends_count'],
                        status['user']['statuses_count']
                        ,
                        status['user']['favourites_count'], user_created_at, status['user']['verified'],
                        status['user']['verified_type'], status['user']['verified_reason'],
                        status['user']['bi_followers_count'] )
                    cursor.execute(REPOSTS_WEIBO_INSERT_SQL, weibo_params)
                    cursor.execute(REPOSTS_USER_INSERT_SQL, user_params)
        except Timeout as t:
            if t is wait_time:
            #                print '处理超时，等待重新抓取!'
                #put timeout url back into the task queue
                IS_NEED_REFETCH = True
        except Exception as e:
            IS_NEED_REFETCH = True
            logger.error(traceback.format_exc())
        finally:
            wait_time.cancel()
            if IS_NEED_REFETCH is not True:
                reposts_fetch_queue.task_done()
            #                print url + ' 抓取完成 --- 转发'
            else:
                reposts_fetch_queue.put(url)
                print status
                print url + ' 抓取失败 --- 转发'

# 需要导入模块: from gevent import Timeout [as 别名]
# 或者: from gevent.Timeout import cancel [as 别名]
 def serve_for_test(self):
     timeout = Timeout(10)
     timeout.start()
     try:
         while self.is_connected():
             if len(self.re_schedule_events) == 10 and len(self.heartbeat_events) == 10:
                 break
             gevent.sleep(0.01)
     finally:
         timeout.cancel()

# 需要导入模块: from gevent import Timeout [as 别名]
# 或者: from gevent.Timeout import cancel [as 别名]
 def timeout_wrapper(*args, **kwargs):
     t = Timeout(seconds,
         TestTimeout('Timed out after %d seconds' % seconds)
     )
     t.start()
     try:
         ret = func(*args, **kwargs)
     finally:
         t.cancel()
     return ret

# 需要导入模块: from gevent import Timeout [as 别名]
# 或者: from gevent.Timeout import cancel [as 别名]
 def requestGet(self, url):
     wait = random.random() * (wait_time[1] - wait_time[0])
     sleep(wait)
     timeout = Timeout(request_timeout)
     timeout.start()
     try:
         req = requests.get(url=url, verify=True, headers=headers, proxies=proxies)
     except IncompleteRead:
         pass
         # todo:未知错误，暂还未查清
     timeout.cancel()
     return req

# 需要导入模块: from gevent import Timeout [as 别名]
# 或者: from gevent.Timeout import cancel [as 别名]
def query_documents_with_timeout(*args, **kwargs):
    timeout = Timeout(30)
    timeout.start()

    try:
        gevent.sleep(0.0001)
        return query_documents(*args, **kwargs)

    except:
        return [[], 0]

    finally:
        timeout.cancel()

# 需要导入模块: from gevent import Timeout [as 别名]
# 或者: from gevent.Timeout import cancel [as 别名]
def get_commits():
    print('Start - {0}'.format(datetime.datetime.now()))
    timeout = Timeout(10)
    timeout.start()
    try:
        job_stack = [gevent.spawn(download(url)) for url in urls]
        gevent.joinall(job_stack)
    except Timeout:
        pass
    finally:
        timeout.cancel()
    cntx = OrderedDict(sorted(result.items()))
    return render_template('start.html', cntx=cntx)
    print('End - {0}'.format(datetime.datetime.now()))

# 需要导入模块: from gevent import Timeout [as 别名]
# 或者: from gevent.Timeout import cancel [as 别名]
	def generate():
		result = None
		while result is None:
			try:
				timeout = Timeout(25)
				timeout.start()
				result = json.dumps(client.get_events(
					queue_id=queue_id,
					last_event_id=last_event_id))
				logging.debug('got a response')
			except Timeout:
				pass
			finally:
				timeout.cancel()
			yield result or ' '

# 需要导入模块: from gevent import Timeout [as 别名]
# 或者: from gevent.Timeout import cancel [as 别名]
 def handle(self, body):
     t = int((self.timestamp + self.expiration) - time.time())
     worker = self.get_worker(self.routing_key)
     log.debug("Running {0} with timeout {1} sec.".format(self.w_name, t))
     timeout = Timeout(t, TimeoutError)
     timeout.start()
     try:
         res = worker(body)
         log.debug('Task finished.')
         return res
     except Exception as e:
         log.debug(traceback.format_exc())
         log.error('Task error: {0}'.format(unicode(e)))
         return e
     finally:
         timeout.cancel()