public CallbackConnection(MQTT mqtt) { this.mqtt = mqtt; if(this.mqtt.dispatchQueue == null) { this.queue = createQueue("mqtt client"); } else { this.queue = this.mqtt.dispatchQueue; } }
public CallbackConnection refiller(Runnable refiller) { queue.assertExecuting(); this.refiller = refiller; return this; }
public boolean full() { queue.assertExecuting(); return this.transport.full(); }
public void ack(final Callback<Void> onAcked) { if(onComplete!=null) { queue.execute(new Task() { Callback<Callback<Void>> onCompleteCopy = onComplete; @Override public void run() { onCompleteCopy.onSuccess(onAcked); } }); onComplete = null; } else { if( onAcked!=null ) { onAcked.onSuccess(null); } } }
void reconnect(final Callback<Transport> onConnect) { long reconnectDelay = mqtt.reconnectDelay; if( reconnectDelay> 0 && mqtt.reconnectBackOffMultiplier > 1.0 ) { reconnectDelay = (long) Math.pow(mqtt.reconnectDelay*reconnects, mqtt.reconnectBackOffMultiplier); } reconnectDelay = Math.min(reconnectDelay, mqtt.reconnectDelayMax); reconnects += 1; queue.executeAfter(reconnectDelay, TimeUnit.MILLISECONDS, new Task() { @Override public void run() { if(disconnected) { onConnect.onFailure(createDisconnectedError()); } else { try { createTransport(onConnect); } catch (Exception e) { onConnect.onFailure(e); } } } }); }
public void setReceiveBuffer(final long receiveBuffer) throws InterruptedException { final CountDownLatch done = new CountDownLatch(1); next.getDispatchQueue().execute(new Runnable() { public void run() { try { next.setReceiveBuffer(receiveBuffer); } finally { done.countDown(); } } }); done.await(); }
public Throwable failure() { queue.assertExecuting(); return failure; }
/** * Storm has determined that the tuple emitted by this spout with the msgId identifier * has been fully processed. Typically, an implementation of this method will take that * message off the queue and prevent it from being replayed. * * @param msgId */ public void ack(Object msgId) { AckableMessage msg = this.pending.remove(msgId); this.connection.getDispatchQueue().execute(msg.ack()); }
public long getReceiveBuffer() { getDispatchQueue().assertExecuting(); return receiveBuffer; }
public Future<Void> connect() { final Promise<Void> future = new Promise<Void>(); next.getDispatchQueue().execute(new Task() { public void run() { next.connect(future); } }); return future; }
public void setReceiveBuffer(long receiveBuffer) { getDispatchQueue().assertExecuting(); long prev = this.receiveBuffer; this.receiveBuffer = receiveBuffer; long diff = prev-receiveBuffer; receiveBufferRemaining -= diff; if( !receiveBufferFull && receiveBufferRemaining <=0 ) { receiveBufferFull = true; suspend(); } else if( receiveBufferFull && receiveBufferRemaining >0 ) { receiveBufferFull = false; resume(); } }
public Future<Void> publish(final UTF8Buffer topic, final Buffer payload, final QoS qos, final boolean retain) { final Promise<Void> future = new Promise<Void>(); next.getDispatchQueue().execute(new Task() { public void run() { next.publish(topic, payload, qos, retain, future); } }); return future; }
public void publish(UTF8Buffer topic, Buffer payload, QoS qos, boolean retain, Callback<Void> cb) { queue.assertExecuting(); if( disconnected ) { cb.onFailure(createDisconnectedError()); return; } PUBLISH command = new PUBLISH().qos(qos).retain(retain); command.topicName(topic).payload(payload); send(command, cb); }
public Future<Void> kill() { final Promise<Void> future = new Promise<Void>(); next.getDispatchQueue().execute(new Task() { public void run() { next.kill(future); } }); return future; }
public Future<byte[]> subscribe(final Topic[] topics) { final Promise<byte[]> future = new Promise<byte[]>(); next.getDispatchQueue().execute(new Task() { public void run() { next.subscribe(topics, future); } }); return future; }
public Future<Void> unsubscribe(final UTF8Buffer[] topics) { final Promise<Void> future = new Promise<Void>(); next.getDispatchQueue().execute(new Task() { public void run() { next.unsubscribe(topics, future); } }); return future; }
public Future<Void> disconnect() { final Promise<Void> future = new Promise<Void>(); next.getDispatchQueue().execute(new Task() { public void run() { next.disconnect(future); } }); return future; }
public Future<Message> receive() { final Promise<Message> future = new Promise<Message>(); getDispatchQueue().execute(new Task(){ public void run() { if( next.failure()!=null ) { future.onFailure(next.failure()); } else { if( receivedFrames.isEmpty() ) { receiveFutures.add(future); } else { future.onSuccess(receivedFrames.removeFirst()); } } } }); return future; }
@Override public void run() { setName("MQTT client shutdown"); connection.getDispatchQueue().execute(new Task() { public void run() { connection.disconnect(new Callback<Void>() { public void onSuccess(Void value) { done.countDown(); } public void onFailure(Throwable value) { done.countDown(); } }); } }); } });
@Override public void run() { setName("MQTT client shutdown"); if(debug) { stderr("Disconnecting the client."); } connection.getDispatchQueue().execute(new Task() { public void run() { connection.disconnect(new Callback<Void>() { public void onSuccess(Void value) { done.countDown(); } public void onFailure(Throwable value) { done.countDown(); } }); } }); } });