com.cinchapi.concourse.importer.debug.ImportDryRunConcourse Maven / Gradle / Ivy

Show more of this group Show more artifacts with this name
Show all versions of concourse-import Show documentation
A framework for building scripts to import data into Concourse.
There is a newer version: 0.11.5
/*
 * Copyright (c) 2013-2018 Cinchapi Inc.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 * http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
package com.cinchapi.concourse.importer.debug;

import java.util.Collection;
import java.util.Collections;
import java.util.List;
import java.util.Map;
import java.util.Set;

import com.cinchapi.concourse.Concourse;
import com.cinchapi.concourse.DuplicateEntryException;
import com.cinchapi.concourse.Timestamp;
import com.cinchapi.concourse.TransactionException;
import com.cinchapi.concourse.lang.Criteria;
import com.cinchapi.concourse.thrift.Diff;
import com.cinchapi.concourse.thrift.Operator;
import com.cinchapi.concourse.util.Convert;
import com.cinchapi.concourse.util.TSets;
import com.google.common.collect.Lists;
import com.google.common.collect.Multimap;
import com.google.common.collect.Sets;

/**
 * A {@link Concourse} API that holds {@link #insert(String) inserted} data in
 * memory.
 * 
 * This particular API is designed to allow the import framework to perform
 * dry-run data imports.
 * 
 * 
 * NOTE: By default, this class intentionally contains
 * static state.. In order to support multi-threaded imports, this
 * class maintains a global view of data that has been inserted from multiple
 * instances.
 * 
 * 
 * @author Jeff Nelson
 */
public class ImportDryRunConcourse extends Concourse {

    /**
     * The imported data across ALL instances.
     */
    private static final List> IMPORTED = Lists
            .newArrayList();

    /**
     * The list that holds each of the imported records, represented as a
     * multimap.
     */
    private final List> imported;

    /**
     * Construct a new instance.
     */
    public ImportDryRunConcourse() {
        this(false);
    }

    /**
     * Construct a new instance.
     * 
     * @param isolated
     */
    public ImportDryRunConcourse(boolean isolated) {
        imported = isolated ? Lists.newArrayList() : IMPORTED;
    }

    @Override
    public void abort() {
        throw new UnsupportedOperationException();
    }

    @Override
    public  long add(String key, T value) {
        throw new UnsupportedOperationException();
    }

    @Override
    public  Map add(String key, T value,
            Collection records) {
        throw new UnsupportedOperationException();
    }

    @Override
    public  boolean add(String key, T value, long record) {
        throw new UnsupportedOperationException();
    }

    @Override
    public Map audit(long record) {
        throw new UnsupportedOperationException();
    }

    @Override
    public Map audit(long record, Timestamp start) {
        throw new UnsupportedOperationException();
    }

    @Override
    public Map audit(long record, Timestamp start,
            Timestamp end) {
        throw new UnsupportedOperationException();
    }

    @Override
    public Map audit(String key, long record) {
        throw new UnsupportedOperationException();
    }

    @Override
    public Map audit(String key, long record,
            Timestamp start) {
        throw new UnsupportedOperationException();
    }

    @Override
    public Map audit(String key, long record,
            Timestamp start, Timestamp end) {
        throw new UnsupportedOperationException();
    }

    @Override
    public Map>> browse(Collection keys) {
        throw new UnsupportedOperationException();
    }

    @Override
    public Map>> browse(Collection keys,
            Timestamp timestamp) {
        throw new UnsupportedOperationException();
    }

    @Override
    public Map> browse(String key) {
        throw new UnsupportedOperationException();
    }

    @Override
    public Map> browse(String key, Timestamp timestamp) {
        throw new UnsupportedOperationException();
    }

    @Override
    public Map> chronologize(String key, long record) {
        throw new UnsupportedOperationException();
    }

    @Override
    public Map> chronologize(String key, long record,
            Timestamp start) {
        throw new UnsupportedOperationException();
    }

    @Override
    public Map> chronologize(String key, long record,
            Timestamp start, Timestamp end) {
        throw new UnsupportedOperationException();
    }

    @Override
    public void clear(Collection records) {
        throw new UnsupportedOperationException();
    }

    @Override
    public void clear(Collection keys, Collection records) {
        throw new UnsupportedOperationException();
    }

    @Override
    public void clear(Collection keys, long record) {
        throw new UnsupportedOperationException();
    }

    @Override
    public void clear(long record) {
        throw new UnsupportedOperationException();
    }

