blob: cec6df1af682864e9bcb5136a237fc53d24c1c4d [file] [log] [blame]
//
//
// Copyright 2018 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_SRC_CORE_RESOLVER_ENDPOINT_ADDRESSES_H
#define GRPC_SRC_CORE_RESOLVER_ENDPOINT_ADDRESSES_H
#include <set>
#include <string>
#include <utility>
#include <vector>
#include "absl/functional/function_ref.h"
#include <grpc/support/port_platform.h>
#include "src/core/lib/channel/channel_args.h"
#include "src/core/lib/iomgr/resolved_address.h"
// A channel arg key prefix used for args that are intended to be used
// only internally to resolvers and LB policies and should not be part
// of the subchannel key. The channel will automatically filter out any
// args with this prefix from the subchannel's args.
#define GRPC_ARG_NO_SUBCHANNEL_PREFIX "grpc.internal.no_subchannel."
// A channel arg indicating the weight of an address.
#define GRPC_ARG_ADDRESS_WEIGHT GRPC_ARG_NO_SUBCHANNEL_PREFIX "address.weight"
namespace grpc_core {
// A list of addresses for a given endpoint with an associated set of channel
// args. Any args present here will be merged into the channel args when a
// subchannel is created for each address.
class EndpointAddresses final {
public:
// For backward compatibility.
// TODO(roth): Remove when callers have been updated.
EndpointAddresses(const grpc_resolved_address& address,
const ChannelArgs& args);
// addresses must not be empty.
EndpointAddresses(std::vector<grpc_resolved_address> addresses,
const ChannelArgs& args);
// Copyable.
EndpointAddresses(const EndpointAddresses& other);
EndpointAddresses& operator=(const EndpointAddresses& other);
// Movable.
EndpointAddresses(EndpointAddresses&& other) noexcept;
EndpointAddresses& operator=(EndpointAddresses&& other) noexcept;
bool operator==(const EndpointAddresses& other) const {
return Cmp(other) == 0;
}
bool operator!=(const EndpointAddresses& other) const {
return Cmp(other) != 0;
}
bool operator<(const EndpointAddresses& other) const {
return Cmp(other) < 0;
}
int Cmp(const EndpointAddresses& other) const;
// For backward compatibility only.
// TODO(roth): Remove when all callers have been updated.
const grpc_resolved_address& address() const { return addresses_[0]; }
const std::vector<grpc_resolved_address>& addresses() const {
return addresses_;
}
const ChannelArgs& args() const { return args_; }
// TODO(ctiller): Prior to making this a public API we should ensure that the
// channel args are not part of the generated string, lest we make that debug
// format load-bearing via Hyrum's law.
std::string ToString() const;
private:
std::vector<grpc_resolved_address> addresses_;
ChannelArgs args_;
};
using EndpointAddressesList = std::vector<EndpointAddresses>;
struct ResolvedAddressLessThan {
bool operator()(const grpc_resolved_address& addr1,
const grpc_resolved_address& addr2) const;
};
class EndpointAddressSet final {
public:
explicit EndpointAddressSet(
const std::vector<grpc_resolved_address>& addresses)
: addresses_(addresses.begin(), addresses.end()) {}
bool operator==(const EndpointAddressSet& other) const;
bool operator<(const EndpointAddressSet& other) const;
std::string ToString() const;
private:
std::set<grpc_resolved_address, ResolvedAddressLessThan> addresses_;
};
// An iterator interface for endpoints.
class EndpointAddressesIterator {
public:
virtual ~EndpointAddressesIterator() = default;
// Invokes callback once for each endpoint.
virtual void ForEach(
absl::FunctionRef<void(const EndpointAddresses&)> callback) const = 0;
};
// Iterator over a fixed list of endpoints.
class EndpointAddressesListIterator final : public EndpointAddressesIterator {
public:
explicit EndpointAddressesListIterator(EndpointAddressesList endpoints)
: endpoints_(std::move(endpoints)) {}
void ForEach(absl::FunctionRef<void(const EndpointAddresses&)> callback)
const override {
for (const auto& endpoint : endpoints_) {
callback(endpoint);
}
}
private:
EndpointAddressesList endpoints_;
};
// Iterator that returns only a single endpoint.
class SingleEndpointIterator final : public EndpointAddressesIterator {
public:
explicit SingleEndpointIterator(EndpointAddresses endpoint)
: endpoint_(std::move(endpoint)) {}
void ForEach(absl::FunctionRef<void(const EndpointAddresses&)> callback)
const override {
callback(endpoint_);
}
private:
EndpointAddresses endpoint_;
};
} // namespace grpc_core
#endif // GRPC_SRC_CORE_RESOLVER_ENDPOINT_ADDRESSES_H