import com.google.appengine.api.memcache.ErrorHandlers; //导入依赖的package包/类
ObjectifyStorageIo() {
  RetryParams retryParams = new RetryParams.Builder().initialRetryDelayMillis(100)
    .retryMaxAttempts(10)
    .totalRetryPeriodMillis(10000).build();
  if (DEBUG) {
    LOG.log(Level.INFO, "RetryParams: getInitialRetryDelayMillis() = " + retryParams.getInitialRetryDelayMillis());
    LOG.log(Level.INFO, "RetryParams: getRequestTimeoutMillis() = " + retryParams.getRequestTimeoutMillis());
    LOG.log(Level.INFO, "RetryParams: getRetryDelayBackoffFactor() = " + retryParams.getRetryDelayBackoffFactor());
    LOG.log(Level.INFO, "RetryParams: getRetryMaxAttempts() = " + retryParams.getRetryMaxAttempts());
    LOG.log(Level.INFO, "RetryParams: getRetryMinAttempts() = " + retryParams.getRetryMinAttempts());
    LOG.log(Level.INFO, "RetryParams: getTotalRetryPeriodMillis() = " + retryParams.getTotalRetryPeriodMillis());
  }
  gcsService = GcsServiceFactory.createGcsService(retryParams);
  memcache.setErrorHandler(ErrorHandlers.getConsistentLogAndContinue(Level.INFO));
  initMotd();
}
 

import com.google.appengine.api.memcache.ErrorHandlers; //导入依赖的package包/类
@Override
public void doGet(HttpServletRequest req, HttpServletResponse resp) throws IOException,
    ServletException {
  String path = req.getRequestURI();
  if (path.startsWith("/favicon.ico")) {
    return; // ignore the request for favicon.ico
  }

  MemcacheService syncCache = MemcacheServiceFactory.getMemcacheService();
  syncCache.setErrorHandler(ErrorHandlers.getConsistentLogAndContinue(Level.INFO));

  byte[] whoKey = "who".getBytes();
  byte[] countKey = "count".getBytes();

  byte[] who = (byte[]) syncCache.get(whoKey);
  String whoString = who == null ? "nobody" : new String(who);
  resp.getWriter().print("Previously incremented by " + whoString + "\n");
  syncCache.put(whoKey, "Java".getBytes());
  Long count = syncCache.increment(countKey, 1L, 0L);
  resp.getWriter().print("Count incremented by Java = " + count + "\n");
}
 

import com.google.appengine.api.memcache.ErrorHandlers; //导入依赖的package包/类
/**
 * @return the number of packages
 */
public static int countPackages() {
    final String key =
            NWUtils.class.getName() + "[email protected]" +
            NWUtils.getDataVersion();
    MemcacheService syncCache = MemcacheServiceFactory.getMemcacheService();
    syncCache.setErrorHandler(ErrorHandlers
            .getConsistentLogAndContinue(Level.INFO));
    Integer value = (Integer) syncCache.get(key); // read from cache
    if (value == null) {
        ShardedCounter sc =
                ShardedCounter.getOrCreateCounter("NumberOfPackages", 2);
        value = sc.getCount();
        if (sc.getCount() == 0) {
            Objectify ofy = DefaultServlet.getObjectify();
            sc.increment(ofy.query(Package.class).count());
            value = sc.getCount();
        }
        syncCache.put(key, value); // populate cache
    }
    return value;
}
 

import com.google.appengine.api.memcache.ErrorHandlers; //导入依赖的package包/类
@Override
protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException
{
    final String uuid = request.getParameter(UpdatePositionServletImpl.PARAMETER_UUID);
    if (uuid == null || uuid.trim().equals("")) {
        response.sendError(HttpStatus.SC_BAD_REQUEST, "?uuid= mandatory");
    }
    
    final MemcacheService syncCache = MemcacheServiceFactory.getMemcacheService();
    syncCache.setErrorHandler(ErrorHandlers.getConsistentLogAndContinue(Level.INFO));
    final Object inMemory = syncCache.get(uuid);
    
    if (inMemory == null) {
        response.sendError(HttpStatus.SC_NOT_FOUND, "element not found");
    }
    
    final Cache cache = Cache.from(inMemory);
    response.getWriter().write(cache.toString());
}
 

import com.google.appengine.api.memcache.ErrorHandlers; //导入依赖的package包/类
@Override
public void doGet(HttpServletRequest req, HttpServletResponse resp) throws IOException,
    ServletException {
  String path = req.getRequestURI();
  if (path.startsWith("/favicon.ico")) {
    return; // ignore the request for favicon.ico
  }

  // [START example]
  AsyncMemcacheService asyncCache = MemcacheServiceFactory.getAsyncMemcacheService();
  asyncCache.setErrorHandler(ErrorHandlers.getConsistentLogAndContinue(Level.INFO));
  String key = "count-async";
  byte[] value;
  long count = 1;
  Future<Object> futureValue = asyncCache.get(key); // Read from cache.
  // ... Do other work in parallel to cache retrieval.
  try {
    value = (byte[]) futureValue.get();
    if (value == null) {
      value = BigInteger.valueOf(count).toByteArray();
      asyncCache.put(key, value);
    } else {
      // Increment value
      count = new BigInteger(value).longValue();
      count++;
      value = BigInteger.valueOf(count).toByteArray();
      // Put back in cache
      asyncCache.put(key, value);
    }
  } catch (InterruptedException | ExecutionException e) {
    throw new ServletException("Error when waiting for future value", e);
  }
  // [END example]

  // Output content
  resp.setContentType("text/plain");
  resp.getWriter().print("Value is " + count + "\n");
}
 

