@Test
  public void failureMonitor() throws Exception {
    ProducerToken token = ProducerToken.create(SimpleProducerModule_SettableFutureStrFactory.class);

    SettableFuture<String> strFuture = SettableFuture.create();
    SettableFuture<SettableFuture<String>> strFutureFuture = SettableFuture.create();
    Producer<SettableFuture<String>> strFutureProducer = producerOfFuture(strFutureFuture);
    Producer<String> producer =
        new SimpleProducerModule_SettableFutureStrFactory(
            executorProvider, componentMonitorProvider, strFutureProducer);
    assertThat(producer.get().isDone()).isFalse();

    InOrder order = inOrder(componentMonitor, monitor);
    order.verify(componentMonitor).producerMonitorFor(token);

    strFutureFuture.set(strFuture);
    order.verify(monitor).methodStarting();
    order.verify(monitor).methodFinished();
    assertThat(producer.get().isDone()).isFalse();

    Throwable t = new RuntimeException("monkey");
    strFuture.setException(t);
    try {
      producer.get().get();
      fail();
    } catch (ExecutionException e) {
      assertThat(e.getCause()).isSameAs(t);
      order.verify(monitor).failed(t);
    }

    order.verifyNoMoreInteractions();
  }
Exemple #2
0
  /**
   * Fences a ledger. From this point on, clients will be unable to write to this ledger. Only
   * recoveryAddEntry will be able to add entries to the ledger. This method is idempotent. Once a
   * ledger is fenced, it can never be unfenced. Fencing a fenced ledger has no effect.
   */
  public SettableFuture<Boolean> fenceLedger(long ledgerId, byte[] masterKey)
      throws IOException, BookieException {
    LedgerDescriptor handle = handles.getHandle(ledgerId, masterKey);
    boolean success;
    synchronized (handle) {
      success = handle.setFenced();
    }
    if (success) {
      // fenced first time, we should add the key to journal ensure we can rebuild
      ByteBuffer bb = ByteBuffer.allocate(8 + 8);
      bb.putLong(ledgerId);
      bb.putLong(METAENTRY_ID_FENCE_KEY);
      bb.flip();

      FutureWriteCallback fwc = new FutureWriteCallback();
      LOG.debug("record fenced state for ledger {} in journal.", ledgerId);
      journal.logAddEntry(bb, fwc, null);
      return fwc.getResult();
    } else {
      // already fenced
      SettableFuture<Boolean> successFuture = SettableFuture.create();
      successFuture.set(true);
      return successFuture;
    }
  }
  @Test
  public void successMonitor() throws Exception {
    ProducerToken token = ProducerToken.create(SimpleProducerModule_SettableFutureStrFactory.class);

    SettableFuture<String> strFuture = SettableFuture.create();
    SettableFuture<SettableFuture<String>> strFutureFuture = SettableFuture.create();
    Producer<SettableFuture<String>> strFutureProducer = producerOfFuture(strFutureFuture);
    Producer<String> producer =
        new SimpleProducerModule_SettableFutureStrFactory(
            executorProvider, componentMonitorProvider, strFutureProducer);
    assertThat(producer.get().isDone()).isFalse();

    InOrder order = inOrder(componentMonitor, monitor);
    order.verify(componentMonitor).producerMonitorFor(token);

    strFutureFuture.set(strFuture);
    order.verify(monitor).methodStarting();
    order.verify(monitor).methodFinished();
    assertThat(producer.get().isDone()).isFalse();

    strFuture.set("monkey");
    assertThat(producer.get().get()).isEqualTo("monkey");
    order.verify(monitor).succeeded("monkey");

    order.verifyNoMoreInteractions();
  }
  private void doWalk(
      Path path, FileStatusCallback callback, AtomicLong taskCount, SettableFuture<Void> future) {
    try (SetThreadName ignored = new SetThreadName("HiveHdfsWalker")) {
      RemoteIterator<LocatedFileStatus> iterator = getLocatedFileStatusRemoteIterator(path);

      while (iterator.hasNext()) {
        LocatedFileStatus status = getLocatedFileStatus(iterator);

        // ignore hidden files. Hive ignores files starting with _ and . as well.
        String fileName = status.getPath().getName();
        if (fileName.startsWith("_") || fileName.startsWith(".")) {
          continue;
        }
        if (isDirectory(status)) {
          recursiveWalk(status.getPath(), callback, taskCount, future);
        } else {
          callback.process(status, status.getBlockLocations());
        }
        if (future.isDone()) {
          return;
        }
      }
    } catch (FileNotFoundException e) {
      future.setException(new FileNotFoundException("Partition location does not exist: " + path));
    } catch (Throwable t) {
      future.setException(t);
    } finally {
      if (taskCount.decrementAndGet() == 0) {
        future.set(null);
      }
    }
  }
