private void clearRemoteTransactions(Xid xid) { NodeEngine nodeEngine = getNodeEngine(); InternalPartitionService partitionService = nodeEngine.getPartitionService(); OperationService operationService = nodeEngine.getOperationService(); SerializableXID serializableXID = new SerializableXID( xid.getFormatId(), xid.getGlobalTransactionId(), xid.getBranchQualifier()); Data xidData = nodeEngine.toData(serializableXID); int partitionId = partitionService.getPartitionId(xidData); ClearRemoteTransactionOperation operation = new ClearRemoteTransactionOperation(xidData); operationService.invokeOnPartition(SERVICE_NAME, operation, partitionId); }
private List<Object>[] buildMapping(InternalPartitionService partitionService) { List<Object>[] mapping = new List[partitionService.getPartitionCount()]; for (Object key : keys) { int pid = partitionService.getPartitionId(key); List<Object> list = mapping[pid]; if (list == null) { list = new ArrayList<Object>(); mapping[pid] = list; } list.add(key); } return mapping; }
@Override public Collection<Integer> getPartitions() { InternalPartitionService partitionService = getClientEngine().getPartitionService(); int partitions = partitionService.getPartitionCount(); int capacity = Math.min(partitions, keys.size()); // todo: is there better way to estimate size? Set<Integer> partitionIds = new HashSet<Integer>(capacity); Iterator<Data> iterator = keys.iterator(); while (iterator.hasNext() && partitionIds.size() < partitions) { Data key = iterator.next(); partitionIds.add(partitionService.getPartitionId(key)); } return partitionIds; }
@Override public void process( EntryTaskScheduler<String, Void> scheduler, Collection<ScheduledEntry<String, Void>> entries) { if (entries.isEmpty()) { return; } InternalPartitionService partitionService = nodeEngine.getPartitionService(); OperationService operationService = nodeEngine.getOperationService(); for (ScheduledEntry<String, Void> entry : entries) { String name = entry.getKey(); int partitionId = partitionService.getPartitionId(nodeEngine.toData(name)); CheckAndEvictOperation op = new CheckAndEvictOperation(entry.getKey()); operationService.invokeOnPartition(QueueService.SERVICE_NAME, op, partitionId).getSafely(); } }
public void run() { backupRecordInfos = new ArrayList<RecordInfo>(); backupEntrySet = new ArrayList<Map.Entry<Data, Data>>(); int partitionId = getPartitionId(); final MapServiceContext mapServiceContext = mapService.getMapServiceContext(); RecordStore recordStore = mapServiceContext.getRecordStore(partitionId, name); Set<Map.Entry<Data, Data>> entries = entrySet.getEntrySet(); InternalPartitionService partitionService = getNodeEngine().getPartitionService(); Set<Data> keysToInvalidate = new HashSet<Data>(); for (Map.Entry<Data, Data> entry : entries) { Data dataKey = entry.getKey(); Data dataValue = entry.getValue(); if (partitionId == partitionService.getPartitionId(dataKey)) { Data dataOldValue = null; if (initialLoad) { recordStore.putFromLoad(dataKey, dataValue, -1); } else { dataOldValue = mapServiceContext.toData(recordStore.put(dataKey, dataValue, -1)); } mapServiceContext.interceptAfterPut(name, dataValue); EntryEventType eventType = dataOldValue == null ? EntryEventType.ADDED : EntryEventType.UPDATED; final MapEventPublisher mapEventPublisher = mapServiceContext.getMapEventPublisher(); mapEventPublisher.publishEvent( getCallerAddress(), name, eventType, dataKey, dataOldValue, dataValue); keysToInvalidate.add(dataKey); if (mapContainer.getWanReplicationPublisher() != null && mapContainer.getWanMergePolicy() != null) { Record record = recordStore.getRecord(dataKey); final Data dataValueAsData = mapServiceContext.toData(dataValue); final EntryView entryView = EntryViews.createSimpleEntryView(dataKey, dataValueAsData, record); mapEventPublisher.publishWanReplicationUpdate(name, entryView); } backupEntrySet.add(entry); RecordInfo replicationInfo = Records.buildRecordInfo(recordStore.getRecord(dataKey)); backupRecordInfos.add(replicationInfo); } } invalidateNearCaches(keysToInvalidate); }
@Override public void run() throws Exception { final int partitionId = getPartitionId(); final InternalPartitionService partitionService = getNodeEngine().getPartitionService(); Set<Data> filteredKeys = new HashSet<Data>(); if (keys != null) { for (Data k : keys) { if (partitionService.getPartitionId(k) == partitionId) { filteredKeys.add(k); } } } if (filteredKeys.isEmpty()) { return; } try { final ICacheService service = getService(); cache = service.getOrCreateRecordStore(name, partitionId); final Set<Data> keysLoaded = cache.loadAll(filteredKeys, replaceExistingValues); shouldBackup = !keysLoaded.isEmpty(); if (shouldBackup) { backupRecords = new HashMap<Data, CacheRecord>(keysLoaded.size()); for (Data key : keysLoaded) { CacheRecord record = cache.getRecord(key); // Loaded keys may have been evicted, then record will be null. // So if the loaded key is evicted, don't send it to backup. if (record != null) { backupRecords.put(key, record); } } } } catch (CacheException e) { response = new CacheClearResponse(e); } }
private void finalizeTransactionRemotely(Xid xid, boolean isCommit) throws XAException { NodeEngine nodeEngine = getNodeEngine(); InternalPartitionService partitionService = nodeEngine.getPartitionService(); OperationService operationService = nodeEngine.getOperationService(); SerializableXID serializableXID = new SerializableXID( xid.getFormatId(), xid.getGlobalTransactionId(), xid.getBranchQualifier()); Data xidData = nodeEngine.toData(serializableXID); int partitionId = partitionService.getPartitionId(xidData); FinalizeRemoteTransactionOperation operation = new FinalizeRemoteTransactionOperation(xidData, isCommit); InternalCompletableFuture<Integer> future = operationService.invokeOnPartition(SERVICE_NAME, operation, partitionId); Integer errorCode; try { errorCode = future.get(); } catch (Exception e) { throw ExceptionUtil.rethrow(e); } if (errorCode != null) { throw new XAException(errorCode); } }
protected boolean keyNotOwnedByThisPartition(Data key) { final InternalPartitionService partitionService = getNodeEngine().getPartitionService(); return partitionService.getPartitionId(key) != getPartitionId(); }
@Override protected int getPartition() { InternalPartitionService partitionService = clientEngine.getPartitionService(); return partitionService.getPartitionId(key); }