import org.infinispan.context.Flag; //导入依赖的package包/类
@Override
public XCourseRequest assign(XCourseRequest request, XEnrollment enrollment) {
	iLog.info("Assign " + request + " with " + enrollment);
	if (!isMaster())
		iLog.warn("Assigning a request on a slave node. That is suspicious.");
	Lock lock = writeLock();
	try {
		XStudent student = iStudentTable.get(request.getStudentId());
		for (XRequest r: student.getRequests()) {
			if (r.equals(request)) {
				XCourseRequest cr = (XCourseRequest)r;

				// assign
				cr.setEnrollment(enrollment);
				
				iStudentTable.getAdvancedCache().withFlags(Flag.IGNORE_RETURN_VALUES).put(student.getStudentId(), student);
				return cr;
			}
		}
		iLog.warn("ASSIGN[3]: Request " + student + " " + request + " was not found among student requests");
		return null;
	} finally {
		lock.release();
	}
}
 

import org.infinispan.context.Flag; //导入依赖的package包/类
@Override
public void remove(XStudent student) {
	Lock lock = writeLock();
	try {
		XStudent oldStudent = iStudentTable.remove(student.getStudentId());
		if (oldStudent != null) {
			for (XRequest request: oldStudent.getRequests())
				if (request instanceof XCourseRequest)
					for (XCourseId course: ((XCourseRequest)request).getCourseIds()) {
						Set<XCourseRequest> requests = iOfferingRequests.get(course.getOfferingId());
						if (requests != null) {
							if (!requests.remove(request))
								iLog.warn("REMOVE[1]: Request " + student + " " + request + " was not present in the offering requests table for " + course);
							iOfferingRequests.getAdvancedCache().withFlags(Flag.IGNORE_RETURN_VALUES).put(course.getOfferingId(), requests);
						} else {
							iLog.warn("REMOVE[2]: Request " + student + " " + request + " was not present in the offering requests table for " + course);
						}
					}
		}
	} finally {
		lock.release();
	}
}
 

import org.infinispan.context.Flag; //导入依赖的package包/类
public static void main(String[] args) throws Exception {
   // Setup up a clustered cache manager
   GlobalConfigurationBuilder global = GlobalConfigurationBuilder.defaultClusteredBuilder();
   // Make the default cache a replicated synchronous one
   ConfigurationBuilder builder = new ConfigurationBuilder();
   builder.clustering().cacheMode(CacheMode.REPL_SYNC);
   // Initialize the cache manager
   DefaultCacheManager cacheManager = new DefaultCacheManager(global.build(), builder.build());
   // Obtain the default cache
   Cache<String, String> cache = cacheManager.getCache();
   // Store the current node address in some random keys
   for(int i=0; i < 10; i++) {
      cache.put(UUID.randomUUID().toString(), cacheManager.getNodeAddress());
   }
   // Display the current cache contents for the whole cluster
   cache.entrySet().forEach(entry -> System.out.printf("%s = %s\n", entry.getKey(), entry.getValue()));
   // Display the current cache contents for this node
   cache.getAdvancedCache().withFlags(Flag.SKIP_REMOTE_LOOKUP)
      .entrySet().forEach(entry -> System.out.printf("%s = %s\n", entry.getKey(), entry.getValue()));
   // Stop the cache manager and release all resources
   cacheManager.stop();
}
 

import org.infinispan.context.Flag; //导入依赖的package包/类
public static void main(String[] args) throws Exception {
   // Setup up a clustered cache manager
   GlobalConfigurationBuilder global = GlobalConfigurationBuilder.defaultClusteredBuilder();
   // Make the default cache a distributed synchronous one
   ConfigurationBuilder builder = new ConfigurationBuilder();
   builder.clustering().cacheMode(CacheMode.DIST_SYNC);
   // Initialize the cache manager
   DefaultCacheManager cacheManager = new DefaultCacheManager(global.build(), builder.build());
   // Obtain the default cache
   Cache<String, String> cache = cacheManager.getCache();
   // Store the current node address in some random keys
   for(int i=0; i < 10; i++) {
      cache.put(UUID.randomUUID().toString(), cacheManager.getNodeAddress());
   }
   // Display the current cache contents for the whole cluster
   cache.entrySet().forEach(entry -> System.out.printf("%s = %s\n", entry.getKey(), entry.getValue()));
   // Display the current cache contents for this node
   cache.getAdvancedCache().withFlags(Flag.SKIP_REMOTE_LOOKUP)
      .entrySet().forEach(entry -> System.out.printf("%s = %s\n", entry.getKey(), entry.getValue()));
   // Stop the cache manager and release all resources
   cacheManager.stop();
}
 

