Example usage for org.apache.cassandra.exceptions ConfigurationException getMessage

List of usage examples for org.apache.cassandra.exceptions ConfigurationException getMessage

  1. HOME
  2. Java
  3. org.apache.cassandra
  4. org.apache.cassandra.exceptions.*
  5. ConfigurationException
  6. getMessage

Introduction

In this page you can find the example usage for org.apache.cassandra.exceptions ConfigurationException getMessage.

Prototype

public String getMessage();

Source Link

Document

The exception message.

Usage

From source file:com.netflix.aegisthus.tools.SSTableExport.java

License:Apache License

@SuppressWarnings("rawtypes")
public static void main(String[] args) throws IOException {
    String usage = String.format("Usage: %s <sstable>", SSTableExport.class.getName());

    CommandLineParser parser = new PosixParser();
    try {/*from  w  w w.  j  av  a2  s  .  c om*/
        cmd = parser.parse(options, args);
    } catch (ParseException e1) {
        System.err.println(e1.getMessage());
        HelpFormatter formatter = new HelpFormatter();
        formatter.printHelp(usage, options);
        System.exit(1);
    }

    if (cmd.getArgs().length != 1) {
        HelpFormatter formatter = new HelpFormatter();
        formatter.printHelp(usage, options);
        System.exit(1);
    }
    Map<String, AbstractType> convertors = null;
    if (cmd.hasOption(COLUMN_NAME_TYPE)) {
        try {
            convertors = new HashMap<String, AbstractType>();
            convertors.put(SSTableScanner.COLUMN_NAME_KEY,
                    TypeParser.parse(cmd.getOptionValue(COLUMN_NAME_TYPE)));
        } catch (ConfigurationException e) {
            System.err.println(e.getMessage());
            HelpFormatter formatter = new HelpFormatter();
            formatter.printHelp(usage, options);
            System.exit(1);
        } catch (SyntaxException e) {
            System.err.println(e.getMessage());
            HelpFormatter formatter = new HelpFormatter();
            formatter.printHelp(usage, options);
            System.exit(1);
        }
    }
    Descriptor.Version version = null;
    if (cmd.hasOption(OPT_VERSION)) {
        version = new Descriptor.Version(cmd.getOptionValue(OPT_VERSION));
    }

    if (cmd.hasOption(INDEX_SPLIT)) {
        String ssTableFileName;
        DataInput input = null;
        if ("-".equals(cmd.getArgs()[0])) {
            ssTableFileName = System.getProperty("aegisthus.file.name");
            input = new DataInputStream(new BufferedInputStream(System.in, 65536 * 10));
        } else {
            ssTableFileName = new File(cmd.getArgs()[0]).getAbsolutePath();
            input = new DataInputStream(
                    new BufferedInputStream(new FileInputStream(ssTableFileName), 65536 * 10));
        }
        if (version == null) {
            version = Descriptor.fromFilename(ssTableFileName).version;
        }
        exportIndexSplit(ssTableFileName, input, version);
    } else if (cmd.hasOption(INDEX)) {
        String ssTableFileName = new File(cmd.getArgs()[0]).getAbsolutePath();
        exportIndex(ssTableFileName);
    } else if (cmd.hasOption(ROWSIZE)) {
        String ssTableFileName = new File(cmd.getArgs()[0]).getAbsolutePath();
        exportRowSize(ssTableFileName);
    } else if ("-".equals(cmd.getArgs()[0])) {
        if (version == null) {
            System.err.println("when streaming must supply file version");
            HelpFormatter formatter = new HelpFormatter();
            formatter.printHelp(usage, options);
            System.exit(1);
        }
        exportStream(version);
    } else {
        String ssTableFileName = new File(cmd.getArgs()[0]).getAbsolutePath();
        FileInputStream fis = new FileInputStream(ssTableFileName);
        InputStream inputStream = new DataInputStream(new BufferedInputStream(fis, 65536 * 10));
        long end = -1;
        if (cmd.hasOption(END)) {
            end = Long.valueOf(cmd.getOptionValue(END));
        }
        if (cmd.hasOption(OPT_COMP)) {
            CompressionMetadata cm = new CompressionMetadata(
                    new BufferedInputStream(new FileInputStream(cmd.getOptionValue(OPT_COMP)), 65536),
                    fis.getChannel().size());
            inputStream = new CompressionInputStream(inputStream, cm);
            end = cm.getDataLength();
        }
        DataInputStream input = new DataInputStream(inputStream);
        if (version == null) {
            version = Descriptor.fromFilename(ssTableFileName).version;
        }
        SSTableScanner scanner = new SSTableScanner(input, convertors, end, version);
        if (cmd.hasOption(OPT_MAX_COLUMN_SIZE)) {
            scanner.setMaxColSize(Long.parseLong(cmd.getOptionValue(OPT_MAX_COLUMN_SIZE)));
        }
        export(scanner);
        if (cmd.hasOption(OPT_MAX_COLUMN_SIZE)) {
            if (scanner.getErrorRowCount() > 0) {
                System.err.println(String.format("%d rows were too large", scanner.getErrorRowCount()));
            }
        }
    }
}

