The parent project which will house the various modules mentioned in the previous section is called hacep-integration. This parent project will do little more than orchestrate the dependencies of the inner modules and control packaging and various other maven commands. We start by initializing a new Maven Project in JBoss Developer Studio with the following information and hitting Finish:

Figure 5.2. Parent Pom Information

With the outlying parent project now present, we can edit the pom.xml file to lay out the project structure required. Begin by adding the modules, license, and properties to the pom file:

These sections define the child modules that will be included, the Apache license which the software will fall under, and various version variables we’ll need throughout the pom configuration. Next, add a default profile referencing the JBoss repositories previously mentioned:

Beneath the profiles, add the dependencyManagement and dependencies sections which will orchestrate child module dependency versions, inclusions, and Java EE API usage:

Lastly, define the build section responsible for configuring the maven plugins used:

This concludes the defining and configuring of the parent project itself. At this time, stub out the 4 child modules which we’ll be using inside the IDE. Rather than going through each inherent pom file of the child modules, please refer to the accompanying attachment hacep-integration folder and child module subfolders to locate and copy the contents of each pom file respectively.

This module, responsible for housing the shared POJO’s and other Java objects necessary within both the rules and main integration modules, consists of a skeleton beans.xml file (necessary for the triggering of CDI across the application) and only three other classes. Both the integration-model and integration-app modules will need a copy of this beans.xml file placed in the src/main/resources/META-INF directory, using the content below:

The other three classes within the integration-model module will fall into two packages:

The model package will contain two classes, Purchase and PurchaseKey, which will serve as the Event POJO fed to the HACEP nodes via the Event Channel and the Key which will be used in classifying the grouping of the events into relevant rules sessions and node ownerships. Define Purchase object as an object extending the Fact interface from within the HACEP core code as follows:

import it.redhat.hacep.model.Fact;
import it.redhat.hacep.model.Key;

import java.time.Instant;
import java.util.Date;
import java.util.Objects;

public class Purchase implements Fact {

    private static final long serialVersionUID = 7517352753296362943L;

    protected long id;

    protected Long customerId;

    protected Date timestamp;

    protected Double amount;

    public Purchase(long id, Long customerId, Date timestamp, Double amount) {
        this.id = id;
        this.customerId = customerId;
        this.timestamp = timestamp;
        this.amount = amount;
    }

    @Override
    public Instant getInstant() {
        return timestamp.toInstant();
    }

    @Override
    public Key extractKey() {
        return new PurchaseKey(String.valueOf(id), String.valueOf(customerId));
    }

    public long getId() {
        return id;
    }

    public void setId(long id) {
        this.id = id;
    }

    public Long getCustomerId() {
        return customerId;
    }

    public void setCustomerId(Long customerId) {
        this.customerId = customerId;
    }

    public Date getTimestamp() {
        return timestamp;
    }

    public void setTimestamp(Date timestamp) {
        this.timestamp = timestamp;
    }

    public Double getAmount() {
        return amount;
    }

    public void setAmount(Double amount) {
        this.amount = amount;
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (!(o instanceof Purchase)) return false;
        Purchase purchase = (Purchase) o;
        return id == purchase.id &&
                Objects.equals(customerId, purchase.customerId) &&
                Objects.equals(timestamp, purchase.timestamp) &&
                Objects.equals(amount, purchase.amount);
    }

    @Override
    public int hashCode() {
        return Objects.hash(id, customerId, timestamp, amount);
    }

    @Override
    public String toString() {
        return "Purchase{" +
                "id=" + id +
                ", customerId=" + customerId +
                ", timestamp=" + timestamp +
                ", amount=" + amount +
                '}';
    }
}

Now define the PurchaseKey as seen below:

import it.redhat.hacep.model.Key;

import java.util.Objects;

public class PurchaseKey extends Key<String> {

    private String id;

    public PurchaseKey(String id, String customer) {
        super(customer);
        this.id = id;
    }

    public String getId() {
        return id;
    }

    public String toString() {
        return id + "::" + getGroup();
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (!(o instanceof PurchaseKey)) return false;
        if (!super.equals(o)) return false;
        PurchaseKey purchaseKey = (PurchaseKey) o;
        return Objects.equals(id, purchaseKey.id);
    }

