예제 #1
0
파일: zk.py 프로젝트: huixiangufl/ncfs
 def watcher(handle, type, state, path):
     self.cv.acquire()
     if state == zookeeper.CONNECTED_STATE:
         print "Connected!"
         self.connected = True
     else:
         print "Disconnected from ZooKeeper: ",
         print zookeeper.zerror(state)
     self.cv.notify()
     self.cv.release()
예제 #2
0
파일: zk.py 프로젝트: ialzuru/ncfs
 def watcher (handle, type, state, path):
     self.cv.acquire()
     if state == zookeeper.CONNECTED_STATE:
         print "Connected!"
         self.connected = True
     else:
         print "Disconnected from ZooKeeper: ",
         print zookeeper.zerror(state)
     self.cv.notify()
     self.cv.release()
예제 #3
0
    def test_async_getchildren(self):
        self.ensureCreated("/zk-python-getchildrentest", flags=0)
        self.ensureCreated("/zk-python-getchildrentest/child")

        def gc_callback(handle, rc, children):
            self.cv.acquire()
            self.rc = rc
            self.children = children
            self.callback_flag = True
            self.cv.notify()
            self.cv.release()

        self.cv.acquire()
        self.callback_flag = False
        zookeeper.aget_children(self.handle, "/zk-python-getchildrentest",
                                None, gc_callback)
        self.cv.wait(15)
        self.assertEqual(self.callback_flag, True, "aget_children timed out")
        self.assertEqual(
            self.rc, zookeeper.OK,
            "Return code for aget_children was not OK - %s" %
            zookeeper.zerror(self.rc))
        self.assertEqual(
            len(self.children), 1,
            "Expected to find 1 child, got " + str(len(self.children)))
예제 #4
0
 def on_auth_callback(state, result):
     with self.cv:
         if result == zookeeper.AUTHFAILED:
             self.logger.error(zookeeper.zerror(zookeeper.AUTHFAILED))
         self.logger.info("on_auth: state %s, result %s",
                          state, result)
         self.cv.notify()
예제 #5
0
    def error_to_exception(self, return_code, message=None):
        """Convert zookeeper error code to the appropriate exception.

        Args:
            return_code: zookeeper return code.
            message: exception message.
        
        Returns:
            zookeeper exception object which should be raised.
        """

        try:
            error_message = zookeeper.zerror(return_code)
        except:
            error_message = "Unknown error code - %s" % return_code

        if message:
            message = "%s: %s" % (message, error_message)
        else:
            message = error_message

        exception_class = ERROR_CODE_EXCEPTION_MAP.get(
            return_code) or Exception

        return exception_class(message)
예제 #6
0
    def _check_result(self, result_code, deferred, extra_codes=(), path=None):
        """Check an API call or result for errors.

        :param result_code: The api result code.
        :param deferred: The deferred returned the client api consumer.
        :param extra_codes: Additional result codes accepted as valid/ok.

        If the result code is an error, an appropriate Exception class
        is constructed and the errback on the deferred is invoked with it.
        """
        error = None
        if not result_code == zookeeper.OK and not result_code in extra_codes:
            error_msg = zookeeper.zerror(result_code)
            if path is not None:
                error_msg += " %s" % path
            error_class = ERROR_MAPPING.get(
                result_code, zookeeper.ZooKeeperException)
            error = error_class(error_msg)

            if is_connection_exception(error):
                # Route connection errors to a connection level error
                # handler if specified.
                if self._connection_error_callback:
                    # The result of the connection error handler is returned
                    # to the api invoker.
                    d = defer.maybeDeferred(
                        self._connection_error_callback,
                        self, error)
                    d.chainDeferred(deferred)
                    return True

            deferred.errback(error)
            return True
        return None
