Merge branch 'develop' of https://github.com/Fork-World/rapidpm-binarycache into develop

# Conflicts:
#	README.md
#	bom/pom.xml
#	modules/app/cache/provider/hazelcast/src/test/java/junit/org/rapidpm/binarycache/provider/hazelcast/v001/HazelcastCacheImplTest001.java
#	modules/app/cache/provider/hazelcast/src/test/java/junit/org/rapidpm/binarycache/provider/hazelcast/v002/HazelcastCacheImplTest002.java
#	modules/client/connect/rest/src/main/java/org/rapidpm/binarycache/client/connect/rest/BinaryCacheRestClient.java
#	pom.xml

Author: svenruppert

.gitignore

@@ -130,3 +130,4 @@ local.properties
 # TeXlipse plugin
 .texlipse
 
+/modules/app/cache/provider/jcs/jcs_swap/

README.md

@@ -1,10 +1,62 @@
-# INfos
+# BinaryCache
 
-## UI Tests with Testbench
-Read the documentation on the Vaadin site: [Vaadin Testbench](https://vaadin.com/docs/-/part/testbench/testbench-overview.html)
+## Overview
+ - RapidPM Microservice
+ - Different JCache implementations, e.g. EHCache or Hazelcast Cache
+ - Inmemory interface for direct access to the cache functionality 
+ - REST endpoints for access via http
+ 
+## JCache?
+Here's a very good article from Matti Tahvonen telling you more about the JSR 107: [JCache, why and how?](https://vaadin.com/blog/-/blogs/jcache-why-and-how-)
 
-Install the Browser dependend driver
- * Chrome [https://sites.google.com/a/chromium.org/chromedriver/downloads](https://sites.google.com/a/chromium.org/chromedriver/downloads)
- * Firefox
- * PhantomJS
+## Build your own cache
+This project comes with an so called **aggregate** module, enabling the configuration of the cache components 
+by using Maven profiles. By default, the aggregate will produce a jar containing the ehcache and a corresponding REST endpoint to the cache. 
+Here's an example how to produce a cache with REST and Hazelcast:
+1. Disable the default profile **binarycache-provider-ehcache**
+2. Enable the profile **binarycache-proivder-hazelcast**
+3. Check that the **binarycache-connect-rest** profile is still active
+4. Execute a clean&install for the **aggregate** module  
+5. You'll find a customized jar cache-hazelcast-rest-xxx.jar in the modules target folder
 
+## Interfaces
+Currently there are two different ways to access the cache from a clients perspective.
+First, you can use the provided **inmemory** interface. Just add the following dependency to your Maven project.
+You'll find an example how to use it in the module **rapidpm-binarycache-modules-client-connect-inmemory** 
+
+```xml
+  <dependency>
+    <groupId>org.rapidpm.binarycache</groupId>
+     <artifactId>rapidpm-binarycache-modules-app-cache-api</artifactId>
+     <version>...</version>
+   </dependency>
+```
+
+Second, you could also use the **REST enpoints**, provided by the BinaryCache implementation. 
+Using the BinaryCacheRestClient, your calls will be transformed into http request to the cache.
+Add the following dependency to use it in your project.
+
+```xml
+  <dependency>
+    <groupId>org.rapidpm.binarycache</groupId>
+     <artifactId>rapidpm-binarycache-modules-client-connect-rest</artifactId>
+     <version>...</version>
+   </dependency>
+```
+ 
+## Provider
+
+### Ehcache
+From the website [ehcache.org](http://www.ehcache.org/):  
+*"Ehcache is an open source, standards-based cache that boosts performance, offloads your database, and simplifies scalability. It's the most widely-used Java-based cache because it's robust, proven, full-featured, and integrates with other popular libraries and frameworks. Ehcache scales from in-process caching, all the way to mixed in-process/out-of-process deployments with terabyte-sized caches."*
+  
+You'll find a default configuration XML in the resource folder config. To use a different configuration file set path to this file with the property **binarcache.config**. [Link]((http://www.ehcache.org/documentation/3.0/xml.html)) to the documentation about configuration files.
+
+
+### Hazelcast
+The implementation of the JSR 107 (JCache) from Hazelcast offers a distribution of the cache content other several instances, based on Hazelcast's own in-mmeory data grid solution. See [Hazelcast Cache](https://hazelcast.com/use-cases/caching/jcache-provider/) for more information.
+
+### Other possible providers
+- Infinispan
+- Apache Ignite
+- JCS

aggregate/pom.xml

@@ -12,6 +12,14 @@
 
   <artifactId>rapidpm-binarycache-aggregate</artifactId>
 
+  <dependencies>
+    <dependency>
+      <groupId>org.rapidpm.microservice</groupId>
+      <artifactId>rapidpm-microservice-modules-core</artifactId>
+      <version>0.8.1-SNAPSHOT</version>
+    </dependency>
+  </dependencies>
+
   <build>
     <finalName>cache-${provider}-${connect}-${project.version}</finalName>
     <plugins>

bom/pom.xml

@@ -14,8 +14,8 @@
   <packaging>pom</packaging>
 
   <properties>
-    <rapidpm.version>0.9.0</rapidpm.version>
-    <vaadin.version>8.1.4</vaadin.version>
+    <rapidpm.version>0.8.1</rapidpm.version>
+    <vaadin.version>8.0.5</vaadin.version>
     <vaadin-testbench-api.version>5.0.0</vaadin-testbench-api.version>
   </properties>
 

modules/app/cache/api/src/test/java/junit/org/rapidpm/binarycache/api/CacheKeyTest001.java

@@ -0,0 +1,50 @@
+package junit.org.rapidpm.binarycache.api;
+
+import org.junit.Test;
+import org.rapidpm.binarycache.api.CacheKey;
+
+import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.assertNull;
+
+/**
+ * Copyright (C) 2010 RapidPM
+ * Licensed 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.
+ * <p>
+ * Created by m.lang - RapidPM - Team on 04.05.2017.
+ */
+public class CacheKeyTest001 {
+
+  @Test
+  public void test001() throws Exception {
+    assertNotNull(ValidatingKey.getInstance("1_d"));
+    assertNull(ValidatingKey.getInstance("d_1"));
+    assertNull(ValidatingKey.getInstance(""));
+  }
+}
+
+class ValidatingKey implements CacheKey {
+
+  private String key;
+
+  private ValidatingKey(String key) {
+    this.key = key;
+  }
+
+  public static CacheKey getInstance(String key) {
+    return key.matches("\\d+_\\w+") ? new ValidatingKey(key) : null;
+  }
+
+  @Override
+  public String keyAsString() {
+    return this.key;
+  }
+}
+

modules/app/cache/connect/rest/src/test/java/junit/org/rapidpm/binarycache/connect/rest/util/ByteUtilsTest.java

@@ -0,0 +1,34 @@
+package junit.org.rapidpm.binarycache.connect.rest.util;
+
+import org.junit.Test;
+import org.rapidpm.binarycache.connect.rest.util.ByteUtils;
+
+import static org.junit.Assert.assertEquals;
+
+/**
+ * Copyright (C) 2010 RapidPM
+ * Licensed 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.
+ * <p>
+ * Created by m.lang - RapidPM - Team on 12.07.2017.
+ */
+public class ByteUtilsTest {
+
+  @Test
+  public void test001() throws Exception {
+    final byte[] testByteArray = "testByteArray".getBytes();
+    final Byte[] nonPrimitive = ByteUtils.fromPrimitive(testByteArray);
+    assertEquals(nonPrimitive.length, testByteArray.length);
+
+    final byte[] primitive = ByteUtils.toPrimitive(nonPrimitive);
+    assertEquals(primitive.length, testByteArray.length);
+    assertEquals("testByteArray", new String(primitive));
+  }
+}

modules/app/cache/connect/rest/src/test/java/junit/org/rapidpm/binarycache/connect/rest/v007/BinaryCacheRestClientTest007.java

@@ -0,0 +1,57 @@
+package junit.org.rapidpm.binarycache.connect.rest.v007;
+
+import junit.org.rapidpm.binarycache.connect.rest.BaseBinaryCacheRestTest;
+import org.junit.Assert;
+import org.junit.Rule;
+import org.junit.Test;
+import org.junit.rules.TemporaryFolder;
+import org.rapidpm.binarycache.api.defaultkey.DefaultCacheKey;
+import org.rapidpm.binarycache.connect.rest.BinaryCacheRestClient;
+import org.rapidpm.ddi.DI;
+
+import javax.ws.rs.core.Response;
+import java.io.File;
+import java.io.FileInputStream;
+
+/**
+ * Copyright (C) 2010 RapidPM
+ * Licensed 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.
+ * <p>
+ * Created by m.lang - RapidPM - Team on 12.07.2017.
+ */
+public class BinaryCacheRestClientTest007 extends BaseBinaryCacheRestTest {
+
+  @Rule
+  public TemporaryFolder folder = new TemporaryFolder();
+
+  @Test
+  public void test001() throws Exception {
+    final BinaryCacheRestClient client = DI.activateDI(BinaryCacheRestClient.class);
+    final DefaultCacheKey key = new DefaultCacheKey("123");
+    final File file = folder.newFile();
+    final FileInputStream inputStream = new FileInputStream(file);
+    inputStream.close();
+    final Response response = client.cacheBinary("notThere", encodedKey(key), inputStream);
+    Assert.assertEquals(500, response.getStatus());
+  }
+
+  @Test
+  public void test002() throws Exception {
+    final BinaryCacheRestClient client = DI.activateDI(BinaryCacheRestClient.class);
+    final DefaultCacheKey key = new DefaultCacheKey("123");
+    final File file = folder.newFile();
+    final FileInputStream inputStream = new FileInputStream(file);
+    inputStream.close();
+    final Response response = client.cacheBinaryIfAbsent("notThere", encodedKey(key), inputStream);
+    Assert.assertEquals(500, response.getStatus());
+  }
+
+}

modules/app/cache/provider/ehcache/src/main/java/org/rapidpm/binarycache/provider/ehcache/EhCacheImpl.java

@@ -9,7 +9,13 @@
 import javax.annotation.PreDestroy;
 import javax.cache.Cache;
 import javax.cache.Caching;
+import javax.cache.configuration.Configuration;
+import javax.cache.configuration.MutableConfiguration;
+import javax.cache.expiry.AccessedExpiryPolicy;
+import javax.cache.expiry.Duration;
 import javax.cache.spi.CachingProvider;
+import java.io.File;
+import java.net.URI;
 import java.net.URISyntaxException;
 
 /**
@@ -28,23 +34,51 @@
  */
 public class EhCacheImpl implements BinaryCacheClient {
 
-  public static final String CONFIG_EHCACHE_XML = "/config/ehcache.xml";
+  public static final String CACHE_CONFIG_PROPERTY = "binarycache.config";
+  private static final String CONFIG_EHCACHE_XML = "/config/ehcache.xml";
   private javax.cache.CacheManager cacheManager;
 
   @PostConstruct
   public void init() throws URISyntaxException {
     final CachingProvider cachingProvider = Caching.getCachingProvider();
     cacheManager = cachingProvider.getCacheManager(
-        getClass().getResource(CONFIG_EHCACHE_XML).toURI(),
+        getUriToConfig(),
         getClass().getClassLoader()
     );
   }
 
+  private URI getUriToConfig() throws URISyntaxException {
+    final String property = System.getProperty(CACHE_CONFIG_PROPERTY);
+    URI uri;
+    if (property != null && !property.isEmpty()) {
+      uri = new File(property).toURI();
+    } else {
+      uri = getClass().getResource(CONFIG_EHCACHE_XML).toURI();
+    }
+    return uri;
+  }
+
   @PreDestroy
   public void destroy() {
     cacheManager.close();
   }
 
+  @Override
+  public Cache<CacheKey, CacheByteArray> createCache(String cacheName) {
+    MutableConfiguration<CacheKey, CacheByteArray> config
+        = new MutableConfiguration<CacheKey, CacheByteArray>()
+        .setTypes(CacheKey.class, CacheByteArray.class)
+        .setExpiryPolicyFactory(
+            AccessedExpiryPolicy.factoryOf(Duration.ONE_HOUR))
+        .setStatisticsEnabled(true);
+    return cacheManager.createCache(cacheName, config);
+  }
+
+  @Override
+  public Cache<CacheKey, CacheByteArray> createCache(String cacheName, Configuration<CacheKey, CacheByteArray> configuration) {
+    return cacheManager.createCache(cacheName, configuration);
+  }
+
   @Override
   public Cache<CacheKey, CacheByteArray> getCache(String cacheName) {
     return cacheManager.getCache(cacheName, CacheKey.class, CacheByteArray.class);
@@ -55,6 +89,4 @@ public Result removeEntry(String cacheName, CacheKey cacheKey) {
     return cacheManager.getCache(cacheName, CacheKey.class, CacheByteArray.class).remove(cacheKey) ? Result.OK : Result.FAILED;
   }
 
-
-
 }

modules/app/cache/provider/ehcache/src/main/resources/config/ehcache.xml

@@ -1,15 +1,17 @@
 <ehcache:config
-    xmlns:ehcache="http://www.ehcache.org/v3"
-    xmlns:jcache="http://www.ehcache.org/v3/jsr107">
+    xmlns:ehcache="http://www.ehcache.org/v3">
 
   <ehcache:cache alias="default" uses-template="defaultTemplate"/>
+  <ehcache:cache alias="myCache" uses-template="defaultTemplate"/>
 
   <ehcache:cache-template name="defaultTemplate">
     <ehcache:key-type>org.rapidpm.binarycache.api.CacheKey</ehcache:key-type>
     <ehcache:value-type>org.rapidpm.binarycache.api.CacheByteArray</ehcache:value-type>
     <ehcache:expiry>
-      <ehcache:tti unit="minutes">30</ehcache:tti>
+      <!-- tti=time to idle; ttl=time to live; -->
+      <ehcache:tti unit="hours">1</ehcache:tti>
     </ehcache:expiry>
+
     <ehcache:heap unit="entries">200</ehcache:heap>
   </ehcache:cache-template>