Java IContext类代码示例

import backtype.storm.messaging.IContext; //导入依赖的package包/类
/**
 * launch a worker in local mode
 * 
 * @param conf
 * @param sharedcontext
 * @param topologyId
 * @param supervisorId
 * @param port
 * @param workerId
 * @param workerThreadPidsAtom
 * @param workerThreadPidsAtomWriteLock
 * @pdOid 405f44c7-bc1b-4e16-85cc-b59352b6ff5d
 */
public void launchWorker(Map conf, IContext sharedcontext,
		String topologyId, String supervisorId, Integer port,
		String workerId,
		ConcurrentHashMap<String, String> workerThreadPidsAtom)
		throws Exception {

	String pid = UUID.randomUUID().toString();

	WorkerShutdown worker = Worker.mk_worker(conf, sharedcontext,
			topologyId, supervisorId, port, workerId, null);

	ProcessSimulator.registerProcess(pid, worker);

	workerThreadPidsAtom.put(workerId, pid);

}
 

import backtype.storm.messaging.IContext; //导入依赖的package包/类
/**
 * create worker instance and run it
 * 
 * @param conf
 * @param mq_context
 * @param topology_id
 * @param supervisor_id
 * @param port
 * @param worker_id
 * @return
 * @throws Exception
 */
public static WorkerShutdown mk_worker(Map conf, IContext context,
		String topology_id, String supervisor_id, int port,
		String worker_id, String jar_path) throws Exception {

	StringBuilder sb = new StringBuilder();
	sb.append("topologyId:" + topology_id + ", ");
	sb.append("port:" + port + ", ");
	sb.append("workerId:" + worker_id + ", ");
	sb.append("jarPath:" + jar_path + "\n");

	LOG.info("Begin to run worker:" + sb.toString());

	Worker w = new Worker(conf, context, topology_id, supervisor_id, port,
			worker_id, jar_path);
	
	w.redirectOutput();

	return w.execute();
}
 

import backtype.storm.messaging.IContext; //导入依赖的package包/类
/**
 * create worker instance and run it
 * 
 * @param conf
 * @param mq_context
 * @param topology_id
 * @param supervisor_id
 * @param port
 * @param worker_id
 * @return
 * @throws Exception
 */
@SuppressWarnings("rawtypes")
public static WorkerShutdown mk_worker(Map conf, IContext context,
		String topology_id, String supervisor_id, int port,
		String worker_id, String jar_path) throws Exception {

	StringBuilder sb = new StringBuilder();
	sb.append("topologyId:" + topology_id + ", ");
	sb.append("port:" + port + ", ");
	sb.append("workerId:" + worker_id + ", ");
	sb.append("jarPath:" + jar_path + "\n");

	LOG.info("Begin to run worker:" + sb.toString());

	Worker w = new Worker(conf, context, topology_id, supervisor_id, port,
			worker_id, jar_path);
	
	w.redirectOutput();

	return w.execute();
}
 

import backtype.storm.messaging.IContext; //导入依赖的package包/类
/**
 * create worker instance and run it
 * 
 * @param conf
 * @param topology_id
 * @param supervisor_id
 * @param port
 * @param worker_id
 * @return
 * @throws Exception
 */
@SuppressWarnings("rawtypes")
public static WorkerShutdown mk_worker(Map conf, IContext context, String topology_id, String supervisor_id, int port, String worker_id, String jar_path)
        throws Exception {

    StringBuilder sb = new StringBuilder();
    sb.append("topologyId:" + topology_id + ", ");
    sb.append("port:" + port + ", ");
    sb.append("workerId:" + worker_id + ", ");
    sb.append("jarPath:" + jar_path + "\n");

    LOG.info("Begin to run worker:" + sb.toString());

    Worker w = new Worker(conf, context, topology_id, supervisor_id, port, worker_id, jar_path);

    w.redirectOutput();

    return w.execute();
}
 

import backtype.storm.messaging.IContext; //导入依赖的package包/类
/**
 * @param conf
 * @param localState
 * @param workerThreadPids
 * @param supervisorId
 * @param sharedContext
 * @param workerThreadPidsReadLock
 * @param workerThreadPidsWriteLock
 */