import org.infinispan.context.Flag; //导入依赖的package包/类
/**
 * Return the node id -> node cache from the cache manager. This cache is heavily used to lookup
 * nodes when querying or loading triples and should therefore have a decent size (default 500.000 elements).
 *
 * @return an EHCache Cache instance containing the node id -> node mappings
 */
public Map getNodeCache() {
    if(nodeCache == null) {
        Configuration nodeConfiguration = new ConfigurationBuilder().read(defaultConfiguration)
                .eviction()
                    .maxEntries(1000000)
                .expiration()
                    .lifespan(60, TimeUnit.MINUTES)
                    .maxIdle(30, TimeUnit.MINUTES)
                .build();
        cacheManager.defineConfiguration(NODE_CACHE, nodeConfiguration);

        nodeCache = new AsyncMap(cacheManager.getCache(NODE_CACHE).getAdvancedCache().withFlags(Flag.SKIP_LOCKING, Flag.SKIP_CACHE_LOAD, Flag.SKIP_REMOTE_LOOKUP));
    }

    return nodeCache;
}
 

import org.infinispan.context.Flag; //导入依赖的package包/类
/**
 * Return the triple id -> triple cache from the cache manager. This cache is used for speeding up the
 * construction of query results.
 *
 * @return
 */
public Map getTripleCache() {
    if(tripleCache == null) {
        Configuration tripleConfiguration = new ConfigurationBuilder().read(defaultConfiguration)
                .clustering()
                    .cacheMode(CacheMode.LOCAL)
                .eviction()
                    .maxEntries(config.getTripleCacheSize())
                .expiration()
                    .lifespan(60, TimeUnit.MINUTES)
                    .maxIdle(30, TimeUnit.MINUTES)
                .build();
        cacheManager.defineConfiguration(TRIPLE_CACHE, tripleConfiguration);

        tripleCache = new AsyncMap(cacheManager.getCache(TRIPLE_CACHE).getAdvancedCache().withFlags(Flag.SKIP_LOCKING, Flag.SKIP_CACHE_LOAD, Flag.SKIP_REMOTE_LOOKUP));
    }
    return tripleCache;
}
 

import org.infinispan.context.Flag; //导入依赖的package包/类
/**
 * HTTP POST request accepted, issued on service/cacheName_put?params...&$filter=... URI
 *
 * @return
 */
private BaseResponse callFunctionPut(String setNameWhichIsCacheName, String entryKey, CachedValue cachedValue,
                                     boolean ignoreReturnValues) {

    log.trace("Putting into " + setNameWhichIsCacheName + " cache, entryKey: " +
            entryKey + " value: " + cachedValue.toString() + " ignoreReturnValues=" + ignoreReturnValues);

    if (ignoreReturnValues) {
        getCache(setNameWhichIsCacheName).withFlags(Flag.IGNORE_RETURN_VALUES).put(entryKey, cachedValue);
        return Responses.infinispanResponse(null, null, null, Response.Status.CREATED);
    } else {
        getCache(setNameWhichIsCacheName).put(entryKey, cachedValue);
        CachedValue resultOfPutForResponse = (CachedValue) getCache(setNameWhichIsCacheName).get(entryKey);
        return Responses.infinispanResponse(EdmSimpleType.STRING, "jsonValue", standardizeJSONresponse(
                new StringBuilder(resultOfPutForResponse.getJsonValueWrapper().getJson())).toString(), Response.Status.CREATED);
    }
}
 

import org.infinispan.context.Flag; //导入依赖的package包/类
public static void main(String[] args) throws IOException, InterruptedException {
	
      //Configuration
	ConfigurationBuilder builder = new ConfigurationBuilder();
	builder
		.eviction()
		.strategy(EvictionStrategy.LRU)
		.type(EvictionType.COUNT)
		.size(3)
		;
      // Initialize the cache manager
	DefaultCacheManager cacheManager = new DefaultCacheManager(builder.build());
    // Obtain the default cache
    Cache<Long, MoneyTransfert> cache = cacheManager.getCache("beosbank-dist");
      
	// Obtain the remote cache
	cache.addListener(new DatagridListener());
	// Create a Money Transfer Object from XML Message using BeaoIO API
	try {
		BeosBankCacheUtils.loadEntries(cache,inputFileNames);

		// Inspect the cache .
		System.out.println(cache.size());
		System.out.println(cache.get(3l));
		
		//Current node content
		cache.getAdvancedCache().withFlags(Flag.SKIP_REMOTE_LOOKUP)
        .entrySet().forEach(entry -> System.out.printf("%s = %s\n", entry.getKey(), entry.getValue().getDescription()));
		
		// Stop the cache
		cache.stop();

	} catch (IOException e) {
		// TODO Auto-generated catch block
		e.printStackTrace();
	}

}
 

