Java Code Examples for com.google.common.util.concurrent.Futures#immediateFailedFuture()

@Test
public void testRunCommandAndDeleteArtifactsUnsuccessfully() throws Exception {
  final String ruleKeyHash = "b64009ae3762a42a1651c139ec452f0d18f48e21";

  ArtifactCache cache =
      new FakeArtifactCache(
          Collections.singletonList(new RuleKey(ruleKeyHash)),
          Futures.immediateFailedFuture(new RuntimeException("test failure")));

  TestConsole console = new TestConsole();

  CommandRunnerParams commandRunnerParams =
      CommandRunnerParamsForTesting.builder().setConsole(console).setArtifactCache(cache).build();

  CacheDeleteCommand cacheDeleteCommand = new CacheDeleteCommand();
  cacheDeleteCommand.setArguments(ImmutableList.of(ruleKeyHash));
  ExitCode exitCode = cacheDeleteCommand.run(commandRunnerParams);
  assertEquals(ExitCode.FATAL_GENERIC, exitCode);
  assertThat(console.getTextWrittenToStdErr(), startsWith("Failed to delete artifacts."));
}
 

protected <T> Future<T> doInvoke(Callable<T> callable) {
   try {
      // always run after the current event finishes processing
      // this gives more natural behavior from the event thread
      SettableFuture<T> result = SettableFuture.create();
      SwingUtilities.invokeLater(() -> {
         if(result.isCancelled()) {
            return;
         }
         try {
            result.set(callable.call());
         }
         catch(Throwable t) {
         	logger.warn("Uncaught exception", t);
            result.setException(t);
         }
      });
      return result;
   }
   catch(Exception e) {
   	logger.warn("Uncaught exception", e);
      return Futures.immediateFailedFuture(e);
   }
}
 

@Override
public ListenableFuture<Object> invoke(ServerInvokeRequest request)
{
    MethodMetadata method = request.getMethod();
    if (!LOG_METHOD_METADATA.getName().equals(method.getName())) {
        return Futures.immediateFailedFuture(new IllegalArgumentException("unknown method " + method));
    }

    Map<Short, Object> parameters = request.getParameters();
    if (parameters.size() != 1 || !parameters.containsKey((short) 1) || !(getOnlyElement(parameters.values()) instanceof List)) {
        return Futures.immediateFailedFuture(new IllegalArgumentException("invalid parameters"));
    }
    List<DriftLogEntry> messages = (List<DriftLogEntry>) getOnlyElement(parameters.values());

    for (DriftLogEntry message : messages) {
        if (message.getCategory().equals("exception")) {
            return Futures.immediateFailedFuture(new TApplicationException(UNSUPPORTED_CLIENT_TYPE, message.getMessage()));
        }
    }
    this.messages.addAll(messages);
    return Futures.immediateFuture(DRIFT_OK);
}
 

/**
 * Deletes items from a queue.
 *
 * @param queueName the queue name
 * @return {@link ListenableFuture} that the caller uses to obtain the result of a delete queue
 *     items operation (using {@link ListenableFuture#get()}).
 * @throws IOException when the service throws an exception
 */
@Override
public ListenableFuture<Operation> deleteQueueItems(String queueName) throws IOException {
  validateRunning();
  checkArgument(!Strings.isNullOrEmpty(queueName), "Queue name cannot be null.");

  DeleteQueueItems request =
      this.service
          .indexing()
          .datasources()
          .items()
          .deleteQueueItems(
              resourcePrefix,
              new DeleteQueueItemsRequest()
                  .setQueue(queueName)
                  .setDebugOptions(new DebugOptions().setEnableDebugging(enableApiDebugging)));
  acquireToken(Operations.DEFAULT);
  try {
    return Futures.immediateFuture(
        executeRequest(request, indexingServiceStats, true /* initializeDefaults */));
  } catch (IOException e) {
    return Futures.immediateFailedFuture(e);
  }
}
 

@Test
public void handlesFailure() throws Exception {
    final AtomicReference<Object> value = new AtomicReference<>();
    Exception ex = new Exception("This is bad");
    ListenableFuture<String> future = Futures.immediateFailedFuture(ex);

    GuavaLFReturnValueHandler handler = new GuavaLFReturnValueHandler() {
        @Override
        protected void startDeferredResultProcessing(ModelAndViewContainer mavContainer, NativeWebRequest webRequest, DeferredResult<Object> deferredResult) throws Exception {
            value.set(deferredResult.getResult());
        }
    };

    handler.handleReturnValue(future, null, null, null);
    assertThat(value.get()).isEqualTo(ex);
}
 

