本文整理汇总了Python中zookeeper.init函数的典型用法代码示例。如果您正苦于以下问题:Python init函数的具体用法?Python init怎么用?Python init使用的例子?那么恭喜您, 这里精选的函数代码示例或许可以为您提供帮助。
在下文中一共展示了init函数的15个代码示例,这些例子默认根据受欢迎程度排序。您可以为喜欢或者感觉有用的代码点赞,您的评价将有助于系统推荐出更棒的Python代码示例。
示例1: _connect
def _connect(self):
"""Creates a connection to a zookeeper instance."""
s = []
for host, port in self._servers:
try:
_, _, ips = socket.gethostbyname_ex(host)
for ip in ips:
s.append('%s:%s' % (ip, port))
except socket.gaierror:
logging.error('Hostname not known: %s', host)
except socket.herror:
logging.error('Unable to resolve %s', host)
if not s:
logging.error('No IPs found to connect to.. trying again in 1 second.')
t = threading.Timer(1.0, self._connect)
t.daemon = True
t.start()
return
if self._clientid is not None:
# Existing connections get registered with the same clientid that was
# used before.
self._zookeeper = zookeeper.init(
','.join(s), self._global_watch, None, clientid)
else:
self._zookeeper = zookeeper.init(','.join(s), self._global_watch)
示例2: testhandlereuse
def testhandlereuse(self):
"""
Test a) multiple concurrent connections b) reuse of closed handles
"""
cv = threading.Condition()
self.connected = False
def connection_watcher(handle, type, state, path):
cv.acquire()
self.connected = True
self.assertEqual(zookeeper.CONNECTED_STATE, state)
self.handle = handle
cv.notify()
cv.release()
cv.acquire()
handles = [ zookeeper.init(self.host) for i in xrange(10) ]
ret = zookeeper.init(self.host, connection_watcher)
cv.wait(15.0)
cv.release()
self.assertEqual(self.connected, True, "Connection timed out to " + self.host)
self.assertEqual(True, all( [ zookeeper.state(handle) == zookeeper.CONNECTED_STATE for handle in handles ] ),
"Not all connections succeeded")
oldhandle = handles[3]
zookeeper.close(oldhandle)
newhandle = zookeeper.init(self.host)
# This assertion tests *internal* behaviour; i.e. that the module
# correctly reuses closed handles. This is therefore implementation
# dependent.
self.assertEqual(newhandle, oldhandle, "Didn't get reused handle")
示例3: testmanyhandles
def testmanyhandles(self):
"""
Test the ability of the module to support many handles.
"""
# We'd like to do more, but currently the C client doesn't
# work with > 83 handles (fails to create a pipe) on MacOS 10.5.8
handles = [ zookeeper.init(self.host) for i in xrange(63) ]
cv = threading.Condition()
self.connected = False
def connection_watcher(handle, type, state, path):
cv.acquire()
self.connected = True
self.assertEqual(zookeeper.CONNECTED_STATE, state)
self.handle = handle
cv.notify()
cv.release()
cv.acquire()
ret = zookeeper.init(self.host, connection_watcher)
cv.wait(15.0)
cv.release()
self.assertEqual(self.connected, True, "Connection timed out to " + self.host)
for i,h in enumerate(handles):
path = "/zkpython-test-handles-%s" % str(i)
self.assertEqual(path, zookeeper.create(h, path, "", [ZOO_OPEN_ACL_UNSAFE], zookeeper.EPHEMERAL))
self.assertEqual(True, all( zookeeper.close(h) == zookeeper.OK for h in handles ))
示例4: __init__
def __init__(self, connection_string="127.0.0.1:2181", session_timeout=None,
wait=False):
self.watches = WatchManager()
self.ephemeral = {}
self.handle = None
connected = self.connected = threading.Event()
def watch_session(handle, event_type, state, path):
assert event_type == zookeeper.SESSION_EVENT
assert not path
if state == zookeeper.CONNECTED_STATE:
if self.handle is None:
self.handle = handle
for watch in self.watches.clear():
self._watch(watch)
for path, data in list(self.ephemeral.items()):
zookeeper.create(self.handle, path, data['data'],
data['acl'], data['flags'])
else:
assert handle == self.handle
connected.set()
logger.info('connected %s', handle)
elif state == zookeeper.CONNECTING_STATE:
connected.clear()
elif state == zookeeper.EXPIRED_SESSION_STATE:
connected.clear()
if self.handle is not None:
zookeeper.close(self.handle)
self.handle = None
init()
else:
logger.critical('unexpected session event %s %s', handle, state)
if session_timeout:
init = (lambda : zookeeper.init(connection_string, watch_session,
session_timeout)
)
else:
init = lambda : zookeeper.init(connection_string, watch_session)
handle = init()
connected.wait(self.initial_connection_wait)
if not connected.is_set():
if wait:
while not connected.is_set():
logger.critical("Can't connect to ZooKeeper at %r",
connection_string)
connected.wait(1)
else:
zookeeper.close(handle)
raise FailedConnect(connection_string)
示例5: connect
def connect(self, servers=None, timeout=10, client_id=None):
"""
Establish a connection to the given zookeeper server(s).
@param servers: A string specifying the servers and their ports to
connect to. Multiple servers can be specified in
comma separated fashion.
@param timeout: How many seconds to wait on a connection to the
zookeeper servers.
@param session_id:
@returns A deferred that's fired when the connection is established.
"""
d = defer.Deferred()
if self.connected:
return defer.fail(
zookeeper.ZooKeeperException("Already Connected"))
# Use a scheduled function to ensure a timeout.
def _check_timeout():
# Close the handle
try:
if self.handle is not None:
zookeeper.close(self.handle)
except zookeeper.ZooKeeperException:
pass
d.errback(
ConnectionTimeoutException("could not connect before timeout"))
scheduled_timeout = reactor.callLater(timeout, _check_timeout)
# Assemble an on connect callback with closure variable access.
callback = partial(self._cb_connected, scheduled_timeout, d)
callback = self._zk_thread_callback(callback)
if self._session_timeout is None:
self._session_timeout = DEFAULT_SESSION_TIMEOUT
if servers is not None:
self._servers = servers
# Use client id if specified.
if client_id:
self.handle = zookeeper.init(
self._servers, callback, self._session_timeout, client_id)
else:
self.handle = zookeeper.init(
self._servers, callback, self._session_timeout)
return d
示例6: connect_async
def connect_async(self):
"""Asynchronously initiate connection to ZK
@return: AsyncResult object set on connection success
@rtype AsyncResult
"""
cb = self._wrap_session_callback(self._session_callback)
if self._provided_client_id:
self._handle = zookeeper.init(self._hosts, cb, self._timeout,
self._provided_client_id)
else:
self._handle = zookeeper.init(self._hosts, cb, self._timeout)
return self._connected_async_result
示例7: __init__
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
示例8: __init__
def __init__(self, barriername, number_of_workers):
self.cv = threading.Condition()
self.connected = False
self.barrier = "/" + barriername
self.workers = number_of_workers
zookeeper.set_log_stream(open('/dev/null'))
def watcher(handle, type, state, path):
self.cv.acquire()
self.connected = True
self.cv.notify()
self.cv.release()
self.cv.acquire()
self.handle = zookeeper.init("localhost:2181", watcher, 10000)
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.barrier, '\x00', [ZOO_OPEN_ACL_UNSAFE], 0)
except zookeeper.NodeExistsException:
pass
except Exception, ex:
print ex
raise ex
示例9: __init__
def __init__(self, setting):
#Connect to ZK servers
print "Connecting to ZooKeeper ... "
self.connected = False
self.log = open("zookeeper.log", 'a')
self.log.write("\n\n=============\nZOOKEEPER LOG\n=============\n")
self.log.write(datetime.now().__str__())
zookeeper.set_log_stream(self.log)
self.cv = threading.Condition()
self.cv2 = threading.Condition()
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()
self.cv.acquire()
self.zh = zookeeper.init(setting.zookeeperloc, watcher, 10000)
self.cv.wait(10.0)
if not self.connected:
print "Cannot connect to ZooKeeper. ",
print "Check that server(s) are on " + setting.zookeeperloc
sys.exit()
self.cv.release()
self.root = setting.zookeeperroot
self.createRootNode(self.root)
self.zpath = '/'
示例10: post
def post(self):
request_dict = self.request.arguments
node_key = (request_dict['node_key'])[0]
cluster_name = (request_dict['cluster_name'])[0]
zk=zookeeper.init(self.zk_connect(cluster_name))
data = []
def get_node_tree(node_key):
if node_key == "/":
for node in zookeeper.get_children(zk,node_key):
key = "/" + node
if (zookeeper.get(zk,key)[1])['numChildren'] > 0:
get_node_tree(key)
print key
else:
print key
else:
for node in zookeeper.get_children(zk,node_key):
key = node_key + "/" + node
if (zookeeper.get(zk,key)[1])['numChildren'] > 0:
get_node_tree(key)
data.append(key)
else:
data.append(key)
return data
get_node_tree(node_key)
data.append(node_key)
for items in data:
zookeeper.delete(zk,items)
zookeeper.close(zk)
self.write("删除成功")
示例11: connect
def connect(servers):
cond = threading.Condition()
connected = [False]
# We attempt a connection for 10 seconds here. This is a long timeout
# for servicing a web request, so hopefully it is successful.
def connect_watcher(zh, event, state, path):
logging.debug("CONNECT WATCHER: event=%s, state=%s, path=%s" % (event, state, path))
try:
cond.acquire()
if state == zookeeper.CONNECTED_STATE:
# We only want to notify the main thread once the state has been
# connected. We store the connected variable in an odd way because
# of the way variables are bound in the local scope for functions.
connected[0] = True
cond.notify()
finally:
cond.release()
cond.acquire()
try:
# We default to port 2181 if no port is provided as part of the host specification.
server_list = ",".join(map(lambda x: (x.find(":") > 0 and x) or "%s:2181" % x, servers))
handle = zookeeper.init(server_list, connect_watcher, 10000)
cond.wait(60.0)
finally:
# Save whether we were successful or not.
is_connected = connected[0]
cond.release()
if not(is_connected):
raise ZookeeperException("Unable to connect.")
return handle
示例12: start
def start(self):
self.handle = zookeeper.init(self.servers, self.connection_watcher, self.timeout * 1000)
self.conn_cv.acquire()
self.conn_cv.wait(self.timeout)
self.conn_cv.release()
if not self.connected:
raise TimeoutException
示例13: __init__
def __init__(self, servers,port=2181, timeout=TIMEOUT):
"""
create connection to zookeeper
@param server e.g. "localhost"
@param port (std 2181)
"""
self.connected = False
self.conn_cv = threading.Condition( )
self.handle = -1
#@todo make cross platform
zookeeper.set_log_stream(open("/dev/null"))
self.conn_cv.acquire()
q.logger.log("Connecting to %s" % (servers))
start = time.time()
self.handle = zookeeper.init(servers, self._connection_watcher, 30000)
self.conn_cv.wait(timeout)
self.conn_cv.release()
if not self.connected:
raise RuntimeError("Unable to connect to %s" % (servers))
q.logger.log("Connected in %d ms, handle is %d" % (int((time.time() - start) * 1000), self.handle))
示例14: __init__
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
示例15: testconnection
def testconnection(self):
cv = threading.Condition()
self.connected = False
def connection_watcher(handle, type, state, path):
cv.acquire()
self.connected = True
self.assertEqual(zookeeper.CONNECTED_STATE, state)
self.handle = handle
cv.notify()
cv.release()
cv.acquire()
ret = zookeeper.init(self.host, connection_watcher)
cv.wait(15.0)
cv.release()
self.assertEqual(self.connected, True, "Connection timed out to " + self.host)
self.assertEqual(zookeeper.CONNECTED_STATE, zookeeper.state(self.handle))
self.assertEqual(zookeeper.close(self.handle), zookeeper.OK)
# Trying to close the same handle twice is an error, and the C library will segfault on it
# so make sure this is caught at the Python module layer
self.assertRaises(zookeeper.ZooKeeperException,
zookeeper.close,
self.handle)
self.assertRaises(zookeeper.ZooKeeperException,
zookeeper.get,
self.handle,
"/")