    @Override
    public void clear(String key, Collection records) {
        throw new UnsupportedOperationException();
    }

    @Override
    public void clear(String key, long record) {
        throw new UnsupportedOperationException();
    }

    @Override
    public boolean commit() {
        throw new UnsupportedOperationException();
    }

    @Override
    public Set describe() {
        synchronized (imported) {
            Set keys = Sets.newHashSet();
            imported.forEach(record -> keys.addAll(record.keySet()));
            return keys;
        }
    }

    @Override
    public Map> describe(Collection records) {
        throw new UnsupportedOperationException();
    }

    @Override
    public Map> describe(Collection records,
            Timestamp timestamp) {
        throw new UnsupportedOperationException();
    }

    @Override
    public Set describe(long record) {
        throw new UnsupportedOperationException();
    }

    @Override
    public Set describe(long record, Timestamp timestamp) {
        throw new UnsupportedOperationException();
    }

    @Override
    public Set describe(Timestamp timestamp) {
        throw new UnsupportedOperationException();
    }

    @Override
    public  Map>> diff(long record,
            Timestamp start) {
        throw new UnsupportedOperationException();
    }

    @Override
    public  Map>> diff(long record, Timestamp start,
            Timestamp end) {
        throw new UnsupportedOperationException();
    }

    @Override
    public  Map> diff(String key, long record,
            Timestamp start) {
        throw new UnsupportedOperationException();
    }

    @Override
    public  Map> diff(String key, long record, Timestamp start,
            Timestamp end) {
        throw new UnsupportedOperationException();
    }

    @Override
    public  Map>> diff(String key, Timestamp start) {
        throw new UnsupportedOperationException();
    }

    @Override
    public  Map>> diff(String key, Timestamp start,
            Timestamp end) {
        throw new UnsupportedOperationException();
    }

    /**
     * Dump the data that was inserted as a JSON blob.
     * 
     * @return a json dump
     */
    public String dump() {
        StringBuilder sb = new StringBuilder();
        synchronized (imported) {
            sb.append("[");
            for (Multimap map : imported) {
                sb.append(Convert.mapToJson(map)).append(",");
            }
            sb.deleteCharAt(sb.length() - 1);
            sb.append("]");
            return sb.toString();
        }

    }

    @Override
    public void exit() {}

    @Override
    public Set find(Criteria criteria) {
        throw new UnsupportedOperationException();
    }

    @Override
    public Set find(Object criteria) {
        throw new UnsupportedOperationException();
    }

    @Override
    public Set find(String ccl) {
        throw new UnsupportedOperationException();
    }

    @Override
    public Set find(String key, Object value) {
        throw new UnsupportedOperationException();
    }

    @Override
    public Set find(String key, Object value, Timestamp timestamp) {
        throw new UnsupportedOperationException();
    }

    @Override
    public Set find(String key, Operator operator, Object value) {
        throw new UnsupportedOperationException();
    }

    @Override
    public Set find(String key, Operator operator, Object value,
            Object value2) {
        throw new UnsupportedOperationException();
    }

    @Override
    public Set find(String key, Operator operator, Object value,
            Object value2, Timestamp timestamp) {
        throw new UnsupportedOperationException();
    }

    @Override
    public Set find(String key, Operator operator, Object value,
            Timestamp timestamp) {
        throw new UnsupportedOperationException();
    }

    @Override
    public Set find(String key, String operator, Object value) {
        throw new UnsupportedOperationException();
    }

    @Override
    public Set find(String key, String operator, Object value,
            Object value2) {
        throw new UnsupportedOperationException();
    }

    @Override
    public Set find(String key, String operator, Object value,
            Object value2, Timestamp timestamp) {
        throw new UnsupportedOperationException();
    }

    @Override
    public Set find(String key, String operator, Object value,
            Timestamp timestamp) {
        throw new UnsupportedOperationException();
    }

    @Override
    public  long findOrAdd(String key, T value)
            throws DuplicateEntryException {
        throw new UnsupportedOperationException();
    }

    @Override
    public long findOrInsert(Criteria criteria, String json)
            throws DuplicateEntryException {
        throw new UnsupportedOperationException();
    }

    @Override
    public long findOrInsert(String ccl, String json)
            throws DuplicateEntryException {
        throw new UnsupportedOperationException();
    }

    @Override
    public  Map> get(Collection keys,
            Collection records) {
        throw new UnsupportedOperationException();
    }

