distributionUrl=https\://services.gradle.org/distributions/gradle-2.3-all.zip

apply plugin: 'groovy'

apply plugin: 'java'

repositories {

maven { url "https://jitpack.io" }

}

description = 'micro-elasticache'

dependencies {

compile group: 'com.amazonaws', name: 'aws-java-sdk-elasticache', version: '1.10.42'

compile project(':micro-core')

compile project(':micro-guava')

testCompile group: 'org.codehaus.groovy', name: 'groovy-all', version:'2.3.3'

testCompile(group: 'org.spockframework', name: 'spock-core', version:'0.7-groovy-2.0') { exclude(module: 'groovy-all') }

testCompile group: 'com.cyrusinnovation', name: 'mockito-groovy-support', version:'1.3'

testCompile 'cglib:cglib-nodep:2.2'

testCompile group: 'org.hamcrest', name: 'hamcrest-all', version:hamcrestVersion

testCompile project(':micro-grizzly-with-jersey')

}

sourceSets {

main {

java { srcDirs = ['src/main/java']}

resources { srcDir 'src/main/resources' }

}

test {

java { srcDirs = []}

groovy { srcDirs = ['src/test/java'] }

resources { srcDir 'src/test/resources' }

}

}

modifyPom {

project {

name 'Microserver elasticache'

description 'Opinionated rest microservices'

url 'https://github.com/aol/micro-server'

inceptionYear '2015'

groupId 'com.aol.microservices'

artifactId 'micro-elasticache'

version "$version"

scm {

url 'scm:git@github.com:aol/micro-server.git'

connection 'scm:git@github.com:aol/micro-server.git'

developerConnection 'scm:git@github.com:aol/micro-server.git'

}

licenses {

license {

name 'The Apache Software License, Version 2.0'

url 'http://www.apache.org/licenses/LICENSE-2.0.txt'

distribution 'repo'

}

}

developers {

developer {

id 'johnmcclean-aol'

name 'John McClean'

email 'john.mcclean@teamaol.com'

}

developer {

id 'morrowgi'

name 'Gordon Morrow'

email 'gordon.morrow@teamaol.com'

}

}

}

}

extraArchive {

sources = true

tests = true

javadoc = true

}

nexus {

sign = true

repositoryUrl = 'https://oss.sonatype.org/service/local/staging/deploy/maven2'

snapshotRepositoryUrl = 'https://oss.sonatype.org/content/repositories/snapshots'

}