    @Override
    public int hashCode() {
        return Objects.hash(super.hashCode(), id);
    }
}

These two POJO’s make up the only shared model needed for our simple integration. Lastly, we’ll create a class called SysoutChannel in the channels package mentioned prior, which will serve as a pipeline for output from within rules sessions, which can be altered to conform to various logging needs. For our purposes, information sent to the sysout channel will simply be dumped to the console.

import org.kie.api.runtime.Channel;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

public class SysoutChannel implements Channel {

    public static final String CHANNEL_ID = "sysout";
    private static final Logger LOGGER = LoggerFactory.getLogger(SysoutChannel.class);

    @Override
    public void send(Object object) {
        if (LOGGER.isInfoEnabled()) {
            LOGGER.info("=============================>" + object);
        }
    }
}

These three classes plus the beans.xml and pom files which have been created above complete the integration-model module.

This module, like the integration-model module, is fairly simplistic and straight-forward. As with any BRMS integration, we’ll define a kmodule.xml in the META-INF directory which defines the rules and sessions to be used. We’ll also create two DRL rules files as well as one Java class containing a custom implementation of the rules accumulate function. Start by defining the two rules files in the src/main/resources/rules directory as follows:

package it.redhat.hacep.playground.rules.reward.catalog;

import com.redhat.refarch.hacep.model.Purchase;

import accumulate com.redhat.refarch.hacep.rules.functions.ConsecutiveDaysAccumulateFunction consecutivedays;

declare Purchase
    @role( event )
    @timestamp( timestamp.getTime() )
    @expires( 60d )
end

package it.redhat.hacep.playground.rules.reward.catalog;

import com.redhat.refarch.hacep.model.Purchase

rule "purchase seen"
when
    $purchase : Purchase ( )
then
    channels["sysout"].send("Purchase rec'd for customer " + $purchase.getCustomerId() + " for amt " + $purchase.getAmount());
end

rule "report multiple purchases by a customer over 30-day window"
when
    $purchase : Purchase ( $customerId : customerId ) over window:length(1)
    $purchaseCount : Number( intValue > 1 )
    				 from accumulate ($iter : Purchase ( $purchase.customerId == customerId ) over window:time( 30d ),
    				 count( $iter ) )
    $purchaseSum : Number( )
                     from accumulate ( Purchase ( $purchase.customerId == customerId, $purchaseAmount : amount ) over window:time( 30d ),
                     sum( $purchaseAmount ) )
then
	channels["sysout"].send("repeat customer " + $purchase.getCustomerId() + " has made " + $purchaseCount + " purchases over last 30 days for a sum of " + $purchaseSum);
end

Lastly, define the custom accumulate implementation in src/main/java under the com.redhat.refarch.hacep.rules.functions package as follows:

import org.kie.api.runtime.rule.AccumulateFunction;

import java.io.*;
import java.math.BigDecimal;
import java.math.RoundingMode;
import java.util.HashMap;
import java.util.Map;
import java.util.concurrent.TimeUnit;

public class ConsecutiveDaysAccumulateFunction implements AccumulateFunction {

    @Override
    public void accumulate(Serializable context, Object value) {
        ConsecutiveDaysBuckets buckets = (ConsecutiveDaysBuckets) context;
        int days = getDays(value);
        if (buckets.buckets.get(days) == null) {
            buckets.buckets.put(days, new Integer(1));
        } else {
            buckets.buckets.put(days, buckets.buckets.get(days) + 1);
        }
    }

    @Override
    public Serializable createContext() {
        return new ConsecutiveDaysBuckets();
    }

    @Override
    public Object getResult(Serializable context) throws Exception {
        ConsecutiveDaysBuckets buckets = (ConsecutiveDaysBuckets) context;
        return buckets.buckets.size();
    }

    @Override
    public void init(Serializable context) throws Exception {
        ConsecutiveDaysBuckets buckets = (ConsecutiveDaysBuckets) context;
        buckets.buckets = new HashMap<>();
    }

    @Override
    public void reverse(Serializable context, Object value) throws Exception {
        ConsecutiveDaysBuckets buckets = (ConsecutiveDaysBuckets) context;
        int days = getDays(value);
        if (buckets.buckets.get(days) == null) {
            //ignore, shouldn't happen
        } else if (buckets.buckets.get(days) == 1) {
            buckets.buckets.remove(days);
        } else {
            buckets.buckets.put(days, buckets.buckets.get(days) - 1);
        }
    }