From source file:org.apache.hadoop.hive.cassandra.CassandraPushdownPredicate.java

License:Apache License

private static AbstractType getValidator(Set<ColumnDef> columnInfos, String columnName) {
    for (ColumnDef column : columnInfos) {
        if (new String(column.getName()).equals(columnName)) {
            try {
                return TypeParser.parse(column.validation_class);
            } catch (ConfigurationException e) {
                logger.error("Error creating validator from string {}", column.validation_class);
                throw new RuntimeException(e);
            } catch (SyntaxException e) {
                logger.error("Syntax exception in parsing: \n {}", e.getMessage());
                throw new RuntimeException(e);
            }/* www .  jav  a2 s . c  o m*/
        }
    }
    logger.error("Error finding validator class for column {}", columnName);
    throw new RuntimeException("Error finding validator class for column " + columnName);
}

From source file:org.pentaho.cassandra.CassandraColumnMetaData.java

License:Apache License

/**
 * Static utility to decompose a Kettle value to a ByteBuffer. Note - does not
 * check if the kettle value is null./* www  .  j ava 2 s  . c o m*/
 * 
 * @param vm the ValueMeta for the Kettle value
 * @param value the actual Kettle value
 * @return a ByteBuffer encapsulating the bytes for the decomposed value
 * @throws KettleException if a problem occurs
 */
