Example #1
0
    def release(self):
        """Releases the lock, that was acquired with the same object.

        .. note::

            If you want to release a lock that you acquired in a different place you have two choices:

            * Use ``Lock("name", id=id_from_other_place).release()``
            * Use ``Lock("name").reset()``
        """
        if self._lock_renewal_thread is not None:
            self._stop_lock_renewer()
        log_info("Releasing %s." % self._name)
        error = _eval_script(self._client,
                             UNLOCK_SCRIPT,
                             self._name,
                             self._signal,
                             self._signal_expire,
                             args=(self._id, ))
        if error == 1:
            raise NotAcquired(
                "Lock %s is not acquired or it already expired." % self._name)
        elif error:
            raise RuntimeError(
                "Unsupported error code %s from EXTEND script." % error)
Example #2
0
def loop():
    identifier1 = str(uuid.uuid1())

    conn = redis.Redis(connection_pool=redis_connection.redis_pool)
    response = conn.client_list()
    log_info('sbsb' + str(response))
    global lock
    lock = Lock(conn, "my_lock1", expire=10, id=identifier1, auto_renewal=True)
    val = conn.get("my_lock1")
    print(str(val))
    pid = os.fork()
    if pid == 0:
        while True:
            w1()
    else:
        print("Create the process w1")
        pid = os.fork()
        identifier2 = str(uuid.uuid1())
        print(identifier1 + ":" + identifier2)
        nlock = Lock(conn,
                     "my_lock1",
                     expire=10,
                     id=identifier2,
                     auto_renewal=True)
        if pid == 0:
            while True:
                w2(nlock)
        else:
            print("Create the process w2")
Example #3
0
def _eval_script(redis, script_id, *keys, **kwargs):
    """Tries to call ``EVALSHA`` with the `hash` and then, if it fails, calls
    regular ``EVAL`` with the `script`.
    """
    args = kwargs.pop('args', ())
    if kwargs:
        raise TypeError("Unexpected keyword arguments %s" % kwargs.keys())
    try:
        return redis.evalsha(SCRIPTS[script_id], len(keys), *keys + args)
    except NoScriptError:
        log_info("%s not cached." % SCRIPTS[script_id + 2])
        return redis.eval(SCRIPTS[script_id + 1], len(keys), *keys + args)
Example #4
0
    def _start_lock_renewer(self):
        """
        Starts the lock refresher thread.
        """
        if self._lock_renewal_thread is not None:
            raise AlreadyStarted("Lock refresh thread already started")

        log_info("Starting thread to refresh lock every %s seconds" %
                 self._lock_renewal_interval)
        self._lock_renewal_stop = threading.Event()
        self._lock_renewal_thread = threading.Thread(
            group=None,
            target=self._lock_renewer,
            kwargs={
                'lockref': weakref.ref(self),
                'interval': self._lock_renewal_interval,
                'stop': self._lock_renewal_stop
            })
        self._lock_renewal_thread.setDaemon(True)
        self._lock_renewal_thread.start()
Example #5
0
def w1():
    global lock
    if lock._held:
        log_info('held')
    if lock.locked():
        log_info('lock live')
    lock.acquire()
    print("w1 get the lock")
    print(lock._client.get('lock:my_lock1'))
    time.sleep(20)
    if lock._lock_renewal_thread is not None:
        log_info('fffgggg')
    if lock._lock_renewal_thread.isAlive():
        log_info('renew fail')
    lock.release()
    print("w1 end")
Example #6
0
    def _stop_lock_renewer(self):
        """
        Stop the lock renewer.

        This signals the renewal thread and waits for its exit.
        """
        if self._lock_renewal_thread is None or not self._lock_renewal_thread.is_alive(
        ):
            return
        log_info("Signalling the lock refresher to stop")
        self._lock_renewal_stop.set()
        log_info("wchao")
        log_info(self._client.get(self._name))
        self._lock_renewal_thread.join()
        self._lock_renewal_thread = None
        log_info("Lock refresher has stopped")
Example #7
0
 def _lock_renewer(lockref, interval, stop):
     """
     Renew the lock key in redis every `interval` seconds for as long
     as `self._lock_renewal_thread.should_exit` is False.
     """
     while True:
         res = stop.wait(timeout=interval)
         log_info(res)
         if res:
             break
         log_info("Refreshing lock")
         lock = lockref()
         if lock is None:
             log_info("The lock no longer exists, "
                      "stopping lock refreshing")
             break
         lock.extend(expire=lock._expire)
         del lock
     log_info("Exit requested, stopping lock refreshing")
Example #8
0
    def acquire(self, blocking=True, timeout=None):
        """
        :param blocking:
            Boolean value specifying whether lock should be blocking or not.
        :param timeout:
            An integer value specifying the maximum number of seconds to block.
        """
        log_info("Getting %s ..." % self._name)

        if self._held:
            raise AlreadyAcquired("Already acquired from this Lock instance.")

        if not blocking and timeout is not None:
            raise TimeoutNotUsable("Timeout cannot be used if blocking=False")

        timeout = timeout if timeout is None else int(timeout)
        if timeout is not None and timeout <= 0:
            raise InvalidTimeout(
                "Timeout (%d) cannot be less than or equal to 0" % timeout)

        if timeout and self._expire and timeout > self._expire:
            raise TimeoutTooLarge(
                "Timeout (%d) cannot be greater than expire (%d)" %
                (timeout, self._expire))

        busy = True
        blpop_timeout = timeout or self._expire or 0
        timed_out = False
        while busy:
            busy = not self._client.set(
                self._name, self._id, nx=True, ex=self._expire)
            if busy:
                if timed_out:
                    return False
                elif blocking:
                    timed_out = not self._client.blpop(
                        self._signal, blpop_timeout) and timeout
                else:
                    log_info("Failed to get %s." % self._name)
                    return False

        log_info("Got lock for %s." % self._name)
        if self._lock_renewal_interval is not None:
            self._start_lock_renewer()
        return True
Example #9
0
import redis

from redis_notes.common.log import log_info


def _set_up_redis_instance():

    instance = redis.ConnectionPool(host='localhost', port=6379, decode_responses=True)

    return instance

redis_pool = None

try:
    redis_pool = _set_up_redis_instance()
    print str(redis_pool)+"wwwwww"
    print redis_pool.ping()
    response = redis_pool.client_list()
    log_info('sbsb' + str(response))
    log_info(redis_pool)
except:
    print "fail initiating redis instance"
try:
    conn = redis.Redis(host='localhost', port=6379, decode_responses=True)
    response = conn.client_list()
    log_info('hbhb'+str(response))
except redis.ConnectionError:
    log_info('connection sbsbsb')