    @Override
    public boolean supportsReverse() {
        return true;
    }

    @Override
    public void writeExternal(ObjectOutput out) throws IOException {
        // TODO Auto-generated method stub

    }

    @Override
    public void readExternal(ObjectInput in) throws IOException, ClassNotFoundException {
        // TODO Auto-generated method stub

    }

    @Override
    public Class<?> getResultType() {
        return Number.class;
    }

    public static class ConsecutiveDaysBuckets implements Externalizable {

        public Map<Integer, Integer> buckets;

        @Override
        public void writeExternal(ObjectOutput out) throws IOException {
            out.writeInt(buckets.size());
            for (int key : buckets.keySet()) {
                out.writeInt(key);
                out.writeInt(buckets.get(key));
            }
        }

        @Override
        public void readExternal(ObjectInput in) throws IOException, ClassNotFoundException {
            buckets = new HashMap<>();
            int size = in.readInt();
            for (int i = 0; i < size; i++) {
                buckets.put(in.readInt(), in.readInt());
            }
        }
    }

    private int getDays(Object value) {
        BigDecimal data = new BigDecimal(((Number) value).longValue());
        int days = data.divide(new BigDecimal(TimeUnit.DAYS.toMillis(1)), 2, RoundingMode.HALF_UP).intValue();
        return days;
    }
}

These 4 files described above make up the entirety of the integration-rules module. Feel free to cross-reference the source code within the accompanying attachment for both structure and content accuracy as required.

Next, define the classes within the helper module which will assist in create and submitting events to the HACEP-integrated application to simulate input from real use case scenarios. In a production system, such a tool wouldn’t be used outside of perhaps testing purposes, but it fulfills the need for event creation that will allow observation and adminstrating of the HACEP framework in real-time. Add the following two classes to the purchase-publisher module under src/main/java in the com.redhat.refarch.hacep.publisher package:

import com.redhat.refarch.hacep.model.Purchase;

import javax.jms.*;
import java.math.BigDecimal;
import java.math.RoundingMode;
import java.util.Date;
import java.util.concurrent.ThreadLocalRandom;

public class PurchaseProducer {

    private final Connection connection;
    private final Session session;

    private String queueName;
    private long customerId;
    ConnectionFactory connectionFactory;

    private static final Double PURCHASE_MIN = 10.0;
    private static final Double PURCHASE_MAX = 500.0;


    public PurchaseProducer(ConnectionFactory connectionFactory, String queueName, long customerId) {

        this.customerId = customerId;
        this.connectionFactory = connectionFactory;
        this.queueName = queueName;
        try {
            connection = connectionFactory.createConnection();
            session = connection.createSession(false, Session.AUTO_ACKNOWLEDGE);
        } catch (JMSException e) {
            throw new RuntimeException(e);
        }
    }

    public void produce(Integer id, Long timestamp) {

        try {

            Queue destination = session.createQueue(queueName);
            MessageProducer producer = session.createProducer(destination);
            producer.setDeliveryMode(DeliveryMode.NON_PERSISTENT);

            Purchase fact = new Purchase(id, customerId, new Date(timestamp),
                    round(ThreadLocalRandom.current().nextDouble(PURCHASE_MIN, PURCHASE_MAX)));

            System.out.println("sending purchase for customer " + customerId + " for amount of " + fact.getAmount());

            ObjectMessage message = session.createObjectMessage(fact);
            message.setStringProperty("JMSXGroupID", String.format("P%05d", customerId));
            message.setIntProperty("JMSXGroupSeq", id);

            producer.send(message);

        } catch (Exception e) {
            System.out.println("Caught: " + e);
        }
    }

    public static double round(double value) {
        BigDecimal bd = new BigDecimal(value);
        bd = bd.setScale(2, RoundingMode.HALF_UP);
        return bd.doubleValue();
    }
}

import org.apache.activemq.ActiveMQConnectionFactory;
import org.apache.activemq.pool.PooledConnectionFactory;

import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.ScheduledFuture;
import java.util.concurrent.TimeUnit;

public class Runner {

    private ScheduledExecutorService scheduler = null;

