src/ledger/cloud_provider_firestore/bin/app/factory_impl.cc

// Copyright 2017 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/ledger/cloud_provider_firestore/bin/app/factory_impl.h"

#include <grpc++/grpc++.h>
#include <lib/fit/function.h>

#include "src/ledger/cloud_provider_firestore/bin/firestore/firestore_service_impl.h"
#include "src/lib/fxl/logging.h"

namespace cloud_provider_firestore {

namespace {
std::shared_ptr<grpc::Channel> MakeChannel() {
  auto opts = grpc::SslCredentialsOptions();
  auto credentials = grpc::SslCredentials(opts);
  return grpc::CreateChannel("firestore.googleapis.com:443", credentials);
}

firebase_auth::FirebaseAuthImpl::Config GetFirebaseAuthConfig(
    const std::string& api_key, const std::string& user_profile_id,
    const std::string& cobalt_client_name) {
  firebase_auth::FirebaseAuthImpl::Config config;
  config.api_key = api_key;
  config.user_profile_id = user_profile_id;
  config.cobalt_client_name = cobalt_client_name;

  return config;
}

}  // namespace

FactoryImpl::FactoryImpl(async_dispatcher_t* dispatcher, rng::Random* random,
                         sys::ComponentContext* component_context,
                         std::string cobalt_client_name)
    : dispatcher_(dispatcher),
      random_(random),
      component_context_(component_context),
      cobalt_client_name_(std::move(cobalt_client_name)) {}

FactoryImpl::~FactoryImpl() {}

void FactoryImpl::ShutDown(fit::closure callback) {
  if (providers_.empty()) {
    callback();
    return;
  }

  providers_.set_on_empty(std::move(callback));
  for (auto& cloud_provider : providers_) {
    cloud_provider.ShutDownAndReportEmpty();
  }
}

void FactoryImpl::GetCloudProvider(
    Config config,
    fidl::InterfaceHandle<fuchsia::auth::TokenManager> token_manager,
    fidl::InterfaceRequest<cloud_provider::CloudProvider>
        cloud_provider_request,
    GetCloudProviderCallback callback) {
  auto firebase_auth = std::make_unique<firebase_auth::FirebaseAuthImpl>(
      GetFirebaseAuthConfig(config.api_key, config.user_profile_id,
                            cobalt_client_name_),
      dispatcher_, random_, token_manager.Bind(), component_context_);

  GetFirebaseCloudProvider(std::move(config), std::move(firebase_auth),
                           std::move(cloud_provider_request),
                           std::move(callback));
}

void FactoryImpl::GetFirebaseCloudProvider(
    Config config,
    std::unique_ptr<firebase_auth::FirebaseAuthImpl> firebase_auth,
    fidl::InterfaceRequest<cloud_provider::CloudProvider>
        cloud_provider_request,
    fit::function<void(cloud_provider::Status)> callback) {
  FXL_DCHECK(firebase_auth);

  auto token_request =
      firebase_auth->GetFirebaseUserId(
          [this, config = std::move(config),
           firebase_auth = std::move(firebase_auth),
           cloud_provider_request = std::move(cloud_provider_request),
           callback = std::move(callback)](firebase_auth::AuthStatus status,
                                           std::string user_id) mutable {
            if (status != firebase_auth::AuthStatus::OK) {
              FXL_LOG(ERROR)
                  << "Failed to retrieve the user ID from auth token provider";
              callback(cloud_provider::Status::AUTH_ERROR);
              return;
            }

            auto firestore_service = std::make_unique<FirestoreServiceImpl>(
                config.server_id, dispatcher_, MakeChannel());

            providers_.emplace(random_, user_id, std::move(firebase_auth),
                               std::move(firestore_service),
                               std::move(cloud_provider_request));
            callback(cloud_provider::Status::OK);
          });
  token_requests_.emplace(token_request);
}

}  // namespace cloud_provider_firestore