Exemple #5
0
  @Test
  public void disconnectOldVersions1() throws Exception {
    // Set up the connection with an old version.
    final SettableFuture<Void> connectedFuture = SettableFuture.create();
    final SettableFuture<Void> disconnectedFuture = SettableFuture.create();
    peer.addEventListener(
        new AbstractPeerEventListener() {
          @Override
          public void onPeerConnected(Peer peer, int peerCount) {
            connectedFuture.set(null);
          }

          @Override
          public void onPeerDisconnected(Peer peer, int peerCount) {
            disconnectedFuture.set(null);
          }
        });
    connectWithVersion(500);
    // We must wait uninterruptibly here because connect[WithVersion] generates a peer that
    // interrupts the current
    // thread when it disconnects.
    Uninterruptibles.getUninterruptibly(connectedFuture);
    Uninterruptibles.getUninterruptibly(disconnectedFuture);
    try {
      peer.writeTarget.writeBytes(new byte[1]);
      fail();
    } catch (IOException e) {
      assertTrue(
          (e.getCause() != null && e.getCause() instanceof CancelledKeyException)
              || (e instanceof SocketException && e.getMessage().equals("Socket is closed")));
    }
  }
Exemple #6
0
  /**
   * Synchronously sends an opaque message to the RpcHandler on the server-side, waiting for up to a
   * specified timeout for a response.
   */
  public ByteBuffer sendRpcSync(ByteBuffer message, long timeoutMs) {
    final SettableFuture<ByteBuffer> result = SettableFuture.create();

    sendRpc(
        message,
        new RpcResponseCallback() {
          @Override
          public void onSuccess(ByteBuffer response) {
            result.set(response);
          }

          @Override
          public void onFailure(Throwable e) {
            result.setException(e);
          }
        });

    try {
      return result.get(timeoutMs, TimeUnit.MILLISECONDS);
    } catch (ExecutionException e) {
      throw Throwables.propagate(e.getCause());
    } catch (Exception e) {
      throw Throwables.propagate(e);
    }
  }
 private void outboundPingAndWait(final InboundMessageQueuer p, long nonce) throws Exception {
   // Send a ping and wait for it to get to the other side
   SettableFuture<Void> pingReceivedFuture = SettableFuture.create();
   p.mapPingFutures.put(nonce, pingReceivedFuture);
   p.peer.sendMessage(new Ping(nonce));
   pingReceivedFuture.get();
   p.mapPingFutures.remove(nonce);
 }
