io.airlift.discovery.client.DiscoveryException java code examples

Common ways to obtain DiscoveryException

private void myMethod () {
 DiscoveryException d =String str;Object[] args;ServiceDescriptorsRepresentation serviceDescriptorsRepresentation;new DiscoveryException(str.format("<changeme>", args, serviceDescriptorsRepresentation.getEnvironment()))
String str2;String str;Object[] args;Throwable throwable;new DiscoveryException(str2.format(str, args), throwable)
Smart code suggestions by Tabnine
}

  @Override
  public final T handleException(Request request, Exception exception)
  {
    if (exception instanceof InterruptedException) {
      throw new DiscoveryException(name + " was interrupted for " + uri);
    }
    if (exception instanceof CancellationException) {
      throw new DiscoveryException(name + " was canceled for " + uri);
    }
    if (exception instanceof DiscoveryException) {
      throw (DiscoveryException) exception;
    }
    throw new DiscoveryException(name + " failed for " + uri, exception);
  }
}

@PreDestroy
public void destroy()
{
  executor.shutdownNow();
  try {
    executor.awaitTermination(30, SECONDS);
  }
  catch (InterruptedException e) {
    Thread.currentThread().interrupt();
  }
  // unannounce
  try {
    getFutureValue(announcementClient.unannounce(), DiscoveryException.class);
  }
  catch (DiscoveryException e) {
    if (e.getCause() instanceof ConnectException) {
      log.error("Cannot connect to discovery server for unannounce: %s", e.getCause().getMessage());
    }
    else {
      log.error(e);
    }
  }
}

  @Override
  public void run()
  {
    Duration duration = DEFAULT_DELAY;
    try {
      duration = future.checkedGet();
      if (serverUp.compareAndSet(false, true)) {
        log.info("Discovery server connect succeeded for announce");
      }
    }
    catch (DiscoveryException e) {
      if (serverUp.compareAndSet(true, false)) {
        log.error("Cannot connect to discovery server for announce: %s", e.getMessage());
      }
      log.debug(e, "Cannot connect to discovery server for announce");
    }
    finally {
      scheduleNextAnnouncement(duration);
    }
  }
}, executor);

@PreDestroy
public void destroy()
{
  executor.shutdownNow();
  try {
    executor.awaitTermination(30, SECONDS);
  }
  catch (InterruptedException e) {
    Thread.currentThread().interrupt();
  }
  // unannounce
  try {
    getFutureResult(announcementClient.unannounce(), DiscoveryException.class);
  }
  catch (DiscoveryException e) {
    if (e.getCause() instanceof ConnectException) {
      log.error("Cannot connect to discovery server for unannounce: %s", e.getCause().getMessage());
    }
    else {
      log.error(e);
    }
  }
}

  @Override
  public void run()
  {
    Duration delay = DEFAULT_DELAY;
    try {
      ServiceDescriptors newDescriptors = future.checkedGet();
      delay = newDescriptors.getMaxAge();
      serviceDescriptors.set(newDescriptors);
      if (serverUp.compareAndSet(false, true)) {
        log.info("Discovery server connect succeeded for refresh (%s/%s)", type, pool);
      }
    }
    catch (DiscoveryException e) {
      if (serverUp.compareAndSet(true, false)) {
        log.error("Cannot connect to discovery server for refresh (%s/%s): %s", type, pool, e.getMessage());
      }
      log.debug(e, "Cannot connect to discovery server for refresh (%s/%s)", type, pool);
    }
    finally {
      scheduleRefresh(delay);
    }
  }
}, executor);

  @Override
  public final T handleException(Request request, Exception exception)
  {
    if (exception instanceof InterruptedException) {
      throw new DiscoveryException(name + " was interrupted for " + uri);
    }
    if (exception instanceof CancellationException) {
      throw new DiscoveryException(name + " was canceled for " + uri);
    }
    if (exception instanceof DiscoveryException) {
      throw (DiscoveryException) exception;
    }
    throw new DiscoveryException(name + " failed for " + uri, exception);
  }
}

