Java InvalidTopologyException类代码示例

import org.apache.storm.generated.InvalidTopologyException; //导入依赖的package包/类
public static void main(String[] args) throws AlreadyAliveException,
		InvalidTopologyException {
	// create an instance of TopologyBuilder class
	TopologyBuilder builder = new TopologyBuilder();
	// set the spout class
	builder.setSpout("SampleSpout", new SampleSpout(), 2);
	// set the bolt class
	builder.setBolt("SampleBolt", new SampleBolt(), 4).shuffleGrouping(
			"SampleSpout");
	Config conf = new Config();
	conf.setNumWorkers(3);
	// This statement submit the topology on remote
	// args[0] = name of topology
	try {
		StormSubmitter.submitTopology(args[0], conf,
				builder.createTopology());
	} catch (AlreadyAliveException alreadyAliveException) {
		System.out.println(alreadyAliveException);
	} catch (InvalidTopologyException invalidTopologyException) {
		System.out.println(invalidTopologyException);
	} catch (AuthorizationException e) {
		// TODO Auto-generated catch block
		e.printStackTrace();
	}
}
 

import org.apache.storm.generated.InvalidTopologyException; //导入依赖的package包/类
private LocalCluster submitTopology() throws AlreadyAliveException,
        InvalidTopologyException {
    Config stormConfig = new Config();
    stormConfig.setDebug(false);
    stormConfig.setFallBackOnJavaSerialization(true);
    stormConfig.setNumWorkers(1);

    // enable backpressure since the spouts can move at a much faster speed than the bolts
    stormConfig.put(Config.TOPOLOGY_BACKPRESSURE_ENABLE, true);
    stormConfig.put(Config.TOPOLOGY_EXECUTOR_RECEIVE_BUFFER_SIZE, 2048);
    stormConfig.put(Config.TOPOLOGY_EXECUTOR_SEND_BUFFER_SIZE, 2048);
    stormConfig.put(Config.TOPOLOGY_SLEEP_SPOUT_WAIT_STRATEGY_TIME_MS, 1000);
    stormConfig.put(Config.TOPOLOGY_MAX_SPOUT_PENDING, 10);

    stormConfig.setSkipMissingKryoRegistrations(true);
    stormConfig.put(ConfigurationConstants.CHATALYTICS_CONFIG.txt,
                    YamlUtils.writeYaml(chatalyticsConfig));

    LocalCluster cluster = new LocalCluster();
    cluster.submitTopology(TOPOLOGY_NAME, stormConfig, chatTopology);
    return cluster;
}
 

import org.apache.storm.generated.InvalidTopologyException; //导入依赖的package包/类
public static void main(final String[] args) throws AlreadyAliveException, InvalidTopologyException,
NotAliveException {

	if (!WordCountTopology.parseParameters(args)) {
		return;
	}

	// build Topology the Storm way
	final TopologyBuilder builder = WordCountTopology.buildTopology();

	// execute program on Flink cluster
	final Config conf = new Config();
	// can be changed to remote address
	conf.put(Config.NIMBUS_HOST, "localhost");
	// use default flink jobmanger.rpc.port
	conf.put(Config.NIMBUS_THRIFT_PORT, 6123);

	final FlinkClient cluster = FlinkClient.getConfiguredClient(conf);
	cluster.submitTopology(topologyId, uploadedJarLocation, FlinkTopology.createTopology(builder));

	Utils.sleep(5 * 1000);

	cluster.killTopology(topologyId);
}
 

import org.apache.storm.generated.InvalidTopologyException; //导入依赖的package包/类
private static void run(String name)
        throws ClassNotFoundException, IllegalAccessException,
        InstantiationException, AlreadyAliveException, InvalidTopologyException {
  LOG.info("running benchmark " + name);
  IBenchmark benchmark =  (IBenchmark) Runner.getApplicationFromName(PACKAGE + "." + name);
  Config config = new Config();
  config.putAll(Utils.readStormConfig());
  config.setDebug(true);
  StormTopology topology = benchmark.getTopology(config);
  LocalCluster localCluster = new LocalCluster();
  localCluster.submitTopology(name, config, topology);
  final int runtime = BenchmarkUtils.getInt(config, MetricsCollectorConfig.METRICS_TOTAL_TIME,
          MetricsCollectorConfig.DEFAULT_TOTAL_TIME);
  IMetricsCollector collector = benchmark.getMetricsCollector(config, topology);
  collector.run();
  try {
    Thread.sleep(runtime);
  } catch (InterruptedException e) {
    LOG.error("benchmark interrupted", e);
  }
  localCluster.shutdown();
}
 

