Java 如何在storm群集上运行拓扑？我看不到输出日志

我正在尝试在集群中执行拓扑。我编写了一个拓扑并将其编译成jar，然后将其注册到集群。但由于某些原因，拓扑似乎没有运行。我只想把这里的暴风当作管道。向cmd注册：

/storm jar/tmp/storm\u test.jar storm.topology.MyTopology/tmp/bigFile.log

拓扑结构：

package storm.topology;

import storm.spouts.LineReaderSpout;

import backtype.storm.Config;
import backtype.storm.StormSubmitter;
import backtype.storm.topology.TopologyBuilder;
import storm.bolts.Bolt;

public class MyTopology {
    public static long tupleCounter = 0;
    public static long endTime = 0;

    public static void main(String[] args) throws Exception {
        Config config = new Config();
        config.put("inputFile", args[0]);
        config.put(Config.TOPOLOGY_WORKERS, 4);
        config.setDebug(true);
        config.put(Config.TOPOLOGY_MAX_SPOUT_PENDING, 10);

        TopologyBuilder builder = new TopologyBuilder();
        builder.setSpout("line-reader-spout", new LineReaderSpout());

        builder.setBolt("boltA", new Bolt()).shuffleGrouping("line-reader-spout");

        StormSubmitter.submitTopology("mytopology", config, builder.createTopology()); 
    }
}

螺栓：

包装风暴螺栓；
导入backtype.storm.task.OutputCollector；
导入backtype.storm.task.TopologyContext；
导入backtype.storm.topology.IRichBolt；
导入backtype.storm.topology.outputfieldsclarer；
导入backtype.storm.tuple.tuple；
导入java.io.FileNotFoundException；
导入java.io.PrintWriter；
导入java.io.UnsupportedEncodingException；
导入storm.topology.MyTopology2；
导入storm.spouts.LineReaderSpout；
导入java.text.NumberFormat；
导入java.util.HashMap；
导入java.util.Locale；
导入java.util.Map；
导入java.util.logging.Level；
导入java.util.logging.Logger；
公共类螺栓实现虹彩螺栓{
整数id；
字符串名；
静态总时间长；
地图计数器；
专用输出采集器；
@凌驾
public void prepare（地图风暴形态、拓扑上下文、OutputCollector）{
this.counters=new HashMap（）；
this.collector=收集器；
this.name=context.getThisComponentId（）；
this.id=context.getHistAskid（）；
}
@凌驾
公共void执行（元组输入）{
//String str=input.getString（0）；
MyTopology2.tupleCounter++；
if（input.getString（0.contains）（“END”））{
MyTopology.endTime=System.nanoTime（）；
System.out.println（“===============================================================================”）；
System.out.println（“元组数：“+MyTopology.tupleCounter”）；
totalTime=MyTopology.endTime-LineReaderSpout.startTime；
双tuplePerSec=MyTopology.tupleCounter/（总时间/1000000000d）；
System.out.println（“测试结果：+NumberFormat.getNumberInstance（Locale.US）.format（tuplePerSec）+“tuple/sec”）；
totalTime=MyTopology2.endTime-LineReaderSpout.star`在此处输入代码`tTime；
System.out.println（“总运行时间：“+totalTime+“nsec”）；
System.out.println（“===============================================================================”）；
版画作家；
试一试{
writer=新的PrintWriter（“/tmp/storm_results.log”，“UTF-8”）；
println（“元组数：+MyTopology.tupleCounter”）；
writer.println（“测试结果：”+
NumberFormat.getNumberInstance（Locale.US）.format（tuplePerSec）+“tuple/sec”）；
println（“总运行时间：“+totalTime+“nsec”）；
writer.println（“===============================================================================”）；
writer.close（）；
}捕获（FileNotFoundException ex）{
Logger.getLogger（TestBolt.class.getName（））.log（Level.SEVERE，null，ex）；
}捕获（不支持DencodingException ex）{
Logger.getLogger（TestBolt.class.getName（））.log（Level.SEVERE，null，ex）；
}
}
}
@凌驾
公共空间清理（）{
}
@凌驾
公共无效申报输出字段（OutputFields申报器申报器）{
//TODO自动生成的方法存根
}
@凌驾
公共映射getComponentConfiguration（）{
//TODO自动生成的方法存根
返回null；
}
}

喷口：

package storm.spouts;

import java.io.BufferedReader;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;
import java.util.Map;

import backtype.storm.spout.SpoutOutputCollector;
import backtype.storm.task.TopologyContext;
import backtype.storm.topology.IRichSpout;
import backtype.storm.topology.OutputFieldsDeclarer;
import backtype.storm.tuple.Fields;
import backtype.storm.tuple.Values;

public class LineReaderSpout implements IRichSpout {
    private SpoutOutputCollector collector;
    private FileReader fileReader;
    private boolean completed = false;
    private TopologyContext context;
    public static long startTime;

    @Override
    public void open(Map conf, TopologyContext context,
            SpoutOutputCollector collector) {
        try {
            this.context = context;
            this.fileReader = new FileReader(conf.get("inputFile").toString());
            startTime = System.nanoTime();
        } catch (FileNotFoundException e) {
            throw new RuntimeException("Error reading file "
                    + conf.get("inputFile"));
        }
        this.collector = collector;
    }