Exemple #8
0
  /**
   * Start the instance using the ports provided
   *
   * @param localPort the local port to expose
   * @param remoteHost the hostname of the remote server to connect to
   * @param remotePort the port of the remote server to connect to
   */
  public DirectProxy(final Integer localPort, final String remoteHost, final Integer remotePort) {
    if (localPort == null) {
      throw new IllegalArgumentException("You must specify a local port");
    }
    if (remoteHost == null) {
      throw new IllegalArgumentException("You must specify a remote port");
    }
    if (remotePort == null) {
      throw new IllegalArgumentException("You must specify a remote hostname");
    }

    hasStarted = SettableFuture.create();

    new Thread(
            new Runnable() {
              @Override
              public void run() {
                try {
                  remoteSocket = new InetSocketAddress(remoteHost, remotePort);
                  channel =
                      new ServerBootstrap()
                          .group(bossGroup, workerGroup)
                          .option(ChannelOption.SO_BACKLOG, 1024)
                          .channel(NioServerSocketChannel.class)
                          .childOption(ChannelOption.AUTO_READ, true)
                          .childHandler(new DirectProxyUnificationHandler())
                          .childOption(ChannelOption.ALLOCATOR, PooledByteBufAllocator.DEFAULT)
                          .childAttr(HTTP_PROXY, DirectProxy.this)
                          .childAttr(REMOTE_SOCKET, remoteSocket)
                          .childAttr(LOG_FILTER, logFilter)
                          .bind(localPort)
                          .sync()
                          .channel();

                  logger.info(
                      "MockServer proxy started on port: {} connected to remote server: {}",
                      ((InetSocketAddress) channel.localAddress()).getPort(),
                      remoteHost + ":" + remotePort);

                  hasStarted.set("STARTED");

                  channel.closeFuture().sync();
                } catch (InterruptedException ie) {
                  logger.error("MockServer proxy receive InterruptedException", ie);
                } finally {
                  bossGroup.shutdownGracefully(0, 1, TimeUnit.MILLISECONDS);
                  workerGroup.shutdownGracefully(0, 1, TimeUnit.MILLISECONDS);
                }
              }
            })
        .start();

    try {
      hasStarted.get();
    } catch (Exception e) {
      logger.warn("Exception while waiting for MockServer proxy to complete starting up", e);
    }
  }
 @Test
 public void singleArgMethod() throws Exception {
   SettableFuture<Integer> intFuture = SettableFuture.create();
   Producer<Integer> intProducer = producerOfFuture(intFuture);
   Producer<String> producer =
       new SimpleProducerModule_StrWithArgFactory(
           executorProvider, componentMonitorProvider, intProducer);
   assertThat(producer.get().isDone()).isFalse();
   intFuture.set(42);
   assertThat(producer.get().get()).isEqualTo("str with arg");
 }
 @Override
 protected void processMessage(Message m) throws Exception {
   if (m instanceof Ping) {
     SettableFuture<Void> future = mapPingFutures.get(((Ping) m).getNonce());
     if (future != null) {
       future.set(null);
       return;
     }
   }
   if (m instanceof BloomFilter) {
     lastReceivedFilter = (BloomFilter) m;
   }
   inboundMessages.offer(m);
 }
 @Override
 public ListenableFuture<Boolean> consumeAsync() {
   // TODO make this actually asynch
   final SettableFuture<Boolean> result = SettableFuture.create();
   try {
     consume();
     result.set(true);
   } catch (final Exception e) {
     LOGGER.warn("Got exception consuming RDF stream", e);
     result.setException(e);
     result.set(false);
   }
   return result;
 }
  @Test
  public void contextAlreadyCancelledNotifiesImmediately() throws Exception {
    // Attach the context which is recorded when the call is created
    Context.CancellableContext cancellableContext = Context.current().withCancellation();
    Throwable cause = new Throwable();
    cancellableContext.cancel(cause);
    Context previous = cancellableContext.attach();

    ClientCallImpl<Void, Void> call =
        new ClientCallImpl<Void, Void>(
                DESCRIPTOR,
                new SerializingExecutor(Executors.newSingleThreadExecutor()),
                CallOptions.DEFAULT,
                provider,
                deadlineCancellationExecutor)
            .setDecompressorRegistry(decompressorRegistry);

    previous.attach();

    final SettableFuture<Status> statusFuture = SettableFuture.create();
    call.start(
        new ClientCall.Listener<Void>() {
          @Override
          public void onClose(Status status, Metadata trailers) {
            statusFuture.set(status);
          }
        },
        new Metadata());

    // Caller should receive onClose callback.
    Status status = statusFuture.get(5, TimeUnit.SECONDS);
    assertEquals(Status.Code.CANCELLED, status.getCode());
    assertSame(cause, status.getCause());

    // Following operations should be no-op.
    call.request(1);
    call.sendMessage(null);
    call.halfClose();

    // Stream should never be created.
    verifyZeroInteractions(transport);

    try {
      call.sendMessage(null);
      fail("Call has been cancelled");
    } catch (IllegalStateException ise) {
      // expected
    }
  }
