C2mon Cache Refactoring.Pdf

C2mon Cache refactoring

issue-39 1. What is caching? Agenda 2. JCache overview 3. Providers overview 4. C2MON Cache What is caching? What is caching?

Cache: A high-performance, low-latency datastructure in which an application places a temporary copy of information that is likely to be used more than once Beneﬁts of using cache

● Performance ● Scale up – get the most out of one machine ● Scale out – add more capacity with more machines ● Usually very fast and easy to apply When to use caching ● When applications use the same data more than once ● When cost (time / resources) of making an initial copy is lower than fetching or producing the data again or when it isfaster to request from a Cache JCache overview What is JCache?

● A common mechanism for performing CRUD operations from Caches

● Provides core caching concepts and API

● Provides application portability between various Caching solutions JCache: Main features ● Read/Write Integration support ● Cache Event Listeners ● Type-safety - fully generic ConcurrentMap like API ● Statistics ● Store-By-Value/Store-By-Reference ● Annotations support ● Support for local and distributed caching ● Topology Agnostic - Topologies not deﬁned or restricted by the speciﬁcation Store-By-Value and Store-By-Reference

JSR-107 storing mechanisms:

● Store-By-Reference (optional)

Object key = ... Object value = ... cache.put(key, value); assert cache.get(key) == value; assert cache.iterator().next().getKey() == key;

● Store-By-Value(default) Method Default Consistency

boolean containsKey(K key) last value

Cache Consistency V get(K key) happen-before

Consistency refers to the behavior of V getAndPut(K key, V value) happen-before caches and the guarantees that exist when concurrent cache mutation occur Iterator> last value iterator() together with the visibility of the mutations when multiple threads are void put(K key, V value) happen-before accessing a cache. boolean putIfAbsent(K key, V happen-before plus compare and value) swap An implementation may provide support for diﬀerent consistency boolean remove(K key) happen-before plus compare and swap models in addition to the required Default Consistency model. T invoke(K key, happen-before EntryProcessor entryProcessor, Object... arguments); Cache Topologies Embedded approach Client/Server approach Cache Types

replicated cache partitioned cache JCache Core interfaces JCache API CacheManager

● Conﬁgures and manages named Caches ○ caches may be created dynamically or predeﬁned ● provides Cache infrastructure ● provides Cache scopes(for clusters) ● provides important for Store-By-Value Cache ClassLoaders ● Provides Cache lifecycle management Cache

A Cache is a Map-like data-structure that permits the temporary storage of Key-based Values, some what like java.util.Map data-structure. A Cache is owned by a single CacheManager. Entry

An Entry is a single key-value pair stored by a Cache. ExpiryPolicy ● Eternal – Cache entries will never expire. ● Access – Cache entries will expire if they have not been accessed within a configured time interval. ● Creation – Cache entries will expire after a configured time interval from when they were added to the cache. ● Update – Cache entries will expire if they have not been modified within a configured time interval. JCache Runtime Structure JCache API example

● if Cache already exists, or it’s configured in XML:

CachingProvider provider = Caching.getCachingProvider(); CacheManager manager = provider.getCacheManager();

Cache personCache = manager.getCache(“personCache”, Long.class, Person.class); personCache.put(1L, new Person()); Person person = personCache.get(1L);

● if Cache doesn’t exist and we want to configure it programmatically:

CacheManager cacheManager = Caching.getCachingProvider().getCacheManager(); MutableConfiguration config = new MutableConfiguration<>(); config.setTypes(Long.class, Person.class); config.setStoreByValue(true); // value is serialized cacheManager.createCache("personCache", config); Atomic Operations: EntryProcessor

● allows develop Lock-Free API ● eliminates round-trips in distributed systems ● Needs Serialization (if distributed) “An invocable function that allows applications to perform compound operations on a Cache.Entry atomically, according the deﬁned* consistency of a Cache. Any Cache.Entry mutations will not take eﬀect until after the EntryProcessor.process(MutableEntry, Object...) method has completed execution. Implementations may execute EntryProcessor}s in situ, thus avoiding locking, round-trips and expensive network transfers.”