@PreDestroy
public void destroy()
{
  executor.shutdownNow();
  try {
    executor.awaitTermination(30, TimeUnit.SECONDS);
  }
  catch (InterruptedException e) {
    Thread.currentThread().interrupt();
  }
  // unannounce
  try {
    announcementClient.unannounce().checkedGet();
  }
  catch (DiscoveryException e) {
    if (e.getCause() instanceof ConnectException) {
      log.error("Cannot connect to discovery server for unannounce: %s", e.getCause().getMessage());
    }
    else {
      log.error(e);
    }
  }
}

  @Override
  public final DiscoveryException handleException(Request request, Exception exception)
  {
    if (exception instanceof InterruptedException) {
      return new DiscoveryException(name + " was interrupted");
    }
    if (exception instanceof CancellationException) {
      return new DiscoveryException(name + " was canceled");
    }
    if (exception instanceof DiscoveryException) {
      throw (DiscoveryException) exception;
    }
    return new DiscoveryException(name + " failed", exception);
  }
}

  @Override
  public final DiscoveryException handleException(Request request, Exception exception)
  {
    if (exception instanceof InterruptedException) {
      return new DiscoveryException(name + " was interrupted");
    }
    if (exception instanceof CancellationException) {
      return new DiscoveryException(name + " was canceled");
    }
    if (exception instanceof DiscoveryException) {
      throw (DiscoveryException) exception;
    }
    return new DiscoveryException(name + " failed", exception);
  }
}

  @Override
  public final T handleException(Request request, Exception exception)
  {
    if (exception instanceof InterruptedException) {
      throw new DiscoveryException(name + " was interrupted for " + uri);
    }
    if (exception instanceof CancellationException) {
      throw new DiscoveryException(name + " was canceled for " + uri);
    }
    if (exception instanceof DiscoveryException) {
      throw (DiscoveryException) exception;
    }
    throw new DiscoveryException(name + " failed for " + uri, exception);
  }
}

  @Override
  public final T handleException(Request request, Exception exception)
  {
    if (exception instanceof InterruptedException) {
      throw new DiscoveryException(name + " was interrupted for " + uri);
    }
    if (exception instanceof CancellationException) {
      throw new DiscoveryException(name + " was canceled for " + uri);
    }
    if (exception instanceof DiscoveryException) {
      throw (DiscoveryException) exception;
    }
    throw new DiscoveryException(name + " failed for " + uri, exception);
  }
}

  @Override
  public DiscoveryException apply(Exception e)
  {
    if (e instanceof InterruptedException) {
      Thread.currentThread().interrupt();
      return new DiscoveryException(name + " was interrupted");
    }
    if (e instanceof CancellationException) {
      return new DiscoveryException(name + " was canceled");
    }
    Throwable cause = e;
    if (e instanceof ExecutionException) {
      if (e.getCause() != null) {
        cause = e.getCause();
      }
    }
    if (cause instanceof DiscoveryException) {
      return (DiscoveryException) cause;
    }
    return new DiscoveryException(name + " failed", cause);
  }
});

  @Override
  public Duration handle(Request request, Response response)
      throws DiscoveryException
  {
    int statusCode = response.getStatusCode();
    if (!isSuccess(statusCode)) {
      throw new DiscoveryException(String.format("Announcement failed with status code %s: %s", statusCode, getBodyForError(response)));
    }
    Duration maxAge = extractMaxAge(response);
    return maxAge;
  }
});

  @Override
  public Duration handle(Request request, Response response)
      throws DiscoveryException
  {
    int statusCode = response.getStatusCode();
    if (!isSuccess(statusCode)) {
      throw new DiscoveryException(String.format("Announcement failed with status code %s: %s", statusCode, getBodyForError(response)));
    }
    Duration maxAge = extractMaxAge(response);
    return maxAge;
  }
});

  @Override
  public Duration handle(Request request, Response response)
      throws DiscoveryException
  {
    int statusCode = response.getStatusCode();
    if (!isSuccess(statusCode)) {
      throw new DiscoveryException(String.format("Announcement failed with status code %s: %s", statusCode, getBodyForError(response)));
    }
    Duration maxAge = extractMaxAge(response);
    return maxAge;
  }
});

public ServiceDescriptors(String type,
    String pool,
    List<ServiceDescriptor> serviceDescriptors,
    Duration maxAge,
    String eTag)
{
  requireNonNull(type, "type is null");
  requireNonNull(serviceDescriptors, "serviceDescriptors is null");
  requireNonNull(maxAge, "maxAge is null");
  this.type = type;
  this.pool = pool;
  this.serviceDescriptors = ImmutableList.copyOf(serviceDescriptors);
  this.maxAge = maxAge;
  this.eTag = eTag;
  // verify service descriptors match expected type
  for (ServiceDescriptor serviceDescriptor : this.serviceDescriptors) {
    if (!type.equals(serviceDescriptor.getType()) || (pool != null && !pool.equals(serviceDescriptor.getPool()))) {
      throw new DiscoveryException(format("Expected %s service descriptor from pool %s, but was %s service descriptor from pool %s",
          type,
          pool,
          serviceDescriptor.getType(),
          serviceDescriptor.getPool()));
    }
  }
}

