[[clustered_counters]]
= Clustered Counters

_Clustered counters_ are counters which are distributed and shared among all nodes in the {brandname} cluster.
Counters can have different consistency levels: strong and weak.

Although a strong/weak consistent counter has separate interfaces, both support updating its value,
return the current value and they provide events when its value is updated.
Details are provided below in this document to help you choose which one fits best your uses-case.

== Installation and Configuration

In order to start using the counters, you needs to add the dependency in your Maven `pom.xml` file:

.pom.xml
[source,xml,options="nowrap",subs=attributes+]
----
include::dependencies_maven/clustered_counters.xml[]
----

The counters can be configured {brandname} configuration file or on-demand via the `CounterManager` interface detailed
later in this document.
A counters configured in {brandname} configuration file is created at boot time when the `EmbeddedCacheManager` is starting.
Theses counters are started eagerly and they are available in all the cluster's nodes.

.configuration.xml
[source,xml,options="nowrap",subs=attributes+]
----
include::config_examples/clustered_counters_config.xml[]
----

or programmatically, in the `GlobalConfigurationBuilder`:

[source,java]
----
include::code_examples/ClusteredCounters.java[]
----

On other hand, the counters can be configured on-demand, at any time after the `EmbeddedCacheManager` is initialized.

[source,java]
----
include::code_examples/ClusteredCountersEmbeddedCacheManager.java[]
----

NOTE: `CounterConfiguration` is immutable and can be reused.

The method `defineCounter()` will return `true` if the counter is successful configured or `false` otherwise.
However, if the configuration is invalid, the method will throw a `CounterConfigurationException`.
To find out if a counter is already defined, use the method `isDefined()`.

[source,java]
----
include::code_examples/ClusteredCountersIsDefined.java[]
----

*Per cluster attributes:*

* `num-owners`: Sets the number of counter's copies to keep cluster-wide.
A smaller number will make update operations faster but will support a lower number of server crashes.
It *must be positive* and its default value is `2`.

* `reliability`: Sets the counter's update behavior in a network partition.
Default value is `AVAILABLE` and valid values are:

** `AVAILABLE`: all partitions are able to read and update the counter's value.
** `CONSISTENT`: only the primary partition (majority of nodes) will be able to read and update the counter's value.
The remaining partitions can only read its value.

*Per counter attributes:*

* `initial-value` [common]: Sets the counter's initial value.
Default is `0` (zero).

* `storage` [common]: Sets the counter's behavior when the cluster is shutdown and restarted.
Default value is ``VOLATILE`` and valid values are:
** `VOLATILE`: the counter's value is only available in memory.
The value will be lost when a cluster is shutdown.
** `PERSISTENT`: the counter's value is stored in a private and local persistent store.
The value is kept when the cluster is shutdown and restored after a restart.

NOTE: On-demand and `VOLATILE` counters will lose its value and configuration after a cluster shutdown.
They must be defined again after the restart.

* `lower-bound` [strong]: Sets the strong consistent counter's lower bound.
Default value is `Long.MIN_VALUE`.

* `upper-bound` [strong]: Sets the strong consistent counter's upper bound.
Default value is `Long.MAX_VALUE`.

NOTE: If neither the `lower-bound` or `upper-bound` are configured, the strong counter is set as unbounded.

WARNING: The `initial-value` must be between `lower-bound` and `upper-bound` inclusive.

* `concurrency-level` [weak]: Sets the number of concurrent updates.
Its value *must be positive* and the default value is `16`.

=== List counter names

To list all the counters defined, the method `CounterManager.getCounterNames()` returns a collection of all counter
names created cluster-wide.

== The `CounterManager` interface.

The `CounterManager` interface is the entry point to define, retrieve and remove a counter.
It automatically listen to the creation of `EmbeddedCacheManager` and proceeds with the registration  of an
instance of it per `EmbeddedCacheManager`.
It starts the caches needed to store the counter state and configures the default counters.

Retrieving the `CounterManager` is as simple as invoke the
`EmbeddedCounterManagerFactory.asCounterManager(EmbeddedCacheManager)`
as shown in the example below:

[source,java]
----
include::code_examples/CounterManagerEmbedded.java[]
----

For Hot Rod client, the `CounterManager` is registered in the RemoteCacheManager and it can be retrieved like:

[source,java]
----
include::code_examples/CounterManagerRemote.java[]
----

=== Remove a counter via CounterManager

WARNING: use with caution.

There is a difference between remove a counter via the `Strong/WeakCounter` interfaces and the `CounterManager`.
The `CounterManager.remove(String)` removes the counter value from the cluster and removes all the listeners registered
in the counter in the local counter instance.
In addition, the counter instance is no longer reusable and it may return an invalid results.

On the other side, the `Strong/WeakCounter` removal only removes the counter value.
The instance can still be reused and the listeners still works.

NOTE: The counter is re-created if it is accessed after a removal.

== The Counter

A counter can be strong (`StrongCounter`) or weakly consistent (``WeakCounter``) and both is identified by a name.
They have a specific interface but they share some logic, namely, both of them are asynchronous
( a `CompletableFuture` is returned by each operation), provide an update event and can be reset to its initial value.

If you don't want to use the async API, it is possible to return a synchronous counter via `sync()` method.
The API is the same but without the `CompletableFuture` return value.