    @Override
    public  Map> get(Collection keys,
            Collection records, Timestamp timestamp) {
        throw new UnsupportedOperationException();
    }

    @Override
    public  Map> get(Collection keys,
            Criteria criteria) {
        throw new UnsupportedOperationException();
    }

    @Override
    public  Map> get(Collection keys,
            Criteria criteria, Timestamp timestamp) {
        throw new UnsupportedOperationException();
    }

    @Override
    public  Map get(Collection keys, long record) {
        throw new UnsupportedOperationException();
    }

    @Override
    public  Map get(Collection keys, long record,
            Timestamp timestamp) {
        throw new UnsupportedOperationException();
    }

    @Override
    public  Map> get(Collection keys,
            Object criteria) {
        throw new UnsupportedOperationException();
    }

    @Override
    public  Map> get(Collection keys,
            Object criteria, Timestamp timestamp) {
        throw new UnsupportedOperationException();
    }

    @Override
    public  Map> get(Collection keys,
            String ccl) {
        throw new UnsupportedOperationException();
    }

    @Override
    public  Map> get(Collection keys,
            String ccl, Timestamp timestamp) {
        throw new UnsupportedOperationException();
    }

    @Override
    public  Map> get(Criteria criteria) {
        throw new UnsupportedOperationException();
    }

    @Override
    public  Map> get(Criteria criteria,
            Timestamp timestamp) {
        throw new UnsupportedOperationException();
    }

    @Override
    public  Map> get(Object criteria) {
        throw new UnsupportedOperationException();
    }

    @Override
    public  Map> get(Object criteria,
            Timestamp timestamp) {
        throw new UnsupportedOperationException();
    }

    @Override
    public  Map> get(String ccl) {
        throw new UnsupportedOperationException();
    }

    @Override
    public  Map get(String key, Collection records) {
        throw new UnsupportedOperationException();
    }

    @Override
    public  Map get(String key, Collection records,
            Timestamp timestamp) {
        throw new UnsupportedOperationException();
    }

    @Override
    public  Map get(String key, Criteria criteria) {
        throw new UnsupportedOperationException();
    }

    @Override
    public  Map get(String key, Criteria criteria,
            Timestamp timestamp) {
        throw new UnsupportedOperationException();
    }

    @Override
    public  T get(String key, long record) {
        throw new UnsupportedOperationException();
    }

    @Override
    public  T get(String key, long record, Timestamp timestamp) {
        throw new UnsupportedOperationException();
    }

    @Override
    public  Map get(String key, Object criteria) {
        throw new UnsupportedOperationException();
    }

    @Override
    public  Map get(String key, Object criteria,
            Timestamp timestamp) {
        throw new UnsupportedOperationException();
    }

    @Override
    public  Map get(String key, String ccl) {
        throw new UnsupportedOperationException();
    }

    @Override
    public  Map get(String key, String ccl, Timestamp timestamp) {
        throw new UnsupportedOperationException();
    }

    @Override
    public  Map> get(String ccl, Timestamp timestamp) {
        throw new UnsupportedOperationException();
    }

    @Override
    public String getServerEnvironment() {
        throw new UnsupportedOperationException();
    }

    @Override
    public String getServerVersion() {
        throw new UnsupportedOperationException();
    }

    @Override
    public Set insert(String json) {
        List> data = Convert.anyJsonToJava(json);
        if(!data.isEmpty()) {
            synchronized (imported) {
                imported.addAll(data);
                long start = imported.size() + 1;
                long end = start + data.size() - 1;
                return TSets.sequence(start, end);
            }
        }
        else {
            return Collections.emptySet();
        }
    }

    @Override
    public Map insert(String json, Collection records) {
        throw new UnsupportedOperationException();
    }

    @Override
    public boolean insert(String json, long record) {
        throw new UnsupportedOperationException();
    }

    @Override
    public Set inventory() {
        throw new UnsupportedOperationException();
    }

    @Override
    public  T invokePlugin(String id, String method, Object... args) {
        throw new UnsupportedOperationException();
    }

    @Override
    public String jsonify(Collection records) {
        throw new UnsupportedOperationException();
    }

    @Override
    public String jsonify(Collection records, boolean identifier) {
        throw new UnsupportedOperationException();
    }

    @Override
    public String jsonify(Collection records, Timestamp timestamp) {
        throw new UnsupportedOperationException();
    }

    @Override
    public String jsonify(Collection records, Timestamp timestamp,
            boolean identifier) {
        throw new UnsupportedOperationException();
    }