예제 #7
0
 def __init__(self,queuename):
     self.connected = False
     self.queuename = "/" + queuename
     self.cv = threading.Condition()
     zookeeper.set_log_stream(open("/dev/null"))        
     def watcher(handle,type,state,path):
         print "Connected"
         self.cv.acquire()
         self.connected = True
         self.cv.notify()
         self.cv.release()
         
     self.cv.acquire()            
     self.handle = zookeeper.init("localhost:2181", watcher, 10000, 0)
     self.cv.wait(10.0)
     if not self.connected:
         print "Connection to ZooKeeper cluster timed out - is a server running on localhost:2181?"
         sys.exit()
     self.cv.release()
     try:
         zookeeper.create(self.handle,self.queuename,"queue top level", [ZOO_OPEN_ACL_UNSAFE],0)
     except IOError, e:
         if e.message == zookeeper.zerror(zookeeper.NODEEXISTS):
             print "Queue already exists"    
         else:
             raise e
예제 #8
0
파일: zk.py 프로젝트: hussam/racs
    def __init__(self, server, root_node, host='localhost', port=2181):
        self.root = root_node
        self.host = host
        self.port = port
        self.counter = random.randint(0,2**30)
        self.server = server
        self.zcv = Condition() 

        def watcher(handle,type,state,path):
            print "Z connected (%s:%s)" % (self.host, self.port)
            self.zcv.acquire()
            self.connected = True
            self.zcv.notify()
            self.zcv.release()

        self.zcv.acquire()
        self.connected = False

        self.handle = z.init("%s:%s"%(self.host,self.port), watcher, 10000, 0)
        self.zcv.wait(10.0)

        if not self.connected:
            print "Connection to Z cluster timed out - is a server running on %s:%s?" % (self.host,self.port)
            self.connected = False
            self.zcv.release()
            return
        self.zcv.release()

        # make sure root node exists
        try:
            self.create(self.root,"RACS root node", [ZOO_OPEN_ACL_UNSAFE])
        except IOError, e:
            if e.args[0] != z.zerror(z.NODEEXISTS):
                raise e
예제 #9
0
    def __init__(self, queuename):
        self.connected = False
        self.queuename = "/" + queuename
        self.cv = threading.Condition()
        zookeeper.set_log_stream(open("/dev/null"))

        def watcher(handle, type, state, path):
            print "Connected"
            self.cv.acquire()
            self.connected = True
            self.cv.notify()
            self.cv.release()

        self.cv.acquire()
        self.handle = zookeeper.init("localhost:2181", watcher, 10000, 0)
        self.cv.wait(10.0)
        if not self.connected:
            print "Connection to ZooKeeper cluster timed out - is a server running on localhost:2181?"
            sys.exit()
        self.cv.release()
        try:
            zookeeper.create(self.handle, self.queuename, "queue top level",
                             [ZOO_OPEN_ACL_UNSAFE], 0)
        except IOError, e:
            if e.message == zookeeper.zerror(zookeeper.NODEEXISTS):
                print "Queue already exists"
            else:
                raise e
예제 #10
0
 def get_and_delete(self, node):
     try:
         (data, stat) = zookeeper.get(self.handle, node, None)
         zookeeper.delete(self.handle, node, stat["version"])
         return data
     except IOError, e:
         if e.message == zookeeper.zerror(zookeeper.NONODE):
             return None
         raise e
예제 #11
0
 def get_and_delete(self,node):
     try:
         (data,stat) = zookeeper.get(self.handle, node, None)
         zookeeper.delete(self.handle, node, stat["version"])
         return data
     except IOError, e:
         if e.message == zookeeper.zerror(zookeeper.NONODE):
             return None 
         raise e