Exemple #13
0
 /**
  * Reserves the given number of bytes. Caller should wait on the returned future, before
  * allocating more memory.
  */
 public synchronized ListenableFuture<?> reserve(QueryId queryId, long bytes) {
   checkArgument(bytes >= 0, "bytes is negative");
   if (bytes != 0) {
     queryMemoryReservations.merge(queryId, bytes, Long::sum);
   }
   freeBytes -= bytes;
   if (freeBytes <= 0) {
     if (future == null) {
       future = SettableFuture.create();
     }
     checkState(!future.isDone(), "future is already completed");
     return future;
   }
   return NOT_BLOCKED;
 }
  @Override
  public ListenableFuture<List<MessageStatus>> list(Folder folder, int start, int end) {
    Preconditions.checkState(
        mailClientHandler.isLoggedIn(), "Can't execute command because client is not logged in");
    Preconditions.checkState(
        !mailClientHandler.idleRequested.get(),
        "Can't execute command while idling (are you watching a folder?)");

    checkCurrentFolder(folder);
    checkRange(start, end);
    Preconditions.checkArgument(
        start > 0, "Start must be greater than zero (IMAP uses 1-based " + "indexing)");
    SettableFuture<List<MessageStatus>> valueFuture = SettableFuture.create();

    // -ve end range means get everything (*).
    String extensions = config.useGmailExtensions() ? " X-GM-MSGID X-GM-THRID X-GM-LABELS UID" : "";
    String args =
        start
            + ":"
            + toUpperBound(end)
            + " (RFC822.SIZE INTERNALDATE FLAGS ENVELOPE"
            + extensions
            + ")";
    send(Command.FETCH_HEADERS, args, valueFuture);

    return valueFuture;
  }
  @Override
  public ListenableFuture<List<MessageStatus>> listUidThin(
      Folder folder, List<Sequence> sequences) {
    Preconditions.checkState(
        mailClientHandler.isLoggedIn(), "Can't execute command because client is not logged in");
    Preconditions.checkState(
        !mailClientHandler.idleRequested.get(),
        "Can't execute command while idling (are you watching a folder?)");

    checkCurrentFolder(folder);
    SettableFuture<List<MessageStatus>> valueFuture = SettableFuture.create();

    // -ve end range means get everything (*).
    String extensions = config.useGmailExtensions() ? " X-GM-MSGID X-GM-THRID X-GM-LABELS UID" : "";
    StringBuilder argsBuilder = new StringBuilder();

    // Emit ranges.
    for (int i = 0, sequencesSize = sequences.size(); i < sequencesSize; i++) {
      Sequence seq = sequences.get(i);
      argsBuilder.append(toUpperBound(seq.start));
      if (seq.end != 0) argsBuilder.append(':').append(toUpperBound(seq.end));
      if (i < sequencesSize - 1) argsBuilder.append(',');
    }
    argsBuilder.append(" (FLAGS" + extensions + ")");
    send(Command.FETCH_THIN_HEADERS_UID, argsBuilder.toString(), valueFuture);

    return valueFuture;
  }
  @Override
  public ListenableFuture<Boolean> canCommit() {
    if (LOG.isDebugEnabled()) {
      LOG.debug("Tx {} canCommit", transactionId);
    }
    final SettableFuture<Boolean> returnFuture = SettableFuture.create();

    // The first phase of canCommit is to gather the list of cohort actor paths that will
    // participate in the commit. buildCohortPathsList combines the cohort path Futures into
    // one Future which we wait on asynchronously here. The cohort actor paths are
    // extracted from ReadyTransactionReply messages by the Futures that were obtained earlier
    // and passed to us from upstream processing. If any one fails then  we'll fail canCommit.

    buildCohortList()
        .onComplete(
            new OnComplete<Void>() {
              @Override
              public void onComplete(Throwable failure, Void notUsed) throws Throwable {
                if (failure != null) {
                  if (LOG.isDebugEnabled()) {
                    LOG.debug("Tx {}: a cohort Future failed: {}", transactionId, failure);
                  }
                  returnFuture.setException(failure);
                } else {
                  finishCanCommit(returnFuture);
                }
              }
            },
            actorContext.getClientDispatcher());

    return returnFuture;
  }