public ByteBuffer kettleValueToByteBuffer(ValueMetaInterface vm, Object value, boolean isKey)
        throws KettleException {

    String fullTransCoder = m_defaultValidationClass;

    // check the key first
    if (isKey) {
        fullTransCoder = m_keyValidator;
    } else {
        fullTransCoder = m_columnMeta.get(vm.getName());
        if (fullTransCoder == null) {
            // use default if not in column meta data
            fullTransCoder = m_defaultValidationClass;
        }
    }

    String transCoder = fullTransCoder;

    // if it's a composite type make sure that we check only against the
    // primary type
    if (transCoder.indexOf('(') > 0) {
        transCoder = transCoder.substring(0, transCoder.indexOf('('));
    }

    ByteBuffer decomposed = null;
    if (transCoder.indexOf("UTF8Type") > 0) {
        UTF8Type u = UTF8Type.instance;
        decomposed = u.decompose(vm.getString(value));
    } else if (transCoder.indexOf("AsciiType") > 0) {
        AsciiType at = AsciiType.instance;
        decomposed = at.decompose(vm.getString(value));
    } else if (transCoder.indexOf("LongType") > 0) {
        LongType lt = LongType.instance;
        decomposed = lt.decompose(vm.getInteger(value));
    } else if (transCoder.indexOf("DoubleType") > 0) {
        DoubleType dt = DoubleType.instance;
        decomposed = dt.decompose(vm.getNumber(value));
    } else if (transCoder.indexOf("DateType") > 0) {
        DateType dt = DateType.instance;
        decomposed = dt.decompose(vm.getDate(value));
    } else if (transCoder.indexOf("IntegerType") > 0) {
        IntegerType it = IntegerType.instance;
        decomposed = it.decompose(vm.getBigNumber(value).toBigInteger());
    } else if (transCoder.indexOf("FloatType") > 0) {
        FloatType ft = FloatType.instance;
        decomposed = ft.decompose(vm.getNumber(value).floatValue());
    } else if (transCoder.indexOf("LexicalUUIDType") > 0) {
        LexicalUUIDType lt = LexicalUUIDType.instance;
        UUID uuid = UUID.fromString((vm.getString(value)));
        decomposed = lt.decompose(uuid);
    } else if (transCoder.indexOf("UUIDType") > 0) {
        UUIDType ut = UUIDType.instance;
        UUID uuid = UUID.fromString((vm.getString(value)));
        decomposed = ut.decompose(uuid);
    } else if (transCoder.indexOf("BooleanType") > 0) {
        BooleanType bt = BooleanType.instance;
        decomposed = bt.decompose(vm.getBoolean(value));
    } else if (transCoder.indexOf("Int32Type") > 0) {
        Int32Type it = Int32Type.instance;
        decomposed = it.decompose(vm.getInteger(value).intValue());
    } else if (transCoder.indexOf("DecimalType") > 0) {
        DecimalType dt = DecimalType.instance;
        decomposed = dt.decompose(vm.getBigNumber(value));
    } else if (transCoder.indexOf("DynamicCompositeType") > 0) {
        AbstractType serializer = null;
        if (vm.isString()) {
            try {
                serializer = TypeParser.parse(fullTransCoder);
                decomposed = ((DynamicCompositeType) serializer).fromString(vm.getString(value));

            } catch (ConfigurationException e) {
                throw new KettleException(e.getMessage(), e);
            } catch (SyntaxException e) {
                throw new KettleException(e.getMessage(), e);
            }
        } else {
            throw new KettleException(BaseMessages.getString(PKG,
                    "CassandraColumnMetaData.Error.CantConvertTypeThrift", vm.getTypeDesc(), fullTransCoder));
        }
    } else if (transCoder.indexOf("CompositeType") > 0) {
        AbstractType serializer = null;
        if (vm.isString()) {
            try {
                serializer = TypeParser.parse(fullTransCoder);
                decomposed = ((CompositeType) serializer).fromString(vm.toString());
            } catch (ConfigurationException e) {
                throw new KettleException(e.getMessage(), e);
            } catch (SyntaxException e) {
                throw new KettleException(e.getMessage(), e);
            }
        } else {
            throw new KettleException(BaseMessages.getString(PKG,
                    "CassandraColumnMetaData.Error.CantConvertTypeThrift", vm.getTypeDesc(), fullTransCoder));
        }
    }

    if (decomposed == null) {
        throw new KettleException(BaseMessages.getString(PKG,
                "CassandraColumnMetaData.Error.UnableToConvertValue", vm.getName()));
    }

    return decomposed;
}

From source file:org.pentaho.cassandra.CassandraColumnMetaData.java

License:Apache License

/**
 * Encode a string representation of a column name using the serializer for
 * the default comparator./* w ww  .ja v a 2  s.c  om*/
 * 
 * @param colName the textual column name to serialze
 * @return a ByteBuffer encapsulating the serialized column name
 * @throws KettleException if a problem occurs during serialization
 */
public ByteBuffer columnNameToByteBuffer(String colName) throws KettleException {

    AbstractType serializer = null;
    String fullEncoder = m_columnComparator;
    String encoder = fullEncoder;

    // if it's a composite type make sure that we check only against the
    // primary type
    if (encoder.indexOf('(') > 0) {
        encoder = encoder.substring(0, encoder.indexOf('('));
    }

    if (encoder.indexOf("UTF8Type") > 0) {
        serializer = UTF8Type.instance;
    } else if (encoder.indexOf("AsciiType") > 0) {
        serializer = AsciiType.instance;
    } else if (encoder.indexOf("LongType") > 0) {
        serializer = LongType.instance;
    } else if (encoder.indexOf("DoubleType") > 0) {
        serializer = DoubleType.instance;
    } else if (encoder.indexOf("DateType") > 0) {
        serializer = DateType.instance;
    } else if (encoder.indexOf("IntegerType") > 0) {
        serializer = IntegerType.instance;
    } else if (encoder.indexOf("FloatType") > 0) {
        serializer = FloatType.instance;
    } else if (encoder.indexOf("LexicalUUIDType") > 0) {
        serializer = LexicalUUIDType.instance;
    } else if (encoder.indexOf("UUIDType") > 0) {
        serializer = UUIDType.instance;
    } else if (encoder.indexOf("BooleanType") > 0) {
        serializer = BooleanType.instance;
    } else if (encoder.indexOf("Int32Type") > 0) {
        serializer = Int32Type.instance;
    } else if (encoder.indexOf("DecimalType") > 0) {
        serializer = DecimalType.instance;
    } else if (encoder.indexOf("DynamicCompositeType") > 0) {
        try {
            serializer = TypeParser.parse(fullEncoder);
        } catch (ConfigurationException e) {
            throw new KettleException(e.getMessage(), e);
        } catch (SyntaxException e) {
            throw new KettleException(e.getMessage(), e);
        }
    } else if (encoder.indexOf("CompositeType") > 0) {
        try {
            serializer = TypeParser.parse(fullEncoder);
        } catch (ConfigurationException e) {
            throw new KettleException(e.getMessage(), e);
        } catch (SyntaxException e) {
            throw new KettleException(e.getMessage(), e);
        }
    }

    ByteBuffer result = serializer.fromString(colName);

    return result;
}

