Package com.hmsonline.storm.cassandra.bolt

Source Code of com.hmsonline.storm.cassandra.bolt.CompositeTest

/*
* Licensed to the Apache Software Foundation (ASF) under one
* or more contributor license agreements.  See the NOTICE file
* distributed with this work for additional information
* regarding copyright ownership.  The ASF licenses this file
* to you 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.hmsonline.storm.cassandra.bolt;

import static com.hmsonline.storm.cassandra.bolt.AstyanaxUtil.createColumnFamily;
import static com.hmsonline.storm.cassandra.bolt.AstyanaxUtil.newClusterContext;
import static com.hmsonline.storm.cassandra.bolt.AstyanaxUtil.newContext;
import static org.junit.Assert.*;

import java.io.IOException;
import java.lang.reflect.Field;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;

import org.apache.cassandra.exceptions.ConfigurationException;
import org.apache.thrift.transport.TTransportException;
import org.junit.BeforeClass;
import org.junit.Test;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import storm.trident.tuple.TridentTuple;
import storm.trident.tuple.TridentTupleView;

import backtype.storm.tuple.Fields;
import backtype.storm.tuple.Tuple;
import backtype.storm.tuple.Values;

import com.hmsonline.storm.cassandra.StormCassandraConstants;
import com.hmsonline.storm.cassandra.bolt.mapper.Equality;
import com.hmsonline.storm.cassandra.bolt.mapper.TupleMapper;
import com.hmsonline.storm.cassandra.client.AstyanaxClient;
import com.hmsonline.storm.cassandra.composite.Composite2;
import com.netflix.astyanax.AstyanaxContext;
import com.netflix.astyanax.Cluster;
import com.netflix.astyanax.Keyspace;
import com.netflix.astyanax.MutationBatch;
import com.netflix.astyanax.model.Column;
import com.netflix.astyanax.model.ColumnFamily;
import com.netflix.astyanax.serializers.AnnotatedCompositeSerializer;
import com.netflix.astyanax.serializers.StringSerializer;

public class CompositeTest {
    private static Logger LOG = LoggerFactory.getLogger(CompositeTest.class);
    private static String KEYSPACE = CompositeTest.class.getSimpleName().toLowerCase();

    @BeforeClass
    public static void setupCassandra() throws TTransportException, IOException, InterruptedException,
            ConfigurationException, Exception {
        SingletonEmbeddedCassandra.getInstance();
        try {

            AstyanaxContext<Cluster> clusterContext = newClusterContext("localhost:9160");

            createColumnFamily(clusterContext, KEYSPACE, "simple", "UTF8Type", "UTF8Type", "UTF8Type");
            createColumnFamily(clusterContext, KEYSPACE, "trident", "UTF8Type", "UTF8Type", "UTF8Type");
            createColumnFamily(clusterContext, KEYSPACE, "generic", "UTF8Type", "UTF8Type", "UTF8Type");
            createColumnFamily(clusterContext, KEYSPACE, "composite", "CompositeType(UTF8Type, UTF8Type)", "UTF8Type", "UTF8Type");

        } catch (Exception e) {
            LOG.warn("Couldn't setup cassandra.", e);
            throw e;
        }
    }

    @Test
    @SuppressWarnings({ "rawtypes", "unchecked" })
    public void testCompositeKey() throws Exception {
        TupleMapper tupleMapper = new SimpleTupleMapper(KEYSPACE, "simple");
        AstyanaxClient client = new AstyanaxClient();
        Map<String, Object> clientConfig = new HashMap<String, Object>();
        clientConfig.put(StormCassandraConstants.CASSANDRA_HOST, "localhost:9160");
        clientConfig.put(StormCassandraConstants.CASSANDRA_KEYSPACE, Arrays.asList(new String [] {KEYSPACE}));
        client.start(clientConfig);

        Fields fields = new Fields("key1", "key2", "foo", "bar");
        Values values = new Values("key1val", "key2val", "fooval", "barval");
        Tuple tuple = new MockTuple(fields, values);

        client.writeTuple(tuple, tupleMapper);

        AstyanaxContext<Keyspace> context = newContext("localhost:9160", KEYSPACE);
        Keyspace ks = context.getEntity();

        Column<String> result = ks
                .prepareQuery(
                        new ColumnFamily<SimpleComposite, String>("simple",
                                new AnnotatedCompositeSerializer<SimpleComposite>(SimpleComposite.class),
                                StringSerializer.get())).getKey(new SimpleComposite("key1val", "key2val"))
                .getColumn("foo").execute().getResult();
        assertEquals("fooval", result.getStringValue());
       
        // test lookup
        Map<String, String> map = client.lookup(tupleMapper, tuple);
        assertEquals("fooval", map.get("foo"));
       
       
        map = client.lookup(tupleMapper, tuple, "bar", "foo", Equality.EQUAL);
        assertNotNull(map.get("foo"));
        assertNotNull(map.get("bar"));
        assertNull(map.get("key1"));
       
        ArrayList<String> slice = new ArrayList<String>();
        slice.add("foo");
        slice.add("bar");
        slice.add("key1");
        map = client.lookup(tupleMapper, tuple, slice);
        assertNotNull(map.get("foo"));
        assertNotNull(map.get("bar"));
        assertNotNull(map.get("key1"));
       
        client.stop();

    }
   
    @Test
    @SuppressWarnings({ "rawtypes", "unchecked" })
    public void testTrident() throws Exception {
        AstyanaxClient client = new AstyanaxClient();
        Map<String, Object> clientConfig = new HashMap<String, Object>();
        clientConfig.put(StormCassandraConstants.CASSANDRA_HOST, "localhost:9160");
        clientConfig.put(StormCassandraConstants.CASSANDRA_KEYSPACE, Arrays.asList(new String [] {KEYSPACE}));
        client.start(clientConfig);
       
        Fields fields = new Fields("key1", "key2", "foo", "bar");
        Values values = new Values("key1val", "key2val", "fooval", "barval");
        TridentTuple tuple = newTridentTuple(fields, values);
       
        SimpleTridentTupleMapper tupleMapper = new SimpleTridentTupleMapper(KEYSPACE, fields);
       
        client.writeTuple(tuple, tupleMapper);
       
        Map<String, String> map = client.lookup(tupleMapper, tuple);
       
        assertEquals("fooval", map.get("foo"));
       
        map = client.lookup(tupleMapper, tuple,"bar", "foo",Equality.GREATER_THAN_EQUAL);
        assertEquals("fooval", map.get("foo"));
        assertEquals("barval", map.get("bar"));
        assertNull(map.get("key1"));
        client.stop();
    }
   
    @SuppressWarnings({ "rawtypes", "unchecked" })
    @Test
    public void testCompositeRangeQuery() throws InterruptedException {
        try{
        AstyanaxClient client = new AstyanaxClient();
        Map<String, Object> clientConfig = new HashMap<String, Object>();
        clientConfig.put(StormCassandraConstants.CASSANDRA_HOST, "localhost:9160");
        clientConfig.put(StormCassandraConstants.CASSANDRA_KEYSPACE, Arrays.asList(new String [] {KEYSPACE}));
        client.start(clientConfig);
       
        Fields fields = new Fields("rowkey", "a", "b", "value");
        Values values = new Values("my_row", "a", "a", "aa");
        TridentTuple tuple = newTridentTuple(fields, values);
       
        CompositeColumnTridentTupleMapper tupleMapper = new CompositeColumnTridentTupleMapper(KEYSPACE);
       
        client.writeTuple(tuple, tupleMapper);
       
        tuple = newTridentTuple(fields, new Values("my_row", "b", "b", "bb"));
        client.writeTuple(tuple, tupleMapper);
       
        tuple = newTridentTuple(fields, new Values("my_row", "a", "b", "ab"));
        client.writeTuple(tuple, tupleMapper);
       
        tuple = newTridentTuple(fields, new Values("my_row", "a", "c", "ac"));
        client.writeTuple(tuple, tupleMapper);
       
        tuple = newTridentTuple(fields, new Values("my_row", "a", "d", "ad"));
        client.writeTuple(tuple, tupleMapper);
       
        tuple = newTridentTuple(fields, new Values("my_row", "c", "c", "cc"));
        client.writeTuple(tuple, tupleMapper);
       
        tuple = newTridentTuple(fields, new Values("my_row", "d", "d", "dd"));
        client.writeTuple(tuple, tupleMapper);
       
       
        Map<SimpleComposite, String> map = client.lookup(tupleMapper, tuple, new SimpleComposite("a", "a"), new SimpleComposite("a", "c"), Equality.GREATER_THAN_EQUAL);
        dumpMap(map);
       
        assertNotNull(map.get(new SimpleComposite("a", "a")));
        assertNotNull(map.get(new SimpleComposite("a", "b")));
        assertNotNull(map.get(new SimpleComposite("a", "c")));
        assertNull(map.get(new SimpleComposite("a", "d")));
        assertNull(map.get(new SimpleComposite("c", "c")));
        assertNull(map.get(new SimpleComposite("d", "d")));
        client.stop();
        } catch (Exception e){
            e.printStackTrace();
            fail();
        }
    }
   
    //@Test
    // TODO this test depends on https://github.com/Netflix/astyanax/pull/203
    @SuppressWarnings("rawtypes")
    public void testGenericComposite() throws Exception {
        Composite2<String, String> c2 = new Composite2<String, String>("foo", "bar");
        LOG.warn("A class: {}", c2.a.getClass());
       
       
        Class<?> clazz = c2.getClass();
        Field[] fields = clazz.getDeclaredFields();
        for(Field field : fields){
            LOG.warn("Field type: " + field.getType());
        }
       
       
       
        AstyanaxContext<Keyspace> context = newContext("localhost:9160", KEYSPACE);
        Keyspace ks = context.getEntity();
       
        AnnotatedCompositeSerializer<Composite2> acs = new AnnotatedCompositeSerializer<Composite2>(Composite2.class);
       
        ColumnFamily<String, Composite2> cf = new ColumnFamily<String, Composite2>("generic", StringSerializer.get(), acs);
       
        MutationBatch mutation = ks.prepareMutationBatch();
       
       
       
        mutation.withRow(cf, "foo").putColumn(c2, "Hello World");
       
        mutation.execute();
       
       
    }
   
   
    private static TridentTuple newTridentTuple(Fields fields, List<Object> values){
        TridentTupleView.FreshOutputFactory fof = new TridentTupleView.FreshOutputFactory(fields);
        return fof.create(values);
    }
   
    private void dumpMap(Map<SimpleComposite, String> values){
      for (Entry<SimpleComposite, String> entry: values.entrySet()){
        LOG.debug("Entry [" + entry.getKey().getPart1() + ":" + entry.getKey().getPart2() + "]");       
      }
     
    }
}
TOP

Related Classes of com.hmsonline.storm.cassandra.bolt.CompositeTest

TOP
Copyright © 2018 www.massapi.com. All rights reserved.
All source code are property of their respective owners. Java is a trademark of Sun Microsystems, Inc and owned by ORACLE Inc. Contact coftware#gmail.com.