private Object handleAuthenticated() {
if (isOwnerConnection()) {
final String uuid = getUuid();
final String localMemberUUID = clientEngine.getLocalMember().getUuid();
principal = new ClientPrincipal(uuid, localMemberUUID);
reAuthLocal();
Collection<Member> members = nodeEngine.getClusterService().getMembers();
for (Member member : members) {
if (!member.localMember()) {
ClientReAuthOperation op = new ClientReAuthOperation(uuid);
op.setCallerUuid(localMemberUUID);
nodeEngine.getOperationService().send(op, member.getAddress());
}
}
}
boolean isNotMember =
clientEngine.getClusterService().getMember(principal.getOwnerUuid()) == null;
if (isNotMember) {
throw new AuthenticationException(
"Invalid owner-uuid: " + principal.getOwnerUuid() + ", it's not member of this cluster!");
}
endpoint.authenticated(principal, credentials, isOwnerConnection());
setConnectionType();
endpointManager.registerEndpoint(endpoint);
clientEngine.bind(endpoint);
final Address thisAddress = clientEngine.getThisAddress();
return encodeAuth(thisAddress, principal.getUuid(), principal.getOwnerUuid());
}
private void ensureConnectionToAllMembers() {
boolean allConnected = false;
if (node.joined()) {
logger.finest("Waiting for all connections");
int connectAllWaitSeconds =
node.groupProperties.getSeconds(GroupProperty.CONNECT_ALL_WAIT_SECONDS);
int checkCount = 0;
while (checkCount++ < connectAllWaitSeconds && !allConnected) {
try {
//noinspection BusyWait
TimeUnit.SECONDS.sleep(1);
} catch (InterruptedException ignored) {
EmptyStatement.ignore(ignored);
}
allConnected = true;
Collection<Member> members = clusterService.getMembers();
for (Member member : members) {
if (!member.localMember()
&& node.connectionManager.getOrConnect(member.getAddress()) == null) {
allConnected = false;
if (logger.isFinestEnabled()) {
logger.finest("Not-connected to " + member.getAddress());
}
}
}
}
}
}
protected void updateCacheListenerConfigOnOtherNodes(
CacheEntryListenerConfiguration<K, V> cacheEntryListenerConfiguration, boolean isRegister) {
final Collection<Member> members = clientContext.getClusterService().getMemberList();
final HazelcastClientInstanceImpl client =
(HazelcastClientInstanceImpl) clientContext.getHazelcastInstance();
final Collection<Future> futures = new ArrayList<Future>();
for (Member member : members) {
try {
final Address address = member.getAddress();
Data configData = toData(cacheEntryListenerConfiguration);
final ClientMessage request =
CacheListenerRegistrationCodec.encodeRequest(
nameWithPrefix, configData, isRegister, address.getHost(), address.getPort());
final ClientInvocation invocation = new ClientInvocation(client, request, address);
final Future future = invocation.invoke();
futures.add(future);
} catch (Exception e) {
ExceptionUtil.sneakyThrow(e);
}
}
// make sure all configs are created
// TODO do we need this ???s
// try {
// FutureUtil.waitWithDeadline(futures,
// CacheProxyUtil.AWAIT_COMPLETION_TIMEOUT_SECONDS, TimeUnit.SECONDS);
// } catch (TimeoutException e) {
// logger.warning(e);
// }
}
private void shutdownNodes() {
final Operation op = new ShutdownNodeOperation();
logger.info("Sending shutting down operations to all members...");
Collection<Member> members = getMembers(NON_LOCAL_MEMBER_SELECTOR);
final long timeout =
node.groupProperties.getNanos(GroupProperty.CLUSTER_SHUTDOWN_TIMEOUT_SECONDS);
final long startTime = System.nanoTime();
while ((System.nanoTime() - startTime) < timeout && !members.isEmpty()) {
for (Member member : members) {
nodeEngine.getOperationService().send(op, member.getAddress());
}
try {
Thread.sleep(CLUSTER_SHUTDOWN_SLEEP_DURATION_IN_MILLIS);
} catch (InterruptedException e) {
Thread.currentThread().interrupt();
logger.warning("Shutdown sleep interrupted. ", e);
break;
}
members = getMembers(NON_LOCAL_MEMBER_SELECTOR);
}
logger.info(
"Number of other nodes remaining: "
+ getSize(NON_LOCAL_MEMBER_SELECTOR)
+ ". Shutting down itself.");
node.shutdown(false);
}
public static void main(String[] args) throws Exception {
HazelcastInstance hz = Hazelcast.newHazelcastInstance();
Cluster cluster = hz.getCluster();
cluster.addMembershipListener(new MembershipListener() {
@Override
public void memberAdded(MembershipEvent membershipEvent) {
System.out.println( "********** MemberAdded " + membershipEvent );
}
@Override
public void memberRemoved(MembershipEvent membershipEvent) {
System.out.println( "********** MemberRemoved " + membershipEvent );
}
@Override
public void memberAttributeChanged(MemberAttributeEvent memberAttributeEvent) {
System.out.println( "********** MemberAttributeChanged " + memberAttributeEvent );
}
});
Member localMember = cluster.getLocalMember();
System.out.println ( "********** my inetAddress= " + localMember.getInetSocketAddress() );
}
@Test
public void testSubmitToKeyOwnerCallable() throws Exception {
final int k = simpleTestNodeCount;
TestHazelcastInstanceFactory factory = createHazelcastInstanceFactory(k);
final HazelcastInstance[] instances = factory.newInstances(new Config());
final AtomicInteger count = new AtomicInteger(0);
final CountDownLatch latch = new CountDownLatch(k / 2);
final ExecutionCallback callback =
new ExecutionCallback() {
public void onResponse(Object response) {
if ((Boolean) response) count.incrementAndGet();
latch.countDown();
}
public void onFailure(Throwable t) {}
};
for (int i = 0; i < k; i++) {
final HazelcastInstance instance = instances[i];
final IExecutorService service = instance.getExecutorService("testSubmitToKeyOwnerCallable");
final String script = "hazelcast.getCluster().getLocalMember().equals(member)";
final HashMap map = new HashMap();
final Member localMember = instance.getCluster().getLocalMember();
map.put("member", localMember);
int key = 0;
while (!localMember.equals(instance.getPartitionService().getPartition(++key).getOwner())) ;
if (i % 2 == 0) {
final Future f = service.submitToKeyOwner(new ScriptCallable(script, map), key);
assertTrue((Boolean) f.get(5, TimeUnit.SECONDS));
} else {
service.submitToKeyOwner(new ScriptCallable(script, map), key, callback);
}
}
assertTrue(latch.await(30, TimeUnit.SECONDS));
assertEquals(k / 2, count.get());
}
@Test
public void testSubmitCallableToMember_withExecutionCallback() throws Exception {
IExecutorService service = client.getExecutorService(randomString());
Callable getUuidCallable = new GetMemberUuidTask();
Member member = server.getCluster().getLocalMember();
final CountDownLatch responseLatch = new CountDownLatch(1);
final AtomicReference<Object> result = new AtomicReference<Object>();
service.submitToMember(
getUuidCallable,
member,
new ExecutionCallback() {
@Override
public void onResponse(Object response) {
result.set(response);
responseLatch.countDown();
}
@Override
public void onFailure(Throwable t) {}
});
assertOpenEventually("responseLatch", responseLatch);
assertEquals(member.getUuid(), result.get());
}
@Override
public boolean isClusterSafe() {
final Node node = getNode();
final Collection<Member> memberList = node.clusterService.getMembers();
if (memberList == null || memberList.isEmpty() || memberList.size() < 2) {
return true;
}
final Collection<Future> futures = new ArrayList<Future>(memberList.size());
for (Member member : memberList) {
final Address target = member.getAddress();
final Operation operation = new SafeStateCheckOperation();
final InternalCompletableFuture future =
node.getNodeEngine()
.getOperationService()
.invokeOnTarget(InternalPartitionService.SERVICE_NAME, operation, target);
futures.add(future);
}
// todo this max wait is appropriate?
final int maxWaitTime = getMaxWaitTime(node);
for (Future future : futures) {
try {
final Object result = future.get(maxWaitTime, TimeUnit.SECONDS);
final boolean safe = (Boolean) result;
if (!safe) {
return false;
}
} catch (Exception e) {
logger.warning("Error while querying cluster's safe state", e);
return false;
}
}
return true;
}
@Override
public List<PartitionQuery<K, T>> getPartitions(Query<K, T> query) throws IOException {
List<PartitionQuery<K, T>> partitions = new ArrayList<>();
try {
Member[] clusterMembers = new Member[hazelcastInstance.getCluster().getMembers().size()];
this.hazelcastInstance.getCluster().getMembers().toArray(clusterMembers);
for (Member member : clusterMembers) {
JCacheResult<K, T> result = ((JCacheResult<K, T>) query.execute());
ConcurrentSkipListSet<K> memberOwnedCacheEntries = new ConcurrentSkipListSet<>();
while (result.next()) {
K key = result.getKey();
Partition partition = hazelcastInstance.getPartitionService().getPartition(key);
if (partition.getOwner().getUuid().equals(member.getUuid())) {
memberOwnedCacheEntries.add(key);
}
}
PartitionQueryImpl<K, T> partition =
new PartitionQueryImpl<>(
query,
memberOwnedCacheEntries.first(),
memberOwnedCacheEntries.last(),
member.getSocketAddress().getHostString());
partition.setConf(this.getConf());
partitions.add(partition);
}
} catch (java.lang.Exception ex) {
LOG.error(
"Exception occurred while partitioning the query based on Hazelcast partitions.", ex);
return null;
}
LOG.info("Query is partitioned to {} number of partitions.", partitions.size());
return partitions;
}
HazelcastNodeStatus(final Member member_) {
super(
member_.getUuid(),
member_.isLiteMember() ? "client" : "node",
member_.getInetSocketAddress().toString());
member = member_;
}
@Override
public Xid[] recover(int flag) throws XAException {
NodeEngine nodeEngine = getNodeEngine();
XAService xaService = getService();
OperationService operationService = nodeEngine.getOperationService();
ClusterService clusterService = nodeEngine.getClusterService();
Collection<Member> memberList = clusterService.getMembers();
List<InternalCompletableFuture<SerializableList>> futureList =
new ArrayList<InternalCompletableFuture<SerializableList>>();
for (Member member : memberList) {
if (member.localMember()) {
continue;
}
CollectRemoteTransactionsOperation op = new CollectRemoteTransactionsOperation();
Address address = member.getAddress();
InternalCompletableFuture<SerializableList> future =
operationService.invokeOnTarget(SERVICE_NAME, op, address);
futureList.add(future);
}
HashSet<SerializableXID> xids = new HashSet<SerializableXID>();
xids.addAll(xaService.getPreparedXids());
for (InternalCompletableFuture<SerializableList> future : futureList) {
SerializableList xidSet = future.getSafely();
for (Data xidData : xidSet) {
SerializableXID xid = nodeEngine.toObject(xidData);
xids.add(xid);
}
}
return xids.toArray(new SerializableXID[xids.size()]);
}
public void clearInternal() {
try {
Operation clearOperation = operationProvider.createClearOperation(name);
clearOperation.setServiceName(SERVICE_NAME);
BinaryOperationFactory factory = new BinaryOperationFactory(clearOperation, getNodeEngine());
Map<Integer, Object> resultMap =
operationService.invokeOnAllPartitions(SERVICE_NAME, factory);
int numberOfAffectedEntries = 0;
for (Object object : resultMap.values()) {
numberOfAffectedEntries += (Integer) object;
}
MemberSelector selector =
MemberSelectors.and(LITE_MEMBER_SELECTOR, NON_LOCAL_MEMBER_SELECTOR);
for (Member member : getNodeEngine().getClusterService().getMembers(selector)) {
operationService.invokeOnTarget(
SERVICE_NAME, new ClearOperation(name), member.getAddress());
}
if (numberOfAffectedEntries > 0) {
publishMapEvent(numberOfAffectedEntries, EntryEventType.CLEAR_ALL);
}
} catch (Throwable t) {
throw rethrow(t);
}
}
@Test
public void submitCallablePartitionAware_WithExecutionCallback() throws Exception {
IExecutorService service = client.getExecutorService(randomString());
String mapName = randomString();
IMap map = client.getMap(mapName);
String key = HazelcastTestSupport.generateKeyOwnedBy(server);
Member member = server.getCluster().getLocalMember();
Callable<String> runnable = new MapPutPartitionAwareCallable<String, String>(mapName, key);
final AtomicReference<String> result = new AtomicReference<String>();
final CountDownLatch responseLatch = new CountDownLatch(1);
service.submit(
runnable,
new ExecutionCallback<String>() {
public void onResponse(String response) {
result.set(response);
responseLatch.countDown();
}
public void onFailure(Throwable t) {}
});
assertOpenEventually("responseLatch", responseLatch);
assertEquals(member.getUuid(), result.get());
assertTrue(map.containsKey(member.getUuid()));
}
@Test
public void submitRunnablePartitionAware_withExecutionCallback() throws Exception {
IExecutorService service = client.getExecutorService(randomString());
String mapName = randomString();
String key = HazelcastTestSupport.generateKeyOwnedBy(server);
Member member = server.getCluster().getLocalMember();
Runnable runnable = new MapPutPartitionAwareRunnable<String>(mapName, key);
final CountDownLatch responseLatch = new CountDownLatch(1);
service.submit(
runnable,
new ExecutionCallback() {
@Override
public void onResponse(Object response) {
responseLatch.countDown();
}
@Override
public void onFailure(Throwable t) {}
});
IMap map = client.getMap(mapName);
assertOpenEventually("responseLatch", responseLatch);
assertTrue(map.containsKey(member.getUuid()));
}
private void updateMembersRef() {
final Map<Address, Member> map = new LinkedHashMap<Address, Member>(members.size());
for (Member member : members) {
map.put(member.getAddress(), member);
}
clusterService.setMembersRef(Collections.unmodifiableMap(map));
}
private List<MembershipEvent> detectMembershipEvents(Map<String, Member> prevMembers) {
final List<MembershipEvent> events = new LinkedList<MembershipEvent>();
final Set<Member> eventMembers =
Collections.unmodifiableSet(new LinkedHashSet<Member>(members));
for (Member member : members) {
final Member former = prevMembers.remove(member.getUuid());
if (former == null) {
events.add(
new MembershipEvent(
client.getCluster(), member, MembershipEvent.MEMBER_ADDED, eventMembers));
}
}
for (Member member : prevMembers.values()) {
events.add(
new MembershipEvent(
client.getCluster(), member, MembershipEvent.MEMBER_REMOVED, eventMembers));
Address address = member.getAddress();
if (clusterService.getMember(address) == null) {
final Connection connection = connectionManager.getConnection(address);
if (connection != null) {
connectionManager.destroyConnection(connection);
}
}
}
return events;
}
private void invokeMemberRemoveOperation(Address deadAddress) {
for (Member member : getMembers()) {
Address address = member.getAddress();
if (!thisAddress.equals(address) && !address.equals(deadAddress)) {
nodeEngine.getOperationService().send(new MemberRemoveOperation(deadAddress), address);
}
}
}
@Override
public Collection<Address> getTargets() {
Collection<Member> memberList = nodeEngine.getClusterService().getMembers();
Collection<Address> addresses = new HashSet<Address>();
for (Member member : memberList) {
addresses.add(member.getAddress());
}
return addresses;
}
protected void destroyCacheOnAllMembers(String name, String callerUuid) {
final OperationService operationService = nodeEngine.getOperationService();
final Collection<Member> members = nodeEngine.getClusterService().getMembers();
for (Member member : members) {
if (!member.localMember() && !member.getUuid().equals(callerUuid)) {
final CacheDestroyOperation op = new CacheDestroyOperation(name, true);
operationService.invokeOnTarget(AbstractCacheService.SERVICE_NAME, op, member.getAddress());
}
}
}
@Override
public Map<ClientType, Integer> getConnectedClientStats() {
int numberOfCppClients = 0;
int numberOfDotNetClients = 0;
int numberOfJavaClients = 0;
int numberOfOtherClients = 0;
Operation clientInfoOperation = new GetConnectedClientsOperation();
OperationService operationService = node.nodeEngine.getOperationService();
Map<ClientType, Integer> resultMap = new HashMap<ClientType, Integer>();
Map<String, ClientType> clientsMap = new HashMap<String, ClientType>();
for (Member member : node.getClusterService().getMembers()) {
Address target = member.getAddress();
Future<Map<String, ClientType>> future =
operationService.invokeOnTarget(SERVICE_NAME, clientInfoOperation, target);
try {
Map<String, ClientType> endpoints = future.get();
if (endpoints == null) {
continue;
}
// Merge connected clients according to their uuid.
for (Map.Entry<String, ClientType> entry : endpoints.entrySet()) {
clientsMap.put(entry.getKey(), entry.getValue());
}
} catch (Exception e) {
logger.warning("Cannot get client information from: " + target.toString(), e);
}
}
// Now we are regrouping according to the client type
for (ClientType clientType : clientsMap.values()) {
switch (clientType) {
case JAVA:
numberOfJavaClients++;
break;
case CSHARP:
numberOfDotNetClients++;
break;
case CPP:
numberOfCppClients++;
break;
default:
numberOfOtherClients++;
}
}
resultMap.put(ClientType.CPP, numberOfCppClients);
resultMap.put(ClientType.CSHARP, numberOfDotNetClients);
resultMap.put(ClientType.JAVA, numberOfJavaClients);
resultMap.put(ClientType.OTHER, numberOfOtherClients);
return resultMap;
}
public static void encode(Member member, ClientMessage clientMessage) {
AddressCodec.encode(member.getAddress(), clientMessage);
clientMessage.set(member.getUuid());
Map<String, Object> attributes = new HashMap<String, Object>(member.getAttributes());
clientMessage.set(attributes.size());
for (Map.Entry<String, Object> entry : attributes.entrySet()) {
clientMessage.set(entry.getKey());
Object value = entry.getValue();
clientMessage.set(value.toString());
}
}
@Test
public void testSubmitCallableToMember() throws Exception {
IExecutorService service = client.getExecutorService(randomString());
Callable<String> getUuidCallable = new GetMemberUuidTask();
Member member = server.getCluster().getLocalMember();
Future<String> result = service.submitToMember(getUuidCallable, member);
assertEquals(member.getUuid(), result.get());
}
/**
* Returns the next {@code long} key owned by the given Hazelcast instance.
*
* @param instance Hazelcast instance to search next key for
* @param lastKey last key to start search from
* @return next key owned by given Hazelcast instance
*/
public static long nextKeyOwnedBy(HazelcastInstance instance, long lastKey) {
Member localMember = instance.getCluster().getLocalMember();
PartitionService partitionService = instance.getPartitionService();
while (true) {
Partition partition = partitionService.getPartition(lastKey);
if (localMember.equals(partition.getOwner())) {
return lastKey;
}
lastKey++;
}
}
@Override
public void memberRemoved(MembershipEvent membershipEvent) {
synchronized (listenerRegLock) {
Member member = membershipEvent.getMember();
members.remove(member);
for (Map<Address, ClientEventRegistration> registrationMap : registrations.values()) {
ClientEventRegistration registration = registrationMap.remove(member.getAddress());
removeEventHandler(registration.getCallId());
}
}
}
public static String generateKeyNotOwnedBy(HazelcastInstance instance) {
final Member localMember = instance.getCluster().getLocalMember();
final PartitionService partitionService = instance.getPartitionService();
for (; ; ) {
String id = UUID.randomUUID().toString();
Partition partition = partitionService.getPartition(id);
if (!localMember.equals(partition.getOwner())) {
return id;
}
}
}
@Test
public void testInstance() {
assertNotNull(instance);
final Set<Member> members = instance.getCluster().getMembers();
assertEquals(1, members.size());
final Member member = members.iterator().next();
final InetSocketAddress inetSocketAddress = member.getSocketAddress();
assertEquals(5700, inetSocketAddress.getPort());
assertEquals("test-instance", config.getInstanceName());
assertEquals("HAZELCAST_ENTERPRISE_LICENSE_KEY", config.getLicenseKey());
}
/**
* This is triggered when a new member joined to the cluster.
*
* @param membershipEvent contains the information about the added node.
*/
@Override
public void memberAdded(MembershipEvent membershipEvent) {
Member member = membershipEvent.getMember();
log.info(
"Handling cluster gossip: New member joined to the cluster. Member Socket Address:"
+ member.getSocketAddress()
+ " UUID:"
+ member.getUuid());
ClusterResourceHolder.getInstance().getClusterManager().memberAdded();
}
public static int calculateDataSize(Member member) {
int dataSize = AddressCodec.calculateDataSize(member.getAddress());
dataSize += ParameterUtil.calculateDataSize(member.getUuid());
dataSize += Bits.INT_SIZE_IN_BYTES;
Map<String, Object> attributes = member.getAttributes();
for (Map.Entry<String, Object> entry : attributes.entrySet()) {
dataSize += ParameterUtil.calculateDataSize(entry.getKey());
Object value = entry.getValue();
// TODO: this is costly to use toString
dataSize += ParameterUtil.calculateDataSize(value.toString());
}
return dataSize;
}
private void callDisconnectionOperation(ClientEndpointImpl endpoint) {
Collection<Member> memberList = nodeEngine.getClusterService().getMembers();
OperationService operationService = nodeEngine.getOperationService();
ClientDisconnectionOperation op = createClientDisconnectionOperation(endpoint.getUuid());
operationService.runOperationOnCallingThread(op);
for (Member member : memberList) {
if (!member.localMember()) {
op = createClientDisconnectionOperation(endpoint.getUuid());
operationService.send(op, member.getAddress());
}
}
}
private void assignNewMaster() {
Address oldMasterAddress = node.getMasterAddress();
if (node.joined()) {
Collection<Member> members = getMembers();
Member newMaster = null;
int size = members.size();
if (size > 1) {
Iterator<Member> iterator = members.iterator();
Member member = iterator.next();
if (member.getAddress().equals(oldMasterAddress)) {
newMaster = iterator.next();
} else {
logger.severe(
format(
"Old master %s is dead, but the first of member list is a different member %s!",
oldMasterAddress, member));
newMaster = member;
}
} else {
logger.warning(
format(
"Old master %s is dead and this node is not master, "
+ "but member list contains only %d members: %s",
oldMasterAddress, size, members));
}
logger.info(
format(
"Old master %s left the cluster, assigning new master %s",
oldMasterAddress, newMaster));
if (newMaster != null) {
node.setMasterAddress(newMaster.getAddress());
} else {
node.setMasterAddress(null);
}
} else {
node.setMasterAddress(null);
}
if (logger.isFinestEnabled()) {
logger.finest(
format("Old master: %s, new master: %s ", oldMasterAddress, node.getMasterAddress()));
}
if (node.isMaster()) {
clusterHeartbeatManager.resetMemberMasterConfirmations();
clusterClock.reset();
} else {
clusterHeartbeatManager.sendMasterConfirmation();
}
}
