Java IConnection类代码示例

import backtype.storm.messaging.IConnection; //导入依赖的package包/类
protected IConnection zmq_bind(boolean distributeZmq, int port) {
	String url = null;
	if (distributeZmq) {
		if (ipc) {
			url = "ipc://" + port + ".ipc";
		} else {
			url = "tcp://*:" + port;
		}
	} else {
		// virtportZmq will be true
		url = "inproc://" + port;
	}
	
	Socket socket = ZeroMq.socket(context, ZeroMq.pull);

	ZeroMq.bind(socket, url);
	ZeroMq.set_hwm(socket, maxQueueMsg);

	// ZeroMq.subscribe(socket);

	LOG.info("Create zmq receiver {}", url);
	return new ZMQRecvConnection(socket);
}
 

import backtype.storm.messaging.IConnection; //导入依赖的package包/类
protected IConnection zmq_connect(boolean distributeZmq, String host, int port) {
	String url = null;

	if (distributeZmq) {
		if (ipc) {
			url = "ipc://" + port + ".ipc";
		} else {
			url = "tcp://" + host + ":" + port;
		}
	} else {
		// virtportZmq will be true
		url = "inproc://" + port;
	}

	Socket socket = ZeroMq.socket(context, ZeroMq.push);
	socket = ZeroMq.set_linger(socket, linger_ms);
	socket = ZeroMq.connect(socket, url);
	ZeroMq.set_hwm(socket, maxQueueMsg);

	LOG.info("Create zmq sender {}", url);
	return new ZMQSendConnection(socket, host, port);
}
 

import backtype.storm.messaging.IConnection; //导入依赖的package包/类
private boolean isOutTaskConnected(int taskId) {
    boolean ret = false;

    if (workerData.getInnerTaskTransfer().get(taskId) != null) {
        // Connections to inner tasks should be done after initialization. 
        // So return true here for all inner tasks.
        ret = true;
    } else {
        WorkerSlot slot = taskNodeport.get(taskId);
        if (slot != null) {
            IConnection connection = nodeportSocket.get(slot);
            if (connection != null) {
                ret = connection.available();
            }
        }
    }

    return ret;
}
 

import backtype.storm.messaging.IConnection; //导入依赖的package包/类
@Override
 public void onEvent(Object event, long sequence, boolean endOfBatch) throws Exception {

     if (event == null) {
         return;
     }

     long start = System.nanoTime();

     try {
			
ITupleExt tuple = (ITupleExt) event;
         int taskid = tuple.getTargetTaskId();
         IConnection conn = getConnection(taskid);
         if (conn != null) {
         	byte[] tupleMessage = serialize(tuple);
             TaskMessage taskMessage = new TaskMessage(taskid, tupleMessage);
             conn.send(taskMessage);
         }
     } finally {
         long end = System.nanoTime();
         serializeTimer.update((end - start)/TimeUtils.NS_PER_US);
     }

 }
 

import backtype.storm.messaging.IConnection; //导入依赖的package包/类
protected void pullTuples(Object event) {
    TupleExt tuple = (TupleExt) event;
    int taskid = tuple.getTargetTaskId();
    IConnection conn = getConnection(taskid);
    if (conn != null) {
        while (conn.available() == false) {
            try {
                Thread.sleep(1);
            } catch (InterruptedException e) {

            }
        }
        byte[] tupleMessage = serializer.serialize(tuple);
        TaskMessage taskMessage = new TaskMessage(taskid, tupleMessage);
        conn.send(taskMessage);
    }
}
 

import backtype.storm.messaging.IConnection; //导入依赖的package包/类
@Override
public void handleEvent(Object event, boolean endOfBatch) throws Exception {
    if (event == null) {
        return;
    }
    ITupleExt tuple = (ITupleExt) event;
    int targetTask = tuple.getTargetTaskId();

    IConnection conn = getConnection(targetTask);
    if (conn != null) {
        byte[] tupleMessage = null;
        try {
            //there might be errors when calling update_topology
            tupleMessage = serialize(tuple);
        } catch (Throwable e) {
            if (Utils.exceptionCauseIsInstanceOf(KryoException.class, e)) {
                throw new RuntimeException(e);
            } else {
                LOG.warn("serialize happened errors!!!", e);
            }
        }
        TaskMessage message = new TaskMessage(TaskMessage.CONTROL_MESSAGE, targetTask, tupleMessage);
        conn.sendDirect(message);
    }
}
 

import backtype.storm.messaging.IConnection; //导入依赖的package包/类
private boolean isOutTaskConnected(int taskId) {
    boolean ret = false;

    if (workerData.getInnerTaskTransfer().get(taskId) != null) {
        // Connections to inner tasks should be done after initialization.
        // So return true here for all inner tasks.
        ret = true;
    } else {
        WorkerSlot slot = taskToNodePort.get(taskId);
        if (slot != null) {
            IConnection connection = nodePortToSocket.get(slot);
            if (connection != null) {
                ret = connection.available(taskId);
            }
        }
    }

    return ret;
}
 

