Adjusted to patch source and image fields only when actor is live

Cargo.toml

@@ -1,5 +1,5 @@
 [workspace.package]
-version = "0.5.7"
+version = "0.5.8"
 edition = "2021"
 license = "Apache-2.0"
 repository = "https://github.com/amphitheatre-app/amphitheatre"

controllers/src/playbook_controller.rs

@@ -134,14 +134,14 @@ async fn resolve(playbook: &Playbook, ctx: &Arc<Context>, recorder: &Recorder) -
     tracing::debug!("The repositories to be fetched are: {fetches:?}");
 
     for (name, partner) in fetches.iter() {
-        let actor = resolver::partner::load(&ctx.k8s, &credentials, name, partner)
+        let character = resolver::partner::load(&ctx.k8s, &credentials, name, partner)
             .await
             .map_err(Error::ResolveError)?;
 
         let message = "Fetch and add the actor to this playbook";
         trace(recorder, message).await.map_err(Error::ResourceError)?;
 
-        playbook::add(&ctx.k8s, playbook, actor)
+        playbook::add(&ctx.k8s, playbook, character)
             .await
             .map_err(Error::ResourceError)?;
     }
@@ -191,17 +191,17 @@ async fn run(playbook: &Playbook, ctx: &Arc<Context>, recorder: &Recorder) -> Re
                     let message = format!("Try to refresh an existing Actor {}", name);
                     trace(recorder, message).await.map_err(Error::ResourceError)?;
 
-                    let spec = resolver::to_actor(&credentials, character).map_err(Error::ResolveError)?;
+                    let spec = resolver::to_actor(character, &credentials).map_err(Error::ResolveError)?;
                     actor::update(&ctx.k8s, playbook, &spec)
                         .await
                         .map_err(Error::ResourceError)?;
                 }
                 false => {
                     // Create a new actor
-                    trace(recorder, format!("Create new Actor: {}", name))
-                        .await
-                        .map_err(Error::ResourceError)?;
-                    let spec = resolver::to_actor(&credentials, character).map_err(Error::ResolveError)?;
+                    let message = format!("Create new Actor: {}", name);
+                    trace(recorder, message).await.map_err(Error::ResourceError)?;
+
+                    let spec = resolver::to_actor(character, &credentials).map_err(Error::ResolveError)?;
                     actor::create(&ctx.k8s, playbook, &spec)
                         .await
                         .map_err(Error::ResourceError)?;

resolver/src/lib.rs

@@ -29,7 +29,7 @@ pub mod utils;
 
 const CATALOG_REPO_URL: &str = "https://github.com/amphitheatre-app/catalog.git";
 
-/// Load mainfest from catalog and return the actor spec.
+/// Load manifest from catalog and return the actor spec.
 pub fn load_from_catalog(credentials: &Credentials, name: &str, version: &str) -> Result<CharacterSpec> {
     let reference = GitReference {
         repo: CATALOG_REPO_URL.to_string(),
@@ -40,7 +40,7 @@ pub fn load_from_catalog(credentials: &Credentials, name: &str, version: &str) -
     load_from_source(credentials, &reference)
 }
 
-/// Load mainfest from remote VCS (like github) and return the actor spec.
+/// Load manifest from remote VCS (like github) and return the actor spec.
 pub fn load_from_source(credentials: &Credentials, reference: &GitReference) -> Result<CharacterSpec> {
     let client = ScmClient::init(credentials, &reference.repo).map_err(ResolveError::SCMError)?;
 
@@ -59,7 +59,7 @@ pub fn load_from_source(credentials: &Credentials, reference: &GitReference) ->
     Ok(CharacterSpec::from(manifest))
 }
 
-/// Load mainfest from Kubernetes cluster and return the actor spec.
+/// Load manifest from Kubernetes cluster and return the actor spec.
 pub async fn load_from_cluster(client: &KubeClient, name: &str) -> Result<CharacterSpec> {
     let character = character::get(client, name)
         .await
@@ -68,12 +68,17 @@ pub async fn load_from_cluster(client: &KubeClient, name: &str) -> Result<Charac
 }
 
 /// Read Character manifest and return the actor spec.
-pub fn to_actor(credentials: &Credentials, manifest: &CharacterSpec) -> Result<ActorSpec> {
-    let client = ScmClient::init(credentials, &manifest.meta.repository).map_err(ResolveError::SCMError)?;
+pub fn to_actor(character: &CharacterSpec, credentials: &Credentials) -> Result<ActorSpec> {
+    let client = ScmClient::init(credentials, &character.meta.repository).map_err(ResolveError::SCMError)?;
 
-    let mut spec = ActorSpec::from(manifest);
-    spec.source = Some(patches::source(&client, &spec.source.unwrap())?);
-    spec.image = patches::image(credentials, &spec)?;
+    let mut actor = ActorSpec::from(character);
 
-    Ok(spec)
+    // Patch the source and image if the actor is not live.
+    // it will be build with the builders later, so these must be valid.
+    if !actor.live {
+        actor.source = Some(patches::source(&client, &actor.source.unwrap())?);
+        actor.image = patches::image(credentials, &actor)?;
+    }
+
+    Ok(actor)
 }

resolver/src/preface.rs

@@ -19,7 +19,7 @@ use crate::{
 use amp_common::{config::Credentials, resource::CharacterSpec, resource::Preface};
 use kube::Client as KubeClient;
 
-/// Load mainfest from different sources and return the actor spec.
+/// Load manifest from different sources and return the actor spec.
 pub async fn load(client: &KubeClient, credentials: &Credentials, preface: &Preface) -> Result<CharacterSpec> {
     if let Some(p) = &preface.registry {
         let registry = p.registry.clone().unwrap_or_else(|| "catalog".to_string());