io.grpc.NameResolver Maven / Gradle / Ivy

/*
 * Copyright 2015, gRPC Authors All rights reserved.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package io.grpc;

import java.net.URI;
import java.util.List;
import javax.annotation.Nullable;
import javax.annotation.concurrent.ThreadSafe;

/**
 * A pluggable component that resolves a target {@link URI} and return addresses to the caller.
 *
 * A {@code NameResolver} uses the URI's scheme to determine whether it can resolve it, and uses
 * the components after the scheme for actual resolution.
 *
 * 
The addresses and attributes of a target may be changed over time, thus the caller registers a
 * {@link Listener} to receive continuous updates.
 */
@ExperimentalApi("https://github.com/grpc/grpc-java/issues/1770")
@ThreadSafe
public abstract class NameResolver {
  /**
   * Returns the authority used to authenticate connections to servers.  It must be
   * from a trusted source, because if the authority is tampered with, RPCs may be sent to the
   * attackers which may leak sensitive user data.
   *
   * 
An implementation must generate it without blocking, typically in line, and
   * must keep it unchanged. {@code NameResolver}s created from the same factory
   * with the same argument must return the same authority.
   */
  public abstract String getServiceAuthority();

  /**
   * Starts the resolution.
   *
   * @param listener used to receive updates on the target
   */
  public abstract void start(Listener listener);

  /**
   * Stops the resolution. Updates to the Listener will stop.
   */
  public abstract void shutdown();

  /**
   * Re-resolve the name.
   *
   * 
Can only be called after {@link #start} has been called.
   *
   * 
This is only a hint. Implementation takes it as a signal but may not start resolution
   * immediately. It should never throw.
   *
   * 
The default implementation is no-op.
   */
  public void refresh() {}

  /**
   * Factory that creates {@link NameResolver} instances.
   */
  public abstract static class Factory {
    /**
     * The port number used in case the target or the underlying naming system doesn't provide a
     * port number.
     */
    public static final Attributes.Key PARAMS_DEFAULT_PORT =
        Attributes.Key.of("params-default-port");

    /**
     * Creates a {@link NameResolver} for the given target URI, or {@code null} if the given URI
     * cannot be resolved by this factory. The decision should be solely based on the scheme of the
     * URI.
     *
     * @param targetUri the target URI to be resolved, whose scheme must not be {@code null}
     * @param params optional parameters. Canonical keys are defined as {@code PARAMS_*} fields in
     *               {@link Factory}.
     */
    @Nullable
    public abstract NameResolver newNameResolver(URI targetUri, Attributes params);

    /**
     * Returns the default scheme, which will be used to construct a URI when {@link
     * ManagedChannelBuilder#forTarget(String)} is given an authority string instead of a compliant
     * URI.
     */
    public abstract String getDefaultScheme();
  }

  /**
   * Receives address updates.
   *
   * 
All methods are expected to return quickly.
   */
  @ThreadSafe
  public interface Listener {
    /**
     * Handles updates on resolved addresses and attributes.
     *
     * 
Implementations will not modify the given {@code servers}.
     *
     * @deprecated call {@link #onAddresses} instead
     * @param servers the resolved server groups, containing {@link ResolvedServerInfo} objects. An
     *                empty list will trigger {@link #onError}
     * @param attributes extra metadata from naming system
     */
    @Deprecated
    void onUpdate(List servers, Attributes attributes);

    /**
     * Handles updates on resolved addresses and attributes.
     *
     * Implementations will not modify the given {@code servers}.
     *
     * @param servers the resolved server addresses. An empty list will trigger {@link #onError}
     * @param attributes extra metadata from naming system
     */
    void onAddresses(List servers, Attributes attributes);

    /**
     * Handles an error from the resolver.
     *
     * @param error a non-OK status
     */
    void onError(Status error);
  }
}