Python lock.Semaphore方法代码示例

# 需要导入模块: from gevent import lock [as 别名]
# 或者: from gevent.lock import Semaphore [as 别名]
def __init__(self, db, expand_targets, message_send_enqueue, sender_app):
        self.db = db
        self.expand_targets = expand_targets
        self.message_send_enqueue = message_send_enqueue
        self.iris_application = None
        if sender_app:
            self.iris_application = iris.cache.applications.get(sender_app)
            if self.iris_application:
                logger.info('Using iris application (%s) for sender quota notifications.', sender_app)
            else:
                logger.error('Invalid iris application (%s) used for sender. Quota breach notificiations/incidents will not work.', sender_app)
        else:
            logger.warning('Iris sender_app not configured so notifications for quota breaches will not work')

        self.rates = {}  # application: (hard_buckets, soft_buckets, hard_limit, soft_limit, wait_time, plan_name, (target_name, target_role))
        self.last_incidents = {}  # application: (incident_id, time())
        self.last_incidents_mutex = Semaphore()
        self.last_soft_quota_notification_time = {}  # application: time()
        self.last_soft_quota_notification_time_mutex = Semaphore()
        metrics.add_new_metrics({'quota_hard_exceed_cnt': 0, 'quota_soft_exceed_cnt': 0})
        spawn(self.refresh) 

# 需要导入模块: from gevent import lock [as 别名]
# 或者: from gevent.lock import Semaphore [as 别名]
def __init__(self, tree_hub, application_name, type_name, semaphore=None):
        assert type_name in ('service', 'switch', 'config')

        self.hub = tree_hub
        self.application_name = application_name
        self.type_name = type_name
        self.path = make_path(self.hub.base_path, type_name, application_name)
        self.cache = make_cache(self.hub.client, self.path)
        self.initialized = Event()
        self._started = False
        self._closed = False
        self.cluster_resolver = ClusterResolver(
            self.get_service_info, self.get_cluster_info)
        if semaphore is None:
            self.throttle_semaphore = Semaphore()
        else:
            self.throttle_semaphore = semaphore 

# 需要导入模块: from gevent import lock [as 别名]
# 或者: from gevent.lock import Semaphore [as 别名]
def __init__(self, *args, **kwargs):
        ImapSyncMonitor.__init__(self, *args, **kwargs)
        self.sync_engine_class = GmailFolderSyncEngine

        # We start a label refresh whenever we find a new labels
        # However, this is a pretty expensive operation, so we
        # use a semaphore to make sure we're not running multiple
        # LabelRenameHandlers for a single account.
        # This is a conservative choice which should be okay most
        # of the time.
        # We could have used something like a table to not start
        # a LabelRenameHandler for a label when another one is
        # already running, but in some cases it gives us better consistency
        # (e.g: I have a label A -> I rename to B, then to C but add some
        #       labels back into A).
        # This is unlikely but worth getting right.
        # - karim
        self.label_rename_semaphore = Semaphore(value=1) 

# 需要导入模块: from gevent import lock [as 别名]
# 或者: from gevent.lock import Semaphore [as 别名]
def __init__(self, address, port, timeout, buffer_size=PAGESIZE,
                 lock_class=Semaphore):
        self.address = address
        self.port = port
        self.timeout = timeout

        self.buffer = b''
        self.buffer_size = buffer_size

        self.socket = None
        self.lock = lock_class() 

# 需要导入模块: from gevent import lock [as 别名]
# 或者: from gevent.lock import Semaphore [as 别名]
def __init__(self, ws, lag_tolerance_secs=0.1):
        self.ws = ws
        self.lag_tolerance_secs = lag_tolerance_secs

        # This lock is used to make sure that multiple greenlets
        # cannot send to the same socket concurrently.
        self.send_lock = Semaphore() 

# 需要导入模块: from gevent import lock [as 别名]
# 或者: from gevent.lock import Semaphore [as 别名]
def __init__(self, *args, **kwargs):
        BaseServer.__init__(self, *args, **kwargs)
        from gevent.lock import Semaphore
        self._writelock = Semaphore() 

