def test_hosts():
hosts, root = collect_hosts('a:1/abc')
assert root == '/abc'
assert hosts.next() == ('a', 1)
hosts, root = collect_hosts('a:12913')
assert root is None
assert hosts.next() == ('a', 12913)
hosts, root = collect_hosts('a')
assert root is None
assert hosts.next() == ('a', 2181)
hosts, root = collect_hosts('a/')
assert root is None
assert hosts.next() == ('a', 2181)
hosts, root = collect_hosts('a/abc')
assert root == '/abc'
assert hosts.next() == ('a', 2181)
hosts, root = collect_hosts('a:1,b:2,c/abc')
assert root == '/abc'
s = set()
for host_port in hosts:
s.add(host_port)
if len(s) == 3: break
assert ('a', 1) in s
assert ('b', 2) in s
assert ('c', 2181) in s
count = 0
previous_host_port = None
for host_port in hosts:
assert previous_host_port != host_port
previous_host_port = host_port
count += 1
if count > 16: break
assert count == 17
def __init__(
self,
hosts,
session_id=None,
session_passwd=None,
session_timeout=30.0,
auth_data=None,
watcher=None,
allow_reconnect=True,
):
self.hosts, chroot = collect_hosts(hosts)
if chroot:
self.chroot = zkpath.normpath(chroot)
if not zkpath.isabs(self.chroot):
raise ValueError("chroot not absolute")
else:
self.chroot = ""
self.session_id = session_id
self.session_passwd = session_passwd if session_passwd else str(bytearray([0] * 16))
self.session_timeout = session_timeout
self.connect_timeout = session_timeout / len(self.hosts)
self.read_timeout = session_timeout * 2.0 / 3.0
self.auth_data = auth_data if auth_data else set([])
self.read_only = False
LOGGER.debug("session_id: %s", self.session_id)
LOGGER.debug("session_passwd: 0x%s", self.session_passwd.encode("hex"))
LOGGER.debug("session_timeout: %s", self.session_timeout)
LOGGER.debug("connect_timeout: %s", self.connect_timeout)
LOGGER.debug(" len(hosts): %s", len(self.hosts))
LOGGER.debug("read_timeout: %s", self.read_timeout)
LOGGER.debug("auth_data: %s", self.auth_data)
self.allow_reconnect = allow_reconnect
LOGGER.debug("allow_reconnect: %s", self.allow_reconnect)
self.last_zxid = 0
self._queue = PeekableQueue()
self._pending = Queue()
self._events = Queue()
self._child_watchers = defaultdict(set)
self._data_watchers = defaultdict(set)
self._exists_watchers = defaultdict(set)
self._default_watcher = watcher or Watcher()
self.state = CONNECTING
self._state_lock = threading.RLock()
self._event_thread_completed = threading.Event()
def event_worker():
try:
while True:
notification = self._events.get()
if notification == self:
break
try:
notification()
except Exception:
LOGGER.exception("Unforeseen error during notification")
finally:
LOGGER.debug("Event loop completed")
self._event_thread_completed.set()
self._event_thread = threading.Thread(target=event_worker, name="event-%s" % self.id)
self._event_thread.daemon = True
self._event_thread.start()
self._writer_thread = WriterThread(self)
self._writer_thread.setDaemon(True)
self._writer_thread.start()
self._check_state()
