import org.apache.hadoop.oncrpc.RpcCallCache.CacheEntry; //导入依赖的package包/类
@Test
public void testAddRemoveEntries() throws UnknownHostException {
  RpcCallCache cache = new RpcCallCache("test", 100);
  InetAddress clientIp = InetAddress.getByName("1.1.1.1");
  int xid = 100;
  
  // Ensure null is returned when there is no entry in the cache
  // An entry is added to indicate the request is in progress
  CacheEntry e = cache.checkOrAddToCache(clientIp, xid);
  assertNull(e);
  e = cache.checkOrAddToCache(clientIp, xid);
  validateInprogressCacheEntry(e);
  
  // Set call as completed
  RpcResponse response = mock(RpcResponse.class);
  cache.callCompleted(clientIp, xid, response);
  e = cache.checkOrAddToCache(clientIp, xid);
  validateCompletedCacheEntry(e, response);
}
 

import org.apache.hadoop.oncrpc.RpcCallCache.CacheEntry; //导入依赖的package包/类
@Test
public void testAddRemoveEntries() throws UnknownHostException {
  RpcCallCache cache = new RpcCallCache("test", 100);
  InetAddress clientIp = InetAddress.getByName("1.1.1.1");
  int xid = 100;
  
  // Ensure null is returned when there is no entry in the cache
  // An entry is added to indicate the request is in progress
  CacheEntry e = cache.checkOrAddToCache(clientIp, xid);
  assertNull(e);
  e = cache.checkOrAddToCache(clientIp, xid);
  validateInprogressCacheEntry(e);
  
  // Set call as completed
  XDR response = new XDR();
  cache.callCompleted(clientIp, xid, response);
  e = cache.checkOrAddToCache(clientIp, xid);
  validateCompletedCacheEntry(e, response);
}
 

import org.apache.hadoop.oncrpc.RpcCallCache.CacheEntry; //导入依赖的package包/类
@Test
public void testCacheEntry() {
  CacheEntry c = new CacheEntry();
  validateInprogressCacheEntry(c);
  assertTrue(c.isInProgress());
  assertFalse(c.isCompleted());
  assertNull(c.getResponse());
  
  RpcResponse response = mock(RpcResponse.class);
  c.setResponse(response);
  validateCompletedCacheEntry(c, response);
}
 

import org.apache.hadoop.oncrpc.RpcCallCache.CacheEntry; //导入依赖的package包/类
@Test
public void testCacheFunctionality() throws UnknownHostException {
  RpcCallCache cache = new RpcCallCache("Test", 10);
  
  // Add 20 entries to the cache and only last 10 should be retained
  int size = 0;
  for (int clientId = 0; clientId < 20; clientId++) {
    InetAddress clientIp = InetAddress.getByName("1.1.1."+clientId);
    System.out.println("Adding " + clientIp);
    cache.checkOrAddToCache(clientIp, 0);
    size = Math.min(++size, 10);
    System.out.println("Cache size " + cache.size());
    assertEquals(size, cache.size()); // Ensure the cache size is correct
    
    // Ensure the cache entries are correct
    int startEntry = Math.max(clientId - 10 + 1, 0);
    Iterator<Entry<ClientRequest, CacheEntry>> iterator = cache.iterator();
    for (int i = 0; i < size; i++) {
      ClientRequest key = iterator.next().getKey();
      System.out.println("Entry " + key.getClientId());
      assertEquals(InetAddress.getByName("1.1.1." + (startEntry + i)),
          key.getClientId());
    }
    
    // Ensure cache entries are returned as in progress.
    for (int i = 0; i < size; i++) {
      CacheEntry e = cache.checkOrAddToCache(
          InetAddress.getByName("1.1.1." + (startEntry + i)), 0);
      assertNotNull(e);
      assertTrue(e.isInProgress());
      assertFalse(e.isCompleted());
    }
  }
}
 

import org.apache.hadoop.oncrpc.RpcCallCache.CacheEntry; //导入依赖的package包/类
@Test
public void testCacheEntry() {
  CacheEntry c = new CacheEntry();
  validateInprogressCacheEntry(c);
  assertTrue(c.isInProgress());
  assertFalse(c.isCompleted());
  assertNull(c.getResponse());
  
  XDR response = new XDR();
  c.setResponse(response);
  validateCompletedCacheEntry(c, response);
}
 

import org.apache.hadoop.oncrpc.RpcCallCache.CacheEntry; //导入依赖的package包/类
private void validateInprogressCacheEntry(CacheEntry c) {
  assertTrue(c.isInProgress());
  assertFalse(c.isCompleted());
  assertNull(c.getResponse());
}
 

import org.apache.hadoop.oncrpc.RpcCallCache.CacheEntry; //导入依赖的package包/类
private void validateCompletedCacheEntry(CacheEntry c, RpcResponse response) {
  assertFalse(c.isInProgress());
  assertTrue(c.isCompleted());
  assertEquals(response, c.getResponse());
}
 

import org.apache.hadoop.oncrpc.RpcCallCache.CacheEntry; //导入依赖的package包/类
public XDR handle(XDR xdr, InetAddress client, Channel channel) {
  XDR out = new XDR();
  RpcCall rpcCall = RpcCall.read(xdr);
  if (LOG.isDebugEnabled()) {
    LOG.debug(program + " procedure #" + rpcCall.getProcedure());
  }
  
  if (!checkProgram(rpcCall.getProgram())) {
    return programMismatch(out, rpcCall);
  }

  if (!checkProgramVersion(rpcCall.getVersion())) {
    return programVersionMismatch(out, rpcCall);
  }
  
  // Check for duplicate requests in the cache for non-idempotent requests
  boolean idempotent = rpcCallCache != null && !isIdempotent(rpcCall);
  if (idempotent) {
    CacheEntry entry = rpcCallCache.checkOrAddToCache(client, rpcCall.getXid());
    if (entry != null) { // in ache 
      if (entry.isCompleted()) {
        LOG.info("Sending the cached reply to retransmitted request "
            + rpcCall.getXid());
        return entry.getResponse();
      } else { // else request is in progress
        LOG.info("Retransmitted request, transaction still in progress "
            + rpcCall.getXid());
        // TODO: ignore the request?
      }
    }
  }
  
  XDR response = handleInternal(rpcCall, xdr, out, client, channel);
  if (response.size() == 0) {
    if (LOG.isDebugEnabled()) {
      LOG.debug("No sync response, expect an async response for request XID="
          + rpcCall.getXid());
    }
  }
  
  // Add the request to the cache
  if (idempotent) {
    rpcCallCache.callCompleted(client, rpcCall.getXid(), response);
  }
  return response;
}
 

import org.apache.hadoop.oncrpc.RpcCallCache.CacheEntry; //导入依赖的package包/类
private void validateCompletedCacheEntry(CacheEntry c, XDR response) {
  assertFalse(c.isInProgress());
  assertTrue(c.isCompleted());
  assertEquals(response, c.getResponse());
}