public ServiceDescriptors(String type,
    String pool,
    List<ServiceDescriptor> serviceDescriptors,
    Duration maxAge,
    String eTag)
{
  Preconditions.checkNotNull(type, "type is null");
  Preconditions.checkNotNull(serviceDescriptors, "serviceDescriptors is null");
  Preconditions.checkNotNull(maxAge, "maxAge is null");
  this.type = type;
  this.pool = pool;
  this.serviceDescriptors = ImmutableList.copyOf(serviceDescriptors);
  this.maxAge = maxAge;
  this.eTag = eTag;
  // verify service descriptors match expected type
  for (ServiceDescriptor serviceDescriptor : this.serviceDescriptors) {
    if (!type.equals(serviceDescriptor.getType()) || (pool != null && !pool.equals(serviceDescriptor.getPool()))) {
      throw new DiscoveryException(format("Expected %s service descriptor from pool %s, but was %s service descriptor from pool %s",
          type,
          pool,
          serviceDescriptor.getType(),
          serviceDescriptor.getPool()));
    }
  }
}

public ServiceDescriptors(String type,
    String pool,
    List<ServiceDescriptor> serviceDescriptors,
    Duration maxAge,
    String eTag)
{
  Preconditions.checkNotNull(type, "type is null");
  Preconditions.checkNotNull(serviceDescriptors, "serviceDescriptors is null");
  Preconditions.checkNotNull(maxAge, "maxAge is null");
  this.type = type;
  this.pool = pool;
  this.serviceDescriptors = ImmutableList.copyOf(serviceDescriptors);
  this.maxAge = maxAge;
  this.eTag = eTag;
  // verify service descriptors match expected type
  for (ServiceDescriptor serviceDescriptor : this.serviceDescriptors) {
    if (!type.equals(serviceDescriptor.getType()) || (pool != null && !pool.equals(serviceDescriptor.getPool()))) {
      throw new DiscoveryException(format("Expected %s service descriptor from pool %s, but was %s service descriptor from pool %s",
          type,
          pool,
          serviceDescriptor.getType(),
          serviceDescriptor.getPool()));
    }
  }
}

return immediateFailedFuture(new DiscoveryException("No discovery servers are available"));
    throw new DiscoveryException(format("Lookup of %s failed with status code %s", type, response.getStatusCode()));
    throw new DiscoveryException(format("Lookup of %s failed", type), e);
    throw new DiscoveryException(format("Expected environment to be %s, but was %s", environment, serviceDescriptorsRepresentation.getEnvironment()));

return Futures.immediateFailedCheckedFuture(new DiscoveryException("No discovery servers are available"));
    throw new DiscoveryException(format("Lookup of %s failed with status code %s", type, response.getStatusCode()));
    throw new DiscoveryException(format("Lookup of %s failed", type), e);
    throw new DiscoveryException(format("Expected environment to be %s, but was %s", environment, serviceDescriptorsRepresentation.getEnvironment()));

Most used methods

Popular in Java

Reading from database using SQL prepared statement
getResourceAsStream (ClassLoader)
getSharedPreferences (Context)
findViewById (Activity)
BufferedImage (java.awt.image)
The BufferedImage subclass describes an java.awt.Image with an accessible buffer of image data. All
BufferedReader (java.io)
Wraps an existing Reader and buffers the input. Expensive interaction with the underlying reader is
URI (java.net)
A Uniform Resource Identifier that identifies an abstract or physical resource, as specified by RFC
ResultSet (java.sql)
An interface for an object which represents a database table entry, returned as the result of the qu
Timestamp (java.sql)
A Java representation of the SQL TIMESTAMP type. It provides the capability of representing the SQL
Comparator (java.util)
A Comparator is used to compare two objects to determine their ordering with respect to each other.
14 Best Plugins for Eclipse

How to useDiscoveryException in io.airlift.discovery.client

Best Java code snippets using io.airlift.discovery.client.DiscoveryException (Showing top 20 results out of 315)

How to use
DiscoveryException
in
io.airlift.discovery.client