    @Override
    public String jsonify(long record) {
        throw new UnsupportedOperationException();
    }

    @Override
    public String jsonify(long record, boolean identifier) {
        throw new UnsupportedOperationException();
    }

    @Override
    public String jsonify(long record, Timestamp timestamp) {
        throw new UnsupportedOperationException();
    }

    @Override
    public String jsonify(long record, Timestamp timestamp,
            boolean identifier) {
        throw new UnsupportedOperationException();
    }

    @Override
    public Map link(String key, Collection destinations,
            long source) {
        throw new UnsupportedOperationException();
    }

    @Override
    public boolean link(String key, long destination, long source) {
        throw new UnsupportedOperationException();
    }

    @Override
    public  Map>> navigate(Collection keys,
            Collection records) {
        throw new UnsupportedOperationException();
    }

    @Override
    public  Map>> navigate(Collection keys,
            Collection records, Timestamp timestamp) {
        throw new UnsupportedOperationException();
    }

    @Override
    public  Map>> navigate(Collection keys,
            Criteria criteria) {
        throw new UnsupportedOperationException();
    }

    @Override
    public  Map>> navigate(Collection keys,
            Criteria criteria, Timestamp timestamp) {
        throw new UnsupportedOperationException();
    }

    @Override
    public  Map>> navigate(Collection keys,
            long record) {
        throw new UnsupportedOperationException();
    }

    @Override
    public  Map>> navigate(Collection keys,
            long record, Timestamp timestamp) {
        throw new UnsupportedOperationException();
    }

    @Override
    public  Map>> navigate(Collection keys,
            String ccl) {
        throw new UnsupportedOperationException();
    }

    @Override
    public  Map>> navigate(Collection keys,
            String ccl, Timestamp timestamp) {
        throw new UnsupportedOperationException();
    }

    @Override
    public  Map> navigate(String key,
            Collection records) {
        throw new UnsupportedOperationException();
    }

    @Override
    public  Map> navigate(String key, Collection records,
            Timestamp timestamp) {
        throw new UnsupportedOperationException();
    }

    @Override
    public  Map> navigate(String key, Criteria criteria) {
        throw new UnsupportedOperationException();
    }

    @Override
    public  Map> navigate(String key, Criteria criteria,
            Timestamp timestamp) {
        throw new UnsupportedOperationException();
    }

    @Override
    public  Map> navigate(String key, long record) {
        throw new UnsupportedOperationException();
    }

    @Override
    public  Map> navigate(String key, long record,
            Timestamp timestamp) {
        throw new UnsupportedOperationException();
    }

    @Override
    public  Map> navigate(String key, String ccl) {
        throw new UnsupportedOperationException();
    }

    @Override
    public  Map> navigate(String key, String ccl,
            Timestamp timestamp) {
        throw new UnsupportedOperationException();
    }

    @Override
    public Map ping(Collection records) {
        throw new UnsupportedOperationException();
    }

    @Override
    public boolean ping(long record) {
        throw new UnsupportedOperationException();
    }

    @Override
    public  void reconcile(String key, long record, Collection values) {
        throw new UnsupportedOperationException();
    }

    @Override
    public  Map remove(String key, T value,
            Collection records) {
        throw new UnsupportedOperationException();
    }

    @Override
    public  boolean remove(String key, T value, long record) {
        throw new UnsupportedOperationException();
    }

    @Override
    public void revert(Collection keys, Collection records,
            Timestamp timestamp) {
        throw new UnsupportedOperationException();
    }

    @Override
    public void revert(Collection keys, long record,
            Timestamp timestamp) {
        throw new UnsupportedOperationException();
    }

    @Override
    public void revert(String key, Collection records,
            Timestamp timestamp) {
        throw new UnsupportedOperationException();
    }

    @Override
    public void revert(String key, long record, Timestamp timestamp) {
        throw new UnsupportedOperationException();
    }

    @Override
    public Set search(String key, String query) {
        throw new UnsupportedOperationException();
    }

    @Override
    public Map>> select(
            Collection records) {
        throw new UnsupportedOperationException();
    }

    @Override
    public Map>> select(Collection records,
            Timestamp timestamp) {
        throw new UnsupportedOperationException();
    }

    @Override
    public  Map>> select(Collection keys,
            Collection records) {
        throw new UnsupportedOperationException();
    }

    @Override
    public  Map>> select(Collection keys,
            Collection records, Timestamp timestamp) {
        throw new UnsupportedOperationException();
    }