/**
 * Sends a {@link Message} to the remote service. Returns a future that will be completed when the message
 * has been processed.
 * @param message The message to send.
 * @param result Object to set into the future when message is being processed.
 * @param <V> Type of the result.
 * @return A {@link ListenableFuture} that will be completed when the message has been processed.
 */
protected final synchronized <V> ListenableFuture<V> sendMessage(Message message, V result) {
  if (!isRunning()) {
    return Futures.immediateFailedFuture(new IllegalStateException("Cannot send message to non-running application"));
  }
  final ListenableFuture<V> messageFuture = ZKMessages.sendMessage(zkClient, getMessagePrefix(), message, result);
  messageFutures.add(messageFuture);
  messageFuture.addListener(new Runnable() {
    @Override
    public void run() {
      // If the completion is triggered when stopping, do nothing.
      if (state() == State.STOPPING) {
        return;
      }
      synchronized (AbstractZKServiceController.this) {
        messageFutures.remove(messageFuture);
      }
    }
  }, Threads.SAME_THREAD_EXECUTOR);

  return messageFuture;
}
 

@Override
public ListenableFuture<Void> uploadFile(Digest digest, Path file) {
  try (InputStream in = file.getInputStream()) {
    uploadBlocking(digest.getHash(), digest.getSizeBytes(), in, /* casUpload= */ true);
  } catch (IOException | InterruptedException e) {
    return Futures.immediateFailedFuture(e);
  }
  return Futures.immediateFuture(null);
}
 

public ListenableFuture<PlayerSearchResponse> findPlayer(CommandSender sender, @Nullable String name, Scope scope, Default def) {
    try {
        final Player player = getLocalPlayer(sender, name);
        if(player != null) {
            return Futures.immediateFuture(localPlayerResponse(sender, player));
        }

        if(scope.noGreaterThan(Scope.LOCAL)) {
            throw new TranslatableCommandException("command.playerNotFound");
        }

        final SettableFuture<PlayerSearchResponse> playerResult = SettableFuture.create();
        mainThreadExecutor.callback(
            findUser(sender, name, scope, def),
            new FutureCallback<UserSearchResponse>() {
                @Override
                public void onSuccess(@Nullable UserSearchResponse userResult) {
                    playerResult.set(new PlayerSearchResponse(userResult, onlinePlayers.find(userResult.user)));
                }

                @Override
                public void onFailure(Throwable t) {
                    playerResult.setException(t);
                }
            }
        );

        return playerResult;
    } catch(CommandException e) {
        return Futures.immediateFailedFuture(e);
    }
}
 

@Override
public ListenableFuture<Object> invoke(ServerInvokeRequest request)
{
    ServiceMethod method = methods.get(request.getMethod().getName());
    if (method == null) {
        return Futures.immediateFailedFuture(new TApplicationException(Type.UNKNOWN_METHOD, "Invalid method name: '" + request.getMethod().getName() + "'"));
    }

    return method.invokeMethod(request);
}
 

private <T> ListenableFuture<T> onExecuteAsyncFailure(
    Exception t, AsyncCallable<T> call, Backoff backoff) {
  long waitMillis = backoff.nextDelayMillis();
  if (waitMillis >= 0 && isRetriable.apply(Status.fromThrowable(t))) {
    try {
      return Futures.scheduleAsync(
          () -> executeAsync(call, backoff), waitMillis, TimeUnit.MILLISECONDS, retryScheduler);
    } catch (RejectedExecutionException e) {
      // May be thrown by .scheduleAsync(...) if i.e. the executor is shutdown.
      return Futures.immediateFailedFuture(new IOException(e));
    }
  } else {
    return Futures.immediateFailedFuture(t);
  }
}
 

@Override
public <T> Supplier<ListenableFuture<T>> aroundListenableFuture(String injectionPoint, Supplier<ListenableFuture<T>> source) {
    if (runBefore) {
        return () -> {
            if (shouldFailFunction.get()) {
                return Futures.immediateFailedFuture(newException(injectionPoint));
            }
            return source.get();
        };
    }
    return () -> Futures.transform(source.get(), input -> doFail(injectionPoint) ? null : input, MoreExecutors.directExecutor());
}
 

/**
 * Sends ARP Request as packet-out from the given port (node connector).
 *
 * @param senderAddress
 *            the addresses used in sender part of ARP packet
 * @param tpa
 *            the target protocol address, in this case IPv4 address for
 *            which MAC should be discovered
 * @param egressNc
 *            the path to node connector from where the ARP packet will be
 *            sent
 * @return future result about success of packet-out
 */