    private final String BROKER_URL = "failover:(tcp://amq1:61616,tcp://amq2:61616,tcp://amq3:61616)";
    private final String QUEUE_NAME = "facts";
    private final String BROKER_USERNAME = "admin";
    private final String BROKER_PASSWORD = "admin";

    private final Integer CONCURRENT_PURCHASERS = 5;
    private final Integer DURATION = 15;
    private final Integer EVENT_DELAY = 15;
    private final Integer EVENT_INTERVAL = 5;
    private final Integer MAX_ACTIVE_SESSIONS = 250;
    private final Integer POOL_SIZE = 8;


    public Runner() {
        scheduler = Executors.newScheduledThreadPool(CONCURRENT_PURCHASERS);
    }

    public static void main(String[] args) throws Exception {
        new Runner().produce();
    }

    private void produce() throws InterruptedException {

        ActiveMQConnectionFactory amqConnectionFactory;

        amqConnectionFactory = new ActiveMQConnectionFactory(BROKER_URL);
        amqConnectionFactory.setUserName(BROKER_USERNAME);
        amqConnectionFactory.setPassword(BROKER_PASSWORD);

        PooledConnectionFactory connectionFactory = new PooledConnectionFactory(amqConnectionFactory);
        connectionFactory.setMaxConnections(POOL_SIZE);
        connectionFactory.setMaximumActiveSessionPerConnection(MAX_ACTIVE_SESSIONS);

        for (int i = 0; i < CONCURRENT_PURCHASERS; i++) {

            int delay = (int) (Math.random() * EVENT_DELAY);

            final ScheduledFuture<?> playerHandle = scheduler
                    .scheduleAtFixedRate(
                            new PurchaseRunner(
                                    new PurchaseProducer(connectionFactory, QUEUE_NAME, i)),
                                        delay,
                                        EVENT_INTERVAL,
                                        TimeUnit.SECONDS);

            scheduler.schedule(() -> playerHandle.cancel(true), DURATION, TimeUnit.MINUTES);
        }
    }

    private class PurchaseRunner implements Runnable {

        private final PurchaseProducer purchaseProducer;
        private int id = 10000;

        public PurchaseRunner(PurchaseProducer purchaseProducer) {
            this.purchaseProducer = purchaseProducer;
        }

        @Override
        public void run() {
            purchaseProducer.produce(id++, System.currentTimeMillis());
        }
    }
}

Lastly, define the various components that make up the main module of the integration. This module will house several HACEP-inherent configurations, the HACEP integration itself, as well as a RESTful interface for monitoring of the application in action.

import com.redhat.refarch.hacep.model.channels.SysoutChannel;
import it.redhat.hacep.configuration.DroolsConfiguration;
import it.redhat.hacep.drools.channels.NullChannel;
import org.kie.api.KieBase;
import org.kie.api.KieServices;
import org.kie.api.runtime.Channel;
import org.kie.api.runtime.KieContainer;
import org.kie.api.runtime.KieSession;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import javax.enterprise.context.ApplicationScoped;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;

@ApplicationScoped
public class DroolsConfigurationImpl implements DroolsConfiguration {

    private static final Logger logger = LoggerFactory.getLogger(DroolsConfigurationImpl.class);

    private final Map<String, Channel> channels = new ConcurrentHashMap<>();
    private final Map<String, Channel> replayChannels = new ConcurrentHashMap<>();
    private final KieContainer kieContainer;
    private final KieBase kieBase;
    private static final String KSESSION_RULES = "hacep-sessions";
    private static final String KBASE_NAME = "hacep-rules";

    public DroolsConfigurationImpl() {
        KieServices kieServices = KieServices.Factory.get();
        kieContainer = kieServices.getKieClasspathContainer();
        kieBase = kieContainer.getKieBase(KBASE_NAME);
        channels.put(SysoutChannel.CHANNEL_ID, new SysoutChannel());
        replayChannels.put(SysoutChannel.CHANNEL_ID, new NullChannel());
        if (logger.isInfoEnabled()) {
            logger.info("[Kie Container] successfully initialized.");
        }
    }

    @Override
    public KieSession getKieSession() {
        return kieContainer.newKieSession(KSESSION_RULES);
    }

    @Override
    public KieBase getKieBase() {
        return kieBase;
    }

    @Override
    public Map<String, Channel> getChannels() {
        return channels;
    }