    @Override
    public void nextTuple() {
        if (completed) {

        }
        String str;
        BufferedReader reader = new BufferedReader(fileReader);
        try {
            while ((str = reader.readLine()) != null) {
                this.collector.emit(new Values(str), str);
            }
        } catch (Exception e) {
            throw new RuntimeException("Error reading typle", e);
        } finally {
            completed = true;
        }
    }

    @Override
    public void declareOutputFields(OutputFieldsDeclarer declarer) {
        declarer.declare(new Fields("line"));
    }

    @Override
    public void close() {
        try {
            fileReader.close();
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }

    public boolean isDistributed() {
        return false;
    }

    @Override
    public void activate() {
        // TODO Auto-generated method stub
    }

    @Override
    public void deactivate() {
        // TODO Auto-generated method stub
    }

    @Override
    public void ack(Object msgId) {
    }

    @Override
    public void fail(Object msgId) {
    }

    @Override
    public Map<String, Object> getComponentConfiguration() {
        return null;
    }
}

package storm.spoots；
导入java.io.BufferedReader；
导入java.io.FileNotFoundException；
导入java.io.FileReader；
导入java.io.IOException；
导入java.util.Map；
导入backtype.storm.spoutt.spoutToutPutCollector；
导入backtype.storm.task.TopologyContext；
导入backtype.storm.topology.IRichSpout；
导入backtype.storm.topology.outputfieldsclarer；
导入backtype.storm.tuple.Fields；
导入backtype.storm.tuple.Values；
公共类LineReaderSpout实现IRichSpout{
私人管道出口收集器；
私有文件读取器文件读取器；
private boolean completed=false；
私有拓扑上下文；
公共静态长启动时间；
@凌驾
公共空间打开（地图形态、拓扑上下文、，
喷出口收集器（收集器）{
试一试{
this.context=上下文；
this.fileReader=newfilereader（conf.get（“inputFile”）.toString（））；
startTime=System.nanoTime（）；
}catch（filenotfounde异常）{
抛出新的运行时异常（“读取文件时出错”
+conf.get（“inputFile”）；
}
this.collector=收集器；
}
@凌驾
public void nextTuple（）{
如果（已完成）{
}
字符串str；
BufferedReader reader=新的BufferedReader（文件读取器）；
试一试{
而（（str=reader.readLine（））！=null）{
emit（新值（str），str）；
}
}捕获（例外e）{
抛出新的运行时异常（“错误读取类型”，e）；
}最后{
完成=正确；
}
}
@凌驾
公共无效申报输出字段（OutputFields申报器申报器）{
申报人申报（新字段（“行”）；
}
@凌驾
公众假期结束（）{
试一试{
fileReader.close（）；
}捕获（IOE异常）{
//TODO自动生成的捕捉块
e、 printStackTrace（）；
}
}
公共布尔值isDistributed（）{
返回false；
}
@凌驾
公开作废激活（）{
//TODO自动生成的方法存根
}
@凌驾
公开作废{
//TODO自动生成的方法存根
}
@凌驾
公共无效确认（对象msgId）{
}
@凌驾
公共无效失败（对象msgId）{
}
@凌驾
公共映射getComponentConf
package storm.spouts;

import java.io.BufferedReader;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;
import java.util.Map;

import backtype.storm.spout.SpoutOutputCollector;
import backtype.storm.task.TopologyContext;
import backtype.storm.topology.IRichSpout;
import backtype.storm.topology.OutputFieldsDeclarer;
import backtype.storm.tuple.Fields;
import backtype.storm.tuple.Values;

public class LineReaderSpout implements IRichSpout {
    private SpoutOutputCollector collector;
    private FileReader fileReader;
    private boolean completed = false;
    private TopologyContext context;
    public static long startTime;

    @Override
    public void open(Map conf, TopologyContext context,
            SpoutOutputCollector collector) {
        try {
            this.context = context;
            this.fileReader = new FileReader(conf.get("inputFile").toString());
            startTime = System.nanoTime();
        } catch (FileNotFoundException e) {
            throw new RuntimeException("Error reading file "
                    + conf.get("inputFile"));
        }
        this.collector = collector;
    }

    @Override
    public void nextTuple() {
        if (completed) {

        }
        String str;
        BufferedReader reader = new BufferedReader(fileReader);
        try {
            while ((str = reader.readLine()) != null) {
                this.collector.emit(new Values(str), str);
            }
        } catch (Exception e) {
            throw new RuntimeException("Error reading typle", e);
        } finally {
            completed = true;
        }
    }

    @Override
    public void declareOutputFields(OutputFieldsDeclarer declarer) {
        declarer.declare(new Fields("line"));
    }

    @Override
    public void close() {
        try {
            fileReader.close();
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }

    public boolean isDistributed() {
        return false;
    }

    @Override
    public void activate() {
        // TODO Auto-generated method stub
    }

    @Override
    public void deactivate() {
        // TODO Auto-generated method stub
    }

    @Override
    public void ack(Object msgId) {
    }

    @Override
    public void fail(Object msgId) {
    }

    @Override
    public Map<String, Object> getComponentConfiguration() {
        return null;
    }
}

    LocalCluster cluster = new LocalCluster();
    cluster.submitTopology("mytopology", conf, builder.createTopology());