public SyncProcessEvent(String supervisorId, Map conf,
		LocalState localState,
		ConcurrentHashMap<String, String> workerThreadPids,
		IContext sharedContext) {

	this.supervisorId = supervisorId;

	this.conf = conf;

	this.localState = localState;

	this.workerThreadPids = workerThreadPids;

	// right now, sharedContext is null
	this.sharedContext = sharedContext;

	this.sandBoxMaker = new SandBoxMaker(conf);

	if (ConfigExtension.isEnableCgroup(conf)) {
		cgroupManager = new CgroupManager(conf);
	}
}
 

import backtype.storm.messaging.IContext; //导入依赖的package包/类
public SyncProcessEvent(String supervisorId, Map conf, LocalState localState,
                        ConcurrentHashMap<String, String> workerThreadPids,
                        IContext sharedContext, WorkerReportError workerReportError,
                        StormClusterState stormClusterState) {
    this.supervisorId = supervisorId;
    this.conf = conf;
    this.localState = localState;
    this.workerThreadPids = workerThreadPids;

    // right now, sharedContext is null
    this.sharedContext = sharedContext;
    this.sandBoxMaker = new SandBoxMaker(conf);
    this.workerIdToStartTimeAndPort = new HashMap<>();
    this.needDownloadTopologies = new AtomicReference<>();
    this.isJstormOnYarn = JStormUtils.parseBoolean(System.getProperty("jstorm-on-yarn"), false) ||
            ConfigExtension.isJStormOnYarn(conf);
    if (ConfigExtension.isEnableCgroup(conf)) {
        cgroupManager = new CgroupManager(conf);
    }
    this.killingWorkers = new HashMap<>();
    this.upgradingTopologyPorts = new HashMap<>();
    this.workerReportError = workerReportError;
    this.stormClusterState = stormClusterState;
}
 

import backtype.storm.messaging.IContext; //导入依赖的package包/类
/**
 * create worker instance and run it
 *
 * @param conf         storm conf
 * @param topologyId   topology id
 * @param supervisorId supervisor iid
 * @param port         worker port
 * @param workerId     worker id
 * @return WorkerShutDown
 * @throws Exception
 */
@SuppressWarnings("rawtypes")
public static WorkerShutdown mk_worker(Map conf, IContext context, String topologyId, String supervisorId,
                                       int port, String workerId, String jarPath) throws Exception {
    StringBuilder sb = new StringBuilder();
    sb.append("topologyId:").append(topologyId).append(", ");
    sb.append("port:").append(port).append(", ");
    sb.append("workerId:").append(workerId).append(", ");
    sb.append("jarPath:").append(jarPath).append("\n");

    LOG.info("Begin to run worker:" + sb.toString());
    Worker w = new Worker(conf, context, topologyId, supervisorId, port, workerId, jarPath);
    //   w.redirectOutput();

    return w.execute();
}
 

import backtype.storm.messaging.IContext; //导入依赖的package包/类
public Worker(Map conf, IContext context, String topology_id,
		String supervisor_id, int port, String worker_id, String jar_path)
		throws Exception {

	workerData = new WorkerData(conf, context, topology_id, supervisor_id,
			port, worker_id, jar_path);

}
 

import backtype.storm.messaging.IContext; //导入依赖的package包/类
private AsyncLoopThread startDispatchThread() {
	Map stormConf = workerData.getStormConf();

	int queue_size = Utils.getInt(
			stormConf.get(Config.TOPOLOGY_TRANSFER_BUFFER_SIZE), 1024);
	WaitStrategy waitStrategy = (WaitStrategy) Utils
			.newInstance((String) stormConf
					.get(Config.TOPOLOGY_DISRUPTOR_WAIT_STRATEGY));
	DisruptorQueue recvQueue = DisruptorQueue.mkInstance("Dispatch", ProducerType.MULTI,
			queue_size, waitStrategy);
	// stop  consumerStarted
	//recvQueue.consumerStarted();

	IContext context = workerData.getContext();
	String topologyId = workerData.getTopologyId();

	IConnection recvConnection = context.bind(topologyId,
			workerData.getPort());
	recvConnection.registerQueue(recvQueue);

	RunnableCallback recvDispather = new VirtualPortDispatch(workerData,
			recvConnection, recvQueue);

	AsyncLoopThread vthread = new AsyncLoopThread(recvDispather, false,
			Thread.MAX_PRIORITY, false);

	return vthread;
}
 