public ListenableFuture<RpcResult<Void>> sendArp(ArpMessageAddress senderAddress, Ipv4Address tpa,
		InstanceIdentifier<NodeConnector> egressNc) {
	checkNotNull(senderAddress);
	checkNotNull(tpa);
	checkNotNull(egressNc);
	final Ethernet arpFrame = createArpFrame(senderAddress, tpa);
	byte[] arpFrameAsBytes;
	try {
		arpFrameAsBytes = arpFrame.serialize();
	} catch (PacketException e) {
		LOG.warn("Serializition of ARP packet is not successful.", e);
		if (LOG.isDebugEnabled()) {
			LOG.debug("ARP packet: {}", ArpUtils.getArpFrameToStringFormat(arpFrame));
		}
		return Futures.immediateFailedFuture(e);
	}
	// Generate packet with destination switch and port

	TransmitPacketInput packet = new TransmitPacketInputBuilder().setEgress(new NodeConnectorRef(egressNc))
			.setNode(new NodeRef(egressNc.firstIdentifierOf(Node.class))).setPayload(arpFrameAsBytes).build();
	if (LOG.isTraceEnabled()) {
		LOG.trace("Sending ARP REQUEST \n{}", ArpUtils.getArpFrameToStringFormat(arpFrame));
	}
	Future<RpcResult<Void>> futureTransmitPacketResult = packetProcessingService.transmitPacket(packet);
	return JdkFutureAdapters.listenInPoolThread(futureTransmitPacketResult);
}
 

@Override
public ListenableFuture<byte[]> decryptAsync(final byte[] ciphertext, final byte[] iv, final byte[] authenticationData, final byte[] authenticationTag, final String algorithm) throws NoSuchAlgorithmException {

    if (ciphertext == null) {
        throw new IllegalArgumentException("ciphertext");
    }

    // Interpret the requested algorithm
    if (Strings.isNullOrWhiteSpace(algorithm)) {
        throw new IllegalArgumentException("algorithm");
    }

    Algorithm baseAlgorithm = AlgorithmResolver.Default.get(algorithm);
    
    if (baseAlgorithm == null || !(baseAlgorithm instanceof AsymmetricEncryptionAlgorithm)) {
        throw new NoSuchAlgorithmException(algorithm);
    }
    
    AsymmetricEncryptionAlgorithm algo = (AsymmetricEncryptionAlgorithm)baseAlgorithm;

    ICryptoTransform         transform;
    ListenableFuture<byte[]> result;

    try {
        transform = algo.CreateDecryptor(_keyPair, _provider);
        result    = Futures.immediateFuture(transform.doFinal(ciphertext));
    } catch (Exception e) {
        result    = Futures.immediateFailedFuture(e);
    }

    return result;
}
 

@SuppressWarnings("unchecked")
@Override
public ListenableFuture<T> answer(InvocationOnMock invocation)
    throws Throwable {
  if (r.nextFloat() < faultProbability) {
    return Futures.immediateFailedFuture(
        new IOException("Injected fault"));
  }
  return (ListenableFuture<T>)invocation.callRealMethod();
}
 

/**
 * Asynchronously saves {@code data} under the key {@code username}. The task will fail if the player is being serviced
 * by the {@link LogoutService}.
 *
 * @param username The player's username.
 * @param data The data to save.
 * @return A listenable future describing the result of the save.
 */
public ListenableFuture<Void> save(String username, PlayerData data) {
    if (world.getLogoutService().hasRequest(username)) {
        // The LogoutService will handle the saving.
        IllegalStateException ex = new IllegalStateException("This player is already being serviced by LogoutService.");
        return Futures.immediateFailedFuture(ex);
    }
    logger.trace("Sending save request for {} to a worker...", username);
    return worker.submit(() -> {
        var timer = Stopwatch.createStarted();
        AuthenticationService.PERSISTENCE.save(username, data);
        logger.debug("Finished saving {}'s data (took {}ms).", username, box(timer.elapsed().toMillis()));
        return null;
    });
}
 

static Stubber futureThrows(Throwable t) {
  ListenableFuture<?> ret = Futures.immediateFailedFuture(t);
  return Mockito.doReturn(ret);
}
 

@Override
public ListenableFuture<Entrant> entrant(String tournamentId, String teamId) {
    return Futures.immediateFailedFuture(new NotFound());
}
 

static Stubber futureThrows(Throwable t) {
  ListenableFuture<?> ret = Futures.immediateFailedFuture(t);
  return Mockito.doReturn(ret);
}
 

@Override
public ListenableFuture<User> changeClass(UserId userId, ChangeClassRequest request) {
    return Futures.immediateFailedFuture(new NotFound());
}
 

@Override
public ListenableFuture<String> createExceptionalFuture(Exception exception) {
    return Futures.immediateFailedFuture(exception);
}