@GET
@Path("/{id}")
public Response get(@PathParam("id") int id, @Context Request request) {
// Create cache control header
CacheControl cc = new CacheControl();
// Set max age to one day
cc.setMaxAge(86400);
Response.ResponseBuilder rb = null;
// Calculate the ETag on last modified date of user resource
EntityTag etag = new EntityTag(UserDao.getLastModifiedById(id).hashCode() + "");
// Verify if it matched with etag available in http request
rb = request.evaluatePreconditions(etag);
// If ETag matches the rb will be non-null;
// Use the rb to return the response without any further processing
if (rb != null) {
return rb.cacheControl(cc).tag(etag).build();
}
// If rb is null then either it is first time request; or resource is modified
// Get the updated representation and return with Etag attached to it
rb = Response.ok(UserDao.get(id).get()).cacheControl(cc).tag(etag);
return rb.build();
}
@Test
public void timeDurationTruncatedToMaxValue() throws Exception {
CacheControl cacheControl =
new CacheControl.Builder()
.maxAge(365 * 100, TimeUnit.DAYS) // Longer than Integer.MAX_VALUE seconds.
.build();
assertEquals(Integer.MAX_VALUE, cacheControl.maxAgeSeconds());
}
public t> cacheControl(CacheControl cachecontrol)
{
cachecontrol = cachecontrol.toString();
if (cachecontrol.isEmpty())
{
return removeHeader("Cache-Control");
} else
{
return header("Cache-Control", cachecontrol);
}
}
/**
* Revert a set of keys to the empty state. Will loop on this several times just in case the
* memcache write fails - we don't want to leave the cache in a nasty state.
*/
public void empty(Iterable<Key> keys) {
Map<Key, Object> updates = new HashMap<>();
for (Key key : keys) if (cacheControl.getExpirySeconds(key) != null) updates.put(key, null);
this.memcacheWithRetry.putAll(updates);
}
public void cancel() {
clearImagesToGrab();
if (cacheControl != null) {
while (!cacheControl.isCachePipeEmpty()) {
Main.info("Try to close a WMSLayer which is currently saving in cache : wait 1 sec.");
CadastrePlugin.safeSleep(1000);
}
}
}
private void clearCache(RolapCube cube) {
// Clear the cache for the Sales cube, so the query runs as if
// for the first time. (TODO: Cleaner way to do this.)
final Cube salesCube = getConnection().getSchema().lookupCube("Sales", true);
RolapHierarchy hierarchy =
(RolapHierarchy)
salesCube.lookupHierarchy(new Id.NameSegment("Store", Id.Quoting.UNQUOTED), false);
SmartMemberReader memberReader = (SmartMemberReader) hierarchy.getMemberReader();
MemberCacheHelper cacheHelper = memberReader.cacheHelper;
cacheHelper.mapLevelToMembers.cache.clear();
cacheHelper.mapMemberToChildren.cache.clear();
// Flush the cache, to ensure that the query gets executed.
cube.clearCachedAggregations(true);
CacheControl cacheControl = getConnection().getCacheControl(null);
final CacheControl.CellRegion measuresRegion = cacheControl.createMeasuresRegion(cube);
cacheControl.flush(measuresRegion);
}
/**
* Gets the Buckets for the specified keys. A bucket is built around an IdentifiableValue so you
* can putAll() them without the risk of overwriting other threads' changes. Buckets also hide the
* underlying details of storage for negative, empty, and uncacheable results.
*
* <p>Note that worst case (a cold cache), obtaining each bucket might require three memcache
* requests: a getIdentifiable() which returns null, a put(EMPTY), and another getIdentifiable().
* Since there is no batch getIdentifiable(), this is *per key*.
*
* <p>When keys are uncacheable (per CacheControl) or the memcache is down, you will still get an
* empty bucket back. The bucket will have null IdentifiableValue so we can identify it as
* uncacheable.
*
* @return the buckets requested. Buckets will never be null. You will always get a bucket for
* every key.
*/
public Map<Key, Bucket> getAll(Iterable<Key> keys) {
Map<Key, Bucket> result = new HashMap<>();
// Sort out the ones that are uncacheable
Set<Key> potentials = new HashSet<>();
for (Key key : keys) {
if (cacheControl.getExpirySeconds(key) == null) result.put(key, new Bucket(key));
else potentials.add(key);
}
Map<Key, IdentifiableValue> ivs;
try {
ivs = this.memcache.getIdentifiables(potentials);
} catch (Exception ex) {
// This should really only be a problem if the serialization format for an Entity changes,
// or someone put a badly-serializing object in the cache underneath us.
log.log(Level.WARNING, "Error obtaining cache for " + potentials, ex);
ivs = new HashMap<>();
}
// Figure out cold cache values
Map<Key, Object> cold = new HashMap<>();
for (Key key : potentials) if (ivs.get(key) == null) cold.put(key, null);
if (!cold.isEmpty()) {
// The cache is cold for those values, so start them out with nulls that we can make an IV for
this.memcache.putAll(cold);
try {
Map<Key, IdentifiableValue> ivs2 = this.memcache.getIdentifiables(cold.keySet());
ivs.putAll(ivs2);
} catch (Exception ex) {
// At this point we should just not worry about it, the ivs will be null and uncacheable
}
}
// Now create the remaining buckets
for (Key key : keys) {
// iv might still be null, which is ok - that means uncacheable
IdentifiableValue iv = ivs.get(key);
Bucket buck = (iv == null) ? new Bucket(key) : new Bucket(key, iv);
result.put(key, buck);
if (buck.isEmpty()) this.stats.recordMiss(buck.getKey());
else this.stats.recordHit(buck.getKey());
}
return result;
}
/**
* Put buckets in the cache, checking for cacheability and collisions.
*
* @return the set of keys that were *successfully* put without collision
*/
private Set<Key> cachePutIfUntouched(Iterable<Bucket> buckets) {
Map<Key, CasValues> payload = new HashMap<>();
for (Bucket buck : buckets) {
if (!buck.isCacheable()) continue;
Integer expirySeconds = cacheControl.getExpirySeconds(buck.getKey());
if (expirySeconds == null) continue;
Expiration expiration = expirySeconds == 0 ? null : Expiration.byDeltaSeconds(expirySeconds);
payload.put(buck.getKey(), new CasValues(buck.iv, buck.getNextToStore(), expiration));
}
return this.memcache.putIfUntouched(payload);
}
@Test
public void parse() throws Exception {
String header =
"no-cache, no-store, max-age=1, s-maxage=2, public, must-revalidate, "
+ "max-stale=3, min-fresh=4, only-if-cached, no-transform";
CacheControl cacheControl =
CacheControl.parse(new Headers.Builder().set("Cache-Control", header).build());
assertTrue(cacheControl.noCache());
assertTrue(cacheControl.noStore());
assertEquals(1, cacheControl.maxAgeSeconds());
assertEquals(2, cacheControl.sMaxAgeSeconds());
assertTrue(cacheControl.isPublic());
assertTrue(cacheControl.mustRevalidate());
assertEquals(3, cacheControl.maxStaleSeconds());
assertEquals(4, cacheControl.minFreshSeconds());
assertTrue(cacheControl.onlyIfCached());
assertTrue(cacheControl.noTransform());
assertEquals(header, cacheControl.toString());
}
@Test
public void parseEmpty() throws Exception {
CacheControl cacheControl =
CacheControl.parse(new Headers.Builder().set("Cache-Control", "").build());
assertEquals("", cacheControl.toString());
assertFalse(cacheControl.noCache());
assertFalse(cacheControl.noStore());
assertEquals(-1, cacheControl.maxAgeSeconds());
assertEquals(-1, cacheControl.sMaxAgeSeconds());
assertFalse(cacheControl.isPublic());
assertFalse(cacheControl.mustRevalidate());
assertEquals(-1, cacheControl.maxStaleSeconds());
assertEquals(-1, cacheControl.minFreshSeconds());
assertFalse(cacheControl.onlyIfCached());
assertFalse(cacheControl.mustRevalidate());
}
@Test
public void completeBuilder() throws Exception {
CacheControl cacheControl =
new CacheControl.Builder()
.noCache()
.noStore()
.maxAge(1, TimeUnit.SECONDS)
.maxStale(2, TimeUnit.SECONDS)
.minFresh(3, TimeUnit.SECONDS)
.onlyIfCached()
.noTransform()
.build();
assertEquals(
"no-cache, no-store, max-age=1, max-stale=2, min-fresh=3, only-if-cached, "
+ "no-transform",
cacheControl.toString());
assertTrue(cacheControl.noCache());
assertTrue(cacheControl.noStore());
assertEquals(1, cacheControl.maxAgeSeconds());
assertEquals(2, cacheControl.maxStaleSeconds());
assertEquals(3, cacheControl.minFreshSeconds());
assertTrue(cacheControl.onlyIfCached());
// These members are accessible to response headers only.
assertEquals(-1, cacheControl.sMaxAgeSeconds());
assertFalse(cacheControl.isPublic());
assertFalse(cacheControl.mustRevalidate());
}
@Test
public void emptyBuilderIsEmpty() throws Exception {
CacheControl cacheControl = new CacheControl.Builder().build();
assertEquals("", cacheControl.toString());
assertFalse(cacheControl.noCache());
assertFalse(cacheControl.noStore());
assertEquals(-1, cacheControl.maxAgeSeconds());
assertEquals(-1, cacheControl.sMaxAgeSeconds());
assertFalse(cacheControl.isPublic());
assertFalse(cacheControl.mustRevalidate());
assertEquals(-1, cacheControl.maxStaleSeconds());
assertEquals(-1, cacheControl.minFreshSeconds());
assertFalse(cacheControl.onlyIfCached());
assertFalse(cacheControl.mustRevalidate());
}
@Test
public void timePrecisionIsTruncatedToSeconds() throws Exception {
CacheControl cacheControl =
new CacheControl.Builder().maxAge(4999, TimeUnit.MILLISECONDS).build();
assertEquals(4, cacheControl.maxAgeSeconds());
}
static {
RuntimeDelegate.setInstance(new RuntimeDelegateImpl());
cacheControl = new CacheControl();
cacheControl.setNoCache(true);
cacheControl.setNoStore(true);
}
/**
* Returns the cache control directives for this response. This is never null, even if this
* response contains no {@code Cache-Control} header.
*/
public CacheControl cacheControl() {
CacheControl result = cacheControl;
return result != null ? result : (cacheControl = CacheControl.parse(headers));
}
private CacheControl cacheControlNoStore() {
CacheControl cacheControl = new CacheControl();
cacheControl.setNoStore(true);
return cacheControl;
}