From source file:org.pentaho.cassandra.CassandraColumnMetaData.java

License:Apache License

private Object getColumnValue(ByteBuffer valueBuff, String decoder) throws KettleException {
    if (valueBuff == null) {
        return null;
    }// ww w .j  a  v a2s.c  o m

    Object result = null;
    AbstractType deserializer = null;
    String fullDecoder = decoder;

    // if it's a composite type make sure that we check only against the
    // primary type
    if (decoder.indexOf('(') > 0) {
        decoder = decoder.substring(0, decoder.indexOf('('));
    }

    if (decoder.indexOf("UTF8Type") > 0) {
        deserializer = UTF8Type.instance;
    } else if (decoder.indexOf("AsciiType") > 0) {
        deserializer = AsciiType.instance;
    } else if (decoder.indexOf("LongType") > 0) {
        deserializer = LongType.instance;
    } else if (decoder.indexOf("DoubleType") > 0) {
        deserializer = DoubleType.instance;
    } else if (decoder.indexOf("DateType") > 0) {
        deserializer = DateType.instance;
    } else if (decoder.indexOf("IntegerType") > 0) {
        deserializer = IntegerType.instance;

        result = new Long(((IntegerType) deserializer).compose(valueBuff).longValue());
        return result;
    } else if (decoder.indexOf("FloatType") > 0) {
        deserializer = FloatType.instance;

        result = new Double(((FloatType) deserializer).compose(valueBuff)).doubleValue();
        return result;
    } else if (decoder.indexOf("LexicalUUIDType") > 0) {
        deserializer = LexicalUUIDType.instance;

        result = new String(((LexicalUUIDType) deserializer).compose(valueBuff).toString());
        return result;
    } else if (decoder.indexOf("UUIDType") > 0) {
        deserializer = UUIDType.instance;

        result = new String(((UUIDType) deserializer).compose(valueBuff).toString());
        return result;
    } else if (decoder.indexOf("BooleanType") > 0) {
        deserializer = BooleanType.instance;
    } else if (decoder.indexOf("Int32Type") > 0) {
        deserializer = Int32Type.instance;

        result = new Long(((Int32Type) deserializer).compose(valueBuff)).longValue();
        return result;
    } else if (decoder.indexOf("DecimalType") > 0) {
        deserializer = DecimalType.instance;
    } else if (decoder.indexOf("DynamicCompositeType") > 0) {
        try {
            deserializer = TypeParser.parse(fullDecoder);

            // now return the string representation of the composite value
            result = ((DynamicCompositeType) deserializer).getString(valueBuff);
            return result;
        } catch (ConfigurationException e) {
            throw new KettleException(e.getMessage(), e);
        } catch (SyntaxException e) {
            throw new KettleException(e.getMessage(), e);
        }
    } else if (decoder.indexOf("CompositeType") > 0) {
        try {
            deserializer = TypeParser.parse(fullDecoder);

            // now return the string representation of the composite value
            result = ((CompositeType) deserializer).getString(valueBuff);
            return result;
        } catch (ConfigurationException e) {
            throw new KettleException(e.getMessage(), e);
        } catch (SyntaxException e) {
            throw new KettleException(e.getMessage(), e);
        }
    }

    if (deserializer == null) {
        throw new KettleException(BaseMessages.getString(PKG,
                "CassandraColumnMetaData.Error.CantFindADeserializerForType", fullDecoder));
    }

    result = deserializer.compose(valueBuff);

    return result;
}