Cassandra 2.0 在Cassandra中创建sstable时，我得到；Can'；“找不到yaml文件”；错误

该程序创建sstables，与cassandra中的sstableloader一起使用。但是，当我运行此程序时，它会给我以下错误：

找不到cassandra.yaml 致命的配置错误；无法启动服务器。有关stacktrace，请参阅日志

我正在32位ubuntu 12.04机器上运行ApacheCassandrav2.1.2。我在datastax网站上找到了一个看似合理的解决方案，但我无法遵循确切的解决方案

有人知道下一步该做什么吗

    package com.cassandra;

    import static org.apache.cassandra.utils.ByteBufferUtil.bytes;
    import static org.apache.cassandra.utils.UUIDGen.decompose;

    import java.io.BufferedReader;
    import java.io.File;
    import java.io.FileReader;
    import java.nio.ByteBuffer;
    import java.util.ArrayList;
    import java.util.List;
    import java.util.UUID;

    import org.apache.cassandra.db.marshal.AbstractType;
    import org.apache.cassandra.db.marshal.AsciiType;
    import org.apache.cassandra.db.marshal.CompositeType;
    import org.apache.cassandra.db.marshal.CompositeType.Builder;
    import org.apache.cassandra.db.marshal.UUIDType;
    import org.apache.cassandra.dht.Murmur3Partitioner;
    import org.apache.cassandra.io.sstable.SSTableSimpleUnsortedWriter;

    public class SStableBuilder {

           static String csvfilename = "records.csv";

           public static void main(String[] args) {

                  try {
                         buildSStables();
                  } catch (Exception e) {
                         // TODO Auto-generated catch block
                         e.printStackTrace();
                  }
           }

           public static void buildSStables() throws Exception {

                  String keyspace = "samplekey";
                  String table = "users";
                  File directory = new File(keyspace + "/" + table);

                  if (!directory.exists()) {
                         directory.mkdirs();
               }

                  List<AbstractType<?>> compositeColumnValues = new ArrayList<AbstractType<?>>();
                  compositeColumnValues.add(AsciiType.instance);
                  compositeColumnValues.add(AsciiType.instance);
                  CompositeType compositeColumn = CompositeType.getInstance(compositeColumnValues);
                  System.out.println("yahahahaha");
                  SSTableSimpleUnsortedWriter bulkWriter = new SSTableSimpleUnsortedWriter(
                               directory, new Murmur3Partitioner(), keyspace, table,
                               compositeColumn, null, 64);

                  // Create a single timestamp for each insert
                  long timestamp = System.currentTimeMillis() * 1000;

                  BufferedReader reader = new BufferedReader(new FileReader(csvfilename));
                  String line;
                  int lineNumber = 1;
                  CsvEntry entry = new CsvEntry();

                  while ((line = reader.readLine()) != null) {

                         if (entry.parse(line, lineNumber)) {

                               ByteBuffer uuid = ByteBuffer.wrap(decompose(entry.key));
                               bulkWriter.newRow(uuid);

                               Builder builder = compositeColumn.builder();
                               builder.add(bytes(entry.firstname));
                               builder.add(bytes("firstname"));
                               bulkWriter.addColumn(builder.build(), bytes(entry.firstname), timestamp);

                               builder = compositeColumn.builder();
                               builder.add(bytes(entry.firstname));
                               builder.add(bytes("lastname"));
                               bulkWriter.addColumn(builder.build(), bytes(entry.lastname), timestamp);

                               builder = compositeColumn.builder();
                               builder.add(bytes(entry.firstname));
                               builder.add(bytes("password"));
                               bulkWriter.addColumn(builder.build(), bytes(entry.password), timestamp);

                               builder = compositeColumn.builder();
                               builder.add(bytes(entry.firstname));
                               builder.add(bytes("age"));
                               bulkWriter.addColumn(builder.build(), bytes(String.valueOf(entry.age)), timestamp);

                               builder = compositeColumn.builder();
                               builder.add(bytes(entry.firstname));
                               builder.add(bytes("email"));
                               bulkWriter.addColumn(builder.build(), bytes(entry.email), timestamp);



                         }
                         lineNumber++;
                  }

                  reader.close();
                  System.out.println("Success");
                  bulkWriter.close();
                  System.exit(0);
           }

           static class CsvEntry {
                  UUID key;
                  String firstname;
                  String lastname;
                  String password;
                  long age;
                  String email;

                  boolean parse(String line, int lineNumber) {
                         // Ghetto csv parsing
                         String[] columns = line.split(",");
                         if (columns.length != 6) {
                               System.out.println(String.format(
                                             "Invalid input '%s' at line %d of %s", line,
                                             lineNumber, csvfilename));
                               return false;
                         }
                         try {
                               key = UUID.fromString(columns[0].trim());
                               firstname = columns[1].trim();
                               lastname = columns[2].trim();
                               password = columns[3].trim();
                               age = Long.parseLong(columns[4].trim());
                               email = columns[5].trim();
                               return true;
                         } catch (NumberFormatException e) {
                               System.out.println(String.format(
                                             "Invalid number in input '%s' at line %d of %s", line,
                                             lineNumber, csvfilename));
                               return false;
                         }
                  }
           }

    }