The following methods are common to both interfaces:

[source,java]
----
include::code_examples/CounterSync.java[]
----

* `getName()` returns the counter name (identifier).
* `getValue()` returns the current counter's value.
* `reset()` allows to reset the counter's value to its initial value.
* `addListener()` register a listener to receive update events.
More details about it in the link:#clustered_counters_notify_events[Notification and Events] section.
* `getConfiguration()` returns the configuration used by the counter.
* `remove()` removes the counter value from the cluster. The instance can still be used and the listeners are kept.
* `sync()` creates a synchronous counter.

NOTE: The counter is re-created if it is accessed after a removal.

=== The `StrongCounter` interface: when the consistency or bounds matters.

The strong counter provides uses a single key stored in {brandname} cache to provide the consistency needed.
All the updates are performed under the key lock to updates its values.
On other hand, the reads don't acquire any locks and reads the current value.
Also, with this scheme, it allows to bound the counter value and provide atomic operations like compare-and-set/swap.

A `StrongCounter` can be retrieved from the `CounterManager` by using the `getStrongCounter()` method.
As an example:

[source,java]
----
include::code_examples/CounterGetStrong.java[]
----

WARNING: Since every operation will hit a single key, the `StrongCounter` has a higher contention rate.

The `StrongCounter` interface adds the following method:

[source,java]
----
include::code_examples/CounterStrongMethod.java[]
----

* `incrementAndGet()` increments the counter by one and returns the new value.
* `decrementAndGet()` decrements the counter by one and returns the new value.
* `addAndGet()` adds a delta to the counter's value and returns the new value.
* `compareAndSet()` and `compareAndSwap()` atomically set the counter's value if the current value is the expected.

NOTE: A operation is considered completed when the ``CompletableFuture`` is completed.

NOTE: The difference between compare-and-set and compare-and-swap is that the former returns true if the operation succeeds
while the later returns the previous value.
The compare-and-swap is successful if the return value is the same as the expected.

==== Bounded `StrongCounter`

When bounded, all the update method above will throw a ``CounterOutOfBoundsException`` when they reached the
lower or upper bound.
The exception has the following methods to check which side bound has been reached:

[source,java]
----
public boolean isUpperBoundReached();
public boolean isLowerBoundReached();
----

==== Uses cases

The strong counter fits better in the following uses cases:

* When counter's value is needed after each update (example, cluster-wise ids generator or sequences)
* When a bounded counter is needed (example, rate limiter)

==== Usage Examples

[source,java]
----
include::code_examples/CounterGetStrongUnbounded.java[]
----

And below, there is another example using a bounded counter:

[source,java]
----
include::code_examples/CounterGetStrongBounded.java[]
----

Compare-and-set vs Compare-and-swap examples:

[source,java]
----
include::code_examples/CounterGetStrongCompareSet.java[]
----

With compare-and-swap, it saves one invocation counter invocation (`counter.getValue()`)

[source,java]
----
include::code_examples/CounterGetStrongCompareSwap.java[]
----

=== The `WeakCounter` interface: when speed is needed

The `WeakCounter` stores the counter's value in multiple keys in {brandname} cache.
The number of keys created is configured by the `concurrency-level` attribute.
Each key stores a partial state of the counter's value and it can be updated concurrently.
It main advantage over the `StrongCounter` is the lower contention in the cache.
On other hand, the read of its value is more expensive and bounds are not allowed.

WARNING: The reset operation should be handled with caution.
It is *not* atomic and it produces intermediates values.
These value may be seen by a read operation and by any listener registered.

A `WeakCounter` can be retrieved from the `CounterManager` by using the `getWeakCounter()` method.
As an example:

[source,java]
----
include::code_examples/CounterGetWeak.java[]
----

==== Weak Counter Interface

The `WeakCounter` adds the following methods:

[source,java]
----
include::code_examples/CounterWeakMethod.java[]
----

They are similar to the `StrongCounter`'s methods but they don't return the new value.

==== Uses cases

The weak counter fits best in uses cases where the result of the update operation is not needed or the counter's value
is not required too often.
Collecting statistics is a good example of such an use case.

==== Examples

Below, there is an example of the weak counter usage.

[source,java]
----
include::code_examples/CounterWeakGetCounter.java[]
----

[[clustered_counters_notify_events]]
== Notifications and Events

Both strong and weak counter supports a listener to receive its updates events.
The listener must implement `CounterListener` and it can be registered by the following method:

[source,java]
----
include::code_examples/CounterListenerAdd.java[]
----

The `CounterListener` has the following interface:

[source,java]
----
include::code_examples/CounterListener.java[]
----

The `Handle` object returned has the main goal to remove the `CounterListener` when it is not longer needed.
Also, it allows to have access to the `CounterListener` instance that is it handling.
It has the following interface:

[source,java]
----
include::code_examples/CounterListenerHandle.java[]
----

Finally, the `CounterEvent` has the previous and current value and state.
It has the following interface:

[source,java]
----
include::code_examples/CounterEvent.java[]
----

NOTE: The state is always `State.VALID` for unbounded strong counter and weak counter.
`State.LOWER_BOUND_REACHED` and `State.UPPER_BOUND_REACHED` are only valid for bounded strong counters.

WARNING: The weak counter `reset()` operation will trigger multiple notification with intermediate values.