import org.apache.storm.generated.InvalidTopologyException; //导入依赖的package包/类
@Override
@SuppressWarnings({"rawtypes", "unchecked"})
public void submitTopology(String topoName,
                           Map config,
                           StormTopology stormTopology)
    throws AlreadyAliveException, InvalidTopologyException {
  assertNotAlive();

  this.topologyName = topoName;
  this.conf = config;
  this.topology = stormTopology;

  simulator.submitTopology(topoName,
      ConfigUtils.translateConfig(config),
      stormTopology.getStormTopology());
}
 

import org.apache.storm.generated.InvalidTopologyException; //导入依赖的package包/类
public static void main(String[] args) throws InterruptedException, AlreadyAliveException, InvalidTopologyException, AuthorizationException {
   TopologyBuilder builder = new TopologyBuilder();
   builder.setSpout(DATA_GENERATOR, new ASpout());
   builder.setBolt(DATA_CALCULATOR, new ABolt()).shuffleGrouping(DATA_GENERATOR);
   builder.setBolt(DATA_PRINTER, new DataPrinter()).shuffleGrouping(DATA_CALCULATOR).shuffleGrouping(DATA_GENERATOR);

   Config config = new Config();

   LocalCluster cluster = new LocalCluster();
   cluster.submitTopology(TOPOLOGY_NAME, config,
         builder.createTopology());

   Thread.sleep(100000);
   cluster.killTopology(TOPOLOGY_NAME);
   cluster.shutdown();
}
 

import org.apache.storm.generated.InvalidTopologyException; //导入依赖的package包/类
protected void run() {
	Config config = new Config();
	config.setNumWorkers(2);
	config.setMessageTimeoutSecs(120);

	try {
		StormSubmitter.submitTopology(builder.getTopologyName(), config, builder.build());
	} catch (AlreadyAliveException | InvalidTopologyException | AuthorizationException e) {
		String message = "could not submit topology" + builder.getTopologyName();
		logger.error(message, e);
		throw new StormException(message, e);
	}	
}
 

import org.apache.storm.generated.InvalidTopologyException; //导入依赖的package包/类
public static void main(String[] args)
        throws InvalidTopologyException, AuthorizationException, AlreadyAliveException, InterruptedException {
    ConfigurableApplicationContext context = SpringApplication.run(DemoApplication.class, args);
    AppMain appMain = context.getBean(AppMain.class);
    appMain.Laugher();
    SpringApplication.exit(context);
}
 

import org.apache.storm.generated.InvalidTopologyException; //导入依赖的package包/类
public static void main(String[] args) throws AlreadyAliveException,
		InvalidTopologyException {
	TopologyBuilder builder = new TopologyBuilder();

	// set the spout class
	builder.setSpout("spout", new SampleSpout(), 2);
	// set the ES bolt class
	builder.setBolt("bolt", new EsperBolt(), 2)
			.shuffleGrouping("spout");
	Config conf = new Config();
	conf.setDebug(true);
	// create an instance of LocalCluster class for
	// executing topology in local mode.
	LocalCluster cluster = new LocalCluster();

	// EsperTopology is the name of submitted topology.
	cluster.submitTopology("EsperTopology", conf,
			builder.createTopology());
	try {
		Thread.sleep(60000);
	} catch (Exception exception) {
		System.out.println("Thread interrupted exception : " + exception);
	}
	System.out.println("Stopped Called : ");
	// kill the LearningStormTopology
	cluster.killTopology("EsperTopology");
	// shutdown the storm test cluster
	cluster.shutdown();

}
 