    @Override
    public Map<String, Channel> getReplayChannels() {
        return replayChannels;
    }

    @Override
    public int getMaxBufferSize() {
        try {
            return Integer.valueOf(System.getProperty("grid.buffer", "1000"));
        } catch (IllegalArgumentException e) {
            return 1000;
        }
    }
}

import it.redhat.hacep.configuration.JmsConfiguration;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import javax.annotation.Resource;
import javax.enterprise.context.ApplicationScoped;
import javax.jms.ConnectionFactory;

@ApplicationScoped
public class JmsConfigurationImpl implements JmsConfiguration {
    private static final Logger LOGGER = LoggerFactory.getLogger(JmsConfigurationImpl.class);

    @Resource(lookup = "java:/HacepConnectionFactory")
    private ConnectionFactory connectionFactory;

    @Override
    public ConnectionFactory getConnectionFactory() {
        if (LOGGER.isDebugEnabled()) {
            LOGGER.debug(String.format("Provide connection factory [%s]", connectionFactory));
        }
        return connectionFactory;
    }

    @Override
    public String getQueueName() {
        try {
            return System.getProperty("queue.name", "facts");
        } catch (IllegalArgumentException e) {
            return "facts";
        }
    }

    @Override
    public int getMaxConsumers() {
        try {
            return Integer.valueOf(System.getProperty("queue.consumers", "5"));
        } catch (IllegalArgumentException e) {
            return 5;
        }
    }
}

import it.redhat.hacep.configuration.HACEPApplication;

import javax.annotation.PostConstruct;
import javax.annotation.PreDestroy;
import javax.ejb.Singleton;
import javax.ejb.Startup;
import javax.inject.Inject;

@Startup
@Singleton
public class Application {

    @Inject
    private HACEPApplication hacepApplication;

    @PostConstruct
    public void start() {
        hacepApplication.start();
    }

    @PreDestroy
    public void stop() {
        hacepApplication.stop();
    }
}

import com.redhat.refarch.hacep.rest.RestInterface;
import com.redhat.refarch.hacep.rest.commands.InterfaceRequest;

import javax.inject.Inject;
import javax.ws.rs.*;
import javax.ws.rs.core.Application;
import javax.ws.rs.core.Response;
import java.util.Arrays;
import java.util.Collections;
import java.util.Optional;

@ApplicationPath("/")
@Path("/")
public class ApplicationRestService extends Application {

    @Inject
    private RestInterface restInterface;

    @GET
    @Path("/execute/{command}")
    @Produces("application/json")
    public Response executeCommand(@PathParam("command") String commandName, @QueryParam("params") String params) {
        try {
            Optional<InterfaceRequest> command = restInterface.findByName(commandName);
            if (command.isPresent()) {
                if (params != null) {
                    command.get().execute(restInterface, Arrays.asList(params.split(",")).iterator());
                } else {
                    command.get().execute(restInterface, Collections.emptyIterator());
                }
            } else {
                restInterface.printUsage();
            }
            return Response.ok(restInterface.getContent()).build();
        } finally {
            restInterface.clear();
        }
    }

    @GET
    @Path("/help")
    @Produces("application/json")
    public Response help() {
        restInterface.printUsage();
        return Response.ok(restInterface.toString()).build();
    }

    @GET
    @Path("/help/{command}")
    @Produces("application/json")
    public Response helpOnCommand(@PathParam("command") String commandName) {
        Optional<InterfaceRequest> command = restInterface.findByName(commandName);
        if (command.isPresent()) {
            command.get().usage(restInterface);
            return Response.ok(restInterface.toString()).build();
        }
        return help();
    }
}

import com.redhat.refarch.hacep.rest.RestInterface;

import java.util.Iterator;

public interface InterfaceRequest {

    String command();

    boolean execute(RestInterface console, Iterator<String> args) throws IllegalArgumentException;

    void usage(RestInterface console);
}

import com.redhat.refarch.hacep.dto.NodeType;
import com.redhat.refarch.hacep.dto.SessionDataObjectInformation;
import com.redhat.refarch.hacep.rest.RestInterface;
import com.redhat.refarch.hacep.util.JDGUtility;
import it.redhat.hacep.configuration.HACEPApplication;
import it.redhat.hacep.configuration.annotations.HACEPSessionCache;
import it.redhat.hacep.model.Key;
import org.infinispan.Cache;
import org.infinispan.manager.DefaultCacheManager;
import org.infinispan.remoting.transport.Address;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import javax.inject.Inject;
import java.util.*;

