private List<MembershipEvent> detectMembershipEvents(Map<String, MemberImpl> prevMembers) { final List<MembershipEvent> events = new LinkedList<MembershipEvent>(); final Set<Member> eventMembers = Collections.unmodifiableSet(new LinkedHashSet<Member>(members)); for (MemberImpl member : members) { final MemberImpl former = prevMembers.remove(member.getUuid()); if (former == null) { events.add( new MembershipEvent( client.getCluster(), member, MembershipEvent.MEMBER_ADDED, eventMembers)); } } for (MemberImpl member : prevMembers.values()) { events.add( new MembershipEvent( client.getCluster(), member, MembershipEvent.MEMBER_REMOVED, eventMembers)); if (clusterService.getMember(member.getAddress()) == null) { final Connection connection = connectionManager.getConnection(member.getAddress()); if (connection != null) { connectionManager.destroyConnection(connection); } } } return events; }
@Test public void testHeartbeatResumedEvent() throws InterruptedException { hazelcastFactory.newHazelcastInstance(); HazelcastInstance client = hazelcastFactory.newHazelcastClient(getClientConfig()); final HazelcastInstance instance2 = hazelcastFactory.newHazelcastInstance(); // make sure client is connected to instance2 String keyOwnedByInstance2 = generateKeyOwnedBy(instance2); IMap<String, String> map = client.getMap(randomString()); map.put(keyOwnedByInstance2, randomString()); HazelcastClientInstanceImpl clientImpl = getHazelcastClientInstanceImpl(client); ClientConnectionManager connectionManager = clientImpl.getConnectionManager(); final CountDownLatch countDownLatch = new CountDownLatch(1); connectionManager.addConnectionHeartbeatListener( new ConnectionHeartbeatListener() { @Override public void heartbeatResumed(Connection connection) { assertEquals( instance2.getCluster().getLocalMember().getAddress(), connection.getEndPoint()); countDownLatch.countDown(); } @Override public void heartbeatStopped(Connection connection) {} }); blockMessagesFromInstance(instance2, client); sleepMillis(HEARTBEAT_TIMEOUT_MILLIS * 2); unblockMessagesFromInstance(instance2, client); assertOpenEventually(countDownLatch); }
private ClientInvocation( HazelcastClientInstanceImpl client, EventHandler handler, ClientMessage clientMessage, int partitionId, Address address, Connection connection) { this.lifecycleService = client.getLifecycleService(); this.invocationService = client.getInvocationService(); this.executionService = client.getClientExecutionService(); this.listenerService = (ClientListenerServiceImpl) client.getListenerService(); this.handler = handler; this.clientMessage = clientMessage; this.partitionId = partitionId; this.address = address; this.connection = connection; final ClientProperties clientProperties = client.getClientProperties(); int waitTime = clientProperties.getInvocationTimeoutSeconds().getInteger(); long retryTimeoutInSeconds = waitTime > 0 ? waitTime : Integer.parseInt(ClientProperties.PROP_INVOCATION_TIMEOUT_SECONDS_DEFAULT); clientInvocationFuture = new ClientInvocationFuture(this, client, clientMessage, handler); this.retryCountLimit = retryTimeoutInSeconds / RETRY_WAIT_TIME_IN_SECONDS; int interval = clientProperties.getHeartbeatInterval().getInteger(); this.heartBeatInterval = interval > 0 ? interval : Integer.parseInt(PROP_HEARTBEAT_INTERVAL_DEFAULT); }
void listenMembershipEvents(Address ownerConnectionAddress) { initialListFetchedLatch = new CountDownLatch(1); try { ClientMessage clientMessage = RegisterMembershipListenerParameters.encode(); Connection connection = connectionManager.getConnection(ownerConnectionAddress); if (connection == null) { System.out.println("FATAL connection null " + ownerConnectionAddress); throw new IllegalStateException( "Can not load initial members list because owner connection is null. " + "Address " + ownerConnectionAddress); } ClientInvocation invocation = new ClientInvocation(client, this, clientMessage, connection); invocation.invoke().get(); waitInitialMemberListFetched(); } catch (Exception e) { if (client.getLifecycleService().isRunning()) { if (LOGGER.isFinestEnabled()) { LOGGER.warning( "Error while registering to cluster events! -> " + ownerConnectionAddress, e); } else { LOGGER.warning( "Error while registering to cluster events! -> " + ownerConnectionAddress + ", Error: " + e.toString()); } } } }
public String addDistributedObjectListener(final DistributedObjectListener listener) { final DistributedObjectListenerRequest request = new DistributedObjectListenerRequest(); final EventHandler<PortableDistributedObjectEvent> eventHandler = new EventHandler<PortableDistributedObjectEvent>() { public void handle(PortableDistributedObjectEvent e) { final ObjectNamespace ns = new DefaultObjectNamespace(e.getServiceName(), e.getName()); ClientProxyFuture future = proxies.get(ns); ClientProxy proxy = future == null ? null : future.get(); if (proxy == null) { proxy = getOrCreateProxy(e.getServiceName(), e.getName()); } DistributedObjectEvent event = new DistributedObjectEvent(e.getEventType(), e.getServiceName(), proxy); if (DistributedObjectEvent.EventType.CREATED.equals(e.getEventType())) { listener.distributedObjectCreated(event); } else if (DistributedObjectEvent.EventType.DESTROYED.equals(e.getEventType())) { listener.distributedObjectDestroyed(event); } } @Override public void beforeListenerRegister() {} @Override public void onListenerRegister() {} }; return client.getListenerService().startListening(request, null, eventHandler); }
public Address findNextAddressToSendCreateRequest() { int clusterSize = client.getClientClusterService().getSize(); Member liteMember = null; final LoadBalancer loadBalancer = client.getLoadBalancer(); for (int i = 0; i < clusterSize; i++) { Member member = loadBalancer.next(); if (member != null && !member.isLiteMember()) { return member.getAddress(); } else if (liteMember == null) { liteMember = member; } } return liteMember != null ? liteMember.getAddress() : null; }
public ClientConnection( HazelcastClientInstanceImpl client, IOSelector in, IOSelector out, int connectionId, SocketChannelWrapper socketChannelWrapper) throws IOException { final Socket socket = socketChannelWrapper.socket(); this.connectionManager = client.getConnectionManager(); this.serializationService = client.getSerializationService(); this.lifecycleService = client.getLifecycleService(); this.socketChannelWrapper = socketChannelWrapper; this.connectionId = connectionId; this.readHandler = new ClientReadHandler(this, in, socket.getReceiveBufferSize()); this.writeHandler = new ClientWriteHandler(this, out, socket.getSendBufferSize()); }
private long getRetryCountLimit() { HazelcastProperties hazelcastProperties = client.getProperties(); int waitTime = hazelcastProperties.getSeconds(INVOCATION_TIMEOUT_SECONDS); long retryTimeoutInSeconds = waitTime > 0 ? waitTime : Integer.parseInt(INVOCATION_TIMEOUT_SECONDS.getDefaultValue()); return retryTimeoutInSeconds / ClientInvocation.RETRY_WAIT_TIME_IN_SECONDS; }
public String addDistributedObjectListener(final DistributedObjectListener listener) { ClientMessage request = AddDistributedObjectListenerParameters.encode(); final EventHandler<ClientMessage> eventHandler = new EventHandler<ClientMessage>() { public void handle(ClientMessage clientMessage) { DistributedObjectEventParameters e = DistributedObjectEventParameters.decode(clientMessage); final ObjectNamespace ns = new DefaultObjectNamespace(e.serviceName, e.name); ClientProxyFuture future = proxies.get(ns); ClientProxy proxy = future == null ? null : future.get(); if (proxy == null) { proxy = getOrCreateProxy(e.serviceName, e.name); } DistributedObjectEvent event = new DistributedObjectEvent(e.eventType, e.serviceName, proxy); if (DistributedObjectEvent.EventType.CREATED.equals(e.eventType)) { listener.distributedObjectCreated(event); } else if (DistributedObjectEvent.EventType.DESTROYED.equals(e.eventType)) { listener.distributedObjectDestroyed(event); } } @Override public void beforeListenerRegister() {} @Override public void onListenerRegister() {} }; return client.getListenerService().startListening(request, null, eventHandler); }
public String addDistributedObjectListener(final DistributedObjectListener listener) { final EventHandler<ClientMessage> eventHandler = new DistributedObjectEventHandler(listener, this); return client .getListenerService() .registerListener(distributedObjectListenerCodec, eventHandler); }
private void registerInvocation(ClientInvocation clientInvocation) { short protocolVersion = client.getProtocolVersion(); final int correlationId = newCorrelationId(); clientInvocation.getClientMessage().setCorrelationId(correlationId).setVersion(protocolVersion); callIdMap.put(correlationId, clientInvocation); if (clientInvocation instanceof ClientListenerInvocation) { eventHandlerMap.put(correlationId, (ClientListenerInvocation) clientInvocation); } }
private void memberAdded(MemberImpl member) { members.add(member); applyMemberListChanges(); MembershipEvent event = new MembershipEvent( client.getCluster(), member, ClientInitialMembershipEvent.MEMBER_ADDED, Collections.unmodifiableSet(new LinkedHashSet<Member>(members))); clusterService.fireMembershipEvent(event); }
public ProxyManager(HazelcastClientInstanceImpl client) { this.client = client; final List<ListenerConfig> listenerConfigs = client.getClientConfig().getListenerConfigs(); if (listenerConfigs != null && !listenerConfigs.isEmpty()) { for (ListenerConfig listenerConfig : listenerConfigs) { if (listenerConfig.getImplementation() instanceof DistributedObjectListener) { addDistributedObjectListener( (DistributedObjectListener) listenerConfig.getImplementation()); } } } }
private Connection getTargetOrOwnerConnection(final Address target) throws IOException { if (target == null) { throw new IOException("Not able to setup owner connection!"); } final ClientConnectionManager connectionManager = client.getConnectionManager(); Connection connection = connectionManager.getConnection(target); if (connection == null) { final Address ownerConnectionAddress = client.getClientClusterService().getOwnerConnectionAddress(); if (ownerConnectionAddress == null) { throw new IOException("Not able to setup owner connection!"); } connection = connectionManager.getConnection(ownerConnectionAddress); if (connection == null) { throw new IOException("Client is not connected to member " + target); } } return connection; }
@Test public void testHeartbeatStoppedEvent() throws InterruptedException { HazelcastInstance instance = hazelcastFactory.newHazelcastInstance(); HazelcastInstance client = hazelcastFactory.newHazelcastClient(getClientConfig()); HazelcastClientInstanceImpl clientImpl = getHazelcastClientInstanceImpl(client); ClientConnectionManager connectionManager = clientImpl.getConnectionManager(); final CountDownLatch countDownLatch = new CountDownLatch(1); connectionManager.addConnectionHeartbeatListener( new ConnectionHeartbeatListener() { @Override public void heartbeatResumed(Connection connection) {} @Override public void heartbeatStopped(Connection connection) { countDownLatch.countDown(); } }); blockMessagesFromInstance(instance, client); assertOpenEventually(countDownLatch); }
protected ClientInvocation( HazelcastClientInstanceImpl client, ClientMessage clientMessage, int partitionId, Address address, Connection connection) { this.lifecycleService = client.getLifecycleService(); this.invocationService = client.getInvocationService(); this.executionService = client.getClientExecutionService(); this.clientMessage = clientMessage; this.partitionId = partitionId; this.address = address; this.connection = connection; HazelcastProperties hazelcastProperties = client.getProperties(); long waitTime = hazelcastProperties.getMillis(INVOCATION_TIMEOUT_SECONDS); long waitTimeResolved = waitTime > 0 ? waitTime : Integer.parseInt(INVOCATION_TIMEOUT_SECONDS.getDefaultValue()); retryTimeoutPointInMillis = System.currentTimeMillis() + waitTimeResolved; logger = ((ClientInvocationServiceSupport) invocationService).invocationLogger; clientInvocationFuture = new ClientInvocationFuture(this, client, clientMessage, logger); }
private void memberRemoved(MemberImpl member) { members.remove(member); final Connection connection = connectionManager.getConnection(member.getAddress()); if (connection != null) { connectionManager.destroyConnection(connection); } applyMemberListChanges(); MembershipEvent event = new MembershipEvent( client.getCluster(), member, ClientInitialMembershipEvent.MEMBER_REMOVED, Collections.unmodifiableSet(new LinkedHashSet<Member>(members))); clusterService.fireMembershipEvent(event); }
@Override public void handle(String uuid, String key, int opType, String value) { Map<Address, Member> memberMap = clusterService.getMembersRef(); if (memberMap == null) { return; } for (Member target : memberMap.values()) { if (target.getUuid().equals(uuid)) { final MemberAttributeOperationType operationType = MemberAttributeOperationType.getValue(opType); ((AbstractMember) target).updateAttribute(operationType, key, value); MemberAttributeEvent memberAttributeEvent = new MemberAttributeEvent(client.getCluster(), target, operationType, key, value); clusterService.fireMemberAttributeEvent(memberAttributeEvent); break; } } }
public ClientInvocationServiceSupport(HazelcastClientInstanceImpl client) { this.client = client; this.connectionManager = client.getConnectionManager(); this.executionService = client.getClientExecutionService(); connectionManager.addConnectionListener(this); connectionManager.addConnectionHeartbeatListener(this); this.partitionService = client.getClientPartitionService(); responseThread = new ResponseThread( client.getThreadGroup(), client.getName() + ".response-", client.getClientConfig().getClassLoader()); responseThread.start(); }
void listenMembershipEvents(Address ownerConnectionAddress) { initialListFetchedLatch = new CountDownLatch(1); try { ClientMessage clientMessage = ClientMembershipListenerCodec.encodeRequest(); Connection connection = connectionManager.getConnection(ownerConnectionAddress); if (connection == null) { throw new IllegalStateException( "Can not load initial members list because owner connection is null. " + "Address " + ownerConnectionAddress); } ClientInvocation invocation = new ClientListenerInvocation( client, this, clientMessage, connection, new ClientMessageDecoder() { @Override public <T> T decodeClientMessage(ClientMessage clientMessage) { return (T) ClientMembershipListenerCodec.decodeResponse(clientMessage).response; } }); invocation.invoke().get(); waitInitialMemberListFetched(); } catch (Exception e) { if (client.getLifecycleService().isRunning()) { if (LOGGER.isFinestEnabled()) { LOGGER.warning( "Error while registering to cluster events! -> " + ownerConnectionAddress, e); } else { LOGGER.warning( "Error while registering to cluster events! -> " + ownerConnectionAddress + ", Error: " + e.toString()); } } } }
private void readProxyDescriptors() { try { ClassLoader classLoader = client.getClientConfig().getClassLoader(); Iterator<Class<ClientProxyDescriptorProvider>> iter = com.hazelcast.util.ServiceLoader.classIterator(PROVIDER_ID, classLoader); while (iter.hasNext()) { Class<ClientProxyDescriptorProvider> clazz = iter.next(); Constructor<ClientProxyDescriptorProvider> constructor = clazz.getDeclaredConstructor(); ClientProxyDescriptorProvider provider = constructor.newInstance(); ClientProxyDescriptor[] services = provider.createClientProxyDescriptors(); for (ClientProxyDescriptor serviceDescriptor : services) { register(serviceDescriptor.getServiceName(), serviceDescriptor.getClientProxyClass()); } } } catch (Exception e) { throw ExceptionUtil.rethrow(e); } }
public ClientListenerServiceImpl( HazelcastClientInstanceImpl client, int eventThreadCount, int eventQueueCapacity) { this.client = client; this.executionService = (ClientExecutionServiceImpl) client.getClientExecutionService(); this.invocationService = client.getInvocationService(); this.serializationService = client.getSerializationService(); client.getClientClusterService().addMembershipListener(this); this.eventExecutor = new StripedExecutor( logger, client.getName() + ".event", client.getThreadGroup(), eventThreadCount, eventQueueCapacity); }
private void memberAttributeChanged(MemberAttributeChange memberAttributeChange) { Map<Address, MemberImpl> memberMap = clusterService.getMembersRef(); if (memberMap == null) { return; } if (memberAttributeChange == null) { return; } for (MemberImpl target : memberMap.values()) { if (target.getUuid().equals(memberAttributeChange.getUuid())) { final MemberAttributeOperationType operationType = memberAttributeChange.getOperationType(); final String key = memberAttributeChange.getKey(); final Object value = memberAttributeChange.getValue(); target.updateAttribute(operationType, key, value); MemberAttributeEvent memberAttributeEvent = new MemberAttributeEvent(client.getCluster(), target, operationType, key, value); clusterService.fireMemberAttributeEvent(memberAttributeEvent); break; } } }
public ClientSmartListenerService( HazelcastClientInstanceImpl client, int eventThreadCount, int eventQueueCapacity) { super(client, eventThreadCount, eventQueueCapacity); client.getClientClusterService().addMembershipListener(this); }
private void unblockMessagesFromInstance(HazelcastInstance instance, HazelcastInstance client) { HazelcastClientInstanceImpl clientImpl = getHazelcastClientInstanceImpl(client); ClientConnectionManager connectionManager = clientImpl.getConnectionManager(); Address address = instance.getCluster().getLocalMember().getAddress(); ((TestClientRegistry.MockClientConnectionManager) connectionManager).unblock(address); }
public ClientMembershipListener(HazelcastClientInstanceImpl client) { this.client = client; connectionManager = (ClientConnectionManagerImpl) client.getConnectionManager(); partitionService = (ClientPartitionServiceImpl) client.getClientPartitionService(); clusterService = (ClientClusterServiceImpl) client.getClientClusterService(); }
public boolean removeDistributedObjectListener(String id) { return client.getListenerService().deregisterListener(id); }
public boolean removeDistributedObjectListener(String id) { ClientMessage request = RemoveDistributedObjectListenerParameters.encode(id); return client.getListenerService().stopListening(request, id); }
private <T> Class<? extends ClientProxy> getServiceProxy(Class<T> service) { ClientExtension clientExtension = client.getClientExtension(); return clientExtension.getServiceProxy(service); }
public boolean removeDistributedObjectListener(String id) { final RemoveDistributedObjectListenerRequest request = new RemoveDistributedObjectListenerRequest(id); return client.getListenerService().stopListening(request, id); }