import backtype.storm.messaging.IContext; //导入依赖的package包/类
public static LocalClusterMap prepareLocalCluster() {
	LocalClusterMap state = new LocalClusterMap();
	try {
		List<String> tmpDirs = new ArrayList();

		String zkDir = getTmpDir();
		tmpDirs.add(zkDir);
		Factory zookeeper = startLocalZookeeper(zkDir);
		Map conf = getLocalConf(zookeeper.getZooKeeperServer()
				.getClientPort());

		String nimbusDir = getTmpDir();
		tmpDirs.add(nimbusDir);
		Map nimbusConf = deepCopyMap(conf);
		nimbusConf.put(Config.STORM_LOCAL_DIR, nimbusDir);
		NimbusServer instance = new NimbusServer();

		Map supervisorConf = deepCopyMap(conf);
		String supervisorDir = getTmpDir();
		tmpDirs.add(supervisorDir);
		supervisorConf.put(Config.STORM_LOCAL_DIR, supervisorDir);
		Supervisor supervisor = new Supervisor();
		IContext context = getLocalContext(supervisorConf);

		state.setNimbusServer(instance);
		state.setNimbus(instance.launcherLocalServer(nimbusConf,
				new DefaultInimbus()));
		state.setZookeeper(zookeeper);
		state.setConf(conf);
		state.setTmpDir(tmpDirs);
		state.setSupervisor(supervisor
				.mkSupervisor(supervisorConf, context));
		return state;
	} catch (Exception e) {
		LOG.error("prepare cluster error!", e);
		state.clean();

	}
	return null;
}
 

import backtype.storm.messaging.IContext; //导入依赖的package包/类
private static IContext getLocalContext(Map conf) {
	if (!(Boolean) conf.get(Config.STORM_LOCAL_MODE_ZMQ)) {
		IContext result = new NettyContext();
		result.prepare(conf);
		return result;
	}
	return null;
}
 

import backtype.storm.messaging.IContext; //导入依赖的package包/类
@Test
public void test_zmq() throws Exception {
	String klassName = "com.alibaba.jstorm.message.zeroMq.MQContext";
	Class klass = Class.forName(klassName);
	Constructor<IContext> constructor = klass.getDeclaredConstructor();
	constructor.setAccessible(true);
	IContext context = (IContext) constructor.newInstance();
	Assert.assertNotNull(context);
}
 

import backtype.storm.messaging.IContext; //导入依赖的package包/类
@Test
public void test_netty() {
	Map storm_conf = Maps.newHashMap();
	storm_conf.put(Config.STORM_MESSAGING_TRANSPORT,
			"com.alibaba.jstorm.message.netty.NettyContext");
	storm_conf.put(Config.STORM_MESSAGING_NETTY_BUFFER_SIZE, 1024);
	storm_conf.put(Config.STORM_MESSAGING_NETTY_MAX_RETRIES, 10);
	storm_conf.put(Config.STORM_MESSAGING_NETTY_MIN_SLEEP_MS, 1000);
	storm_conf.put(Config.STORM_MESSAGING_NETTY_MAX_SLEEP_MS, 5000);
	storm_conf.put(Config.STORM_MESSAGING_NETTY_SERVER_WORKER_THREADS, 1);
	storm_conf.put(Config.STORM_MESSAGING_NETTY_CLIENT_WORKER_THREADS, 1);
	IContext context = TransportFactory.makeContext(storm_conf);
	Assert.assertNotNull(context);
}
 

import backtype.storm.messaging.IContext; //导入依赖的package包/类
@SuppressWarnings({ "rawtypes", "unchecked" })
public Worker(Map conf, IContext context, String topology_id,
		String supervisor_id, int port, String worker_id, String jar_path)
		throws Exception {

	workerData = new WorkerData(conf, context, topology_id, supervisor_id,
			port, worker_id, jar_path);

}
 

import backtype.storm.messaging.IContext; //导入依赖的package包/类
private void startDispatchThread() {
    // remove dispatch thread, send tuple directly from nettyserver
    // startDispatchDisruptor();

    IContext context = workerData.getContext();
    String topologyId = workerData.getTopologyId();

    IConnection recvConnection = context.bind(topologyId, workerData.getPort(), workerData.getDeserializeQueues());

    workerData.setRecvConnection(recvConnection);
}