public void start() { // subscribe to incoming channel inChannel.subscribe(fiber, callback); }
public void send(Runnable code) { channel.publish(code); } }
public Agent() { this.channel = new MemoryChannel<Runnable>(); this.fiber = Fibers.pooledFiber(); channel.subscribe(fiber, callback); }
public void dispose() { if (req.dispose()) { SessionClosed<R> end = new SessionClosedImpl<>(request, req.getSession()); endChannel.publish(end); } } };
/** * Creates a batch subscription to the jetlang memory channel for the ANY * event handler. This method does not require synchronization since we are * using CopyOnWriteArrayList * * @param eventHandler */ protected void addANYHandler(final EventHandler eventHandler) { final int eventType = eventHandler.getEventType(); if (eventType != Events.ANY) { LOG.error("The incoming handler {} is not of type ANY", eventHandler); throw new IllegalArgumentException( "The incoming handler is not of type ANY"); } anyHandler.add(eventHandler); Callback<List<Event>> eventCallback = createEventCallbackForHandler(eventHandler); BatchSubscriber<Event> batchEventSubscriber = new BatchSubscriber<Event>( fiber, eventCallback, 0, TimeUnit.MILLISECONDS); Disposable disposable = eventQueue.subscribe(batchEventSubscriber); disposableHandlerMap.put(eventHandler, disposable); }
public Disposable publish(DisposingExecutor target, final R request, Callback<V> reply) { final RequestImpl req = new RequestImpl(target, request, reply); channel.publish(req); return new Disposable() { public void dispose() { if (req.dispose()) { SessionClosed<R> end = new SessionClosedImpl<>(request, req.getSession()); endChannel.publish(end); } } }; }
public Disposable subscribe(DisposingExecutor queue, Callback<T> onReceive) { ChannelSubscription<T> subber = new ChannelSubscription<>(queue, onReceive); return subscribe(subber); }
public static <R, V> Disposable publish(Fiber fiber, RequestChannel<R, V> channel, R request, final Callback<V> reply) { AsyncRequest<R, V> async = new AsyncRequest<>(fiber); async.setResponseCount(1); Callback<List<V>> onMsg = new Callback<List<V>>() { public void onMessage(List<V> message) { reply.onMessage(message.get(0)); } }; return async.publish(channel, request, onMsg); }
@Override public void fireEvent(final Event event) { if (null != dispatcherLane && dispatcherLane.isOnSameLane(Thread.currentThread().getName())) { dispatchEventOnSameLane(event); } else { eventQueue.publish(event); } }
public Disposable subscribe(Subscribable<T> sub) { return subscribeOnProducerThread(sub.getQueue(), sub); }
public JetlangActor() { this.inChannel = new MemoryChannel<T>(); this.outChannel = new MemoryChannel<T>(); this.callback = new Callback<T>(){ public void onMessage(T message) { act(message); }; }; this.fiber = Fibers.pooledFiber(); }
@Override public synchronized void close() { if (!isCloseCalled) { fiber.dispose(); eventQueue.clearSubscribers(); // Iterate through the list of disposables and dispose each one. Collection<Disposable> disposables = disposableHandlerMap.values(); for (Disposable disposable : disposables) { disposable.dispose(); } handlersByEventType.clear(); handlersByEventType = null; anyHandler.clear(); anyHandler = null; isCloseCalled = true; } }
public void dispose() { if (req.dispose()) { SessionClosed<R> end = new SessionClosedImpl<>(request, req.getSession()); endChannel.publish(end); } } };
public void sendMessage(T message) { outChannel.publish(message); }
public Downloader() { PoolFiberFactory f = new PoolFiberFactory(pool); //subscribe multiple fibers for parallel execution for (int i = 0, numThreads = 10; i < numThreads; i++) { Fiber fiber = f.create(); fiber.start(); fibers.add(fiber); channel.subscribe(fiber, new DownloadCallback()); } }
BatchSubscriber<Event> batchEventSubscriber = new BatchSubscriber<Event>( fiber, eventCallback, eventFilter, 0, TimeUnit.MILLISECONDS); Disposable disposable = eventQueue.subscribe(batchEventSubscriber); disposableHandlerMap.put(eventHandler, disposable);
public Disposable publish(DisposingExecutor target, final R request, Callback<V> reply) { final RequestImpl req = new RequestImpl(target, request, reply); channel.publish(req); return new Disposable() { public void dispose() { if (req.dispose()) { SessionClosed<R> end = new SessionClosedImpl<>(request, req.getSession()); endChannel.publish(end); } } }; }
public Disposable subscribe(DisposingExecutor queue, Callback<T> onReceive) { ChannelSubscription<T> subber = new ChannelSubscription<>(queue, onReceive); return subscribe(subber); }
public static EventDispatcher newJetlangEventDispatcher(GameRoom room, LaneStrategy<String, ExecutorService, GameRoom> strategy) { Fiber fiber = null; JetlangEventDispatcher dispatcher = null; if (null == room) { fiber = Fibers.pooledFiber(); dispatcher = new JetlangEventDispatcher(new MemoryChannel<Event>(), fiber, null); } else { Lane<String, ExecutorService> lane = strategy.chooseLane(room); fiber = Fibers.pooledFiber(lane); dispatcher = new JetlangEventDispatcher(new MemoryChannel<Event>(), fiber, lane); } dispatcher.initialize(); return dispatcher; } }
public void add(DownloadJob job) { if (job.getState() == State.PREPARING) { throw new IllegalArgumentException("Job already preparing"); } if (job.getState() == State.WORKING) { throw new IllegalArgumentException("Job already working"); } if (job.getState() == State.FINISHED) { throw new IllegalArgumentException("Job already finished"); } job.setState(State.NEW); jobs.add(job); channel.publish(job); }