public class InfoInterfaceRequest implements InterfaceRequest {

    private static final String COMMAND_NAME = "info";

    private final HACEPApplication application;

    @Inject
    private JDGUtility jdgUtility;

    @Inject
    @HACEPSessionCache
    private Cache<Key, Object> sessionCache;

    @Inject
    public InfoInterfaceRequest(HACEPApplication application) {
        this.application = application;
    }

    @Override
    public String command() {
        return COMMAND_NAME;
    }

    @Override
    public boolean execute(RestInterface console, Iterator<String> args) throws IllegalArgumentException {
        try {
            DefaultCacheManager cacheManager = application.getCacheManager();
            console.println(generalInfo());
            for (String cacheName : cacheManager.getCacheNames()) {
                console.println("\n");
                console.println(buildInfo(cacheManager.getCache(cacheName)));
            }

            console.println("\n\nSession cache objects:");
            Map<Address, List<SessionDataObjectInformation>> sessions = new HashMap<>();
            for (Map.Entry<Key, List<Address>> entry : jdgUtility.getKeysAddresses(sessionCache).entrySet()) {
                List<Address> addresses = entry.getValue() != null ? entry.getValue() : Collections.emptyList();
                for (int i = 0; i < addresses.size(); i++) {
                    boolean isPrimary = (i == 0);
                    sessions.compute(addresses.get(i), (a, l) -> {
                        if (l == null) {
                            l = new ArrayList<>();
                        }
                        SessionDataObjectInformation object = new SessionDataObjectInformation(entry.getKey().toString(), isPrimary ? NodeType.PRIMARY : NodeType.REPLICA);
                        l.add(object);
                        return l;
                    });
                }
            }

            console.print(sessions);

        } catch (NoSuchElementException e) {
            console.println(generalInfo());
        }
        return true;

    }

    private String generalInfo() {
        DefaultCacheManager cacheManager = application.getCacheManager();
        StringBuilder info = new StringBuilder();
        info.append("Cache Manager Status: ").append(cacheManager.getStatus()).append("\n");
        info.append("Cache Manager Address: ").append(cacheManager.getAddress()).append("\n");
        info.append("Coordinator address: ").append(cacheManager.getCoordinator()).append("\n");
        info.append("Is Coordinator: ").append(cacheManager.isCoordinator()).append("\n");
        info.append("Cluster Name: ").append(cacheManager.getClusterName()).append("\n");
        info.append("Cluster Size: ").append(cacheManager.getClusterSize()).append("\n");
        info.append("Member list: ").append(cacheManager.getMembers()).append("\n");
        info.append("Caches: ").append(cacheManager.getCacheNames()).append("\n");
        return info.toString();
    }

    private String buildInfo(Cache<Key, Object> cache) {

        StringBuilder info = new StringBuilder();

        info.append("Cache: ").append(cache).append("\n");
        info.append("Cache Mode: ").append(cache.getCacheConfiguration().clustering().cacheModeString()).append("\n");
        info.append("Cache Size: ").append(cache.size()).append("\n");
        info.append("Cache Status: ").append(cache.getStatus()).append("\n");
        info.append("Number of Owners: ").append(cache.getAdvancedCache().getDistributionManager().getConsistentHash().getNumOwners()).append("\n");
        info.append("Number of Segments: ").append(cache.getAdvancedCache().getDistributionManager().getConsistentHash().getNumSegments()).append("\n");

        return info.toString();
    }

    @Override
    public void usage(RestInterface console) {
        console.println(COMMAND_NAME);
        console.println("\t\tGeneral information on caches.");
    }
}

public enum NodeType {
    PRIMARY, REPLICA;
}

public class SessionDataObjectInformation {

    private String name;
    private NodeType nodeType;

    public SessionDataObjectInformation() {
    }

    public SessionDataObjectInformation(String name, NodeType nodeType) {
        this.name = name;
        this.nodeType = nodeType;
    }

    public String getName() {
        return name;
    }

    public NodeType getNodeType() {
        return nodeType;
    }
}