public Runnable prepareMergeRunnable() {
Map<MapContainer, Collection<Record>> recordMap =
new HashMap<MapContainer, Collection<Record>>(mapContainers.size());
InternalPartitionService partitionService = nodeEngine.getPartitionService();
int partitionCount = partitionService.getPartitionCount();
Address thisAddress = nodeEngine.getClusterService().getThisAddress();
for (MapContainer mapContainer : mapContainers.values()) {
for (int i = 0; i < partitionCount; i++) {
RecordStore recordStore = getPartitionContainer(i).getRecordStore(mapContainer.getName());
// add your owned entries to the map so they will be merged
if (thisAddress.equals(partitionService.getPartitionOwner(i))) {
Collection<Record> records = recordMap.get(mapContainer);
if (records == null) {
records = new ArrayList<Record>();
recordMap.put(mapContainer, records);
}
records.addAll(recordStore.getReadonlyRecordMap().values());
}
// clear all records either owned or backup
recordStore.reset();
}
}
return new Merger(recordMap);
}
@Override
public void shutdown() {
for (Address address : nodes.keySet()) {
if (address.equals(node.getThisAddress())) {
continue;
}
final NodeEngineImpl nodeEngine = nodes.get(address);
if (nodeEngine != null && nodeEngine.isRunning()) {
nodeEngine
.getExecutionService()
.execute(
ExecutionService.SYSTEM_EXECUTOR,
new Runnable() {
public void run() {
ClusterServiceImpl clusterService =
(ClusterServiceImpl) nodeEngine.getClusterService();
clusterService.removeAddress(node.getThisAddress());
}
});
}
}
for (MockConnection connection : mapConnections.values()) {
connection.close();
}
}
/**
* Binding completes the connection and makes it available to be used with the ConnectionManager.
*/
private boolean bind(
TcpIpConnection connection, Address remoteEndPoint, Address localEndpoint, boolean reply) {
if (logger.isFinestEnabled()) {
logger.finest("Binding " + connection + " to " + remoteEndPoint + ", reply is " + reply);
}
final Address thisAddress = ioService.getThisAddress();
if (ioService.isSocketBindAny()
&& !connection.isClient()
&& !thisAddress.equals(localEndpoint)) {
logger.warning(
"Wrong bind request from "
+ remoteEndPoint
+ "! This node is not requested endpoint: "
+ localEndpoint);
connection.close();
return false;
}
connection.setEndPoint(remoteEndPoint);
ioService.onSuccessfulConnection(remoteEndPoint);
if (reply) {
sendBindRequest(connection, remoteEndPoint, false);
}
if (checkAlreadyConnected(connection, remoteEndPoint)) {
return false;
}
return registerConnection(remoteEndPoint, connection);
}
// CHECKSTYLE:OFF
// This equals method is to complex for our rules due to many internal object type members
@Override
public boolean equals(Object o) {
if (this == o) {
return true;
}
if (o == null || getClass() != o.getClass()) {
return false;
}
MigrationInfo that = (MigrationInfo) o;
if (partitionId != that.partitionId) {
return false;
}
if (destination != null ? !destination.equals(that.destination) : that.destination != null) {
return false;
}
if (masterUuid != null ? !masterUuid.equals(that.masterUuid) : that.masterUuid != null) {
return false;
}
if (source != null ? !source.equals(that.source) : that.source != null) {
return false;
}
return true;
}
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 static ClientConfig getClientConfig(HazelcastInstance instance) {
ClientConfig clientConfig = new ClientConfig();
Address address = getNode(instance).address;
clientConfig.getNetworkConfig().addAddress(address.getHost() + ":" + address.getPort());
clientConfig.getGroupConfig().setName(instance.getConfig().getGroupConfig().getName());
return clientConfig;
}
private boolean isLocalAddress(final Address address) throws UnknownHostException {
final Address thisAddress = node.getThisAddress();
final boolean local = thisAddress.getInetSocketAddress().equals(address.getInetSocketAddress());
if (logger.isFinestEnabled()) {
logger.finest(address + " is local? " + local);
}
return local;
}
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 int hashCode() {
int result = partitionId;
result = 31 * result + (source != null ? source.hashCode() : 0);
result = 31 * result + (destination != null ? destination.hashCode() : 0);
result = 31 * result + (masterUuid != null ? masterUuid.hashCode() : 0);
return result;
}
private void sendRemoveMemberToOthers(final Address deadAddress) {
for (MemberImpl member : lsMembers) {
Address address = member.getAddress();
if (!thisAddress.equals(address) && !address.equals(deadAddress)) {
sendProcessableTo(new MemberRemover(deadAddress), address);
}
}
}
protected final boolean isValid() {
final ClusterServiceImpl clusterService = getService();
final Connection conn = getConnection();
final Address masterAddress = conn != null ? conn.getEndPoint() : null;
return conn == null
|| // which means this is a local call.
(masterAddress != null && masterAddress.equals(clusterService.getMasterAddress()));
}
public LocalMapStats createStats(String name) {
LocalMultiMapStatsImpl stats = getLocalMultiMapStatsImpl(name);
long ownedEntryCount = 0;
long backupEntryCount = 0;
long hits = 0;
long lockedEntryCount = 0;
ClusterServiceImpl clusterService = (ClusterServiceImpl) nodeEngine.getClusterService();
Address thisAddress = clusterService.getThisAddress();
for (int i = 0; i < nodeEngine.getPartitionService().getPartitionCount(); i++) {
InternalPartition partition = nodeEngine.getPartitionService().getPartition(i);
MultiMapPartitionContainer partitionContainer = getPartitionContainer(i);
MultiMapContainer multiMapContainer = partitionContainer.getCollectionContainer(name);
if (multiMapContainer == null) {
continue;
}
Address owner = partition.getOwnerOrNull();
if (owner != null) {
if (owner.equals(thisAddress)) {
lockedEntryCount += multiMapContainer.getLockedCount();
for (MultiMapWrapper wrapper : multiMapContainer.multiMapWrappers.values()) {
hits += wrapper.getHits();
ownedEntryCount += wrapper.getCollection(false).size();
}
} else {
int backupCount = multiMapContainer.config.getTotalBackupCount();
for (int j = 1; j <= backupCount; j++) {
Address replicaAddress = partition.getReplicaAddress(j);
int memberSize = nodeEngine.getClusterService().getMembers().size();
int tryCount = REPLICA_ADDRESS_TRY_COUNT;
// wait if the partition table is not updated yet
while (memberSize > backupCount && replicaAddress == null && tryCount-- > 0) {
try {
Thread.sleep(REPLICA_ADDRESS_SLEEP_WAIT_MILLIS);
} catch (InterruptedException e) {
throw ExceptionUtil.rethrow(e);
}
replicaAddress = partition.getReplicaAddress(j);
}
if (replicaAddress != null && replicaAddress.equals(thisAddress)) {
for (MultiMapWrapper wrapper : multiMapContainer.multiMapWrappers.values()) {
backupEntryCount += wrapper.getCollection(false).size();
}
}
}
}
}
}
stats.setOwnedEntryCount(ownedEntryCount);
stats.setBackupEntryCount(backupEntryCount);
stats.setHits(hits);
stats.setLockedEntryCount(lockedEntryCount);
return stats;
}
public void writeData(DataOutput out) throws IOException {
out.writeUTF(script);
out.writeUTF(engine);
out.writeBoolean(targetAllMembers);
out.writeInt(targets.size());
for (Address target : targets) {
target.writeData(out);
}
writeMap(out, bindings);
}
@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;
}
private MemberImpl createMember(MemberInfo memberInfo, String ipV6ScopeId) {
Address address = memberInfo.getAddress();
address.setScopeId(ipV6ScopeId);
return new MemberImpl(
address,
thisAddress.equals(address),
memberInfo.getUuid(),
(HazelcastInstanceImpl) nodeEngine.getHazelcastInstance(),
memberInfo.getAttributes(),
memberInfo.isLiteMember());
}
@Override
public void writeData(ObjectDataOutput out) throws IOException {
out.writeInt(members.length);
for (Address member : members) {
member.writeData(out);
}
out.writeInt(ownerIndexes.length);
for (int index : ownerIndexes) {
out.writeInt(index);
}
}
@Override
public void connectionRemoved(Connection connection) {
if (logger.isFinestEnabled()) {
logger.finest("Removed connection " + connection.getEndPoint());
}
if (!node.joined()) {
Address masterAddress = node.getMasterAddress();
if (masterAddress != null && masterAddress.equals(connection.getEndPoint())) {
node.setMasterAddress(null);
}
}
}
public void readData(DataInput in) throws IOException {
script = in.readUTF();
engine = in.readUTF();
targetAllMembers = in.readBoolean();
int size = in.readInt();
targets = new HashSet<Address>(size);
for (int i = 0; i < size; i++) {
Address target = new Address();
target.readData(in);
targets.add(target);
}
bindings = readMap(in);
}
@Override
public void run() {
final long now = Clock.currentTimeMillis();
final String mapName = this.mapName;
final MapServiceContext mapServiceContext = this.mapServiceContext;
final NodeEngine nodeEngine = mapServiceContext.getNodeEngine();
final ClusterService clusterService = nodeEngine.getClusterService();
final InternalPartitionService partitionService = nodeEngine.getPartitionService();
final Address thisAddress = clusterService.getThisAddress();
final int partitionCount = partitionService.getPartitionCount();
Map<Integer, Integer> partitionToEntryCountHolder = Collections.emptyMap();
List<DelayedEntry> entries = Collections.emptyList();
boolean createLazy = true;
for (int partitionId = 0; partitionId < partitionCount; partitionId++) {
final InternalPartition partition = partitionService.getPartition(partitionId, false);
final Address owner = partition.getOwnerOrNull();
final RecordStore recordStore = getRecordStoreOrNull(mapName, partitionId);
if (owner == null || recordStore == null) {
// no-op because no owner is set yet.
// Therefore we don't know anything about the map
continue;
}
final WriteBehindQueue<DelayedEntry> queue = getWriteBehindQueue(recordStore);
final List<DelayedEntry> delayedEntries = filterItemsLessThanOrEqualToTime(queue, now);
if (delayedEntries.isEmpty()) {
continue;
}
if (!owner.equals(thisAddress)) {
if (now > lastRunTime + backupRunIntervalTime) {
doInBackup(queue, delayedEntries, partitionId);
}
continue;
}
// initialize when needed, we do not want
// to create these on backups for every second.
if (createLazy) {
partitionToEntryCountHolder = new HashMap<Integer, Integer>();
entries = new ArrayList<DelayedEntry>();
createLazy = false;
}
partitionToEntryCountHolder.put(partitionId, delayedEntries.size());
entries.addAll(delayedEntries);
}
if (!entries.isEmpty()) {
final Map<Integer, List<DelayedEntry>> failsPerPartition =
writeBehindProcessor.process(entries);
removeProcessed(mapName, getEntryPerPartitionMap(entries));
addFailsToQueue(mapName, failsPerPartition);
lastRunTime = now;
}
}
private boolean isThisNodeMasterCandidate(Collection<Address> possibleAddresses) {
int thisHashCode = node.getThisAddress().hashCode();
for (Address address : possibleAddresses) {
if (isBlacklisted(address)) {
continue;
}
if (node.connectionManager.getConnection(address) != null) {
if (thisHashCode > address.hashCode()) {
return false;
}
}
}
return true;
}
protected Collection<Address> getMemberAddresses() {
Address thisAddress = getNodeEngine().getThisAddress();
Collection<Member> members =
getNodeEngine().getClusterService().getMembers(MemberSelectors.DATA_MEMBER_SELECTOR);
Collection<Address> addresses = new ArrayList<Address>();
for (Member member : members) {
Address address = member.getAddress();
if (address.equals(thisAddress)) {
continue;
}
addresses.add(address);
}
return addresses;
}
@Override
public void readData(ObjectDataInput in) throws IOException {
int len = in.readInt();
members = new Address[len];
for (int i = 0; i < len; i++) {
Address a = new Address();
a.readData(in);
members[i] = a;
}
len = in.readInt();
ownerIndexes = new int[len];
for (int i = 0; i < len; i++) {
ownerIndexes[i] = in.readInt();
}
}
void doRemoveAddress(Address deadAddress, boolean destroyConnection) {
if (!ensureMemberIsRemovable(deadAddress)) {
return;
}
lock.lock();
try {
if (deadAddress.equals(node.getMasterAddress())) {
assignNewMaster();
}
if (node.isMaster()) {
clusterJoinManager.removeJoin(new MemberInfo(deadAddress));
}
Connection conn = node.connectionManager.getConnection(deadAddress);
if (destroyConnection && conn != null) {
node.connectionManager.destroyConnection(conn);
}
MemberImpl deadMember = getMember(deadAddress);
if (deadMember != null) {
removeMember(deadMember);
logger.info(membersString());
}
} finally {
lock.unlock();
}
}
/**
* @param queue write behind queue.
* @param delayedEntries entries to be processed.
* @param partitionId corresponding partition id.
*/
private void doInBackup(
final WriteBehindQueue queue,
final List<DelayedEntry> delayedEntries,
final int partitionId) {
final NodeEngine nodeEngine = mapServiceContext.getNodeEngine();
final ClusterService clusterService = nodeEngine.getClusterService();
final InternalPartitionService partitionService = nodeEngine.getPartitionService();
final Address thisAddress = clusterService.getThisAddress();
final InternalPartition partition = partitionService.getPartition(partitionId, false);
final Address owner = partition.getOwnerOrNull();
if (owner != null && !owner.equals(thisAddress)) {
writeBehindProcessor.callBeforeStoreListeners(delayedEntries);
removeProcessed(mapName, getEntryPerPartitionMap(delayedEntries));
writeBehindProcessor.callAfterStoreListeners(delayedEntries);
}
}
@Override
protected void writeInternal(ObjectDataOutput out) throws IOException {
super.writeInternal(out);
out.writeUTF(newState.toString());
initiator.writeData(out);
out.writeUTF(txnId);
}
// CHECKSTYLE:OFF
@Override
public boolean equals(Object o) {
if (this == o) {
return true;
}
if (o == null || getClass() != o.getClass()) {
return false;
}
Registration that = (Registration) o;
if (id != null ? !id.equals(that.id) : that.id != null) {
return false;
}
if (serviceName != null ? !serviceName.equals(that.serviceName) : that.serviceName != null) {
return false;
}
if (topic != null ? !topic.equals(that.topic) : that.topic != null) {
return false;
}
if (filter != null ? !filter.equals(that.filter) : that.filter != null) {
return false;
}
if (subscriber != null ? !subscriber.equals(that.subscriber) : that.subscriber != null) {
return false;
}
return true;
}
@Override
public void onDisconnect(final Address dead) {
if (dead.equals(target)) {
removeRemoteCall(getCallId());
setResult(Boolean.FALSE);
}
}
private void joinViaTargetMember(Address targetAddress, long maxJoinMillis) {
try {
if (targetAddress == null) {
throw new IllegalArgumentException("Invalid target address -> NULL");
}
if (logger.isFinestEnabled()) {
logger.finest("Joining over target member " + targetAddress);
}
if (targetAddress.equals(node.getThisAddress()) || isLocalAddress(targetAddress)) {
node.setAsMaster();
return;
}
long joinStartTime = Clock.currentTimeMillis();
Connection connection;
while (node.isRunning()
&& !node.joined()
&& (Clock.currentTimeMillis() - joinStartTime < maxJoinMillis)) {
connection = node.connectionManager.getOrConnect(targetAddress);
if (connection == null) {
//noinspection BusyWait
Thread.sleep(JOIN_RETRY_WAIT_TIME);
continue;
}
if (logger.isFinestEnabled()) {
logger.finest("Sending joinRequest " + targetAddress);
}
clusterJoinManager.sendJoinRequest(targetAddress, true);
//noinspection BusyWait
Thread.sleep(JOIN_RETRY_WAIT_TIME);
}
} catch (final Exception e) {
logger.warning(e);
}
}
public InetAddress getInetAddress() {
try {
return localEndpoint.getInetAddress();
} catch (UnknownHostException e) {
throw ExceptionUtil.rethrow(e);
}
}
@Override
public void writeData(ObjectDataOutput out) throws IOException {
out.writeUTF(id);
out.writeUTF(serviceName);
out.writeUTF(topic);
subscriber.writeData(out);
out.writeObject(filter);
}