private void accessRecord(Record record) {
increaseRecordEvictionCounter(record, mapContainer.getMapConfig().getEvictionPolicy());
record.onAccess();
final int maxIdleSeconds = mapContainer.getMapConfig().getMaxIdleSeconds();
if (maxIdleSeconds > 0) {
mapService.scheduleIdleEviction(
name, record.getKey(), TimeUnit.SECONDS.toMillis(maxIdleSeconds));
}
}
@SuppressWarnings("unchecked")
public void dispatchEvent(EventData eventData, EntryListener listener) {
Member member = nodeEngine.getClusterService().getMember(eventData.getCaller());
EntryEvent event =
new DataAwareEntryEvent(
member,
eventData.getEventType(),
eventData.getMapName(),
eventData.getDataKey(),
eventData.getDataNewValue(),
eventData.getDataOldValue(),
getSerializationService());
switch (event.getEventType()) {
case ADDED:
listener.entryAdded(event);
break;
case EVICTED:
listener.entryEvicted(event);
break;
case UPDATED:
listener.entryUpdated(event);
break;
case REMOVED:
listener.entryRemoved(event);
break;
default:
throw new IllegalArgumentException("Invalid event type: " + event.getEventType());
}
MapContainer mapContainer = getMapContainer(eventData.getMapName());
if (mapContainer.getMapConfig().isStatisticsEnabled()) {
getLocalMapStatsImpl(eventData.getMapName()).incrementReceivedEvents();
}
}
public Record createRecord(
String name, Data dataKey, Object value, long ttl, boolean shouldSchedule) {
MapContainer mapContainer = getMapContainer(name);
Record record = mapContainer.getRecordFactory().newRecord(dataKey, value);
if (shouldSchedule) {
// if ttl is 0 then no eviction. if ttl is -1 then default configured eviction is applied
if (ttl < 0 && mapContainer.getMapConfig().getTimeToLiveSeconds() > 0) {
scheduleTtlEviction(
name, record, mapContainer.getMapConfig().getTimeToLiveSeconds() * 1000);
} else if (ttl > 0) {
scheduleTtlEviction(name, record, ttl);
}
if (mapContainer.getMapConfig().getMaxIdleSeconds() > 0) {
scheduleIdleEviction(name, dataKey, mapContainer.getMapConfig().getMaxIdleSeconds() * 1000);
}
}
return record;
}
public void run() {
for (final MapContainer mapContainer : recordMap.keySet()) {
Collection<Record> recordList = recordMap.get(mapContainer);
String mergePolicyName = mapContainer.getMapConfig().getMergePolicy();
MapMergePolicy mergePolicy = getMergePolicy(mergePolicyName);
// todo number of records may be high. below can be optimized a many records can be send in
// single invocation
final MapMergePolicy finalMergePolicy = mergePolicy;
for (final Record record : recordList) {
// todo too many submission. should submit them in subgroups
nodeEngine
.getExecutionService()
.submit(
"hz:map-merge",
new Runnable() {
public void run() {
SimpleEntryView entryView =
new SimpleEntryView(
record.getKey(),
toData(record.getValue()),
record.getStatistics(),
record.getCost(),
record.getVersion());
MergeOperation operation =
new MergeOperation(
mapContainer.getName(), record.getKey(), entryView, finalMergePolicy);
try {
int partitionId =
nodeEngine.getPartitionService().getPartitionId(record.getKey());
Future f =
nodeEngine
.getOperationService()
.invokeOnPartition(SERVICE_NAME, operation, partitionId);
f.get();
} catch (Throwable t) {
throw ExceptionUtil.rethrow(t);
}
}
});
}
}
}
public boolean isNearCacheAndInvalidationEnabled(String mapName) {
final MapContainer mapContainer = getMapContainer(mapName);
return mapContainer.isNearCacheEnabled()
&& mapContainer.getMapConfig().getNearCacheConfig().isInvalidateOnChange();
}
public LocalMapStatsImpl createLocalMapStats(String mapName) {
MapContainer mapContainer = getMapContainer(mapName);
LocalMapStatsImpl localMapStats = getLocalMapStatsImpl(mapName);
if (!mapContainer.getMapConfig().isStatisticsEnabled()) {
return localMapStats;
}
long ownedEntryCount = 0;
long backupEntryCount = 0;
long dirtyCount = 0;
long ownedEntryMemoryCost = 0;
long backupEntryMemoryCost = 0;
long hits = 0;
long lockedEntryCount = 0;
long heapCost = 0;
int backupCount = mapContainer.getTotalBackupCount();
ClusterService clusterService = nodeEngine.getClusterService();
final InternalPartitionService partitionService = nodeEngine.getPartitionService();
Address thisAddress = clusterService.getThisAddress();
for (int partitionId = 0; partitionId < partitionService.getPartitionCount(); partitionId++) {
InternalPartition partition = partitionService.getPartition(partitionId);
Address owner = partition.getOwner();
if (owner == null) {
// no-op because no owner is set yet. Therefor we don't know anything about the map
continue;
}
if (owner.equals(thisAddress)) {
PartitionContainer partitionContainer = getPartitionContainer(partitionId);
RecordStore recordStore = partitionContainer.getExistingRecordStore(mapName);
// we don't want to force loading the record store because we are loading statistics. So
// that is why
// we ask for 'getExistingRecordStore' instead of 'getRecordStore' which does the load.
if (recordStore != null) {
heapCost += recordStore.getHeapCost();
Map<Data, Record> records = recordStore.getReadonlyRecordMap();
for (Record record : records.values()) {
RecordStatistics stats = record.getStatistics();
// there is map store and the record is dirty (waits to be stored)
ownedEntryCount++;
ownedEntryMemoryCost += record.getCost();
localMapStats.setLastAccessTime(stats.getLastAccessTime());
localMapStats.setLastUpdateTime(stats.getLastUpdateTime());
hits += stats.getHits();
if (recordStore.isLocked(record.getKey())) {
lockedEntryCount++;
}
}
}
} else {
for (int replica = 1; replica <= backupCount; replica++) {
Address replicaAddress = partition.getReplicaAddress(replica);
int tryCount = 30;
// wait if the partition table is not updated yet
while (replicaAddress == null
&& clusterService.getSize() > backupCount
&& tryCount-- > 0) {
try {
Thread.sleep(100);
} catch (InterruptedException e) {
throw ExceptionUtil.rethrow(e);
}
replicaAddress = partition.getReplicaAddress(replica);
}
if (replicaAddress != null && replicaAddress.equals(thisAddress)) {
PartitionContainer partitionContainer = getPartitionContainer(partitionId);
RecordStore recordStore = partitionContainer.getRecordStore(mapName);
heapCost += recordStore.getHeapCost();
Map<Data, Record> records = recordStore.getReadonlyRecordMap();
for (Record record : records.values()) {
backupEntryCount++;
backupEntryMemoryCost += record.getCost();
}
} else if (replicaAddress == null && clusterService.getSize() > backupCount) {
logger.warning("Partition: " + partition + ", replica: " + replica + " has no owner!");
}
}
}
}
if (mapContainer.getMapStoreScheduler() != null) {
dirtyCount = mapContainer.getMapStoreScheduler().size();
}
localMapStats.setBackupCount(backupCount);
localMapStats.setDirtyEntryCount(zeroOrPositive(dirtyCount));
localMapStats.setLockedEntryCount(zeroOrPositive(lockedEntryCount));
localMapStats.setHits(zeroOrPositive(hits));
localMapStats.setOwnedEntryCount(zeroOrPositive(ownedEntryCount));
localMapStats.setBackupEntryCount(zeroOrPositive(backupEntryCount));
localMapStats.setOwnedEntryMemoryCost(zeroOrPositive(ownedEntryMemoryCost));
localMapStats.setBackupEntryMemoryCost(zeroOrPositive(backupEntryMemoryCost));
// add near cache heap cost.
heapCost += mapContainer.getNearCacheSizeEstimator().getSize();
localMapStats.setHeapCost(heapCost);
if (mapContainer.getMapConfig().isNearCacheEnabled()) {
NearCacheStatsImpl nearCacheStats = getNearCache(mapName).getNearCacheStats();
localMapStats.setNearCacheStats(nearCacheStats);
}
return localMapStats;
}