def acquire(self, blocking=True, timeout=-1): # This is the Python 3 signature. # On Python 2, Lock.acquire has the signature `Lock.acquire([wait])` # where `wait` is a boolean that cannot be passed by name, only position. # so we're fine to use the Python 3 signature. # Transform the default -1 argument into the None that our # semaphore implementation expects, and raise the same error # the stdlib implementation does. if timeout == -1: timeout = None if not blocking and timeout is not None: raise ValueError("can't specify a timeout for a non-blocking call") if timeout is not None: if timeout < 0: # in C: if(timeout < 0 && timeout != -1) raise ValueError("timeout value must be strictly positive") if timeout > self._TIMEOUT_MAX: raise OverflowError('timeout value is too large') acquired = BoundedSemaphore.acquire(self, blocking, timeout) if not acquired and not blocking and getcurrent( ) is not get_hub_if_exists(): # Run other callbacks. This makes spin locks works. # We can't do this if we're in the hub, which we could easily be: # printing the repr of a thread checks its tstate_lock, and sometimes we # print reprs in the hub. # See https://github.com/gevent/gevent/issues/1464 # By using sleep() instead of self.wait(0), we don't force a trip # around the event loop *unless* we've been running callbacks for # longer than our switch interval. sleep() return acquired
def acquire(self, blocking=1): tid = get_ident() gid = id(getcurrent()) tid_gid = (tid, gid) if tid_gid == self._owner: # We trust the GIL here so we can do this comparison w/o locking. self._count = self._count + 1 return True greenlet_lock = self._get_greenlet_lock() self._wait_queue.append(gid) # this is a safety in case an exception is raised somewhere and we must make sure we're not in the queue # otherwise it'll get stuck forever. remove_from_queue_on_return = True try: while True: if not greenlet_lock.acquire(blocking): return False # non-blocking and failed to acquire lock if self._wait_queue[0] == gid: # Hurray, we can have the lock. self._owner = tid_gid self._count = 1 remove_from_queue_on_return = False # don't remove us from the queue return True else: # we already hold the greenlet lock so obviously the owner is not in our thread. greenlet_lock.release() if blocking: sleep(0.0005) # 500 us -> initial delay of 1 ms else: return False finally: if remove_from_queue_on_return: self._wait_queue.remove(gid)
def join(timeout=None): end = None if threading_mod.current_thread() is thread: raise RuntimeError("Cannot join current thread") if thread_greenlet is not None and thread_greenlet.dead: return # You may ask: Why not call thread_greenlet.join()? # Well, in the one case we actually have a greenlet, it's the # low-level greenlet.greenlet object for the main thread, which # doesn't have a join method. # # You may ask: Why not become the main greenlet's *parent* # so you can get notified when it finishes? Because you can't # create a greenlet cycle (the current greenlet is a descendent # of the parent), and nor can you set a greenlet's parent to None, # so there can only ever be one greenlet with a parent of None: the main # greenlet, the one we need to watch. # # You may ask: why not swizzle out the problematic lock on the main thread # into a gevent friendly lock? Well, the interpreter actually depends on that # for the main thread in threading._shutdown; see below. if not thread.is_alive(): return if timeout: end = time() + timeout while thread.is_alive(): if end is not None and time() > end: return sleep(0.01)
def _shutdown(): # Release anyone trying to join() me, # and let us switch to them. if not main_thread._tstate_lock: return main_thread._tstate_lock.release() from gevent import sleep try: sleep() except: # pylint:disable=bare-except # A greenlet could have .kill() us # or .throw() to us. I'm the main greenlet, # there's no where else for this to go. from gevent import get_hub get_hub().print_exception(_greenlet, *sys.exc_info()) # Now, this may have resulted in us getting stopped # if some other greenlet actually just ran there. # That's not good, we're not supposed to be stopped # when we enter _shutdown. main_thread._is_stopped = False main_thread._tstate_lock = main_thread.__real_tstate_lock main_thread.__real_tstate_lock = None # The only truly blocking native shutdown lock to # acquire should be our own (hopefully), and the call to # _stop that orig_shutdown makes will discard it. orig_shutdown() patch_item(threading_mod, '_shutdown', orig_shutdown)
def test_feed_manager(self): """Test attack feed manager""" # Create a session manager and the feed manager attached to it config = Configuration() session_manager = SessionManager(config) feed_manager = FeedManager(config, session_manager) feed_manager.add_feed(DummyFeed(config)) feed_manager.run() # Create an event event = Event("Test event") # Obtain a session and add the event session = session_manager.get_session("test", "127.0.0.1", 3200, "127.0.0.1", 3201) session.add_event(event) # Give the feed manager time for processing the event sleep(1) # Stop the feed manager and check if the event was processed feed_manager.stop() new_event = DummyFeed.events.get() self.assertIs(event, new_event)
def _set_size(self, size): if size < 0: raise ValueError('Size of the pool cannot be negative: %r' % (size, )) if size > self._maxsize: raise ValueError( 'Size of the pool cannot be bigger than maxsize: %r > %r' % (size, self._maxsize)) if self.manager: self.manager.kill() while len(self._worker_greenlets) < size: self._add_thread() delay = self.hub.loop.approx_timer_resolution while len(self._worker_greenlets) > size: while len(self._worker_greenlets ) - size > self.task_queue.unfinished_tasks: self.task_queue.put(None) if getcurrent() is self.hub: break sleep(delay) delay = min(delay * 2, .05) if self._worker_greenlets: self.fork_watcher.start(self._on_fork) else: self.fork_watcher.stop()
def _adjust_wait(self): delay = 0.0001 while True: self._adjust_step() if self._size <= self._maxsize: return sleep(delay) delay = min(delay * 2, .05)
def _adjust_wait(self): delay = 0.0001 while True: self._adjust_step() if len(self._worker_greenlets) <= self._maxsize: return sleep(delay) delay = min(delay * 2, .05)
def _adjust_wait(self): delay = self.hub.loop.approx_timer_resolution while True: self._adjust_step() if len(self._worker_greenlets) <= self._maxsize: return sleep(delay) delay = min(delay * 2, .05)
def _manage(self, maxsize=None): if maxsize is None: maxsize = self._maxsize delay = 0.0001 while True: self._adjust(maxsize) if self._size <= maxsize: return sleep(delay) delay = min(delay * 2, 0.05)
def _internal_poll(self): """Check if child process has terminated. Returns returncode attribute. """ if self.returncode is None: if get_hub() is not getcurrent(): sig_pending = getattr(self._loop, 'sig_pending', True) if sig_pending: sleep(0.00001) return self.returncode
def setUp(self): # drive_path = os.path.abspath(".\geckodriver.exe") # drive_path = os.path.abspath(".\geckodriver.exe") # self.driver.implicitly_wait(2) # self.addCleanup(self.driver.quit) self.driver = webdriver.Firefox() self.driver.maximize_window() sleep(3) # 隐性等待时间为30秒 self.base_url = "https://www.baidu.com"
def _manage(self, maxsize=None): if maxsize is None: maxsize = self._maxsize delay = 0.0001 while True: self._adjust(maxsize) if self._size <= maxsize: return sleep(delay) delay = min(delay * 2, .05)
def join(timeout=None): if threading.current_thread() is main_thread: raise RuntimeError("Cannot join current thread") if _greenlet.dead or not main_thread.is_alive(): return elif timeout: raise ValueError("Cannot use a timeout to join the main thread") # XXX: Make that work else: while main_thread.is_alive(): sleep(0.01)
def joinall(greenlets, polling_period=0.2): """Wait for the greenlets to finish by polling their status""" current = 0 while current < len(greenlets) and greenlets[current].dead: current += 1 delay = 0.002 while current < len(greenlets): delay = min(polling_period, delay * 2) sleep(delay) while current < len(greenlets) and greenlets[current].dead: current += 1
def wait(self, check_interval=0.1): # non-blocking, use hub.sleep try: while True: status = self.poll() if status is not None: return status hub.sleep(check_interval) except OSError, e: if e.errno == errno.ECHILD: # no child process, this happens if the child process # already died and has been cleaned up return -1
def _set_size(self, size): if size < 0: raise ValueError('Size of the pool cannot be negative: %r' % (size, )) if size > self._maxsize: raise ValueError('Size of the pool cannot be bigger than maxsize: %r > %r' % (size, self._maxsize)) if self.manager: self.manager.kill() while self._size < size: self._add_thread() delay = 0.0001 while self._size > size: while self._size - size > self.task_queue.unfinished_tasks: self.task_queue.put(None) sleep(delay) delay = min(delay * 2, .05)
def join(timeout=None): end = None if threading_mod.current_thread() is thread: raise RuntimeError("Cannot join current thread") if thread_greenlet is not None and thread_greenlet.dead: return if not thread.is_alive(): return if timeout: end = time() + timeout while thread.is_alive(): if end is not None and time() > end: return sleep(0.01)
def _set_size(self, size): if size < 0: raise ValueError('Size of the pool cannot be negative: %r' % (size, )) if size > self._maxsize: raise ValueError('Size of the pool cannot be bigger than maxsize: %r > %r' % (size, self._maxsize)) if self.manager: self.manager.kill() while self._size < size: self._add_thread() delay = 0.0001 while self._size > size: while self._size - size > self.task_queue.unfinished_tasks: self.task_queue.put(None) if getcurrent() is self.hub: break sleep(delay) delay = min(delay * 2, .05) if self._size: self.fork_watcher.start(self._on_fork) else: self.fork_watcher.stop()
def _shutdown(): # Release anyone trying to join() me, # and let us switch to them. if not main_thread._tstate_lock: return main_thread._tstate_lock.release() from gevent import sleep sleep() # Now, this may have resulted in us getting stopped # if some other greenlet actually just ran there. # That's not good, we're not supposed to be stopped # when we enter _shutdown. main_thread._is_stopped = False main_thread._tstate_lock = main_thread.__real_tstate_lock main_thread.__real_tstate_lock = None # The only truly blocking native shutdown lock to # acquire should be our own (hopefully), and the call to # _stop that orig_shutdown makes will discard it. orig_shutdown() patch_item(threading_mod, '_shutdown', orig_shutdown)
def use_cloud(self,token): while True: if self.wav_queue.qsize(): filename = self.readQ(queue=self.wav_queue) else: continue fp = wave.open(filename, 'rb') nf = fp.getnframes() # print 'sampwidth:',fp.getsampwidth() # print 'framerate:',fp.getframerate() # print 'channels:',fp.getnchannels() f_len = nf*2 audio_data = fp.readframes(nf) cuid = 'xxxxxxxxxx' srv_url = 'http://vop.baidu.com/server_api'+'?cuid='+cuid+'&token='+token http_header = [ 'Content-Type:audio/pcm;rate=8000', 'Content-length:%d' % f_len ] c = pycurl.Curl() c.setopt(pycurl.URL,str(srv_url)) #curl doesn't support unicode #c.setopt(c.RETURNTRANSE,1) c.setopt(c.HTTPHEADER,http_header) c.setopt(c.POST,1) c.setopt(c.CONNECTTIMEOUT,80) c.setopt(c.TIMEOUT,80) c.setopt(c.WRITEFUNCTION,self.dump_res) c.setopt(c.POSTFIELDS,audio_data) c.setopt(c.POSTFIELDSIZE,f_len) try: c.perform() #pycurl.perform() has no return val except Exception as e: print e sleep(0.3)
def join(greenlet, polling_period=0.2): """Wait for a greenlet to finish by polling its status""" delay = 0.002 while not greenlet.dead: delay = min(polling_period, delay * 2) sleep(delay)
def _heartbeat(self, time): while self.socket: sleep(time) message = msg_base.ProtobufMessage(steammessages_clientserver_pb2.CMsgClientHeartBeat, EMsg.ClientHeartBeat) self.send_message(message)
def join(self): delay = 0.0005 while self.task_queue.unfinished_tasks > 0: sleep(delay) delay = min(delay * 2, .05)
def join(self): """Waits until all outstanding tasks have been completed.""" delay = 0.0005 while self.task_queue.unfinished_tasks > 0: sleep(delay) delay = min(delay * 2, .05)
def setUp(self): self.driver = webutils() self.driver.max_window() sleep(5) # 隐性等待时间为30秒 self.base_url = "https://www.baidu.com"
def join(self): """Waits until all outstanding tasks have been completed.""" delay = max(0.0005, self.hub.loop.approx_timer_resolution) while self.task_queue.unfinished_tasks > 0: sleep(delay) delay = min(delay * 2, .05)
def kill(self): delay = 0.0005 while self._size > 0: self._remove_threads(0) sleep(delay) delay = min(delay * 2, .05)