예제 #12
0
    def __init__(self, **config):
        logger_name = config.get("logger_name")
        self.logger = logging.getLogger(logger_name) if logger_name else Null()
        self.zkhandle = None
        self.auth = None
        self.cv = threading.Condition()

        try:
            auth_config = config.get("auth")
            if auth_config is not None:
                auth_scheme = auth_config["scheme"]
                auth_data = auth_config["data"]
                self.auth = (auth_scheme, auth_data)
            zklogfile_path, zklog_level = config.get("ZookeeperLog", ("/dev/stderr", "WARN"))
            self.connection_timeout = config["timeout"]
            self.zkhosts = ",".join(config["host"])
        except KeyError as err:
            self.logger.exception("Missing configuration option: %s", err)
            raise
        except Exception as err:
            self.logger.exception("Unknown configuration error: %s", err)
            raise

        try:
            _f = open(zklogfile_path, "a")
        except IOError as err:
            self.logger.error("Unable to open logfile %s %s", zklogfile_path, err)
        else:
            zookeeper.set_log_stream(_f)
            zookeeper.set_debug_level(LOG_LEVELS.get(zklog_level.upper(), zookeeper.LOG_LEVEL_WARN))

        self.connect()
        if zookeeper.state(self.zkhandle) == zookeeper.CONNECTED_STATE:
            self.logger.info("Connected to Zookeeper successfully")
        else:
            raise zookeeper.ZooKeeperException("Unable to connect " "to Zookeeper")

        def on_auth_callback(state, result):
            with self.cv:
                if result == zookeeper.AUTHFAILED:
                    self.logger.error(zookeeper.zerror(zookeeper.AUTHFAILED))
                self.logger.info("on_auth: state %s, result %s", state, result)
                self.cv.notify()

        if self.auth:
            self.logger.info("Auth using %s", self.auth[0])
            with self.cv:
                res = zookeeper.add_auth(self.zkhandle, self.auth[0], self.auth[1], on_auth_callback)
                if res != zookeeper.OK:
                    self.logger.error("Invalid status %d", zookeeper.zerror(res))
                    raise Exception("Invalid status")
                self.cv.wait(self.connection_timeout)

            if zookeeper.state(self.zkhandle) == zookeeper.AUTH_FAILED_STATE:
                raise zookeeper.ZooKeeperException("authentication failed")
예제 #13
0
    def error_to_exception(self, return_code, message=None):
        """Convert zookeeper error code to exceptions."""
        try:
            error_message = zookeeper.zerror(return_code)
        except:
            error_message = "Unknown error code - %s" % return_code
        
        if message:
            message = "%s: %s" % (message, error_message)
        else:
            message = error_message

        exception_class = ERROR_CODE_EXCEPTION_MAP.get(return_code) or Exception
        
        return exception_class(message)
예제 #14
0
    def test_async_getchildren(self):
        self.ensureCreated("/zk-python-getchildrentest", flags=0)
        self.ensureCreated("/zk-python-getchildrentest/child")

        def gc_callback(handle, rc, children):
            self.cv.acquire()
            self.rc = rc
            self.children = children
            self.callback_flag = True
            self.cv.notify()
            self.cv.release()

        self.cv.acquire()
        self.callback_flag = False
        zookeeper.aget_children(self.handle, "/zk-python-getchildrentest", None, gc_callback)
        self.cv.wait(15)
        self.assertEqual(self.callback_flag, True, "aget_children timed out")
        self.assertEqual(
            self.rc, zookeeper.OK, "Return code for aget_children was not OK - %s" % zookeeper.zerror(self.rc)
        )
        self.assertEqual(len(self.children), 1, "Expected to find 1 child, got " + str(len(self.children)))
예제 #15
0
    def test_async_exists(self):
        self.cv = threading.Condition()
        def callback(handle, rc, stat):
            self.cv.acquire()
            self.callback_flag = True            
            self.cv.notify()
            self.cv.release()
            self.rc = rc
            
        self.assertEqual(self.connected, True)

        self.cv.acquire()        
        ret = zookeeper.aexists(self.handle, "/zk-python-aexiststest", None,
                                callback )
        self.assertEqual(ret, zookeeper.OK)
        while not self.callback_flag:
            self.cv.wait(15)
        self.cv.release()

        self.assertEqual(self.callback_flag, True, "aexists timed out")
        self.assertEqual(self.rc, zookeeper.OK, "Return code not ok:" + zookeeper.zerror(self.rc))
예제 #16
0
def err_to_exception(error_code, msg=None):
    """Return an exception object for a Zookeeper error code
    """
    try:
        zkmsg = zookeeper.zerror(error_code)
    except Exception:
        zkmsg = ""

    if msg:
        if zkmsg:
            msg = "%s: %s" % (zkmsg, msg)
    else:
        msg = zkmsg

    exc = _ERR_TO_EXCEPTION.get(error_code)
    if exc is None:

        # double check that it isn't an ok resonse
        if error_code == zookeeper.OK:
            return None

        # otherwise generic exception
        exc = Exception
    return exc(msg)