import org.apache.storm.generated.InvalidTopologyException; //导入依赖的package包/类
public static void main(String[] args) throws AlreadyAliveException,
		InvalidTopologyException {
	TopologyBuilder builder = new TopologyBuilder();

	List<String> zks = new ArrayList<String>();
	zks.add("127.0.0.1");

	List<String> cFs = new ArrayList<String>();
	cFs.add("personal");
	cFs.add("company");

	// set the spout class
	builder.setSpout("spout", new SampleSpout(), 2);
	// set the bolt class
	builder.setBolt("bolt", new StormHBaseBolt("user", cFs, zks, 2181), 2)
			.shuffleGrouping("spout");
	Config conf = new Config();
	conf.setDebug(true);
	// create an instance of LocalCluster class for
	// executing topology in local mode.
	LocalCluster cluster = new LocalCluster();

	// LearningStormTopolgy is the name of submitted topology.
	cluster.submitTopology("StormHBaseTopology", conf,
			builder.createTopology());
	try {
		Thread.sleep(60000);
	} catch (Exception exception) {
		System.out.println("Thread interrupted exception : " + exception);
	}
	System.out.println("Stopped Called : ");
	// kill the LearningStormTopology
	cluster.killTopology("StormHBaseTopology");
	// shutdown the storm test cluster
	cluster.shutdown();

}
 

import org.apache.storm.generated.InvalidTopologyException; //导入依赖的package包/类
public static void main(String[] args) throws AlreadyAliveException,
		InvalidTopologyException {
	TopologyBuilder builder = new TopologyBuilder();

	//ES Node list
	List<String> esNodes = new ArrayList<String>();
	esNodes.add("10.191.209.14");

	// set the spout class
	builder.setSpout("spout", new SampleSpout(), 2);
	// set the ES bolt class
	builder.setBolt("bolt", new ESBolt(esNodes), 2)
			.shuffleGrouping("spout");
	Config conf = new Config();
	conf.setDebug(true);
	// create an instance of LocalCluster class for
	// executing topology in local mode.
	LocalCluster cluster = new LocalCluster();

	// ESTopology is the name of submitted topology.
	cluster.submitTopology("ESTopology", conf,
			builder.createTopology());
	try {
		Thread.sleep(60000);
	} catch (Exception exception) {
		System.out.println("Thread interrupted exception : " + exception);
	}
	System.out.println("Stopped Called : ");
	// kill the LearningStormTopology
	cluster.killTopology("StormHBaseTopology");
	// shutdown the storm test cluster
	cluster.shutdown();

}
 

import org.apache.storm.generated.InvalidTopologyException; //导入依赖的package包/类
public static void main(String[] args) throws AlreadyAliveException,
		InvalidTopologyException {
	// create an instance of TopologyBuilder class
	TopologyBuilder builder = new TopologyBuilder();
	// set the spout class
	builder.setSpout("SampleSpout", new SampleSpout(), 2);
	// set the bolt class
	builder.setBolt("SampleBolt", new SampleBolt(), 4).shuffleGrouping(
			"SampleSpout");
	Config conf = new Config();
	conf.setDebug(true);
	// create an instance of LocalCluster class for
	// executing topology in local mode.
	LocalCluster cluster = new LocalCluster();
	// SampleStormTopology is the name of submitted topology
	cluster.submitTopology("SampleStormTopology", conf,
			builder.createTopology());
	try {
		Thread.sleep(100000);
	} catch (Exception exception) {
		System.out.println("Thread interrupted exception : " + exception);
	}
	// kill the SampleStormTopology
	cluster.killTopology("SampleStormTopology");
	// shutdown the storm test cluster
	cluster.shutdown();
}
 