import backtype.storm.messaging.IConnection; //导入依赖的package包/类
private boolean isOutboundTaskAvailable(int taskId) {
    boolean ret = false;
    DisruptorQueue targetQueue = workerData.getInnerTaskTransfer().get(taskId);

    if (targetQueue != null) {
        float queueLoadRatio = targetQueue.pctFull();
        if (queueLoadRatio < loadMark) {
            ret = true;
        }
    } else {
        WorkerSlot slot = taskNodePort.get(taskId);
        if (slot != null) {
            IConnection connection = nodePortToSocket.get(slot);
            if (connection != null) {
                ret = connection.available(taskId);
            }
        }
    }

    if (!ret) {
        LOG.debug("taskId:{} is unavailable", taskId);
    }

    return ret;
}
 

import backtype.storm.messaging.IConnection; //导入依赖的package包/类
protected void serialize(KryoTupleSerializer serializer, Object event) {
    long start = serializeTimer.getTime();
    try {
        ITupleExt tuple = (ITupleExt) event;
        int targetTaskId = tuple.getTargetTaskId();
        IConnection conn = getConnection(targetTaskId);
        if (conn != null) {
            byte[] tupleMessage = serializer.serialize((TupleExt) tuple);
            //LOG.info("Task-{} sent msg to task-{}, data={}", task.getTaskId(), taskid,
            // JStormUtils.toPrintableString(tupleMessage));
            TaskMessage taskMessage = new TaskMessage(taskId, targetTaskId, tupleMessage);
            conn.send(taskMessage);
        } else {
            LOG.error("Can not find connection for task-{}", targetTaskId);
        }
    } finally {
        if (MetricUtils.metricAccurateCal) {
            serializeTimer.updateTime(start);
        }
    }
}
 

import backtype.storm.messaging.IConnection; //导入依赖的package包/类
private IConnection initNettyServer(int port) {
    ConcurrentHashMap<Integer, DisruptorQueue> deserializeQueues = new ConcurrentHashMap<Integer, DisruptorQueue>();
    //ConcurrentHashMap<Integer, DisruptorQueue> deserializeCtrlQueues = new ConcurrentHashMap<Integer, DisruptorQueue>();

    WaitStrategy wait = (WaitStrategy)Utils.newInstance("com.lmax.disruptor.TimeoutBlockingWaitStrategy", 5, TimeUnit.MILLISECONDS);
    DisruptorQueue recvControlQueue = DisruptorQueue.mkInstance("Dispatch-control", ProducerType.MULTI,
            256, wait, false, 0, 0);
    Set<Integer> taskSet = new HashSet<Integer>();
    taskSet.add(1);
    IConnection server = context.bind(null, port, deserializeQueues, recvControlQueue, true, taskSet);

    WaitStrategy waitStrategy = new BlockingWaitStrategy();
    DisruptorQueue recvQueue = DisruptorQueue.mkInstance("NettyUnitTest", ProducerType.SINGLE, 1024, waitStrategy, false, 0, 0);
    server.registerQueue(task, recvQueue);

    return server;
}
 

import backtype.storm.messaging.IConnection; //导入依赖的package包/类
@Override
public IConnection bind(String topology_id, int port) {
	IConnection retConnection = null;
	try {

		retConnection = new NettyServer(storm_conf, port, isSyncMode);
	} catch (Throwable e) {
		LOG.error("Failed to instance NettyServer", e.getCause());
		JStormUtils.halt_process(-1, "Failed to bind " + port);
	}

	return retConnection;
}
 

import backtype.storm.messaging.IConnection; //导入依赖的package包/类
@Override
public IConnection connect(String topology_id, String host, int port) {
	if (isSyncMode == true) {
		return new NettyClientSync(storm_conf, clientChannelFactory, clientScheduleService, host, port, reconnector);
	}else {
		return new NettyClientAsync(storm_conf, clientChannelFactory, clientScheduleService, host, port, reconnector);
	}
}
 

import backtype.storm.messaging.IConnection; //导入依赖的package包/类
public VirtualPortDispatch(WorkerData workerData,
		IConnection recvConnection, DisruptorQueue recvQueue) {
	super(recvQueue, timer, VirtualPortDispatch.class.getSimpleName(), 
			workerData.getActive());

	this.recvConnection = recvConnection;
	this.deserializeQueues = workerData.getDeserializeQueues();

	Metrics.registerQueue(null, MetricDef.DISPATCH_QUEUE, queue, null, Metrics.MetricType.WORKER);
}
 

import backtype.storm.messaging.IConnection; //导入依赖的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.IConnection; //导入依赖的package包/类
public BatchTupleRunable(WorkerData workerData) {
	super(workerData.getTransferQueue(), timer, BatchTupleRunable.class.getSimpleName(), workerData.getActive());
	this.sendingQueue = workerData.getSendingQueue();
	this.nodeportSocket = workerData.getNodeportSocket();
	this.taskNodeport = workerData.getTaskNodeport();
	this.dispatchMap = new HashMap<IConnection, List<TaskMessage>>();
	
	this.queue = workerData.getTransferQueue();
	Metrics.registerQueue(null, MetricDef.BATCH_TUPLE_QUEUE, this.queue, null, Metrics.MetricType.WORKER);
	
	this.queue.consumerStarted();
}