[micro-elasticache example apps](https://github.com/aol/micro-server/tree/master/micro-elasticache/src/test/java/app)

Basically Available Soft statE

* Simple Couchbase Client (Couchbase bucket as distributed / persistent map)

* Manifest comparator : Versioned key for loading refreshed state

Manifest comparison stores a manifest along with each value. The manifest contains the version for the value, if the version has changed, the latest verson of the value will be loaded.

key : manifest [contains version info]

versionedKey : key with version

This allows large immutable datastructures to be stored in as a key/value pair (with separate key/value pairing for version info), and reloaded automatically on change.

Inject the Spring bean created by micro-couchbase ManifestComparator into your own beans. Customise the key used (allows multiple ManifestComparators to be used)

public class ManifestComparatorResource {

private final ManifestComparator<String> comparator;

@Autowired

public ManifestComparatorResource(ManifestComparator comparator) {

this.comparator = comparator.<String>withKey("test-key");

}

```

## Create a scheduled job

See micro-events, for Microserver help in managing scheduled jobs.

Create a scheduled job to check the manifest for changes & automatically reload data when stale.

In the example below we run the versioned key cleaner once per day, and check for changes every minute.

```java

public class DataLoader implements ScheduledJob<Job>{

private final ManifestComparator<String> comparator;

@Autowired

public DataLoader(ManifestComparator comparator) {

this.comparator = comparator.<String>withKey("test-key");

}

@Override

public SystemData<String,String> scheduleAndLog() {

try{

boolean changed = comparator.isOutOfDate();

comparator.load();

return SystemData.<String,String>builder().errors(0).processed(isOutOfDate?1:0).build();

}catch(Exception e){

return SystemData.<String,String>builder().errors(1).processed(0).build();

}

}

}

public class DataCleaner implements ScheduledJob<Job>{

private final ManifestComparator<String> comparator;

@Autowired

public DataCleaner(ManifestComparator comparator) {

this.comparator = comparator.<String>withKey("test-key");

}

@Override

public SystemData<String,String> scheduleAndLog() {

try{

comparator.cleanAll();

return SystemData.<String,String>builder().errors(0).processed(1).build();

}catch(Exception e){

return SystemData.<String,String>builder().errors(1).processed(0).build();

}

}

}

public class Schedular{

private final DataCleaner cleaner;

private final DataLoader loader;

public Schedular(DataCleaner cleaner,DataLoader loader){

this.cleaner = cleaner;

this.loader = loader;

}

@Scheduled(cron = "0 1 1 * * ?")

public synchronized void scheduleCleaner(){

cleaner.scheduleAndLog();

}

@Scheduled(cron = "0 * * * * *")

public synchronized void scheduleLoader(){

loader.scheduleAndLog();

}

}

```

Elsewhere a single writer service can write data to the store for all services of a type to load. See micro-mysql or micro-curator for a DistributedLock implementation

e.g.

```java

@Component

public class DataWriter {

private final DistributedLockService lockService;

private final ManifestComparator<String> comparator;

@Autowired

public DataWriter(DistributedLockService lockService,ManifestComparator comparator) {

this.lockService = lockService;

this.comparator = comparator.<String>withKey("test-key");

}

public void write(Supplier<String> data){

if(lockService.tryLock("single-writer-lock-a") {

comparator.saveAndIncrement(data.get());

}

}

}

```

## Configurable properties

Key used to store data used by the configured ManfiestComparator in Couchbase (default is default-key)

couchbase.manifest.comparison.key=default-key

Comma separate list of Couchbase servers

couchbaseServers=

Couchbase bucket (default is couchbase_bucket) to store / read data in

couchbaseBucket=couchbase_bucket

Couchbase password

couchbasePassword=

Switch off Couchbase enabled / disabled

couchbaseClientEnabled:true

Couchbase client operation

couchbaseClientOperationTimeout:120000

## Getting The Microserver Couchbase Plugin

[](https://maven-badges.herokuapp.com/maven-central/com.aol.microservices/micro-couchbase)

### Maven

```xml

<dependency>

<groupId>com.aol.microservices</groupId>

<artifactId>micro-couchbase</artifactId>

<version>x.yz</version>

</dependency>

```

### Gradle

```groovy

compile 'com.aol.microservices:micro-couchbase:x.yz'

```

package com.aol.micro.server.elasticache;

import org.springframework.scheduling.annotation.Async;

import java.util.Optional;

import java.util.concurrent.Future;

public interface CacheService {

@Async("distributedCacheTaskExecutor")

public abstract Future<Boolean> put(String key, Object o);

public abstract Optional<Object> get(String key);

public abstract boolean isAvailable();

}

package com.aol.micro.server.elasticache;

import lombok.extern.slf4j.Slf4j;

import net.spy.memcached.*;

import java.io.IOException;

import java.net.URISyntaxException;

import java.util.ArrayList;

import net.spy.memcached.auth.AuthDescriptor;

import net.spy.memcached.auth.PlainCallbackHandler;

import net.spy.memcached.MemcachedClient;

import org.springframework.beans.factory.annotation.Value;

import org.springframework.context.annotation.Bean;

import org.springframework.context.annotation.Configuration;

import org.springframework.util.StringUtils;

import java.net.InetSocketAddress;

import java.util.List;

import java.util.Optional;

public class ConfigureElasticache {

private ClientMode mode = ClientMode.Dynamic;

@Value("${elasticache.hostname:lana-staging-ec.6o3auf.cfg.use1.cache.amazonaws.com")

private String hostname = "lana-staging-ec.6o3auf.cfg.use1.cache.amazonaws.com";

@Value("${elasticache.port:6379")

private int port = 6379;

@Value("${elasticache.retries:3")

private int retries = 3;

@Value("${elastiache.retry.after.seconds:1")

private int retryAfterSeconds = 1;

private MemcachedClient cache;

InetSocketAddress socketAddress = new InetSocketAddress(hostname, port);

@Bean(name = "elasticacheClient")

public TransientElasticacheDataConnection transientCache() throws IOException, URISyntaxException {

log.info("Creating MemcacheClient for servers: {}", hostname);

return new TransientElasticacheDataConnection(createMemcachedClient(socketAddress), retries, retryAfterSeconds);

}

private MemcachedClient createMemcachedClient(InetSocketAddress socketAddress) throws IOException {

try {

return new MemcachedClient(socketAddress);

} catch (IOException e) {

e.printStackTrace();

return null;

}

}

}

package com.aol.micro.server.elasticache;

import java.util.Optional;

public interface DistributedCacheManager<V> {

void setConnectionTested(boolean result);

boolean isAvailable();

boolean put(String key, int exp, V value);

Optional<V> get(String key);

}

package com.aol.micro.server.elasticache;

import com.aol.cyclops.data.collections.extensions.persistent.PSetX;

import com.aol.micro.server.Plugin;

public class ElasticachePlugin implements Plugin {

public PSetX<Class> springClasses() {

return PSetX.of(ConfigureElasticache.class);

}

}