| // 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. |
| |
| #ifndef COBALT_SRC_PUBLIC_COBALT_CONFIG_H_ |
| #define COBALT_SRC_PUBLIC_COBALT_CONFIG_H_ |
| |
| #include <memory> |
| |
| #include "src/lib/clearcut/http_client.h" |
| #include "src/lib/util/clock.h" |
| #include "src/lib/util/encrypted_message_util.h" |
| #include "src/lib/util/file_system.h" |
| #include "src/logger/project_context.h" |
| #include "src/registry/metric_definition.pb.h" |
| #include "src/system_data/client_secret.h" |
| #include "src/system_data/configuration_data.h" |
| |
| namespace cobalt { |
| |
| constexpr char kDefaultClearcutEndpoint[] = "https://play.googleapis.com/staging/log"; |
| constexpr size_t kDefaultClearcutMaxRetries = 5; |
| |
| class TargetPipelineInterface { |
| public: |
| explicit TargetPipelineInterface(system_data::Environment environment) |
| : environment_(environment){}; |
| virtual ~TargetPipelineInterface() = default; |
| |
| // The target environment for the pipeline. Used to determine where to send the data. |
| [[nodiscard]] system_data::Environment environment() const { return environment_; } |
| |
| // An encoded CobaltEncryptionKey proto representing the encryption key to be used for envelopes |
| // sent to the shuffler. (Or nullopt for no encryption) |
| [[nodiscard]] virtual std::optional<std::string> shuffler_encryption_key() const { |
| return std::nullopt; |
| } |
| |
| // An encoded CobaltEncryptionKey proto representing the encryption key to be used for |
| // observations sent to the analyzer. (Or nullopt for no encryption) |
| [[nodiscard]] virtual std::optional<std::string> analyzer_encryption_key() const { |
| return std::nullopt; |
| } |
| |
| // The URL for the desired clearcut endpoint. |
| [[nodiscard]] virtual std::string clearcut_endpoint() const { return ""; }; |
| |
| // Returns an implementation of lib::clearcut::HTTPClient. Will be used for uploading data in the |
| // ShippingManager. |
| [[nodiscard]] virtual std::unique_ptr<lib::clearcut::HTTPClient> TakeHttpClient() { |
| return nullptr; |
| } |
| |
| // How many times should the clearcut upload be reattempted, before returning the observations to |
| // the ObservationStore. |
| [[nodiscard]] virtual size_t clearcut_max_retries() const { return 0; } |
| |
| private: |
| system_data::Environment environment_; |
| }; |
| |
| class LocalPipeline : public TargetPipelineInterface { |
| public: |
| LocalPipeline() : TargetPipelineInterface(system_data::Environment::LOCAL) {} |
| ~LocalPipeline() override = default; |
| }; |
| |
| class ExtraPipeline : public TargetPipelineInterface { |
| public: |
| ExtraPipeline(system_data::Environment environment, std::string shuffler_encryption_key) |
| : TargetPipelineInterface(environment), |
| shuffler_encryption_key_(std::move(shuffler_encryption_key)) {} |
| ~ExtraPipeline() override = default; |
| |
| [[nodiscard]] std::optional<std::string> shuffler_encryption_key() const override { |
| return shuffler_encryption_key_; |
| } |
| |
| private: |
| std::string shuffler_encryption_key_; |
| }; |
| |
| class TargetPipeline : public TargetPipelineInterface { |
| public: |
| TargetPipeline(system_data::Environment environment, std::string shuffler_encryption_key, |
| std::string analyzer_encryption_key, |
| std::unique_ptr<lib::clearcut::HTTPClient> http_client, |
| size_t clearcut_max_retries = kDefaultClearcutMaxRetries, |
| std::string clearcut_endpoint = kDefaultClearcutEndpoint) |
| : TargetPipelineInterface(environment), |
| shuffler_encryption_key_(std::move(shuffler_encryption_key)), |
| analyzer_encryption_key_(std::move(analyzer_encryption_key)), |
| http_client_(std::move(http_client)), |
| clearcut_endpoint_(std::move(clearcut_endpoint)), |
| clearcut_max_retries_(clearcut_max_retries) {} |
| ~TargetPipeline() override = default; |
| |
| [[nodiscard]] std::optional<std::string> shuffler_encryption_key() const override { |
| return shuffler_encryption_key_; |
| } |
| [[nodiscard]] std::optional<std::string> analyzer_encryption_key() const override { |
| return analyzer_encryption_key_; |
| } |
| |
| [[nodiscard]] std::string clearcut_endpoint() const override { return clearcut_endpoint_; }; |
| [[nodiscard]] std::unique_ptr<lib::clearcut::HTTPClient> TakeHttpClient() override { |
| return std::move(http_client_); |
| } |
| [[nodiscard]] size_t clearcut_max_retries() const override { return clearcut_max_retries_; } |
| |
| private: |
| std::string shuffler_encryption_key_; |
| std::string analyzer_encryption_key_; |
| std::unique_ptr<lib::clearcut::HTTPClient> http_client_; |
| std::string clearcut_endpoint_; |
| size_t clearcut_max_retries_; |
| }; |
| |
| struct CobaltConfig { |
| // |product_name|: The value to use for the |product_name| field of the SystemProfile. |
| std::string product_name = ""; |
| |
| // |board_name_suggestion|: A suggestion for the value to use for the |board_name| field of the |
| // SystemProfile. This may be ignored if SystemData is able to determine the board name directly. |
| // A value of "" indicates that the caller has no information about board name, so one should be |
| // guessed. |
| std::string board_name_suggestion = ""; |
| |
| // |version|: The version of the running system. The use of this field is system-specific. For |
| // example on Fuchsia a possible value for |version| is "20190220_01_RC00". |
| std::string version = ""; |
| |
| // |release_stage|: The ReleaseStage of the running system. |
| ReleaseStage release_stage = ReleaseStage::GA; |
| |
| // |file_system|: The FileSystem implementation to be used for all file system operations in |
| // Cobalt. |
| std::unique_ptr<util::FileSystem> file_system; |
| |
| // |use_memory_observation_store|: If true, the ObservaitonStore used will be memory backed intead |
| // of file backed. |
| bool use_memory_observation_store = false; |
| |
| // These three values are provided to the ObservationStore. |
| // |
| //|max_bytes_per_event|: Attempting to log an event that is larger than this value will result in |
| // an error code kObservationTooBig. (See observation_store.h) |
| // |
| // |max_bytes_per_envelope|: When pooling together Observaitons into an Envelope, the |
| // ObservationStore will try not to form envelopes larger than this size. This value is used to |
| // avoid sending messages over HTTP that are too large. (see observation_store.h) |
| // |
| // |max_bytes_total|: This is the maximum size of the Observations in the ObservationStore. If the |
| // size of the accumulated Observation data reaches this value, then ObservationStore will not |
| // accept any more Observations, resulting in an error code of kStoreFull. (See |
| // observaiton_store.h) |
| // |
| // REQUIRED: |
| // 0 <= max_bytes_per_event <= max_bytes_per_envelope <= max_bytes_total |
| // 0 <= max_bytes_per_envelope |
| size_t max_bytes_per_event; |
| size_t max_bytes_per_envelope; |
| size_t max_bytes_total; |
| |
| // |observation_store_directory|: If |use_memory_observation_store| is false, this is the absolute |
| // path to the directory the observation_store will use to store observations. |
| std::string observation_store_directory; |
| |
| // |local_aggregate_proto_store_path|: The absolute path where the local aggregate proto should be |
| // stored. |
| std::string local_aggregate_proto_store_path; |
| |
| // |obs_history_proto_store_path|: The absolute path where the observation history proto should be |
| // stored. |
| std::string obs_history_proto_store_path; |
| |
| // These three values are provided to the UploadScheduler of the shipping manager. |
| // |
| // |target_interval|: How frequently should ShippingManager perform regular periodic sends to the |
| // Shuffler? Set to kMaxSeconds to effectively disable periodic sends. |
| // |
| // |min_interval|: Used as the basis for exponentially increasing the upload interval. The |
| // resulting interval starts at this value, and then is multiplied by 2 each time until the value |
| // is greater than or equal to |target_interval|. |
| // |
| // REQUIRED: |
| // 0 <= min_interval <= target_interval <= kMaxSeconds |
| std::chrono::seconds target_interval; |
| std::chrono::seconds min_interval; |
| std::chrono::seconds initial_interval; |
| |
| // |target_pipeline|: Used to determine where to send observations, and how to encrypt them. |
| std::unique_ptr<TargetPipelineInterface> target_pipeline; |
| |
| // |extra_pipelines|: A list of extra pipelines where observations should be sent. |
| std::vector<std::unique_ptr<TargetPipelineInterface>> extra_pipelines; |
| |
| // |local_shipping_manager_path|: If |environments| is equal to {LOCAL}, the observations will be |
| // written to this path, instead of being shipped to clearcut. |
| std::string local_shipping_manager_path; |
| |
| // |api_key|: An API key included in each request to the Shuffler. If the API key is unrecognized |
| // on the server, the observations may be discarded. |
| std::string api_key; |
| |
| // |client_secret|: The ClientSecret for this device. |
| system_data::ClientSecret client_secret; |
| |
| // |internal_logger_project_context|: A ProjectContext that can be used to construct the internal |
| // Logger. |
| std::unique_ptr<logger::ProjectContext> internal_logger_project_context; |
| |
| // |local_aggregation_backfill_days|: The number of past days for which the AggregateStore |
| // generates and sends Observations, in addition to a requested day index. |
| size_t local_aggregation_backfill_days; |
| |
| // |validated_clock|: A reference to a ValidatedClockInterface, used to determine when the system |
| // has a clock that we can rely on. |
| util::ValidatedClockInterface* validated_clock; |
| }; |
| |
| } // namespace cobalt |
| |
| #endif // COBALT_SRC_PUBLIC_COBALT_CONFIG_H_ |