def _update(self, data, stat):
"""Function executed by Kazoo upon data/stat changes for a path.
This function is registered during the __init__ process of this
Object with Kazoo. Upon the initial registration, and any subsequent
changes to the 'data' or 'stat' of a path, this function is called
again.
This function is responsible for updating the local Watcher object
state (its path data, stat data, etc) and triggering any callbacks
that have been registered with this Watcher.
args:
data: The 'data' stored in Zookeeper for this path
stat: The 'stat' data for this path
"""
self._data = funcs.decode(data)
self._stat = stat
log.debug('[%s] Data change detected: %s, Stat: %s' %
(self._path, self._data, self._stat))
# ChildrenWatches can only be applied to already existing paths
# (Kazoo throws a NoNodeError otherwise). To prevent this NoNodeError
# from being thrown, we only register an additional ChildrenWatch
# in the event that 'stat' was not None.
if self._watch_children and stat and not self._current_children_watch:
log.debug('[%s] Registering ChildrenWatch' % self._path)
self._current_children_watch = watchers.ChildrenWatch(
client=self._zk, path=self._path, func=self._update_children)
# Lastly, execute our callbacks
self._execute_callbacks()
def connect(self, timeout=10.0):
def try_clean():
# Attempt to do the needed cleanup if post-connection setup does
# not succeed (maybe the connection is lost right after it is
# obtained).
try:
self.close()
except k_exceptions.KazooException:
LOG.exception("Failed cleaning-up after post-connection"
" initialization failed")
try:
if timeout is not None:
timeout = float(timeout)
self._client.start(timeout=timeout)
except (self._client.handler.timeout_exception,
k_exceptions.KazooException) as e:
raise excp.ConnectionFailure("Failed to connect to"
" zookeeper due to: %s" % (e))
try:
kazoo_utils.check_compatible(self._client, MIN_ZK_VERSION)
self._client.ensure_path(self.path)
self._job_watcher = watchers.ChildrenWatch(
self._client,
self.path,
func=self._on_job_posting,
allow_session_lost=False)
except excp.IncompatibleVersion:
with excutils.save_and_reraise_exception():
try_clean()
except (self._client.handler.timeout_exception,
k_exceptions.KazooException) as e:
try_clean()
raise excp.ConnectionFailure("Failed to do post-connection"
" initialization due to: %s" % (e))
def connect(self, timeout=10.0):
def try_clean():
# Attempt to do the needed cleanup if post-connection setup does
# not succeed (maybe the connection is lost right after it is
# obtained).
try:
self.close()
except k_exceptions.KazooException:
LOG.exception("Failed cleaning-up after post-connection"
" initialization failed")
try:
if timeout is not None:
timeout = float(timeout)
self._client.start(timeout=timeout)
self._closing = False
except (self._client.handler.timeout_exception,
k_exceptions.KazooException):
excp.raise_with_cause(excp.JobFailure,
"Failed to connect to zookeeper")
try:
if self._conf.get('check_compatible', True):
kazoo_utils.check_compatible(self._client, self.MIN_ZK_VERSION)
if self._worker is None and self._emit_notifications:
self._worker = futurist.ThreadPoolExecutor(max_workers=1)
self._client.ensure_path(self.path)
self._client.ensure_path(self.trash_path)
if self._job_watcher is None:
self._job_watcher = watchers.ChildrenWatch(
self._client,
self.path,
func=self._on_job_posting,
allow_session_lost=True)
self._connected = True
except excp.IncompatibleVersion:
with excutils.save_and_reraise_exception():
try_clean()
except (self._client.handler.timeout_exception,
k_exceptions.KazooException):
exc_type, exc, exc_tb = sys.exc_info()
try:
try_clean()
excp.raise_with_cause(excp.JobFailure,
"Failed to do post-connection"
" initialization",
cause=exc)
finally:
del (exc_type, exc, exc_tb)
def test_child_watch(self):
updates = collections.deque()
ev = Event()
def one_time_collector_func(children):
updates.extend(children)
if children:
ev.set()
return False
with start_close(self.client) as c:
k_watchers.ChildrenWatch(self.client,
"/",
func=one_time_collector_func)
c.ensure_path("/b")
self.assertTrue(ev.wait(WAIT_TIME))
self.assertEqual(['b'], list(updates))
def __init__(self, zookeeperHosts='localhost:2181'):
# might need to handle exceptions here
# and try a list of zookeeper hosts
self.zookeeper = KazooClient(zookeeperHosts)
self.zookeeper.start()
# use a hashtable to store all circuit states fetched from zookeeper
self.circuitStates = {}
# update the circuit state dictionary
self._getCircuitState()
# add to serval service table
for auth in self.circuitStates.keys():
next_ip = self.circuitStates[auth]['next_ip']
next_auth = self.circuitStates[auth]['next_auth']
register_service(auth, next_ip, next_auth)
# set watcher on root node
watchers.ChildrenWatch(self.zookeeper, '/circuit', self._circuitNodeWatcher)