use of com.hazelcast.core.LifecycleListener in project hazelcast by hazelcast.
the class LifecycleServiceImpl method fireLifecycleEvent.
public void fireLifecycleEvent(LifecycleEvent.LifecycleState lifecycleState) {
final LifecycleEvent lifecycleEvent = new LifecycleEvent(lifecycleState);
String revision = buildInfo.getRevision();
if (isNullOrEmpty(revision)) {
revision = "";
} else {
revision = " - " + revision;
BuildInfo upstreamInfo = buildInfo.getUpstreamBuildInfo();
if (upstreamInfo != null) {
String upstreamRevision = upstreamInfo.getRevision();
if (!isNullOrEmpty(upstreamRevision)) {
revision += ", " + upstreamRevision;
}
}
}
getLogger().info("HazelcastClient " + buildInfo.getVersion() + " (" + buildInfo.getBuild() + revision + ") is " + lifecycleEvent.getState());
executor.execute(new Runnable() {
@Override
public void run() {
for (LifecycleListener lifecycleListener : lifecycleListeners.values()) {
lifecycleListener.stateChanged(lifecycleEvent);
}
}
});
}
use of com.hazelcast.core.LifecycleListener in project hazelcast by hazelcast.
the class ClientConnectionTest method destroyConnection_whenDestroyedMultipleTimes_thenListenerRemoveCalledOnce.
@Test
public void destroyConnection_whenDestroyedMultipleTimes_thenListenerRemoveCalledOnce() {
HazelcastInstance server = hazelcastFactory.newHazelcastInstance();
HazelcastInstance client = hazelcastFactory.newHazelcastClient();
HazelcastClientInstanceImpl clientImpl = ClientTestUtil.getHazelcastClientInstanceImpl(client);
ClientConnectionManager connectionManager = clientImpl.getConnectionManager();
final CountingConnectionRemoveListener listener = new CountingConnectionRemoveListener();
connectionManager.addConnectionListener(listener);
final Address serverAddress = new Address(server.getCluster().getLocalMember().getSocketAddress());
final Connection connectionToServer = connectionManager.getConnection(serverAddress);
final CountDownLatch isConnected = new CountDownLatch(1);
clientImpl.getLifecycleService().addLifecycleListener(new LifecycleListener() {
@Override
public void stateChanged(LifecycleEvent event) {
if (LifecycleEvent.LifecycleState.CLIENT_CONNECTED == event.getState()) {
isConnected.countDown();
}
}
});
connectionToServer.close(null, null);
assertTrueEventually(new AssertTask() {
@Override
public void run() throws Exception {
assertTrue(isConnected.await(5, TimeUnit.SECONDS));
}
});
connectionToServer.close(null, null);
assertEquals("connection removed should be called only once", 1, listener.count.get());
}
use of com.hazelcast.core.LifecycleListener in project hazelcast by hazelcast.
the class ClientHeartbeatTest method testAuthentication_whenHeartbeatResumed.
@Test
public void testAuthentication_whenHeartbeatResumed() throws Exception {
HazelcastInstance hazelcastInstance = hazelcastFactory.newHazelcastInstance();
ClientConfig config = new ClientConfig();
config.setProperty(ClientProperty.SHUFFLE_MEMBER_LIST.getName(), "false");
final HazelcastInstance client = hazelcastFactory.newHazelcastClient(config);
HazelcastClientInstanceImpl hazelcastClientInstanceImpl = getHazelcastClientInstanceImpl(client);
final ClusterListenerSupport clientClusterService = (ClusterListenerSupport) hazelcastClientInstanceImpl.getClientClusterService();
final CountDownLatch countDownLatch = new CountDownLatch(2);
client.getLifecycleService().addLifecycleListener(new LifecycleListener() {
@Override
public void stateChanged(LifecycleEvent event) {
countDownLatch.countDown();
}
});
final HazelcastInstance instance2 = hazelcastFactory.newHazelcastInstance();
blockMessagesFromInstance(instance2, client);
final HazelcastInstance instance3 = hazelcastFactory.newHazelcastInstance();
hazelcastInstance.shutdown();
//wait for disconnect from instance1 since it is shutdown // CLIENT_DISCONNECTED event
//and wait for connect to from instance3 // CLIENT_CONNECTED event
assertOpenEventually(countDownLatch);
//verify and wait for authentication to 3 is complete
assertTrueEventually(new AssertTask() {
@Override
public void run() throws Exception {
String uuid = instance3.getLocalEndpoint().getUuid();
assertEquals(uuid, getClientEngineImpl(instance3).getOwnerUuid(client.getLocalEndpoint().getUuid()));
assertEquals(uuid, getClientEngineImpl(instance2).getOwnerUuid(client.getLocalEndpoint().getUuid()));
assertEquals(uuid, clientClusterService.getPrincipal().getOwnerUuid());
assertEquals(instance3.getCluster().getLocalMember().getAddress(), clientClusterService.getOwnerConnectionAddress());
}
});
//unblock instance 2 for authentication response.
unblockMessagesFromInstance(instance2, client);
//late authentication response from instance2 should not be able to change state in both client and cluster
assertTrueEventually(new AssertTask() {
@Override
public void run() throws Exception {
String uuid = instance3.getLocalEndpoint().getUuid();
assertEquals(uuid, getClientEngineImpl(instance3).getOwnerUuid(client.getLocalEndpoint().getUuid()));
assertEquals(uuid, getClientEngineImpl(instance2).getOwnerUuid(client.getLocalEndpoint().getUuid()));
assertEquals(uuid, clientClusterService.getPrincipal().getOwnerUuid());
assertEquals(instance3.getCluster().getLocalMember().getAddress(), clientClusterService.getOwnerConnectionAddress());
}
});
}
use of com.hazelcast.core.LifecycleListener in project hazelcast by hazelcast.
the class AbstractListenersOnReconnectTest method testListenersWaitMemberDestroySmartRouting.
//-------------------------- testListenersWaitMemberDestroy --------------------- //
@Test
public void testListenersWaitMemberDestroySmartRouting() {
Config config = new Config();
int endpointDelaySeconds = 2;
config.setProperty(GroupProperty.CLIENT_ENDPOINT_REMOVE_DELAY_SECONDS.getName(), String.valueOf(endpointDelaySeconds));
factory.newInstances(config, 3);
client = factory.newHazelcastClient(getSmartClientConfig());
setupListener();
Collection<HazelcastInstance> allHazelcastInstances = factory.getAllHazelcastInstances();
final CountDownLatch disconnectedLatch = new CountDownLatch(1);
final CountDownLatch connectedLatch = new CountDownLatch(1);
client.getLifecycleService().addLifecycleListener(new LifecycleListener() {
@Override
public void stateChanged(LifecycleEvent event) {
if (LifecycleEvent.LifecycleState.CLIENT_DISCONNECTED == event.getState()) {
disconnectedLatch.countDown();
}
if (LifecycleEvent.LifecycleState.CLIENT_CONNECTED == event.getState()) {
connectedLatch.countDown();
}
}
});
final HazelcastClientInstanceImpl clientInstanceImpl = getHazelcastClientInstanceImpl(client);
assertTrueEventually(new AssertTask() {
@Override
public void run() throws Exception {
assertEquals(3, clientInstanceImpl.getConnectionManager().getActiveConnections().size());
}
});
HazelcastInstance ownerMember = getOwnerServer(factory, clientInstanceImpl);
for (HazelcastInstance member : allHazelcastInstances) {
blockMessagesFromInstance(member, client);
}
ownerMember.getLifecycleService().terminate();
for (HazelcastInstance member : allHazelcastInstances) {
unblockMessagesFromInstance(member, client);
}
assertOpenEventually(disconnectedLatch);
assertOpenEventually(connectedLatch);
sleepAtLeastMillis(endpointDelaySeconds * 1000 + 2000);
clusterSize = clusterSize - 1;
validateRegistrationsAndListenerFunctionality();
}
use of com.hazelcast.core.LifecycleListener in project hazelcast by hazelcast.
the class AbstractListenersOnReconnectTest method testListenersHeartbeatTimeoutToOwner.
private void testListenersHeartbeatTimeoutToOwner() {
setupListener();
HazelcastClientInstanceImpl clientInstanceImpl = getHazelcastClientInstanceImpl(client);
HazelcastInstance server = getOwnerServer(factory, clientInstanceImpl);
final CountDownLatch disconnectedLatch = new CountDownLatch(1);
final CountDownLatch connectedLatch = new CountDownLatch(1);
client.getLifecycleService().addLifecycleListener(new LifecycleListener() {
@Override
public void stateChanged(LifecycleEvent event) {
if (LifecycleEvent.LifecycleState.CLIENT_DISCONNECTED == event.getState()) {
disconnectedLatch.countDown();
}
if (LifecycleEvent.LifecycleState.CLIENT_CONNECTED == event.getState()) {
connectedLatch.countDown();
}
}
});
blockMessagesFromInstance(server, client);
assertOpenEventually(disconnectedLatch);
unblockMessagesFromInstance(server, client);
assertOpenEventually(connectedLatch);
validateRegistrationsAndListenerFunctionality();
}
Aggregations