resolver/resolver.h

Go to the documentation of this file.

//
// Copyright 2015 gRPC authors.
//
// 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.
//
 
#ifndef GRPC_CORE_LIB_RESOLVER_RESOLVER_H
#define GRPC_CORE_LIB_RESOLVER_RESOLVER_H
 
#include <grpc/support/port_platform.h>
 
#include <string>
 
#include "absl/status/statusor.h"
 
#include <grpc/impl/codegen/grpc_types.h>
 
#include "src/core/lib/debug/trace.h"
#include "src/core/lib/gprpp/orphanable.h"
#include "src/core/lib/gprpp/ref_counted_ptr.h"
#include "src/core/lib/resolver/server_address.h"
#include "src/core/lib/service_config/service_config.h"
 
extern grpc_core::DebugOnlyTraceFlag grpc_trace_resolver_refcount;
 
// Name associated with individual address, if available.
#define GRPC_ARG_ADDRESS_NAME "grpc.address_name"
 
namespace grpc_core {
 
class Resolver : public InternallyRefCounted<Resolver> {
 public:
  struct Result {
    absl::StatusOr<ServerAddressList> addresses;
    absl::StatusOr<RefCountedPtr<ServiceConfig>> service_config = nullptr;
    std::string resolution_note;
    // TODO(roth): Before making this a public API, figure out a way to
    // avoid exposing channel args this way.
    const grpc_channel_args* args = nullptr;
 
    // TODO(roth): Remove everything below once grpc_channel_args is
    // converted to a copyable and movable C++ object.
    Result() = default;
    ~Result();
    Result(const Result& other);
    Result(Result&& other) noexcept;
    Result& operator=(const Result& other);
    Result& operator=(Result&& other) noexcept;
  };
 
  class ResultHandler {
   public:
    virtual ~ResultHandler() {}
 
    // TODO(roth): Add a mechanism for the resolver to get back a signal
    // indicating if the result was accepted by the LB policy, so that it
    // knows whether to go into backoff to retry to resolution.
    virtual void ReportResult(Result result) = 0;  // NOLINT
  };
 
  // Not copyable nor movable.
  Resolver(const Resolver&) = delete;
  Resolver& operator=(const Resolver&) = delete;
  ~Resolver() override = default;
 
  virtual void StartLocked() = 0;
 
  virtual void RequestReresolutionLocked() {}
 
  virtual void ResetBackoffLocked() {}
 
  // Note: This must be invoked while holding the work_serializer.
  void Orphan() override {
    ShutdownLocked();
    Unref();
  }
 
 protected:
  Resolver();
 
  virtual void ShutdownLocked() = 0;
};
 
}  // namespace grpc_core
 
#endif  // GRPC_CORE_LIB_RESOLVER_RESOLVER_H