import org.apache.storm.generated.InvalidTopologyException; //导入依赖的package包/类
public static void main(String[] args)
		throws InterruptedException, AlreadyAliveException, InvalidTopologyException, AuthorizationException {
	RandomSpout r = new RandomSpout();

	// Sliding window used to test withLag
	// BaseWindowedBolt b = new WindowDemoBolt().withTimestampField("time")
	// .withWindow(new Duration(5, TimeUnit.SECONDS), new Duration(3,
	// TimeUnit.SECONDS))
	// // When get tuple with timestamp
	// // t1(10:00:10)，t2(10:00:14)，t3(10:00:12)，t4(10:00:16) in turn,
	// // If we won't set withLag, storm would throw t3 away. But if
	// // setted and (lag + t3) > t2, t3 will not be dropped.
	// .withLag(new Duration(2, TimeUnit.SECONDS));

	// Sliding window used to test watermark
	BaseWindowedBolt b = new WindowDemoBolt().withTimestampField("time")
			.withWindow(new Duration(20, TimeUnit.SECONDS), new Duration(10, TimeUnit.SECONDS))
			.withLag(new Duration(5, TimeUnit.SECONDS));

	TopologyBuilder builder = new TopologyBuilder();
	builder.setSpout("spout", r);
	builder.setBolt("window-bolt", b).shuffleGrouping("spout");

	Config conf = new Config();
	if (args.length == 0) {
		LocalCluster cluster = new LocalCluster();
		cluster.submitTopology("test", conf, builder.createTopology());
		Thread.sleep(3600000L);
		cluster.shutdown();
	} else {
		StormSubmitter.submitTopology("test-window", conf, builder.createTopology());
	}
}
 

import org.apache.storm.generated.InvalidTopologyException; //导入依赖的package包/类
public static void runPirkTopology() throws PIRException
{
  // Set up Kafka parameters
  logger.info("Configuring Kafka.");
  String zkRoot = "/" + kafkaTopic + "_pirk_storm";
  BrokerHosts zkHosts = new ZkHosts(brokerZk);
  SpoutConfig kafkaConfig = new SpoutConfig(zkHosts, kafkaTopic, zkRoot, kafkaClientId);
  kafkaConfig.ignoreZkOffsets = forceFromStart;

  // Create conf
  logger.info("Retrieving Query and generating Storm conf.");
  Config conf = createStormConf();
  Query query = StormUtils.getQuery(useHdfs, hdfsUri, queryFile);
  conf.put(StormConstants.N_SQUARED_KEY, query.getNSquared().toString());
  conf.put(StormConstants.QUERY_INFO_KEY, query.getQueryInfo().toMap());

  // Configure this for different types of input data on Kafka.
  kafkaConfig.scheme = new SchemeAsMultiScheme(new PirkHashScheme(conf));

  // Create topology
  StormTopology topology = getPirkTopology(kafkaConfig);

  // Run topology
  logger.info("Submitting Pirk topology to Storm...");
  try
  {
    StormSubmitter.submitTopologyWithProgressBar(topologyName, conf, topology);
  } catch (AlreadyAliveException | InvalidTopologyException | AuthorizationException e)
  {
    throw new PIRException(e);
  }

}
 

import org.apache.storm.generated.InvalidTopologyException; //导入依赖的package包/类
public static void main(String[] args)
		throws InterruptedException, InvalidTopologyException, AuthorizationException, AlreadyAliveException {

	String topologyName = "TSAS";// 元组名
	// Zookeeper主机地址，会自动选取其中一个
	ZkHosts zkHosts = new ZkHosts("192.168.230.128:2181,192.168.230.129:2181,192.168.230.131:2181");
	String topic = "trademx";
	String zkRoot = "/storm";// storm在Zookeeper上的根路径
	String id = "tsaPro";

	// 创建SpoutConfig对象
	SpoutConfig spontConfig = new SpoutConfig(zkHosts, topic, zkRoot, id);

	TopologyBuilder builder = new TopologyBuilder();
	builder.setSpout("kafka", new KafkaSpout(spontConfig), 2);
	builder.setBolt("AccBolt", new AccBolt()).shuffleGrouping("kafka");
	builder.setBolt("ToDbBolt", new ToDbBolt()).shuffleGrouping("AccBolt");

	Config config = new Config();
	config.setDebug(false);

	if (args.length == 0) { // 本地运行，用于测试
		LocalCluster localCluster = new LocalCluster();
		localCluster.submitTopology(topologyName, config, builder.createTopology());
		Thread.sleep(1000 * 3600);
		localCluster.killTopology(topologyName);
		localCluster.shutdown();
	} else { // 提交至集群运行
		StormSubmitter.submitTopology(topologyName, config, builder.createTopology());
	}

}