# 需要导入模块: from gevent import lock [as 别名]
# 或者: from gevent.lock import Semaphore [as 别名]
def __init__(self, fobj, *args, **kwargs):
        """
        :param fobj: The underlying file-like object to wrap, or an integer fileno
           that will be pass to :func:`os.fdopen` along with everything in *args*.
        :keyword bool lock: If True (the default) then all operations will
           be performed one-by-one. Note that this does not guarantee that, if using
           this file object from multiple threads/greenlets, operations will be performed
           in any particular order, only that no two operations will be attempted at the
           same time. You can also pass your own :class:`gevent.lock.Semaphore` to synchronize
           file operations with an external resource.
        :keyword bool close: If True (the default) then when this object is closed,
           the underlying object is closed as well.
        """
        self._close = kwargs.pop('close', True)
        self.threadpool = kwargs.pop('threadpool', None)
        self.lock = kwargs.pop('lock', True)
        if kwargs:
            raise TypeError('Unexpected arguments: %r' % kwargs.keys())
        if self.lock is True:
            self.lock = Semaphore()
        elif not self.lock:
            self.lock = DummySemaphore()
        if not hasattr(self.lock, '__enter__'):
            raise TypeError('Expected a Semaphore or boolean, got %r' % type(self.lock))
        if isinstance(fobj, integer_types):
            if not self._close:
                # we cannot do this, since fdopen object will close the descriptor
                raise TypeError('FileObjectThread does not support close=False')
            fobj = os.fdopen(fobj, *args)
        self.io = fobj
        if self.threadpool is None:
            self.threadpool = get_hub().threadpool 

# 需要导入模块: from gevent import lock [as 别名]
# 或者: from gevent.lock import Semaphore [as 别名]
def __init__(self, size=None, greenlet_class=None):
        """
        Create a new pool.

        A pool is like a group, but the maximum number of members
        is governed by the *size* parameter.

        :keyword int size: If given, this non-negative integer is the
            maximum count of active greenlets that will be allowed in
            this pool. A few values have special significance:

            * ``None`` (the default) places no limit on the number of
              greenlets. This is useful when you need to track, but not limit,
              greenlets, as with :class:`gevent.pywsgi.WSGIServer`. A :class:`Group`
              may be a more efficient way to achieve the same effect.
            * ``0`` creates a pool that can never have any active greenlets. Attempting
              to spawn in this pool will block forever. This is only useful
              if an application uses :meth:`wait_available` with a timeout and checks
              :meth:`free_count` before attempting to spawn.
        """
        if size is not None and size < 0:
            raise ValueError('size must not be negative: %r' % (size, ))
        Group.__init__(self)
        self.size = size
        if greenlet_class is not None:
            self.greenlet_class = greenlet_class
        if size is None:
            self._semaphore = DummySemaphore()
        else:
            self._semaphore = Semaphore(size) 

# 需要导入模块: from gevent import lock [as 别名]
# 或者: from gevent.lock import Semaphore [as 别名]
def _init(self, maxsize):
        self._size = 0
        self._semaphore = Semaphore(1)
        self._lock = Lock()
        self.task_queue = Queue()
        self._set_maxsize(maxsize) 

# 需要导入模块: from gevent import lock [as 别名]
# 或者: from gevent.lock import Semaphore [as 别名]
def __init__(self, listener, profiler=None, interval=INTERVAL,
                 log=LOG, pickle_protocol=PICKLE_PROTOCOL, **server_kwargs):
        StreamServer.__init__(self, listener, **server_kwargs)
        ProfilingServer.__init__(self, profiler, interval,
                                 log, pickle_protocol)
        self.lock = Semaphore()
        self.profiling_greenlet = None 

# 需要导入模块: from gevent import lock [as 别名]
# 或者: from gevent.lock import Semaphore [as 别名]
def __init__(self, parent, io_loop=None):
        self._parent = parent
        self._closing = False
        self._user_queries = {}
        self._cursor_cache = {}

        self._write_mutex = Semaphore()
        self._socket = None 

# 需要导入模块: from gevent import lock [as 别名]
# 或者: from gevent.lock import Semaphore [as 别名]
def __init__(self, huskar_client, startup_max_concurrency=None):
        self.base_path = huskar_client.base_path
        self.client = huskar_client.client
        self.tree_map = {}
        self.tree_holder_class = TreeHolder
        self.tree_watcher_class = TreeWatcher
        self.lock = Semaphore()
        if startup_max_concurrency:
            self.throttle = Semaphore(startup_max_concurrency)
        else:
            self.throttle = None 

# 需要导入模块: from gevent import lock [as 别名]
# 或者: from gevent.lock import Semaphore [as 别名]
def _new_gevent_lock(*args, **kwargs):
    from gevent.lock import Semaphore
    return Semaphore(*args, **kwargs) 

# 需要导入模块: from gevent import lock [as 别名]
# 或者: from gevent.lock import Semaphore [as 别名]
def __init__(self, name, task):
        self.name = name
        self.task = task
        self.lock = Semaphore(task.max_concurrent) 

# 需要导入模块: from gevent import lock [as 别名]
# 或者: from gevent.lock import Semaphore [as 别名]
def __init__(self, rdb, key_name):
        self.rdb = rdb
        self.key_name = key_name
        self.update_key_name = u'redis-set:{}'.format(self.key_name)

        self._set = rdb.smembers(key_name)
        self._lock = Semaphore()
        self._ps = self.rdb.pubsub()
        self._ps.subscribe(self.update_key_name)

        self._inst = gevent.spawn(self._listener)