import com.google.appengine.api.memcache.ErrorHandlers; //导入依赖的package包/类
@Override
public void doGet(HttpServletRequest req, HttpServletResponse resp) throws IOException,
    ServletException {
  String path = req.getRequestURI();
  if (path.startsWith("/favicon.ico")) {
    return; // ignore the request for favicon.ico
  }

  MemcacheService syncCache = MemcacheServiceFactory.getMemcacheService();
  syncCache.setErrorHandler(ErrorHandlers.getConsistentLogAndContinue(Level.INFO));
  String key = "count-sync";
  byte[] value;
  long count = 1;
  value = (byte[]) syncCache.get(key);
  if (value == null) {
    value = BigInteger.valueOf(count).toByteArray();
    syncCache.put(key, value);
  } else {
    // Increment value
    count = new BigInteger(value).longValue();
    count++;
    value = BigInteger.valueOf(count).toByteArray();
    // Put back in cache
    syncCache.put(key, value);
  }

  // Output content
  resp.setContentType("text/plain");
  resp.getWriter().print("Value is " + count + "\n");
}
 

import com.google.appengine.api.memcache.ErrorHandlers; //导入依赖的package包/类
/**
 * Returns possible cached result of a query.
 * 
 * @param <T>
 *            datastore object class
 * @param ofy
 *            Objectify
 * @param q
 *            a query
 * @param cacheSuffix
 *            suffix for the cache key
 * @return possible cached result of the query
 */
public static <T> List<Key<T>> getKeys(Objectify ofy,
        com.googlecode.objectify.Query<T> q, String cacheSuffix) {
	String key = q.toString() + cacheSuffix;

	MemcacheService syncCache = MemcacheServiceFactory.getMemcacheService();
	syncCache.setErrorHandler(ErrorHandlers
	        .getConsistentLogAndContinue(Level.INFO));
	String value = (String) syncCache.get(key); // read from cache
	List<Key<T>> result;
	if (value == null) {
		result = q.listKeys();

		StringBuilder sb = new StringBuilder();
		for (int i = 0; i < result.size(); i++) {
			if (i != 0)
				sb.append(' ');
			sb.append(result.get(i).getString());
		}
		value = sb.toString();

		syncCache.put(key, value); // populate cache
	} else {
		List<String> keys = NWUtils.split(value, ' ');
		result = new ArrayList<Key<T>>();
		for (String k : keys) {
			result.add(new Key<T>(k));
		}
	}
	return result;
}
 

import com.google.appengine.api.memcache.ErrorHandlers; //导入依赖的package包/类
/**
 * Increments the version of the data.
 *
 * @return new version number
 */
public static long incDataVersion() {
    MemcacheService syncCache = MemcacheServiceFactory.getMemcacheService();
    syncCache.setErrorHandler(ErrorHandlers
            .getConsistentLogAndContinue(Level.INFO));
    Long v = syncCache.increment("DataVersion", 1L);
    if (v == null) {
        syncCache.put("DataVersion", 1L);
        v = 1L;
    }
    return v;
}
 

import com.google.appengine.api.memcache.ErrorHandlers; //导入依赖的package包/类
/**
 * @return current data version
 */
public static long getDataVersion() {
    MemcacheService syncCache = MemcacheServiceFactory.getMemcacheService();
    syncCache.setErrorHandler(ErrorHandlers
            .getConsistentLogAndContinue(Level.INFO));
    Long v = (Long) syncCache.get("DataVersion");
    if (v == null) {
        syncCache.put("DataVersion", 1L);
        v = 1L;
    }
    return v;
}
 

import com.google.appengine.api.memcache.ErrorHandlers; //导入依赖的package包/类
@Override
protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException
{
    final String position = request.getParameter(PARAMETER_POSITION);
    final String uuid = request.getParameter(PARAMETER_UUID);
    final MemcacheService syncCache = MemcacheServiceFactory.getMemcacheService();
    syncCache.setErrorHandler(ErrorHandlers.getConsistentLogAndContinue(Level.INFO));
    syncCache.put(uuid, Cache.to(position));
}
 

import com.google.appengine.api.memcache.ErrorHandlers; //导入依赖的package包/类
/**
 * Gets a list of all game board entities.
 *
 * @return non null map of board entities indexed by entity keys.
 */
