def test_rejoin(self): handler = TestHandler(1) service = LeaderElectedService(self.client, "test", ("127.0.0.1", 80), handler) service.join() assert_that(handler. await (5), is_(True)) assert_that(handler.value, is_(1)) # Expected number depends on how many times expire_session # interrupted our session. handler.expected = None handler.calls = 0 count = [0] def session_watcher(state): if state == kazoo.protocol.states.KazooState.CONNECTED: count[0] += 1 self.client.add_listener(session_watcher) self.expire_session() self.client.retry(self.client.get, "/") self.client.remove_listener(session_watcher) # Should have received 2x number of calls as CONNECTED events: # on_left and a following on_joined. handler.expected = count[0] * 2 assert_that(handler. await (5), is_(True)) assert_that(handler.value, is_(1))
def test_rejoin(self): handler = TestHandler(1) service = LeaderElectedService(self.client, "test", ("127.0.0.1", 80), handler) service.join() assert_that(handler.await(5), is_(True)) assert_that(handler.value, is_(1)) # Expected number depends on how many times expire_session # interrupted our session. handler.expected = None handler.calls = 0 count = [0] def session_watcher(state): if state == kazoo.protocol.states.KazooState.CONNECTED: count[0] += 1 self.client.add_listener(session_watcher) self.expire_session() self.client.retry(self.client.get, "/") self.client.remove_listener(session_watcher) # Should have received 2x number of calls as CONNECTED events: # on_left and a following on_joined. handler.expected = count[0] * 2 assert_that(handler.await(5), is_(True)) assert_that(handler.value, is_(1))
def test_join(self): handler = TestHandler(1) service_name = "test" service = LeaderElectedService(self.client, service_name, ("127.0.0.1", 80), handler) service_path = service.join() assert_that(handler.await(5), is_(True)) assert_that(handler.value, is_(1)) assert_that(service_path, starts_with("/services/{0}/node-".format(service_name)))
def test_join(self): handler = TestHandler(1) service_name = "test" service = LeaderElectedService(self.client, service_name, ("127.0.0.1", 80), handler) service_path = service.join() assert_that(handler. await (5), is_(True)) assert_that(handler.value, is_(1)) assert_that(service_path, starts_with("/services/{0}/node-".format(service_name)))
def test_service_node(self): handler = TestHandler(1) service = LeaderElectedService(self.client, "test", ("127.0.0.1", 80), handler) service.join() assert_that(handler.await(5), is_(True)) assert_that(handler.value, is_(1)) children = self.client.get_children("/services/test") assert_that(children, has_len(1)) child, _ = self.client.get("/services/test/%s" % children[0]) assert_that(parse_address(child), is_(("127.0.0.1", 80)))
def test_service_node(self): handler = TestHandler(1) service = LeaderElectedService(self.client, "test", ("127.0.0.1", 80), handler) service.join() assert_that(handler. await (5), is_(True)) assert_that(handler.value, is_(1)) children = self.client.get_children("/services/test") assert_that(children, has_len(1)) child, _ = self.client.get("/services/test/%s" % children[0]) assert_that(parse_address(child), is_(("127.0.0.1", 80)))
def test_single_concurrent_member(self): handler_a = TestHandler(1) handler_b = TestHandler(1) service_name = "test" service_a = LeaderElectedService(self.client, service_name, ("127.0.0.1", 80), handler_a) service_path_a = service_a.join() # Just A assert_that(handler_a.await(5), is_(True)) assert_that(handler_a.value, is_(1)) assert_that(service_path_a, starts_with("/services/{0}/node-".format(service_name))) service_b = LeaderElectedService(self.client, service_name, ("127.0.0.1", 8080), handler_b) service_path_b = service_b.join() # B is still waiting to get membership (timeout after 1 second) assert_that(handler_b.await(1), is_(False)) assert_that(handler_b.value, is_(0)) assert_that(service_path_b, starts_with("/services/{0}/node-".format(service_name))) assert_that(service_path_a, not equal_to_ignoring_case(service_path_b)) handler_a.calls = 0 service_a.leave() # A left assert_that(handler_a.await(5), is_(True)) assert_that(handler_a.value, is_(0)) # B should have joined since A is gone assert_that(handler_b.await(5), is_(True)) assert_that(handler_b.value, is_(1))
def test_single_concurrent_member(self): handler_a = TestHandler(1) handler_b = TestHandler(1) service_name = "test" service_a = LeaderElectedService(self.client, service_name, ("127.0.0.1", 80), handler_a) service_path_a = service_a.join() # Just A assert_that(handler_a. await (5), is_(True)) assert_that(handler_a.value, is_(1)) assert_that(service_path_a, starts_with("/services/{0}/node-".format(service_name))) service_b = LeaderElectedService(self.client, service_name, ("127.0.0.1", 8080), handler_b) service_path_b = service_b.join() # B is still waiting to get membership (timeout after 1 second) assert_that(handler_b. await (1), is_(False)) assert_that(handler_b.value, is_(0)) assert_that(service_path_b, starts_with("/services/{0}/node-".format(service_name))) assert_that(service_path_a, not equal_to_ignoring_case(service_path_b)) handler_a.calls = 0 service_a.leave() # A left assert_that(handler_a. await (5), is_(True)) assert_that(handler_a.value, is_(0)) # B should have joined since A is gone assert_that(handler_b. await (5), is_(True)) assert_that(handler_b.value, is_(1))