SLING-2555 moving into the right place this time, sorry.
git-svn-id: https://svn.apache.org/repos/asf/sling/trunk@1407364 13f79535-47bb-0310-9956-ffa450edef68
diff --git a/README.txt b/README.txt
new file mode 100644
index 0000000..4664850
--- /dev/null
+++ b/README.txt
@@ -0,0 +1,12 @@
+Support Jar for implementations of CacheManagerService.
+
+This is support jar for implementing Cache services. It contains an abstract implementation of all the in
+memory versions of cache that the cache service has to supply leaving instance, cluster invalidated and cluster
+replicated caches upto the supporting cache library.
+
+
+Acknowledgments
+
+This code was based on a module from Sparse Content Map 29 September 2012 (git:sha1:a222df1937434ad3f07bf6c4f60b19524a158bcb), which itself was based on a snapshot of a
+module in Sakai Nakamura 27 Jan 2011 (git:sha1:b9d8e65b733ec7c35a3d194c9a5dc12acf13cb34). All know contributors to code in this module have been
+contacted for permission to grant license to the Apache Foundation.
\ No newline at end of file
diff --git a/pom.xml b/pom.xml
new file mode 100644
index 0000000..5acbc20
--- /dev/null
+++ b/pom.xml
@@ -0,0 +1,69 @@
+<?xml version="1.0" encoding="ISO-8859-1"?>
+<!--
+ Licensed to the Apache Software Foundation (ASF) under one
+ or more contributor license agreements. See the NOTICE file
+ distributed with this work for additional information
+ regarding copyright ownership. The ASF licenses this file
+ to you under the Apache License, Version 2.0 (the
+ "License"); you may not use this file except in compliance
+ with the License. You may obtain a copy of the License at
+
+ http://www.apache.org/licenses/LICENSE-2.0
+
+ Unless required by applicable law or agreed to in writing,
+ software distributed under the License is distributed on an
+ "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ KIND, either express or implied. See the License for the
+ specific language governing permissions and limitations
+ under the License.
+-->
+<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd">
+
+ <modelVersion>4.0.0</modelVersion>
+ <parent>
+ <groupId>org.apache.sling</groupId>
+ <artifactId>sling</artifactId>
+ <version>13</version>
+ <relativePath>../../../parent/pom.xml</relativePath>
+ </parent>
+
+ <artifactId>org.apache.sling.commons.cache.impl</artifactId>
+ <version>0.1-SNAPSHOT</version>
+ <packaging>jar</packaging>
+
+ <name>Apache Sling Cache API Implementation support library</name>
+ <description>
+ This bundle provides an implementation support for Cache implementations. It is a utility jar that should be embedded.
+ </description>
+
+ <scm>
+ <connection>scm:svn:http://svn.apache.org/repos/asf/sling/whiteboard/ieb/cache/impl</connection>
+ <developerConnection>scm:svn:https://svn.apache.org/repos/asf/sling/whiteboard/ieb/cache/impl</developerConnection>
+ <url>http://svn.apache.org/viewvc/sling/whiteboard/ieb/cache/impl</url>
+ </scm>
+
+
+ <dependencies>
+ <dependency>
+ <groupId>org.apache.sling</groupId>
+ <artifactId>org.apache.sling.commons.cache.api</artifactId>
+ <version>0.1-SNAPSHOT</version>
+ </dependency>
+
+ <dependency>
+ <groupId>commons-io</groupId>
+ <artifactId>commons-io</artifactId>
+ <version>1.4</version>
+ </dependency>
+ <dependency>
+ <groupId>org.slf4j</groupId>
+ <artifactId>slf4j-api</artifactId>
+ <scope>provided</scope>
+ </dependency>
+ <dependency>
+ <groupId>junit</groupId>
+ <artifactId>junit</artifactId>
+ </dependency>
+
+ </dependencies>
+</project>
diff --git a/src/main/java/org/apache/sling/commons/cache/impl/AbstractCacheManagerService.java b/src/main/java/org/apache/sling/commons/cache/impl/AbstractCacheManagerService.java
new file mode 100644
index 0000000..c5542f1
--- /dev/null
+++ b/src/main/java/org/apache/sling/commons/cache/impl/AbstractCacheManagerService.java
@@ -0,0 +1,194 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+package org.apache.sling.commons.cache.impl;
+
+import java.io.ByteArrayInputStream;
+import java.io.IOException;
+import java.io.InputStream;
+import java.util.Map;
+
+import org.apache.commons.io.IOUtils;
+import org.apache.sling.commons.cache.api.Cache;
+import org.apache.sling.commons.cache.api.CacheManagerService;
+import org.apache.sling.commons.cache.api.CacheScope;
+
+/**
+ * The <code>AbstractCacheManagerService</code>
+ */
+public abstract class AbstractCacheManagerService implements CacheManagerService {
+
+
+ private ThreadLocalCacheMap requestCacheMapHolder = new ThreadLocalCacheMap();
+ private ThreadLocalCacheMap threadCacheMapHolder = new ThreadLocalCacheMap();
+
+ public AbstractCacheManagerService() throws IOException {
+ }
+
+
+
+ /**
+ * {@inheritDoc}
+ *
+ * @see org.apache.sling.commons.cache.api.CacheManagerService#getCache(java.lang.String)
+ */
+ public <V> Cache<V> getCache(String name, CacheScope scope) {
+ switch (scope) {
+ case INSTANCE:
+ return getInstanceCache(name);
+ case CLUSTERINVALIDATED:
+ return getInstanceCache(name);
+ case CLUSTERREPLICATED:
+ return getInstanceCache(name);
+ case REQUEST:
+ return getRequestCache(name);
+ case THREAD:
+ return getThreadCache(name);
+ default:
+ return getInstanceCache(name);
+ }
+ }
+
+
+
+ /**
+ * Generate a cache bound to the thread.
+ *
+ * @param name
+ * @return
+ */
+ @SuppressWarnings("unchecked")
+ protected <V> Cache<V> getThreadCache(String name) {
+ Map<String, Cache<?>> threadCacheMap = threadCacheMapHolder.get();
+ Cache<V> threadCache = (Cache<V>) threadCacheMap.get(name);
+ if (threadCache == null) {
+ threadCache = new MapCacheImpl<V>();
+ threadCacheMap.put(name, threadCache);
+ }
+ return threadCache;
+ }
+
+ /**
+ * Generate a cache bound to the request
+ *
+ * @param name
+ * @return
+ */
+ @SuppressWarnings("unchecked")
+ protected <V> Cache<V> getRequestCache(String name) {
+ Map<String, Cache<?>> requestCacheMap = requestCacheMapHolder.get();
+ Cache<V> requestCache = (Cache<V>) requestCacheMap.get(name);
+ if (requestCache == null) {
+ requestCache = new MapCacheImpl<V>();
+ requestCacheMap.put(name, requestCache);
+ }
+ return requestCache;
+ }
+
+ /**
+ * @param name
+ * @return
+ */
+ protected abstract <V> Cache<V> getInstanceCache(String name);
+
+ /**
+ * {@inheritDoc}
+ *
+ * @see org.apache.sling.commons.cache.api.CacheManagerService#unbind(org.apache.sling.commons.cache.api.CacheScope)
+ */
+ public void unbind(CacheScope scope) {
+ switch (scope) {
+ case REQUEST:
+ unbindRequest();
+ break;
+ case THREAD:
+ unbindThread();
+ break;
+ default:
+ break;
+ }
+ }
+
+ /**
+ *
+ */
+ private void unbindThread() {
+ Map<String, Cache<?>> threadCache = threadCacheMapHolder.get();
+ for (Cache<?> cache : threadCache.values()) {
+ cache.clear();
+ }
+ threadCacheMapHolder.remove();
+ }
+
+ /**
+ *
+ */
+ private void unbindRequest() {
+ Map<String, Cache<?>> requestCache = requestCacheMapHolder.get();
+ for (Cache<?> cache : requestCache.values()) {
+ cache.clear();
+ }
+ requestCacheMapHolder.remove();
+ }
+
+
+ protected String toString(Object object, String defaultValue) {
+ if (object == null) {
+ return defaultValue;
+ }
+ return String.valueOf(object);
+ }
+
+
+ protected InputStream processConfig(InputStream in,
+ Map<String, Object> properties) throws IOException {
+ if (in == null) {
+ return null;
+ }
+ StringBuilder config = new StringBuilder(IOUtils.toString(in, "UTF-8"));
+ in.close();
+ int pos = 0;
+ for (;;) {
+ int start = config.indexOf("${", pos);
+ if (start < 0) {
+ break;
+ }
+ int end = config.indexOf("}", start);
+ if (end < 0) {
+ throw new IllegalArgumentException(
+ "Config file malformed, unterminated variable "
+ + config.substring(start,
+ Math.min(start + 10, config.length())));
+ }
+ String key = config.substring(start + 2, end);
+ if (properties.containsKey(key)) {
+ String replacement = (String) properties.get(key);
+ config.replace(start, end + 1, replacement);
+ pos = start + replacement.length();
+ } else {
+ throw new IllegalArgumentException(
+ "Missing replacement property " + key);
+ }
+ }
+ return new ByteArrayInputStream(config.toString().getBytes("UTF-8"));
+
+ }
+
+
+}
diff --git a/src/main/java/org/apache/sling/commons/cache/impl/MapCacheImpl.java b/src/main/java/org/apache/sling/commons/cache/impl/MapCacheImpl.java
new file mode 100644
index 0000000..51f8c29
--- /dev/null
+++ b/src/main/java/org/apache/sling/commons/cache/impl/MapCacheImpl.java
@@ -0,0 +1,119 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+package org.apache.sling.commons.cache.impl;
+
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Set;
+
+import org.apache.sling.commons.cache.api.Cache;
+import org.apache.sling.commons.cache.api.ThreadBound;
+
+/**
+ *
+ */
+public class MapCacheImpl<V> extends HashMap<String, V> implements Cache<V> {
+
+ /**
+ *
+ */
+ private static final long serialVersionUID = -5400056532743570231L;
+
+ /**
+ * {@inheritDoc}
+ *
+ * @see org.apache.sling.commons.cache.api.Cache#containsKey(java.lang.String)
+ */
+ public boolean containsKey(String key) {
+ return super.containsKey(key);
+ }
+
+ /**
+ * {@inheritDoc}
+ *
+ * @see org.apache.sling.commons.cache.api.Cache#get(java.lang.String)
+ */
+ public V get(String key) {
+ return super.get(key);
+ }
+
+ /**
+ * {@inheritDoc}
+ *
+ * @see org.apache.sling.commons.cache.api.Cache#remove(java.lang.String)
+ */
+ public boolean remove(String key) {
+ V o = super.remove(key);
+ if (o instanceof ThreadBound) {
+ ((ThreadBound) o).unbind();
+ }
+ return ( o != null );
+ }
+
+ /**
+ * {@inheritDoc}
+ *
+ * @see java.util.HashMap#clear()
+ */
+ @Override
+ public void clear() {
+ for (String k : super.keySet()) {
+ Object o = get(k);
+ if (o instanceof ThreadBound) {
+ ((ThreadBound) o).unbind();
+ }
+ }
+ super.clear();
+ }
+
+ /**
+ * {@inheritDoc}
+ *
+ * @see org.apache.sling.commons.cache.api.Cache#removeChildren(java.lang.String)
+ */
+ public void removeChildren(String key) {
+ super.remove(key);
+ if (!key.endsWith("/")) {
+ key = key + "/";
+ }
+ Set<String> keys = super.keySet();
+ for (String k : keys) {
+ if ((k).startsWith(key)) {
+ super.remove(k);
+ }
+ }
+ }
+
+ /**
+ * {@inheritDoc}
+ *
+ * @see org.apache.sling.commons.cache.api.Cache#list()
+ */
+ public Collection<V> values() {
+ return super.values();
+ }
+
+ public Collection<String> keys() {
+ return super.keySet();
+ }
+
+}
diff --git a/src/main/java/org/apache/sling/commons/cache/impl/MapDeligate.java b/src/main/java/org/apache/sling/commons/cache/impl/MapDeligate.java
new file mode 100644
index 0000000..a54b030
--- /dev/null
+++ b/src/main/java/org/apache/sling/commons/cache/impl/MapDeligate.java
@@ -0,0 +1,87 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+package org.apache.sling.commons.cache.impl;
+
+import java.util.Collection;
+import java.util.Map;
+import java.util.Set;
+
+import org.apache.sling.commons.cache.api.Cache;
+
+public class MapDeligate<K, V> implements Map<K, V> {
+
+ private Cache<V> cache;
+
+ public MapDeligate(Cache<V> cache) {
+ this.cache = cache;
+ }
+
+ public void clear() {
+ cache.clear();
+ }
+
+ public boolean containsKey(Object key) {
+ return cache.containsKey((java.lang.String) key);
+ }
+
+ public boolean containsValue(Object value) {
+ throw new UnsupportedOperationException("This map is lookup only.");
+ }
+
+ public Set<Entry<K, V>> entrySet() {
+ throw new UnsupportedOperationException("This map is lookup only.");
+ }
+
+ public V get(Object key) {
+ return cache.get((String) key);
+ }
+
+ public boolean isEmpty() {
+ return false;
+ }
+
+ public Set<K> keySet() {
+ throw new UnsupportedOperationException("This map is lookup only.");
+ }
+
+ public V put(K key, V value) {
+ return cache.put((String) key, value);
+ }
+
+ public void putAll(Map<? extends K, ? extends V> m) {
+ throw new UnsupportedOperationException(
+ "This map is singly add only, use an iterator or loop.");
+ }
+
+ public int size() {
+ throw new UnsupportedOperationException("This map is lookup only.");
+ }
+
+ public V remove(Object key) {
+ V value = cache.get((String) key);
+ cache.remove((String) key);
+ return value;
+ }
+
+ public Collection<V> values() {
+ throw new UnsupportedOperationException("This map is lookup only.");
+ }
+
+}
diff --git a/src/main/java/org/apache/sling/commons/cache/impl/ThreadLocalCacheMap.java b/src/main/java/org/apache/sling/commons/cache/impl/ThreadLocalCacheMap.java
new file mode 100644
index 0000000..8d70c77
--- /dev/null
+++ b/src/main/java/org/apache/sling/commons/cache/impl/ThreadLocalCacheMap.java
@@ -0,0 +1,43 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+package org.apache.sling.commons.cache.impl;
+
+import java.util.HashMap;
+import java.util.Map;
+
+import org.apache.sling.commons.cache.api.Cache;
+
+/**
+ * Represents a Cache stored on the thread, used in the request thread and in
+ * other threads. When used in Threads there is a potential for memory leaks as
+ * perm space is not cleaned up. This will be caused by references to
+ * classloaders being in the Map, and keeping the classloaders open.
+ */
+public class ThreadLocalCacheMap extends ThreadLocal<Map<String, Cache<?>>> {
+ /**
+ * {@inheritDoc}
+ *
+ * @see java.lang.ThreadLocal#initialValue()
+ */
+ @Override
+ protected Map<String, Cache<?>> initialValue() {
+ return new HashMap<String, Cache<?>>();
+ }
+}