Exemple #17
0
 public boolean isFinished() {
   boolean finished = split.isFinished();
   if (finished) {
     finishedFuture.set(null);
   }
   return finished || destroyed.get();
 }
  @Override
  protected void doSubscribe(String eventName, final SettableFuture<?> future) {
    List<SettableFuture<?>> futures = new ArrayList<SettableFuture<?>>();

    for (RedisConnection conn : connections) {
      SettableFuture<?> newFuture = SettableFuture.create();
      conn.subscribe(eventName, newFuture);
      futures.add(newFuture);
    }

    final ListenableFuture<?> combined = Futures.allAsList(futures);

    combined.addListener(
        new Runnable() {
          @Override
          public void run() {
            try {
              combined.get();
              future.set(null);
            } catch (InterruptedException e) {
              future.setException(e);
            } catch (ExecutionException e) {
              future.setException(e.getCause());
            }
          }
        },
        getExecutorService());
  }
  @Override
  protected void setUp() throws Exception {
    super.setUp();

    LocalWaveletContainer.Factory localFactory = mock(LocalWaveletContainer.Factory.class);

    WaveletNotificationSubscriber notifiee = mock(WaveletNotificationSubscriber.class);

    SettableFuture<ImmutableSet<WaveletId>> lookedupWavelets = SettableFuture.create();
    lookedupWavelets.set(ImmutableSet.of(WAVELET_NAME.waveletId));

    Wave wave =
        new Wave(
            WAVELET_NAME.waveId,
            lookedupWavelets,
            notifiee,
            localFactory,
            null,
            WAVELET_NAME.waveId.getDomain());
    Map<WaveId, Wave> waves = Maps.newHashMap();
    waves.put(WAVELET_NAME.waveId, wave);
    when(waveMap.getWaves()).thenReturn(waves);
    ImmutableSet<WaveletId> wavelets = ImmutableSet.of(WAVELET_NAME.waveletId);
    when(waveMap.lookupWavelets(WAVELET_NAME.waveId)).thenReturn(wavelets);

    LocalWaveletContainer c = mock(LocalWaveletContainer.class);
    when(c.hasParticipant(PARTICIPANT)).thenReturn(true);
    when(waveMap.getLocalWavelet(WAVELET_NAME)).thenReturn(c);
  }
Exemple #20
0
  @Override
  public <T> Future<T> submit(final GenericType<T> responseType) {
    final SettableFuture<T> responseFuture = SettableFuture.create();
    configuration()
        .submit(
            requestContext,
            new InvocationCallback<Response>() {

              @Override
              public void completed(Response response) {
                if (response.getStatus() < 300) {
                  try {
                    responseFuture.set(response.readEntity(responseType));
                  } catch (Exception e) {
                    failed(
                        new InvocationException(
                            LocalizationMessages.UNEXPECTED_ERROR_RESPONSE_PROCESSING(), e));
                  }
                } else {
                  failed(convertToException(response));
                }
              }

              @Override
              public void failed(InvocationException error) {
                responseFuture.setException(error);
              }
            });

    return responseFuture;
  }
  /**
   * Called when the client provides the multi-sig contract. Checks that the previously-provided
   * refund transaction spends this transaction (because we will use it as a base to create payment
   * transactions) as well as output value and form (ie it is a 2-of-2 multisig to the correct
   * keys).
   *
   * @param multisigContract The provided multisig contract. Do not mutate this object after this
   *     call.
   * @return A future which completes when the provided multisig contract successfully broadcasts,
   *     or throws if the broadcast fails for some reason Note that if the network simply rejects
   *     the transaction, this future will never complete, a timeout should be used.
   * @throws VerificationException If the provided multisig contract is not well-formed or does not
   *     meet previously-specified parameters
   */
  public synchronized ListenableFuture<PaymentChannelServerState> provideMultiSigContract(
      final Transaction multisigContract) throws VerificationException {
    checkNotNull(multisigContract);
    checkState(state == State.WAITING_FOR_MULTISIG_CONTRACT);
    try {
      multisigContract.verify();
      this.multisigContract = multisigContract;
      this.multisigScript = multisigContract.getOutput(0).getScriptPubKey();

      // Check that multisigContract's first output is a 2-of-2 multisig to the correct pubkeys in
      // the correct order
      final Script expectedScript =
          ScriptBuilder.createMultiSigOutputScript(2, Lists.newArrayList(clientKey, serverKey));
      if (!Arrays.equals(multisigScript.getProgram(), expectedScript.getProgram()))
        throw new VerificationException(
            "Multisig contract's first output was not a standard 2-of-2 multisig to client and server in that order.");

      this.totalValue = multisigContract.getOutput(0).getValue();
      if (this.totalValue.signum() <= 0)
        throw new VerificationException(
            "Not accepting an attempt to open a contract with zero value.");
    } catch (VerificationException e) {
      // We couldn't parse the multisig transaction or its output.
      log.error("Provided multisig contract did not verify: {}", multisigContract.toString());
      throw e;
    }
    log.info("Broadcasting multisig contract: {}", multisigContract);
    state = State.WAITING_FOR_MULTISIG_ACCEPTANCE;
    final SettableFuture<PaymentChannelServerState> future = SettableFuture.create();
    Futures.addCallback(
        broadcaster.broadcastTransaction(multisigContract).future(),
        new FutureCallback<Transaction>() {
          @Override
          public void onSuccess(Transaction transaction) {
            log.info(
                "Successfully broadcast multisig contract {}. Channel now open.",
                transaction.getHashAsString());
            try {
              // Manually add the multisigContract to the wallet, overriding the isRelevant checks
              // so we can track
              // it and check for double-spends later
              wallet.receivePending(multisigContract, null, true);
            } catch (VerificationException e) {
              throw new RuntimeException(
                  e); // Cannot happen, we already called multisigContract.verify()
            }
            state = State.READY;
            future.set(PaymentChannelServerState.this);
          }

          @Override
          public void onFailure(Throwable throwable) {
            // Couldn't broadcast the transaction for some reason.
            log.error("Broadcast multisig contract failed", throwable);
            state = State.ERROR;
            future.setException(throwable);
          }
        });
    return future;
  }