private Map<Key, BoardEntity> getBoards() {
  // Gets a list of all game boards from memcache.
  MemcacheService cache = MemcacheServiceFactory.getMemcacheService();
  cache.setErrorHandler(ErrorHandlers.getConsistentLogAndContinue(Level.INFO));

  @SuppressWarnings("unchecked")
  Map<Key, BoardEntity> boards = (Map<Key, BoardEntity>) cache.get(ALL_BOARDS_CACHE_KEY);

  // If the list wasn't in the cache then retrieve it from Datastore
  // and cache it (unless the list is empty).
  if (boards == null) {
    boards = new HashMap<Key, BoardEntity>();

    Query query = new Query(BoardEntity.KIND);
    PreparedQuery preparedQuery = dataStore.prepare(query);

    for (Entity board : preparedQuery.asIterable()) {
      boards.put(board.getKey(), new BoardEntity(board));
    }

    if (boards.size() > 0) {
      cache.put(ALL_BOARDS_CACHE_KEY, boards);
    }
  }

  return boards;
}
 

import com.google.appengine.api.memcache.ErrorHandlers; //导入依赖的package包/类
@Override
public void create(HttpServletRequest request, HttpServletResponse resp)
        throws IOException {
    resp.setContentType("application/xml");

    final String key =
            this.getClass().getName() + "@" + NWUtils.getDataVersion() +
            "@" + user + "@" + tag;
    MemcacheService syncCache = MemcacheServiceFactory.getMemcacheService();
    syncCache.setErrorHandler(ErrorHandlers
            .getConsistentLogAndContinue(Level.INFO));
    byte[] value = (byte[]) syncCache.get(key); // read from cache
    if (value == null) {
        NWUtils.LOG.warning("Found no value in cache");
        try {
            Objectify ofy = DefaultServlet.getObjectify();
            ArrayList<PackageVersion> pvs = new ArrayList<PackageVersion>();
            Query<PackageVersion> q =
                    ofy.query(PackageVersion.class).limit(20)
                            .order("-lastModifiedAt");
            if (user != null) {
                q =
                        q.filter(
                                "lastModifiedBy =",
                                new User(user, user.substring(user
                                        .indexOf('@'))));
            }
            if (tag != null) {
                q = q.filter("tags =", tag);
            }
            pvs.addAll(q.list());
            Document d = RepXMLPage.toXML(ofy, pvs, false, null);

            ByteArrayOutputStream baos = new ByteArrayOutputStream();
            NWUtils.serializeXML(d, baos);
            value = baos.toByteArray();
            syncCache.put(key, value); // populate cache
        } catch (Exception e) {
            throw new IOException(e);
        }
    } else {
        NWUtils.LOG.log(Level.WARNING, "Found value in cache {0} bytes",
                value.length);
    }

    ServletOutputStream ros = resp.getOutputStream();
    ros.write(value);
    ros.close();
}
 

import com.google.appengine.api.memcache.ErrorHandlers; //导入依赖的package包/类
protected NotificationWorker(Queue queue) {
	this.queue = queue;
	cache.setErrorHandler(ErrorHandlers
			.getConsistentLogAndContinue(Level.INFO));

}
 

import com.google.appengine.api.memcache.ErrorHandlers; //导入依赖的package包/类
public MemcacheSessionStore() {
  memcache = MemcacheServiceFactory.getMemcacheService("");
  memcache.setErrorHandler(ErrorHandlers.getConsistentLogAndContinue(Level.INFO));
}
 

import com.google.appengine.api.memcache.ErrorHandlers; //导入依赖的package包/类
/**
 * @constructor
 *
 * @param queue Task queue that needs to be processed
 */
protected Worker(Queue queue) {
  this.queue = queue;

  cache.setErrorHandler(ErrorHandlers.getConsistentLogAndContinue(Level.INFO));
}
 

import com.google.appengine.api.memcache.ErrorHandlers; //导入依赖的package包/类
private static MemcacheService initMemcache() {
  MemcacheService m = MemcacheServiceFactory.getMemcacheService();
  m.setErrorHandler(ErrorHandlers.getConsistentLogAndContinue(Level.INFO));
  return m;
}
 

import com.google.appengine.api.memcache.ErrorHandlers; //导入依赖的package包/类
public InvitationService() {
  cache.setErrorHandler(ErrorHandlers.getConsistentLogAndContinue(Level.INFO));
}
 

import com.google.appengine.api.memcache.ErrorHandlers; //导入依赖的package包/类
/**
 * @constructor
 *
 * @param queue Task queue that needs to be processed
 */
protected PushNotificationWorker(Queue queue) {
  this.queue = queue;

  cache.setErrorHandler(ErrorHandlers.getConsistentLogAndContinue(Level.INFO));
}
 

import com.google.appengine.api.memcache.ErrorHandlers; //导入依赖的package包/类
/**
 * Get a Memcache service for specific namespace
 *
 * @param namespace namespace of memcache
 * @return the Memcache
 */
private MemcacheService getService(String namespace) {
    MemcacheService cache = MemcacheServiceFactory.getMemcacheService("alarmClock");
    cache.setErrorHandler(ErrorHandlers.getConsistentLogAndContinue(Level.WARNING));
    return cache;
}