refactor: merge hash and remote values management

Creates a `ConfigStatusManager` trait (with implementations for `onhost`/`k8s`) that is now in charge of managing both the hash repository and the yaml config. Previously, the management of these two items was split due to design decisions that are no longer in place

Given both the hash and the remote config values come in a single OpAMP payload, I think we should read and persist this data with a unique service, and only split if absolutely needed.

Author: DavSanchez

agent-control/src/agent_control/agent_control.rs

@@ -1,7 +1,7 @@
 use crate::agent_control::config::{
     AgentControlConfig, AgentControlConfigError, AgentControlDynamicConfig,
 };
-use crate::values::yaml_config::YAMLConfig;
+use crate::opamp::remote_config::status::AgentRemoteConfigStatus;
 
 /// AgentControlConfigLoader loads a whole AgentControlConfig
 #[cfg_attr(test, mockall::automock)]
@@ -11,7 +11,7 @@ pub trait AgentControlConfigLoader {
 
 /// AgentControlDynamicConfigStorer stores the dynamic part of the AgentControlConfig
 pub trait AgentControlDynamicConfigStorer {
-    fn store(&self, config: &YAMLConfig) -> Result<(), AgentControlConfigError>;
+    fn store(&self, config: &AgentRemoteConfigStatus) -> Result<(), AgentControlConfigError>;
 }
 
 /// AgentControlDynamicConfigLoader loads the dynamic part of the AgentControlConfig
@@ -33,14 +33,14 @@ pub(crate) mod tests {
         AgentControlDynamicConfigStorer,
     };
     use crate::agent_control::config::AgentControlDynamicConfig;
-    use crate::values::yaml_config::YAMLConfig;
+    use crate::opamp::remote_config::status::AgentRemoteConfigStatus;
     use mockall::{mock, predicate};
 
     mock! {
         pub AgentControlDynamicConfigStore {}
 
         impl AgentControlDynamicConfigStorer for AgentControlDynamicConfigStore {
-            fn store(&self, config: &YAMLConfig) -> Result<(), AgentControlConfigError>;
+            fn store(&self, config: &AgentRemoteConfigStatus) -> Result<(), AgentControlConfigError>;
         }
         impl AgentControlDynamicConfigLoader for AgentControlDynamicConfigStore {
             fn load(&self) -> Result<AgentControlDynamicConfig, AgentControlConfigError>;
@@ -58,11 +58,10 @@ pub(crate) mod tests {
                 .returning(move || Ok(sub_agents_config.clone()));
         }
 
-        pub fn should_store(&mut self, sub_agents_config: &AgentControlDynamicConfig) {
-            let sub_agents_config: YAMLConfig = sub_agents_config.try_into().unwrap();
+        pub fn should_store(&mut self, sub_agents_config: &AgentRemoteConfigStatus) {
             self.expect_store()
                 .once()
-                .with(predicate::eq(sub_agents_config))
+                .with(predicate::eq(sub_agents_config.clone()))
                 .returning(move |_| Ok(()));
         }
     }

agent-control/src/agent_control/config_storer/loader_storer.rs

@@ -6,73 +6,75 @@ use crate::agent_control::config_storer::loader_storer::{
     AgentControlDynamicConfigStorer,
 };
 use crate::agent_control::defaults::{default_capabilities, AGENT_CONTROL_CONFIG_ENV_VAR_PREFIX};
-use crate::values::yaml_config::{YAMLConfig, YAMLConfigError};
-use crate::values::yaml_config_repository::{YAMLConfigRepository, YAMLConfigRepositoryError};
+use crate::opamp::remote_config::status::AgentRemoteConfigStatus;
+use crate::opamp::remote_config::status_manager::error::ConfigStatusManagerError;
+use crate::opamp::remote_config::status_manager::ConfigStatusManager;
+use crate::values::yaml_config::YAMLConfigError;
 use config::builder::DefaultState;
 use config::{Config, ConfigBuilder, Environment, File, FileFormat};
 use opamp_client::operation::capabilities::Capabilities;
 use std::sync::Arc;
 
-pub struct AgentControlConfigStore<Y>
+pub struct AgentControlConfigStore<M>
 where
-    Y: YAMLConfigRepository,
+    M: ConfigStatusManager,
 {
     config_builder: ConfigBuilder<DefaultState>,
-    values_repository: Arc<Y>,
+    config_manager: Arc<M>,
     agent_control_id: AgentID,
     agent_control_capabilities: Capabilities,
 }
 
-impl<Y> AgentControlConfigLoader for AgentControlConfigStore<Y>
+impl<M> AgentControlConfigLoader for AgentControlConfigStore<M>
 where
-    Y: YAMLConfigRepository,
+    M: ConfigStatusManager,
 {
     fn load(&self) -> Result<AgentControlConfig, AgentControlConfigError> {
         self._load_config()
     }
 }
 
-impl<Y> AgentControlDynamicConfigLoader for AgentControlConfigStore<Y>
+impl<M> AgentControlDynamicConfigLoader for AgentControlConfigStore<M>
 where
-    Y: YAMLConfigRepository,
+    M: ConfigStatusManager,
 {
     fn load(&self) -> Result<AgentControlDynamicConfig, AgentControlConfigError> {
         Ok(self._load_config()?.dynamic)
     }
 }
 
-impl<Y> AgentControlDynamicConfigDeleter for AgentControlConfigStore<Y>
+impl<M> AgentControlDynamicConfigDeleter for AgentControlConfigStore<M>
 where
-    Y: YAMLConfigRepository,
+    M: ConfigStatusManager,
 {
     fn delete(&self) -> Result<(), AgentControlConfigError> {
-        self.values_repository
-            .delete_remote(&self.agent_control_id)?;
+        self.config_manager
+            .delete_remote_status(&self.agent_control_id)?;
         Ok(())
     }
 }
 
-impl<Y> AgentControlDynamicConfigStorer for AgentControlConfigStore<Y>
+impl<M> AgentControlDynamicConfigStorer for AgentControlConfigStore<M>
 where
-    Y: YAMLConfigRepository,
+    M: ConfigStatusManager,
 {
-    fn store(&self, yaml_config: &YAMLConfig) -> Result<(), AgentControlConfigError> {
-        self.values_repository
-            .store_remote(&self.agent_control_id, yaml_config)?;
+    fn store(&self, yaml_config: &AgentRemoteConfigStatus) -> Result<(), AgentControlConfigError> {
+        self.config_manager
+            .store_remote_status(&self.agent_control_id, yaml_config)?;
         Ok(())
     }
 }
 
-impl<V> AgentControlConfigStore<V>
+impl<M> AgentControlConfigStore<M>
 where
-    V: YAMLConfigRepository,
+    M: ConfigStatusManager,
 {
-    pub fn new(values_repository: Arc<V>) -> Self {
+    pub fn new(config_manager: Arc<M>) -> Self {
         let config_builder = Config::builder();
 
         Self {
             config_builder,
-            values_repository,
+            config_manager,
             agent_control_id: AgentID::new_agent_control_id(),
             agent_control_capabilities: default_capabilities(),
         }
@@ -83,8 +85,8 @@ where
     /// on top of the local config
     fn _load_config(&self) -> Result<AgentControlConfig, AgentControlConfigError> {
         let local_config_string: String = self
-            .values_repository
-            .load_local(&self.agent_control_id)?
+            .config_manager
+            .retrieve_local_config(&self.agent_control_id)?
             .ok_or(AgentControlConfigError::Load(
                 "missing local agent control config".to_string(),
             ))?
@@ -110,8 +112,9 @@ where
             .try_deserialize::<AgentControlConfig>()?;
 
         if let Some(remote_config) = self
-            .values_repository
-            .load_remote(&self.agent_control_id, &self.agent_control_capabilities)?
+            .config_manager
+            .retrieve_remote_status(&self.agent_control_id, &self.agent_control_capabilities)?
+            .and_then(|status| status.remote_config)
         {
             let dynamic_config: AgentControlDynamicConfig = remote_config.try_into()?;
             config.dynamic = dynamic_config;
@@ -121,12 +124,12 @@ where
     }
 }
 
-impl From<YAMLConfigRepositoryError> for AgentControlConfigError {
-    fn from(e: YAMLConfigRepositoryError) -> Self {
+impl From<ConfigStatusManagerError> for AgentControlConfigError {
+    fn from(e: ConfigStatusManagerError) -> Self {
         match e {
-            YAMLConfigRepositoryError::LoadError(e) => AgentControlConfigError::Load(e),
-            YAMLConfigRepositoryError::StoreError(e) => AgentControlConfigError::Store(e),
-            YAMLConfigRepositoryError::DeleteError(e) => AgentControlConfigError::Delete(e),
+            ConfigStatusManagerError::Retrieval(e) => AgentControlConfigError::Load(e),
+            ConfigStatusManagerError::Store(e) => AgentControlConfigError::Store(e),
+            ConfigStatusManagerError::Deletion(e) => AgentControlConfigError::Delete(e),
         }
     }
 }
@@ -138,9 +141,10 @@ pub(crate) mod tests {
         AgentControlConfig, AgentID, AgentTypeFQN, OpAMPClientConfig, SubAgentConfig,
     };
     use crate::agent_control::defaults::AGENT_CONTROL_CONFIG_FILENAME;
-    use crate::values::file::YAMLConfigRepositoryFile;
+    use crate::opamp::remote_config::status_manager::local_filesystem::FileSystemConfigStatusManager;
+    // use crate::values::file::YAMLConfigRepositoryFile;
     use serial_test::serial;
-    use std::path::PathBuf;
+
     use std::{collections::HashMap, env};
     use url::Url;
 
@@ -166,8 +170,8 @@ fleet_control:
         "#;
         std::fs::write(remote_file.as_path(), remote_config).unwrap();
 
-        let vr = YAMLConfigRepositoryFile::new(local_dir, remote_dir).with_remote();
-        let store = AgentControlConfigStore::new(Arc::new(vr));
+        let cm = FileSystemConfigStatusManager::new(local_dir).with_remote(remote_dir);
+        let store = AgentControlConfigStore::new(Arc::new(cm));
         let actual = AgentControlConfigLoader::load(&store).unwrap();
 
         let expected = AgentControlConfig {
@@ -212,8 +216,8 @@ fleet_control:
         let env_var_name = "NR_AC_AGENTS__ROLLDICE1__AGENT_TYPE";
         env::set_var(env_var_name, "namespace/com.newrelic.infrastructure:0.0.2");
 
-        let vr = YAMLConfigRepositoryFile::new(local_dir, PathBuf::new()).with_remote();
-        let store = AgentControlConfigStore::new(Arc::new(vr));
+        let cm = FileSystemConfigStatusManager::new(local_dir);
+        let store = AgentControlConfigStore::new(Arc::new(cm));
         let actual = AgentControlConfigLoader::load(&store).unwrap();
 
         let expected = AgentControlConfig {
@@ -260,8 +264,8 @@ agents:
         let env_var_name = "NR_AC_AGENTS__ROLLDICE2__AGENT_TYPE";
         env::set_var(env_var_name, "namespace/com.newrelic.infrastructure:0.0.2");
 
-        let vr = YAMLConfigRepositoryFile::new(local_dir, PathBuf::new()).with_remote();
-        let store = AgentControlConfigStore::new(Arc::new(vr));
+        let cm = FileSystemConfigStatusManager::new(local_dir);
+        let store = AgentControlConfigStore::new(Arc::new(cm));
         let actual: AgentControlConfig = AgentControlConfigLoader::load(&store).unwrap();
 
         let expected = AgentControlConfig {

agent-control/src/agent_control/config_storer/store.rs

@@ -44,6 +44,7 @@ pub const SUB_AGENT_DIR: &str = "fleet/agents.d";
 pub const AGENT_CONTROL_CONFIG_FILENAME: &str = "config.yaml";
 pub const DYNAMIC_AGENT_TYPE_FILENAME: &str = "dynamic-agent-type.yaml";
 pub const IDENTIFIERS_FILENAME: &str = "identifiers.yaml";
+pub const REMOTE_CONFIG_STATUS_FILENAME: &str = "config_status.yaml";
 pub const VALUES_DIR: &str = "values";
 pub const VALUES_FILENAME: &str = "values.yaml";
 pub const GENERATED_FOLDER_NAME: &str = "auto-generated";

agent-control/src/agent_control/defaults.rs

@@ -3,14 +3,12 @@ use crate::agent_type::agent_type_registry::AgentRepositoryError;
 use crate::agent_type::error::AgentTypeError;
 use crate::event::channel::EventPublisherError;
 use crate::opamp::client_builder::OpAMPClientBuilderError;
-use crate::opamp::hash_repository::repository::HashRepositoryError;
 use crate::opamp::instance_id;
 use crate::opamp::remote_config::RemoteConfigError;
 use crate::sub_agent::effective_agents_assembler::EffectiveAgentsAssemblerError;
 use crate::sub_agent::error::{SubAgentBuilderError, SubAgentCollectionError, SubAgentError};
 use crate::sub_agent::persister::config_persister::PersistError;
 use crate::values::yaml_config::YAMLConfigError;
-use crate::values::yaml_config_repository::YAMLConfigRepositoryError;
 use fs::file_reader::FileReaderError;
 use opamp_client::{ClientError, NotStartedClientError, StartedClientError};
 use std::fmt::Debug;
@@ -70,18 +68,12 @@ pub enum AgentError {
     #[error("system time error: `{0}`")]
     SystemTimeError(#[from] SystemTimeError),
 
-    #[error("remote config hash error: `{0}`")]
-    RemoteConfigHashError(#[from] HashRepositoryError),
-
     #[error("effective agents assembler error: `{0}`")]
     EffectiveAgentsAssemblerError(#[from] EffectiveAgentsAssemblerError),
 
     #[error("remote config error: `{0}`")]
     RemoteConfigError(#[from] RemoteConfigError),
 
-    #[error("sub agent remote config error: `{0}`")]
-    SubAgentRemoteConfigError(#[from] YAMLConfigRepositoryError),
-
     #[error("External module error: `{0}`")]
     ExternalError(String),