import org.infinispan.context.Flag; //导入依赖的package包/类
@Override
public void update(XExpectations expectations) {
	if (!isMaster())
		iLog.warn("Updating expectations on a slave node. That is suspicious.");
	Lock lock = writeLock();
	try {
		iExpectations.getAdvancedCache().withFlags(Flag.IGNORE_RETURN_VALUES).put(expectations.getOfferingId(), expectations);
	} finally {
		lock.release();
	}
}
 

import org.infinispan.context.Flag; //导入依赖的package包/类
@Override
public void remove(XStudent student) {
	if (!isMaster())
		iLog.warn("Removing student on a slave node. That is suspicious.");
	Lock lock = writeLock();
	try {
		iStudentTable.getAdvancedCache().withFlags(Flag.IGNORE_RETURN_VALUES).remove(student.getStudentId());
	} finally {
		lock.release();
	}
}
 

import org.infinispan.context.Flag; //导入依赖的package包/类
@Override
public <E> void setProperty(String name, E value) {
	Cache<String, Object> properties = (Cache<String, Object>)iProperties;
	if (value == null)
		properties.getAdvancedCache().withFlags(Flag.FORCE_SYNCHRONOUS, Flag.IGNORE_RETURN_VALUES).remove(name);
	else
		properties.getAdvancedCache().withFlags(Flag.FORCE_SYNCHRONOUS, Flag.IGNORE_RETURN_VALUES).put(name,  value);
	flushCache(properties);
}
 

import org.infinispan.context.Flag; //导入依赖的package包/类
@Override
public void update(XExpectations expectations) {
	Lock lock = writeLock();
	try {
		iExpectations.getAdvancedCache().withFlags(Flag.IGNORE_RETURN_VALUES).put(expectations.getOfferingId(), expectations);
	} finally {
		lock.release();
	}
}
 

import org.infinispan.context.Flag; //导入依赖的package包/类
@Override
public void put(K k, V v, Handler<AsyncResult<Void>> completionHandler) {
  Object kk = DataConverter.toCachedObject(k);
  Object vv = DataConverter.toCachedObject(v);
  Future<Object> vertxFuture = Future.future();
  vertxFuture.map((Void) null).setHandler(completionHandler);
  whenComplete(cache.withFlags(Flag.IGNORE_RETURN_VALUES).putAsync(kk, vv), vertxFuture);
}
 

import org.infinispan.context.Flag; //导入依赖的package包/类
public static <K, V> BasicCache<K, V> ignoreReturnValuesCache(BasicCache<K, V> cache) {
    if (isEmbedded(cache)) {
        return ((Cache<K, V>) cache).getAdvancedCache().withFlags(Flag.IGNORE_RETURN_VALUES);
    } else {
        return cache;
    }
}
 

import org.infinispan.context.Flag; //导入依赖的package包/类
/**
 * A comma separated list of Flag to be applied by default on each cache
 * invocation, not applicable to remote caches.
 */
public void setFlags(String flagsAsString) {
    String[] flagsArray = flagsAsString.split(",");
    this.flags = new Flag[flagsArray.length];

    for (int i = 0; i < flagsArray.length; i++) {
        this.flags[i] = Flag.valueOf(flagsArray[i]);
    }
}
 