/** Created by Eric on 01/10/2015. */
public class SnitcoinDownloadProgressTracker extends DownloadProgressTracker {
  private final Logger log = LoggerFactory.getLogger(SnitcoinDownloadProgressTracker.class);
  private int originalBlocksLeft = -1;
  private int lastPercent = 0;
  private SettableFuture<Long> future = SettableFuture.create();
  private boolean caughtUp = false;

  @Override
  public void onChainDownloadStarted(Peer peer, int blocksLeft) {
    super.onChainDownloadStarted(peer, blocksLeft);
    log.info("SnitcoinDownloadProgressTracker - Starting blockchain download " + blocksLeft);
  }

  @Override
  public void onBlocksDownloaded(
      Peer peer, Block block, @Nullable FilteredBlock filteredBlock, int blocksLeft) {
    super.onBlocksDownloaded(peer, block, filteredBlock, blocksLeft);
    double pct = 100.0 - (100.0 * (blocksLeft / (double) originalBlocksLeft));
    if ((int) pct != lastPercent) {
      log.info("SnitcoinDownloadProgressTracker " + lastPercent + " " + blocksLeft);
      lastPercent = (int) pct;
    }
  }

  protected void doneDownload() {
    log.info("SnitcoinDownloadProgressTracker - Blockchain download done!");
  }
}
 private void handleFailure(
     final SettableFuture<Response> future,
     final Supplier<ListenableFuture<Response>> code,
     final long deadline,
     final long delay,
     final TimeUnit timeUnit,
     final Throwable t) {
   if (clock.now().getMillis() < deadline) {
     if (delay > 0) {
       executorService.schedule(
           new Runnable() {
             @Override
             public void run() {
               startRetry(future, code, deadline - 1, delay, timeUnit);
             }
           },
           delay,
           timeUnit);
     } else {
       startRetry(future, code, deadline - 1, delay, timeUnit);
     }
   } else {
     future.setException(t);
   }
 }
 @Override
 public void onRemoval(
     RemovalNotification<String, InstallFuture> removalNotification) {
   switch (removalNotification.getCause()) {
     case EXPLICIT:
       break;
     case REPLACED:
     case COLLECTED:
     case EXPIRED:
     case SIZE:
       SettableFuture<Boolean> value = removalNotification.getValue().future;
       if (value != null) { // May have been GCed
         value.set(false);
       }
       break;
   }
 }
