redis_cluster.cc

Network::Address::InstanceConstSharedPtr
RedisCluster::RedisDiscoverySession::RedisDiscoverySession::ProcessCluster(
    const NetworkFilters::Common::Redis::RespValue& value) {
  if (value.type() != NetworkFilters::Common::Redis::RespType::Array) {
    return nullptr;
  }
  auto& array = value.asArray();

  if (array.size() < 2 || array[0].type() != NetworkFilters::Common::Redis::RespType::BulkString ||
      array[1].type() != NetworkFilters::Common::Redis::RespType::Integer) {
    return nullptr;
  }

  try {
    return Network::Utility::parseInternetAddress(array[0].asString(), array[1].asInteger(), false);
  } catch (const EnvoyException& ex) {
    // hostnames are given, instead of IP address, from ElastiCache; resolve again
    try {
        parent_.dns_resolver_->resolve(array[0].asString(), parent_.dns_lookup_family_,
                           [this, array](Network::DnsResolver::ResolutionStatus status,
                                      std::list<Network::DnsResponse>&& response) -> void {
                              if (status == Network::DnsResolver::ResolutionStatus::Success) {
                                Network::Address::InstanceConstSharedPtr slotAddress_ = !response.empty()
                                                             ? Network::Utility::parseInternetAddress(response.front().address_->ip()->addressAsString(),
                                                                                                      array[1].asInteger())
                                                             : nullptr;
                                if (slotAddress_) {
                                  discovery_address_list_.push_back(slotAddress_);
                                }
                              }
                            });
        return discovery_address_list_.back();

    } catch (const EnvoyException& ex) {
      ENVOY_LOG(debug, "Invalid node address in CLUSTER SLOTS response: '{}'", ex.what());
      return nullptr;
    }
  }
}