예제 #17
0
def err_to_exception(error_code, msg=None):
    """Return an exception object for a Zookeeper error code
    """
    try:
        zkmsg = zookeeper.zerror(error_code)
    except Exception:
        zkmsg = ""

    if msg:
        if zkmsg:
            msg = "%s: %s" % (zkmsg, msg)
    else:
        msg = zkmsg

    exc = _ERR_TO_EXCEPTION.get(error_code)
    if exc is None:

        # double check that it isn't an ok resonse
        if error_code == zookeeper.OK:
            return None

        # otherwise generic exception
        exc = Exception
    return exc(msg)
예제 #18
0
파일: client.py 프로젝트: jmullins/trpycore
    def error_to_exception(self, return_code, message=None):
        """Convert zookeeper error code to the appropriate exception.

        Args:
            return_code: zookeeper return code.
            message: exception message.
        
        Returns:
            zookeeper exception object which should be raised.
        """

        try:
            error_message = zookeeper.zerror(return_code)
        except:
            error_message = "Unknown error code - %s" % return_code
        
        if message:
            message = "%s: %s" % (message, error_message)
        else:
            message = error_message

        exception_class = ERROR_CODE_EXCEPTION_MAP.get(return_code) or Exception
        
        return exception_class(message)
예제 #19
0
 def _raise_exception(self, rc):
     raise self._rc2exception[rc](zookeeper.zerror(rc))
예제 #20
0
 def _raise_exception(self, rc):
     raise self._rc2exception[rc](zookeeper.zerror(rc))
예제 #21
0
 def on_auth_callback(state, result):
     with self.cv:
         if result == zookeeper.AUTHFAILED:
             self.logger.error(zookeeper.zerror(zookeeper.AUTHFAILED))
         self.logger.info("on_auth: state %s, result %s", state, result)
         self.cv.notify()
예제 #22
0
    def __init__(self, **config):
        logger_name = config.get('logger_name')
        self.logger = logging.getLogger(logger_name) if logger_name else Null()
        self.zkhandle = None
        self.auth = None
        self.cv = threading.Condition()

        try:
            auth_config = config.get("auth")
            if auth_config is not None:
                auth_scheme = auth_config["scheme"]
                auth_data = auth_config["data"]
                self.auth = (auth_scheme, auth_data)
            zklogfile_path, zklog_level = config.get("ZookeeperLog",
                                                     ("/dev/stderr", "WARN"))
            self.connection_timeout = config['timeout']
            self.zkhosts = ','.join(config['host'])
        except KeyError as err:
            self.logger.exception("Missing configuration option: %s", err)
            raise
        except Exception as err:
            self.logger.exception("Unknown configuration error: %s", err)
            raise

        try:
            _f = open(zklogfile_path, 'a')
        except IOError as err:
            self.logger.error("Unable to open logfile %s %s",
                              zklogfile_path, err)
        else:
            zookeeper.set_log_stream(_f)
            zookeeper.set_debug_level(LOG_LEVELS.get(zklog_level.upper(),
                                                     zookeeper.LOG_LEVEL_WARN))

        self.connect()
        if zookeeper.state(self.zkhandle) == zookeeper.CONNECTED_STATE:
            self.logger.info('Connected to Zookeeper successfully')
        else:
            raise zookeeper.ZooKeeperException('Unable to connect '
                                               'to Zookeeper')

        def on_auth_callback(state, result):
            with self.cv:
                if result == zookeeper.AUTHFAILED:
                    self.logger.error(zookeeper.zerror(zookeeper.AUTHFAILED))
                self.logger.info("on_auth: state %s, result %s",
                                 state, result)
                self.cv.notify()

        if self.auth:
            self.logger.info("Auth using %s", self.auth[0])
            with self.cv:
                res = zookeeper.add_auth(self.zkhandle, self.auth[0],
                                         self.auth[1], on_auth_callback)
                if res != zookeeper.OK:
                    self.logger.error("Invalid status %d",
                                      zookeeper.zerror(res))
                    raise Exception("Invalid status")
                self.cv.wait(self.connection_timeout)

            if zookeeper.state(self.zkhandle) == zookeeper.AUTH_FAILED_STATE:
                raise zookeeper.ZooKeeperException('authentication failed')