Exemple #25
0
 public synchronized ListenableFuture<?> waitForNotEmpty() {
   if (finishing || !buffer.isEmpty()) {
     return NOT_BLOCKED;
   }
   SettableFuture<?> settableFuture = SettableFuture.create();
   blockedCallers.add(settableFuture);
   return settableFuture;
 }
  private ListenableFuture<Void> voidOperation(
      final String operationName,
      final Object message,
      final Class<?> expectedResponseClass,
      final boolean propagateException,
      final OperationCallback callback) {

    if (LOG.isDebugEnabled()) {
      LOG.debug("Tx {} {}", transactionId, operationName);
    }
    final SettableFuture<Void> returnFuture = SettableFuture.create();

    // The cohort actor list should already be built at this point by the canCommit phase but,
    // if not for some reason, we'll try to build it here.

    if (cohorts != null) {
      finishVoidOperation(
          operationName,
          message,
          expectedResponseClass,
          propagateException,
          returnFuture,
          callback);
    } else {
      buildCohortList()
          .onComplete(
              new OnComplete<Void>() {
                @Override
                public void onComplete(Throwable failure, Void notUsed) throws Throwable {
                  if (failure != null) {
                    if (LOG.isDebugEnabled()) {
                      LOG.debug(
                          "Tx {}: a {} cohort path Future failed: {}",
                          transactionId,
                          operationName,
                          failure);
                    }
                    if (propagateException) {
                      returnFuture.setException(failure);
                    } else {
                      returnFuture.set(null);
                    }
                  } else {
                    finishVoidOperation(
                        operationName,
                        message,
                        expectedResponseClass,
                        propagateException,
                        returnFuture,
                        callback);
                  }
                }
              },
              actorContext.getClientDispatcher());
    }

    return returnFuture;
  }
Exemple #27
0
  @SuppressWarnings({"rawtypes", "unchecked"})
  @Override
  public void processResult(JsonNode response) {
    log.debug("Handle result");
    String requestId = response.get("id").asText();
    SettableFuture sf = requestResult.get(requestId);
    if (sf == null) {
      log.debug("No such future to process");
      return;
    }
    String methodName = requestMethod.get(requestId);

    Object result;
    result = FromJsonUtil.jsonResultParser(response, methodName);

    sf.set(result);
    return;
  }
  static void pingBeforeActivate(
      final AsyncCommand<?, ?, ?> cmd,
      final SettableFuture<Boolean> initializedFuture,
      final ChannelHandlerContext ctx,
      final List<ChannelHandler> handlers)
      throws Exception {
    cmd.handle(
        (o, throwable) -> {
          if (throwable == null) {
            initializedFuture.set(true);
            ctx.fireChannelActive();
          } else {
            initializedFuture.setException(throwable);
          }
          return null;
        });

    ctx.channel().writeAndFlush(cmd);
  }
 private void inboundPongAndWait(final InboundMessageQueuer p, final long nonce) throws Exception {
   // Receive a ping (that the Peer doesn't see) and wait for it to get through the socket
   final SettableFuture<Void> pongReceivedFuture = SettableFuture.create();
   PeerEventListener listener =
       new AbstractPeerEventListener() {
         @Override
         public Message onPreMessageReceived(Peer p, Message m) {
           if (m instanceof Pong && ((Pong) m).getNonce() == nonce) {
             pongReceivedFuture.set(null);
             return null;
           }
           return m;
         }
       };
   p.peer.addEventListener(listener, Threading.SAME_THREAD);
   inbound(p, new Pong(nonce));
   pongReceivedFuture.get();
   p.peer.removeEventListener(listener);
 }
    private ListenableFuture<Void> fetchMoreResults(FetchingState fetchState) {
      if (fetchState == null) return MoreFutures.VOID_SUCCESS;

      if (fetchState.inProgress != null) return fetchState.inProgress;

      assert fetchState.nextStart != null;
      ByteBuffer state = fetchState.nextStart;
      SettableFuture<Void> future = SettableFuture.create();
      this.fetchState = new FetchingState(null, future);
      return queryNextPage(state, future);
    }