com.eucalyptus.simplequeue.persistence.cassandra.CassandraSessionManager.java Source code

Introduction

Here is the source code for com.eucalyptus.simplequeue.persistence.cassandra.CassandraSessionManager.java

Source

/*************************************************************************
 * (c) Copyright 2016 Hewlett Packard Enterprise Development Company LP
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; version 3 of the License.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program.  If not, see http://www.gnu.org/licenses/.
 ************************************************************************/
package com.eucalyptus.simplequeue.persistence.cassandra;

import com.datastax.driver.core.Cluster;
import com.datastax.driver.core.Session;
import com.eucalyptus.cassandra.common.CassandraComponent;
import com.eucalyptus.cassandra.common.CassandraKeyspaceSpecification;
import com.eucalyptus.cassandra.common.CassandraPersistence;
import com.eucalyptus.cassandra.common.util.CqlUtil;
import com.eucalyptus.configurable.ConfigurableProperty;
import com.eucalyptus.configurable.ConfigurablePropertyException;
import com.eucalyptus.configurable.PropertyChangeListener;
import com.eucalyptus.simplequeue.config.SimpleQueueProperties;
import com.eucalyptus.simplequeue.exceptions.SimpleQueueException;
import com.eucalyptus.util.Exceptions;
import com.eucalyptus.util.ThrowingFunction;
import com.google.common.base.Splitter;
import com.google.common.collect.Lists;
import com.google.common.io.Resources;
import org.apache.log4j.Logger;

import java.io.IOException;
import java.nio.charset.StandardCharsets;
import java.text.ParseException;
import java.util.List;
import java.util.function.Function;

/**
 * Created by ethomas on 11/22/16.
 */
@CassandraKeyspaceSpecification("eucalyptus_simplequeue")
public class CassandraSessionManager implements CassandraComponent {
    private static final Logger LOG = Logger.getLogger(CassandraSessionManager.class);

    private static final CassandraSessionManager external = new CassandraSessionManager();

    private Cluster cluster = null;
    private Session session = null;

    public static CassandraSessionManager external() {
        return external;
    }

    private synchronized void initCluster() {
        initCluster(SimpleQueueProperties.CASSANDRA_HOST);
    }

    private synchronized void initCluster(String contactPoint) {
        if (session != null) {
            session.close();
            session = null;
        }
        if (cluster != null) {
            cluster.close();
            cluster = null;
        }
        LOG.info("Trying to connect to the cluster " + contactPoint);
        List<String> contactPoints = Lists.newArrayList();
        for (String s : Splitter.on(",").omitEmptyStrings().split(contactPoint)) {
            contactPoints.add(s);
        }
        cluster = Cluster.builder().addContactPoints(contactPoints.toArray(new String[0])).build();
        session = cluster.connect();
        createSchema(session);
    }

    private static void createSchema(final Session session) {
        // create new keyspace/tables (should not do here)  TODO: move
        session.execute("CREATE KEYSPACE IF NOT EXISTS eucalyptus_simplequeue "
                + "WITH replication = {'class':'SimpleStrategy', 'replication_factor':1}; ");

        session.execute("USE eucalyptus_simplequeue;");

        try {
            final String cql = Resources.toString(
                    Resources.getResource("2017-03-03-eucalyptus-simplequeue-base.cql"), StandardCharsets.UTF_8);
            CqlUtil.splitCql(cql).forEach(session::execute);
        } catch (final IOException | ParseException e) {
            throw Exceptions.toUndeclared(e);
        }
    }

    public synchronized Session getSession() {
        if (session == null) {
            initCluster();
        }
        return session;
    }

    public static SessionProvider externalProvider() {
        return new ExternalSessionProvider();
    }

    public static SessionProvider internalProvider() {
        return new InternalSessionProvider();
    }

    public static class ChangeListener implements PropertyChangeListener {
        @Override
        public void fireChange(ConfigurableProperty t, Object newValue) throws ConfigurablePropertyException {
            try {
                external().initCluster((String) newValue);
            } catch (Exception e) {
                throw new ConfigurablePropertyException(e.getMessage());
            }
        }
    }

    static interface SessionProvider {
        <R, E extends SimpleQueueException> R doThrowsWithSession(
                final ThrowingFunction<Session, R, E> callbackFunction) throws E;

        <R> R doWithSession(final Function<Session, R> callbackFunction);
    }

    static class ExternalSessionProvider implements SessionProvider {
        public <R, E extends SimpleQueueException> R doThrowsWithSession(
                final ThrowingFunction<Session, R, E> callbackFunction) throws E {
            return callbackFunction.apply(CassandraSessionManager.external().getSession());
        }

        public <R> R doWithSession(final Function<Session, R> callbackFunction) {
            return callbackFunction.apply(CassandraSessionManager.external().getSession());
        }
    }

    private static class InternalSessionProvider implements SessionProvider {
        public <R, E extends SimpleQueueException> R doThrowsWithSession(
                final ThrowingFunction<Session, R, E> callbackFunction) throws E {
            return CassandraPersistence.doThrowsWithSession("eucalyptus_simplequeue", callbackFunction);
        }

        public <R> R doWithSession(final Function<Session, R> callbackFunction) {
            return CassandraPersistence.doWithSession("eucalyptus_simplequeue", callbackFunction);
        }
    }
}