import org.infinispan.context.Flag; //导入依赖的package包/类
private void refresh() {
    long now = System.currentTimeMillis();
    if (health == null || ((now - lastUpdate) > 1000)) {
        InventoryHealth.Builder builder = InventoryHealth.builder();
        MemoryMXBean memoryMXBean = ManagementFactory.getMemoryMXBean();
        builder.timestamp(System.currentTimeMillis());
        builder.heapMemoryUsage(memoryMXBean.getHeapMemoryUsage());
        builder.nonHeapMemoryUsage(memoryMXBean.getNonHeapMemoryUsage());
        builder.systemLoadAverage(ManagementFactory.getOperatingSystemMXBean().getSystemLoadAverage());
        List<GarbageCollectorMXBean> gcMXBeans = ManagementFactory.getGarbageCollectorMXBeans();
        builder.gcCollectionCount(gcMXBeans.stream()
                .mapToLong(gc -> gc.getCollectionCount())
                .sum());
        builder.gcCollectionTime(gcMXBeans.stream()
                .mapToLong(gc -> gc.getCollectionTime())
                .sum());
        try {
            builder.inventoryTotalSpace(Files.walk(inventoryLocation.toPath())
                    .map(f -> f.toFile())
                    .filter(f -> f.isFile())
                    .mapToLong( f -> f.length())
                    .sum());
            builder.inventoryFreeSpace(inventoryLocation.getUsableSpace());
        } catch (Exception e) {
            log.errorReadingInventoryDisk(e);
        }
        Stats resourceStats = resource.getAdvancedCache().getStats();
        builder.numberOfResources(resource.size());
        builder.numberOfResourcesInMemory(resource.getAdvancedCache().withFlags(Flag.SKIP_CACHE_LOAD).size());
        builder.averageReadTimeForResources(resourceStats.getAverageReadTime());
        builder.averageWriteTimeForResources(resourceStats.getAverageWriteTime());
        Stats resourceTypeStats = resourceType.getAdvancedCache().getStats();
        builder.numberOfResourceTypes(resourceType.size());
        builder.numberOfResourceTypesInMemory(resourceType.getAdvancedCache().withFlags(Flag.SKIP_CACHE_LOAD).size());
        builder.averageReadTimeForResourceTypes(resourceTypeStats.getAverageReadTime());
        builder.averageWriteTimeForResourceTypes(resourceTypeStats.getAverageWriteTime());
        health = builder.build();
    }
}
 

import org.infinispan.context.Flag; //导入依赖的package包/类
@SuppressWarnings("unchecked")
@Override
public void notifyTrigger(Operation operation, String tenantId, String triggerId) {
    if (distributed) {
        PartitionEntry newEntry = new PartitionEntry(tenantId, triggerId);
        int toNode = calculateNewEntry(newEntry, (Map<Integer, Integer>)partitionCache.get(BUCKETS));
        NotifyTrigger nTrigger = new NotifyTrigger(currentNode, toNode, operation, tenantId, triggerId);
        Integer key = nTrigger.hashCode();
        triggersCache.getAdvancedCache().withFlags(Flag.IGNORE_RETURN_VALUES)
                .putAsync(key, nTrigger, LIFESPAN, TimeUnit.MILLISECONDS);
    }
}
 

import org.infinispan.context.Flag; //导入依赖的package包/类
@Override
@SuppressWarnings("unchecked")
public void notifyData(Collection<Data> data) {
    if (distributed) {
        NotifyData nData = new NotifyData(currentNode, data, Data.class);
        Integer key = nData.hashCode();
        log.debugf("Sending data [%s]", nData);
        dataCache.getAdvancedCache().withFlags(Flag.IGNORE_RETURN_VALUES)
                .putAsync(key, nData, LIFESPAN, TimeUnit.MILLISECONDS);
    }
}
 

import org.infinispan.context.Flag; //导入依赖的package包/类
@Override
@SuppressWarnings("unchecked")
public void notifyEvents(Collection<Event> events) {
    if (distributed) {
        NotifyData nEvent = new NotifyData(currentNode, events, Event.class);
        Integer key = nEvent.hashCode();
        log.debugf("Sending events [%s]", nEvent);
        dataCache.getAdvancedCache().withFlags(Flag.IGNORE_RETURN_VALUES)
                .putAsync(key, nEvent, LIFESPAN, TimeUnit.MILLISECONDS);
    }
}
 

import org.infinispan.context.Flag; //导入依赖的package包/类
/**
 * Return the uri -> KiWiUriResource cache from the cache manager. This cache is used when constructing new
 * KiWiUriResources to avoid a database lookup.
 *
 * @return
 */
public Map getUriCache() {
    if(uriCache == null) {
        Configuration uriConfiguration = new ConfigurationBuilder().read(defaultConfiguration)
                .eviction()
                    .maxEntries(config.getUriCacheSize())
                .build();
        cacheManager.defineConfiguration(URI_CACHE, uriConfiguration);

        uriCache = new AsyncMap(cacheManager.getCache(URI_CACHE).getAdvancedCache().withFlags(Flag.SKIP_LOCKING, Flag.SKIP_CACHE_LOAD, Flag.SKIP_REMOTE_LOOKUP));
    }
    return uriCache;
}