    @Override
    public  Map>> select(Collection keys,
            Criteria criteria) {
        throw new UnsupportedOperationException();
    }

    @Override
    public  Map>> select(Collection keys,
            Criteria criteria, Timestamp timestamp) {
        throw new UnsupportedOperationException();
    }

    @Override
    public  Map> select(Collection keys,
            long record) {
        throw new UnsupportedOperationException();
    }

    @Override
    public  Map> select(Collection keys, long record,
            Timestamp timestamp) {
        throw new UnsupportedOperationException();
    }

    @Override
    public  Map>> select(Collection keys,
            Object criteria) {
        throw new UnsupportedOperationException();
    }

    @Override
    public  Map>> select(Collection keys,
            Object criteria, Timestamp timestamp) {
        throw new UnsupportedOperationException();
    }

    @Override
    public  Map>> select(Collection keys,
            String ccl) {
        throw new UnsupportedOperationException();
    }

    @Override
    public  Map>> select(Collection keys,
            String ccl, Timestamp timestamp) {
        throw new UnsupportedOperationException();
    }

    @Override
    public  Map>> select(Criteria criteria) {
        throw new UnsupportedOperationException();
    }

    @Override
    public  Map>> select(Criteria criteria,
            Timestamp timestamp) {
        throw new UnsupportedOperationException();
    }

    @Override
    public Map> select(long record) {
        throw new UnsupportedOperationException();
    }

    @Override
    public Map> select(long record, Timestamp timestamp) {
        throw new UnsupportedOperationException();
    }

    @Override
    public  Map>> select(Object criteria) {
        throw new UnsupportedOperationException();
    }

    @Override
    public  Map>> select(Object criteria,
            Timestamp timestamp) {
        throw new UnsupportedOperationException();
    }

    @Override
    public  Map>> select(String ccl) {
        throw new UnsupportedOperationException();
    }

    @Override
    public  Map> select(String key, Collection records) {
        throw new UnsupportedOperationException();
    }

    @Override
    public  Map> select(String key, Collection records,
            Timestamp timestamp) {
        throw new UnsupportedOperationException();
    }

    @Override
    public  Map> select(String key, Criteria criteria) {
        throw new UnsupportedOperationException();
    }

    @Override
    public  Map> select(String key, Criteria criteria,
            Timestamp timestamp) {
        throw new UnsupportedOperationException();
    }

    @Override
    public  Set select(String key, long record) {
        throw new UnsupportedOperationException();
    }

    @Override
    public  Set select(String key, long record, Timestamp timestamp) {
        throw new UnsupportedOperationException();
    }

    @Override
    public  Map> select(String key, Object criteria) {
        throw new UnsupportedOperationException();
    }

    @Override
    public  Map> select(String key, Object criteria,
            Timestamp timestamp) {
        throw new UnsupportedOperationException();
    }

    @Override
    public  Map> select(String key, String ccl) {
        throw new UnsupportedOperationException();
    }

    @Override
    public  Map> select(String key, String ccl,
            Timestamp timestamp) {
        throw new UnsupportedOperationException();
    }

    @Override
    public  Map>> select(String ccl,
            Timestamp timestamp) {
        throw new UnsupportedOperationException();
    }

    @Override
    public void set(String key, Object value, Collection records) {
        throw new UnsupportedOperationException();
    }

    @Override
    public  void set(String key, T value, long record) {
        throw new UnsupportedOperationException();
    }

    @Override
    public void stage() throws TransactionException {
        throw new UnsupportedOperationException();
    }

    @Override
    public Timestamp time() {
        throw new UnsupportedOperationException();
    }

    @Override
    public Timestamp time(String phrase) {
        throw new UnsupportedOperationException();
    }

    @Override
    public boolean unlink(String key, long destination, long source) {
        throw new UnsupportedOperationException();
    }

    @Override
    public boolean verify(String key, Object value, long record) {
        throw new UnsupportedOperationException();
    }

    @Override
    public boolean verify(String key, Object value, long record,
            Timestamp timestamp) {
        throw new UnsupportedOperationException();
    }

    @Override
    public boolean verifyAndSwap(String key, Object expected, long record,
            Object replacement) {
        throw new UnsupportedOperationException();
    }

    @Override
    public void verifyOrSet(String key, Object value, long record) {
        throw new UnsupportedOperationException();
    }

    @Override
    protected Concourse copyConnection() {
        return new ImportDryRunConcourse();
    }

}