metricsd/uploader/system_profile_cache.cc

/*
 * Copyright (C) 2015 The Android Open Source Project
 *
 * 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.
 */

#include "uploader/system_profile_cache.h"

#include <base/files/file_util.h>
#include <base/guid.h>
#include <base/logging.h>
#include <base/strings/string_number_conversions.h>
#include <base/strings/string_util.h>
#include <brillo/osrelease_reader.h>
#include <string>
#include <update_engine/client.h>
#include <vector>

#include "constants.h"
#include "persistent_integer.h"
#include "uploader/metrics_log_base.h"
#include "uploader/proto/chrome_user_metrics_extension.pb.h"

namespace {

const char kPersistentSessionIdFilename[] = "Sysinfo.SessionId";

}  // namespace

std::string ChannelToString(
    const metrics::SystemProfileProto_Channel& channel) {
  switch (channel) {
    case metrics::SystemProfileProto::CHANNEL_STABLE:
    return "STABLE";
  case metrics::SystemProfileProto::CHANNEL_DEV:
    return "DEV";
  case metrics::SystemProfileProto::CHANNEL_BETA:
    return "BETA";
  case metrics::SystemProfileProto::CHANNEL_CANARY:
    return "CANARY";
  default:
    return "UNKNOWN";
  }
}

SystemProfileCache::SystemProfileCache()
    : initialized_(false),
      testing_(false),
      metrics_directory_(metrics::kMetricsdDirectory),
      session_id_(new chromeos_metrics::PersistentInteger(
          kPersistentSessionIdFilename, metrics_directory_)) {}

SystemProfileCache::SystemProfileCache(bool testing,
                                       const base::FilePath& metrics_directory)
    : initialized_(false),
      testing_(testing),
      metrics_directory_(metrics_directory),
      session_id_(new chromeos_metrics::PersistentInteger(
          kPersistentSessionIdFilename, metrics_directory)) {}

bool SystemProfileCache::Initialize() {
  CHECK(!initialized_)
      << "this should be called only once in the metrics_daemon lifetime.";

  brillo::OsReleaseReader reader;
  std::string channel;
  if (testing_) {
    reader.LoadTestingOnly(metrics_directory_);
    channel = "unknown";
  } else {
    reader.Load();
    auto client = update_engine::UpdateEngineClient::CreateInstance();
    if (!client) {
      LOG(ERROR) << "failed to create the update engine client";
      return false;
    }
    if (!client->GetChannel(&channel)) {
      LOG(ERROR) << "failed to read the current channel from update engine.";
      return false;
    }
  }

  if (!reader.GetString(metrics::kProductId, &profile_.product_id)
      || profile_.product_id.empty()) {
    LOG(ERROR) << "product_id is not set.";
    return false;
  }

  if (!reader.GetString(metrics::kProductVersion, &profile_.version)) {
    LOG(ERROR) << "failed to read the product version";
  }

  if (channel.empty() || profile_.version.empty()) {
    // If the channel or version is missing, the image is not official.
    // In this case, set the channel to unknown and the version to 0.0.0.0 to
    // avoid polluting the production data.
    channel = "";
    profile_.version = metrics::kDefaultVersion;
  }
  std::string guid_path = metrics_directory_.Append(
      metrics::kMetricsGUIDFileName).value();
  profile_.client_id = testing_ ?
      "client_id_test" :
      GetPersistentGUID(guid_path);
  profile_.model_manifest_id = "unknown";
  if (!testing_) {
    brillo::KeyValueStore weave_config;
    if (!weave_config.Load(base::FilePath(metrics::kWeaveConfigurationFile))) {
      LOG(ERROR) << "Failed to load the weave configuration file.";
    } else if (!weave_config.GetString(metrics::kModelManifestId,
                                       &profile_.model_manifest_id)) {
      LOG(ERROR) << "The model manifest id (model_id) is undefined in "
                 << metrics::kWeaveConfigurationFile;
    }
  }

  profile_.channel = ProtoChannelFromString(channel);

  // Increment the session_id everytime we initialize this. If metrics_daemon
  // does not crash, this should correspond to the number of reboots of the
  // system.
  session_id_->Add(1);
  profile_.session_id = static_cast<int32_t>(session_id_->Get());

  initialized_ = true;
  return initialized_;
}

bool SystemProfileCache::InitializeOrCheck() {
  return initialized_ || Initialize();
}

bool SystemProfileCache::Populate(
    metrics::ChromeUserMetricsExtension* metrics_proto) {
  CHECK(metrics_proto);
  if (not InitializeOrCheck()) {
    return false;
  }

  // The client id is hashed before being sent.
  metrics_proto->set_client_id(
      metrics::MetricsLogBase::Hash(profile_.client_id));
  metrics_proto->set_session_id(profile_.session_id);

  // Sets the product id.
  metrics_proto->set_product(9);

  metrics::SystemProfileProto* profile_proto =
      metrics_proto->mutable_system_profile();
  profile_proto->mutable_hardware()->set_hardware_class(
      profile_.model_manifest_id);
  profile_proto->set_app_version(profile_.version);
  profile_proto->set_channel(profile_.channel);
  metrics::SystemProfileProto_BrilloDeviceData* device_data =
      profile_proto->mutable_brillo();
  device_data->set_product_id(profile_.product_id);

  return true;
}

std::string SystemProfileCache::GetPersistentGUID(
    const std::string& filename) {
  std::string guid;
  base::FilePath filepath(filename);
  if (!base::ReadFileToString(filepath, &guid)) {
    guid = base::GenerateGUID();
    // If we can't read or write the file, the guid will not be preserved during
    // the next reboot. Crash.
    CHECK(base::WriteFile(filepath, guid.c_str(), guid.size()));
  }
  return guid;
}

metrics::SystemProfileProto_Channel SystemProfileCache::ProtoChannelFromString(
    const std::string& channel) {
  if (channel == "stable-channel") {
    return metrics::SystemProfileProto::CHANNEL_STABLE;
  } else if (channel == "dev-channel") {
    return metrics::SystemProfileProto::CHANNEL_DEV;
  } else if (channel == "beta-channel") {
    return metrics::SystemProfileProto::CHANNEL_BETA;
  } else if (channel == "canary-channel") {
    return metrics::SystemProfileProto::CHANNEL_CANARY;
  }

  DLOG(INFO) << "unknown channel: " << channel;
  return metrics::SystemProfileProto::CHANNEL_UNKNOWN;
}