src/developer/debug/zxdb/client/symbol_server.cc

// Copyright 2019 The Fuchsia Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

#include "src/developer/debug/zxdb/client/symbol_server.h"

#include <filesystem>
#include <fstream>

#include <rapidjson/document.h>
#include <rapidjson/istreamwrapper.h>

#include "src/developer/debug/shared/logging/logging.h"
#include "src/developer/debug/shared/string_util.h"
#include "src/developer/debug/zxdb/client/symbol_server_impl.h"

namespace zxdb {
namespace {

constexpr size_t kMaxRetries = 5;
constexpr char kClientId[] =
    "446450136466-2hr92jrq8e6i4tnsa56b52vacp7t3936"
    ".apps.googleusercontent.com";
constexpr char kClientSecret[] = "uBfbay2KCy9t4QveJ-dOqHtp";

std::optional<std::filesystem::path> GetGcloudCredentialsFile() {
  std::string config_dir;
  if (auto cloudsdk_config = std::getenv("CLOUDSDK_CONFIG")) {
    config_dir = cloudsdk_config;
  } else if (auto home = std::getenv("HOME")) {
    config_dir = std::string(home) + "/.config/gcloud";
  }

  if (!std::filesystem::is_directory(config_dir)) {
    return std::nullopt;
  }

  std::filesystem::path credentials = config_dir + "/application_default_credentials.json";
  if (!std::filesystem::exists(credentials) || !std::filesystem::is_regular_file(credentials)) {
    return std::nullopt;
  }

  return credentials;
}

}  // namespace

void SymbolServer::IncrementRetries() {
  if (++retries_ == kMaxRetries) {
    ChangeState(SymbolServer::State::kUnreachable);
  }
}

void SymbolServer::ChangeState(SymbolServer::State state) {
  if (state_ == state) {
    return;
  }

  state_ = state;

  if (state_ == SymbolServer::State::kReady) {
    retries_ = 0;
    error_log_.clear();
    ready_count_++;
  }

  if (state_change_callback_)
    state_change_callback_(this, state_);
}

std::unique_ptr<SymbolServer> SymbolServer::FromURL(Session* session, const std::string& url,
                                                    bool require_authentication) {
  return std::make_unique<SymbolServerImpl>(session, url, require_authentication);
}

void SymbolServer::DoInit() {
  if (state() != SymbolServer::State::kAuth && state() != SymbolServer::State::kInitializing) {
    return;
  }

  if (std::getenv("GCE_METADATA_HOST") || LoadCachedAuth() || LoadGCloudAuth()) {
    ChangeState(SymbolServer::State::kBusy);
    AuthRefresh();
  } else {
    ChangeState(SymbolServer::State::kAuth);
    if (!GetGcloudCredentialsFile()) {
      LOGS(Warn)
          << name_ << " failed to authenticate: "
          << "Gcloud credentials file not found. You may need to install the gcloud command line"
             " tool: https://cloud.google.com/sdk/docs/install and run"
             " `gcloud auth application-default login`.";
    }
  }
}

void SymbolServer::AuthRefresh() {
  std::map<std::string, std::string> post_data;
  post_data["refresh_token"] = refresh_token_;
  post_data["client_id"] = client_id_;
  post_data["client_secret"] = client_secret_;
  post_data["grant_type"] = "refresh_token";

  DoAuthenticate(post_data, [this](const Err& err) {
    if (err.has_error()) {
      LOGS(Warn) << "Server " << name_ << " failed authentication: " << err.msg() << ".";
      if (client_secret_.empty() && !GetGcloudCredentialsFile()) {
        LOGS(Warn) << "Could not load gcloud auth token. You may need to run "
                      "`gcloud auth application-default login`";
      } else if (auto credentials_file = GetGcloudCredentialsFile()) {
        LOGS(Warn) << "gcloud application-default credentials exist in "
                   << *GetGcloudCredentialsFile()
                   << ". Check file permissions and your account permissions.";
      }
    }
  });
}

FILE* SymbolServer::GetGoogleApiAuthCache(const char* mode) {
  if (auto home = std::getenv("HOME")) {
    std::filesystem::path path =
        std::filesystem::path(home) / ".fuchsia" / "debug" / "googleapi_auth";

    if (!std::filesystem::exists(path)) {
      return nullptr;
    }

    return fopen(path.c_str(), mode);
  }

  return nullptr;
}

bool SymbolServer::LoadCachedAuth() {
  FILE* fp = GetGoogleApiAuthCache("rb");

  if (!fp) {
    return false;
  }

  std::vector<char> buf(65536);
  buf.resize(fread(buf.data(), 1, buf.size(), fp));
  bool success = feof(fp);
  fclose(fp);

  if (!success) {
    return false;
  }

  client_id_ = kClientId;
  client_secret_ = kClientSecret;
  refresh_token_ = std::string(buf.data(), buf.data() + buf.size());

  return true;
}

bool SymbolServer::LoadGCloudAuth() {
  std::optional<std::string> gcloud_credentials = GetGcloudCredentialsFile();
  if (!gcloud_credentials) {
    return false;
  }

  std::ifstream credential_file(*gcloud_credentials);
  if (!credential_file) {
    return false;
  }

  rapidjson::IStreamWrapper input_stream(credential_file);
  rapidjson::Document credentials;
  credentials.ParseStream(input_stream);

  if (credentials.HasParseError() || !credentials.IsObject() ||
      !credentials.HasMember("client_id") || !credentials.HasMember("client_secret") ||
      !credentials.HasMember("refresh_token")) {
    return false;
  }

  client_id_ = credentials["client_id"].GetString();
  client_secret_ = credentials["client_secret"].GetString();
  refresh_token_ = credentials["refresh_token"].GetString();

  return true;
}

std::string ServerStateToString(const SymbolServer::State& state) {
  switch (state) {
    case SymbolServer::State::kInitializing:
      return "initializing";
    case SymbolServer::State::kAuth:
      return "authenticating";
    case SymbolServer::State::kBusy:
      return "busy";
    case SymbolServer::State::kReady:
      return "ready";
    case SymbolServer::State::kUnreachable:
      return "unreachable";
    default:
      return "unknown";
  }
}

}  // namespace zxdb