JCache specification EntryProcessor usage example

String name = “Foo”; cache.invoke(K key, (entry, arguments) -> { V value = entry.getValue(); value.setName(name); entry.setValue(value); return null; });

public class CustomEntryProcessor implements EntryProcessor { @Override public T process(MutableEntry entry, Object... arguments) throws EntryProcessorException { V value = entry.getValue(); value.setName(arguments[0]); entry.setValue(value); return null; } }

// Usage cache.invoke(K key, new CustomEntryProcessor(), T… arguments); Cache Annotations The JCache covers the most common cache operations:

● @CacheDefaults ● @CacheKey ● @CacheResult ● @CacheValue ● @CachePut ● @CacheRemove ● @CacheRemoveAll JCache annotations example

@CacheDefaults(cacheName = “personCache”) public class PersonRepository {

@CachePut public void put(@CacheKey Long id, @CacheValue Person person) {...}

@CacheResult public Person get(@CacheKey Long id) { Person person = // get object from DB return person; }

@CacheRemove public void invalidate(@CacheKey Long id) {}

@CacheRemoveAll public void invalidateAll() {} } JCache supporting frameworks Cache Providers with JCache Support

● Ehcache

● Hazelcast

● Ignite

● Coherence

● Inﬁnispan Ehcache

● Terracotta as one of the companies supporting actively JSR107 ● Full JSR107 support ● Flexible ● Scalable ● minimal dependencies ● Open Source Licensing - Apache 2.0 license Hazelcast

Full TCK Compliant implementation for:

● Embedded Members

● Very fast and highly scalable

JCache Implementation

● Dead simple

● Near Cache support Apache Ignite

● Near Cache support

● fully JCache TCK compliant

● Distributed Queries

● Apache 2 license

● Web Console

● Docker&Kubernetes support C2MON use case evaluation Exisitng C2MON Cache module Runs on Ehcache + Terracotta

Ehcache dependent

Cluster based on Terracotta(license required)

Limited amount of clients

Forced Store-By-Value very complex clustered locking system Goals

Support for JCache standard Easier cluster-locking mechanism

Fully Open Source No limitations on cache clients

Clusterable eventual replacement for JMS messaging Support of jUnit tests Nice to have: Continuous query Auto detections of nodes in the cluster Summary + lesson learned

JCache vs vendor speciﬁc features

Which is my favoured cache?

Best documentation, material, resources C2mon Cache Motivations

● Simplifying codebase ● Responsibility Separation ● Provider independency SOC & SRP

● removal of heavy Facades ● introduction of single responsibility services, grouped by operations ● easier to use speciﬁed services Existing modules

cache-dbaccess cache-loading cache cache-persistence Existing modules

cache-dbaccess cache-loading cache cache-persistence

This module is responsible for connecting to database using MyBatis for mapping models Existing modules

cache-dbaccess cache-loading cache cache-persistence

Here DAO objects are created and all Cache loaders are initialized.

Basic interfaces:

● C2monCacheLoader ● SimpleCacheLoader Existing modules

cache-dbaccess cache-loading cache cache-persistence

Main module for cache operations. Provides functionality for caching as well as for data manipulating and C2MON logic for tags.

All caches have three related classes: Conﬁguration, Cache and Facade. Cache structure

On AlarmCache example

<> <> <> AlarmCache C2monCacheWithListeners C2monCache

AlarmCacheImpl

AbstractCache BasicCache Facade structure

On AlarmCache example

<> AlarmFacade

<> AlarmFacadeImpl ConfigurableCacheFacade

AbstractFacade Existing modules

cache-dbaccess cache-loading cache cache-persistence

Responsible for storing the data into database. Modules restructuration

cache-loader