chromecast/crash/linux/crash_testing_utils.cc

   1 // Copyright 2015 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "chromecast/crash/linux/crash_testing_utils.h"
   6
   7 #include "base/files/file_util.h"
   8 #include "base/strings/string_split.h"
   9 #include "base/strings/stringprintf.h"
  10 #include "base/values.h"
  11 #include "chromecast/base/path_utils.h"
  12 #include "chromecast/base/serializers.h"
  13 #include "chromecast/crash/linux/dump_info.h"
  14
  15 #define RCHECK(cond, retval, err) \
  16   do {                            \
  17     LOG(ERROR) << (err);          \
  18     if (!(cond)) {                \
  19       return (retval);            \
  20     }                             \
  21   } while (0)
  22
  23 namespace chromecast {
  24 namespace {
  25
  26 const char kRatelimitKey[] = "ratelimit";
  27 const char kRatelimitPeriodStartKey[] = "period_start";
  28 const char kRatelimitPeriodDumpsKey[] = "period_dumps";
  29
  30 scoped_ptr<base::ListValue> ParseLockFile(const std::string& path) {
  31   std::string lockfile_string;
  32   RCHECK(base::ReadFileToString(base::FilePath(path), &lockfile_string),
  33          nullptr,
  34          "Failed to read file");
  35
  36   std::vector<std::string> lines = base::SplitString(
  37       lockfile_string, "\n", base::KEEP_WHITESPACE, base::SPLIT_WANT_NONEMPTY);
  38
  39   scoped_ptr<base::ListValue> dumps = make_scoped_ptr(new base::ListValue());
  40
  41   // Validate dumps
  42   for (const std::string& line : lines) {
  43     if (line.size() == 0)
  44       continue;
  45     scoped_ptr<base::Value> dump_info = DeserializeFromJson(line);
  46     DumpInfo info(dump_info.get());
  47     RCHECK(info.valid(), nullptr, "Invalid DumpInfo");
  48     dumps->Append(dump_info.Pass());
  49   }
  50
  51   return dumps;
  52 }
  53
  54 scoped_ptr<base::Value> ParseMetadataFile(const std::string& path) {
  55   return DeserializeJsonFromFile(base::FilePath(path));
  56 }
  57
  58 int WriteLockFile(const std::string& path, base::ListValue* contents) {
  59   DCHECK(contents);
  60   std::string lockfile;
  61
  62   for (const base::Value* elem : *contents) {
  63     scoped_ptr<std::string> dump_info = SerializeToJson(*elem);
  64     RCHECK(dump_info, -1, "Failed to serialize DumpInfo");
  65     lockfile += *dump_info;
  66     lockfile += "\n";  // Add line seperatators
  67   }
  68
  69   return WriteFile(base::FilePath(path), lockfile.c_str(), lockfile.size()) >= 0
  70              ? 0
  71              : -1;
  72 }
  73
  74 bool WriteMetadataFile(const std::string& path, const base::Value* metadata) {
  75   DCHECK(metadata);
  76   return SerializeJsonToFile(base::FilePath(path), *metadata);
  77 }
  78
  79 }  // namespace
  80
  81 scoped_ptr<DumpInfo> CreateDumpInfo(const std::string& json_string) {
  82   scoped_ptr<base::Value> value(DeserializeFromJson(json_string));
  83   return make_scoped_ptr(new DumpInfo(value.get()));
  84 }
  85
  86 bool FetchDumps(const std::string& lockfile_path,
  87                 ScopedVector<DumpInfo>* dumps) {
  88   DCHECK(dumps);
  89   scoped_ptr<base::ListValue> dump_list = ParseLockFile(lockfile_path);
  90   RCHECK(dump_list, false, "Failed to parse lockfile");
  91
  92   dumps->clear();
  93
  94   for (base::Value* elem : *dump_list) {
  95     scoped_ptr<DumpInfo> dump = make_scoped_ptr(new DumpInfo(elem));
  96     RCHECK(dump->valid(), false, "Invalid DumpInfo");
  97     dumps->push_back(dump.Pass());
  98   }
  99
 100   return true;
 101 }
 102
 103 bool ClearDumps(const std::string& lockfile_path) {
 104   scoped_ptr<base::ListValue> dump_list =
 105       make_scoped_ptr(new base::ListValue());
 106   return WriteLockFile(lockfile_path, dump_list.get()) == 0;
 107 }
 108
 109 bool CreateFiles(const std::string& lockfile_path,
 110                  const std::string& metadata_path) {
 111   scoped_ptr<base::DictionaryValue> metadata =
 112       make_scoped_ptr(new base::DictionaryValue());
 113
 114   base::DictionaryValue* ratelimit_fields = new base::DictionaryValue();
 115   metadata->Set(kRatelimitKey, make_scoped_ptr(ratelimit_fields));
 116   ratelimit_fields->SetString(kRatelimitPeriodStartKey, "0");
 117   ratelimit_fields->SetInteger(kRatelimitPeriodDumpsKey, 0);
 118
 119   scoped_ptr<base::ListValue> dumps = make_scoped_ptr(new base::ListValue());
 120
 121   return WriteLockFile(lockfile_path, dumps.get()) == 0 &&
 122          WriteMetadataFile(metadata_path, metadata.get());
 123 }
 124
 125 bool AppendLockFile(const std::string& lockfile_path,
 126                     const std::string& metadata_path,
 127                     const DumpInfo& dump) {
 128   scoped_ptr<base::ListValue> contents = ParseLockFile(lockfile_path);
 129   if (!contents) {
 130     CreateFiles(lockfile_path, metadata_path);
 131     if (!(contents = ParseLockFile(lockfile_path))) {
 132       return false;
 133     }
 134   }
 135
 136   contents->Append(dump.GetAsValue());
 137
 138   return WriteLockFile(lockfile_path, contents.get()) == 0;
 139 }
 140
 141 bool SetRatelimitPeriodStart(const std::string& metadata_path, time_t start) {
 142   scoped_ptr<base::Value> contents = ParseMetadataFile(metadata_path);
 143
 144   base::DictionaryValue* dict;
 145   base::DictionaryValue* ratelimit_params;
 146   if (!contents || !contents->GetAsDictionary(&dict) ||
 147       !dict->GetDictionary(kRatelimitKey, &ratelimit_params)) {
 148     return false;
 149   }
 150
 151   std::string period_start_str =
 152       base::StringPrintf("%lld", static_cast<long long>(start));
 153   ratelimit_params->SetString(kRatelimitPeriodStartKey, period_start_str);
 154
 155   return WriteMetadataFile(metadata_path, contents.get()) == 0;
 156 }
 157
 158 }  // namespace chromecast