package com.cassandra；
导入静态org.apache.cassandra.utils.ByteBufferUtil.bytes；
导入静态org.apache.cassandra.utils.UUIDGen.decompose；
导入java.io.BufferedReader；
导入java.io.File；
导入java.io.FileReader；
导入java.nio.ByteBuffer；
导入java.util.ArrayList；
导入java.util.List；
导入java.util.UUID；
导入org.apache.cassandra.db.marshal.AbstractType；
导入org.apache.cassandra.db.marshal.ascitype；
导入org.apache.cassandra.db.marshal.CompositeType；
导入org.apache.cassandra.db.marshal.CompositeType.Builder；
导入org.apache.cassandra.db.marshal.UUIDType；
导入org.apache.cassandra.dht.3分区器；
导入org.apache.cassandra.io.sstable.sstableImpleUseredWriter；
公共类SStableBuilder{
静态字符串csvfilename=“records.csv”；
公共静态void main（字符串[]args）{
试一试{
buildSStables（）；
}捕获（例外e）{
//TODO自动生成的捕捉块
e、 printStackTrace（）；
}
}
public static void buildSStables（）引发异常{
字符串keyspace=“samplekey”；
String table=“用户”；
文件目录=新文件（键空间+“/”+表）；
如果（！directory.exists（））{
mkdirs（）目录；
}
列表>（）；
添加（AsciiType.instance）；
添加（AsciiType.instance）；
CompositeType compositeColumn=CompositeType.getInstance（compositeColumnValues）；
System.out.println（“yahahahaha”）；
SSTABLESImpleUsertedWriter bulkWriter=新SSTABLESImpleUsertedWriter(
目录，新的分区器（），键空间，表，
复合柱，空，64）；
//为每个插入创建一个时间戳
长时间戳=System.currentTimeMillis（）*1000；
BufferedReader reader=新的BufferedReader（新文件读取器（csvfilename））；
弦线；
int lineNumber=1；
CsvEntry entry=新的CsvEntry（）；
而（（line=reader.readLine（））！=null）{
if（entry.parse（行，行号））{
ByteBuffer uuid=ByteBuffer.wrap（分解（entry.key））；
bulkWriter.newRow（uuid）；
Builder=compositeColumn.Builder（）；
add（字节（entry.firstname））；
添加（字节（“名字”））；
addColumn（builder.build（），字节（entry.firstname），时间戳）；
builder=compositeColumn.builder（）；
add（字节（entry.firstname））；
builder.add（字节（“lastname”）；
addColumn（builder.build（），字节（entry.lastname），时间戳）；
builder=compositeColumn.builder（）；
add（字节（entry.firstname））；
添加（字节（“密码”）；
addColumn（builder.build（），字节（entry.password），时间戳）；
builder=compositeColumn.builder（）；
add（字节（entry.firstname））；
builder.add（字节（“年龄”）；
addColumn（builder.build（），字节（String.valueOf（entry.age）），时间戳）；
builder=compositeColumn.builder（）；
add（字节（entry.firstname））；
添加（字节（“电子邮件”）；
addColumn（builder.build（），字节（entry.email），时间戳）；
}
lineNumber++；
}
reader.close（）；
System.out.println（“成功”）；
bulkWriter.close（）；
系统出口（0）；
}
静态类CsvEntry{
UUID密钥；
字符串名；
字符串lastname；
字符串密码；
年龄长；
字符串电子邮件；
布尔解析（字符串行、整数行号）{
//犹太人区
String[]columns=line.split（“，”）；
如果（columns.length！=6）{
System.out.println（String.format(
“第%d行（共%s行）的输入“%s”无效”，第行，
行号（csvfilename））；
返回false；
}
试一试{
key=UUID.fromString（列[0].trim（））；
firstname=列[1]。trim（）；
lastname=columns[2].trim（）；