schematics/src/builder.rs

use crate::command_runner::{SetuidCommandRunner, StdCommandRunner};
use crate::resources::{
  AcmeAccountKey, AcmeChallengesDir, AcmeChallengesNginxSnippet, AcmeRootCert, AcmeUser, Cert,
  CertChain, Cron, Csr, DefaultServer, Dir, File, GitCheckout, Key, KeyAndCertBundle,
  LoadedDirectory, MariaDbDatabase, MariaDbUser, NpmInstall, Owner, PhpFpmPool, PostgresqlDatabase,
  Resource, ServeCustom, ServePhp, ServeRedir, ServeService, ServeStatic, StoredDirectory,
  SystemdSocketService, User, UserForDomain, WordpressPlugin, WordpressTranslation,
};
use crate::static_files::LETS_ENCRYPT_R3;
use crate::storage::SimpleStorage;
use crate::storage::Storage;
use crate::symbols::acme::Cert as CertSymbol;
use crate::symbols::concat::Concat as ConcatSymbol;
use crate::symbols::cron::Cron as CronSymbol;
use crate::symbols::dir::Dir as DirSymbol;
use crate::symbols::file::File as FileSymbol;
use crate::symbols::git::Checkout as GitCheckoutSymbol;
use crate::symbols::mariadb::{
  Database as MariaDbDatabaseSymbol, Dump as MariaDbDumpSymbol, User as MariaDbUserSymbol,
};
use crate::symbols::npm::Install as NpmInstallSymbol;
use crate::symbols::owner::Owner as OwnerSymbol;
use crate::symbols::postgresql::PostgreSQLDatabase as PostgreSQLDatabaseSymbol;
use crate::symbols::saved_directory::{SavedDirectory as SavedDirectorySymbol, StorageDirection};
use crate::symbols::systemd::{
  ReloadService as ReloadServiceSymbol, UserService as UserServiceSymbol,
  UserSession as SystemdUserSessionSymbol,
};
use crate::symbols::tls::Csr as CsrSymbol;
use crate::symbols::tls::Key as KeySymbol;
use crate::symbols::user::User as UserSymbol;
use crate::symbols::wordpress::{
  Plugin as WordpressPluginSymbol, Translation as WordpressTranslationSymbol,
};
use crate::templates::nginx;
use crate::templates::php::{
  fpm_pool_config as php_fpm_pool_config, FpmPoolConfig as PhpFpmPoolConfig,
};
use crate::templates::systemd::{
  nodejs_service as systemd_nodejs_service, socket_service as systemd_socket_service,
};
use crate::to_artifact::ToArtifact;
use std::fmt::Display;
use std::path::Path;
use std::rc::Rc;

pub trait ImplementationBuilder<R> {
  type Prerequisites: ToArtifact;
  fn prerequisites(resource: &R) -> Self::Prerequisites;

  type Implementation;
  fn create(
    resource: &R,
    target: &R::Artifact,
    inputs: <Self::Prerequisites as ToArtifact>::Artifact,
  ) -> Self::Implementation
  where
    R: Resource;
}

#[derive(Debug)]
pub struct DefaultBuilder;

impl<D> ImplementationBuilder<Key<D>> for DefaultBuilder {
  type Prerequisites = ();
  fn prerequisites(_resource: &Key<D>) -> Self::Prerequisites {}

  type Implementation = KeySymbol<StdCommandRunner, Rc<Path>>;
  fn create(
    _resource: &Key<D>,
    target: &<Key<D> as Resource>::Artifact,
    (): <Self::Prerequisites as ToArtifact>::Artifact,
  ) -> Self::Implementation {
    KeySymbol::new(StdCommandRunner, target.clone_rc())
  }
}

impl<D: Clone> ImplementationBuilder<Csr<D>> for DefaultBuilder {
  type Prerequisites = Key<D>;
  fn prerequisites(resource: &Csr<D>) -> Self::Prerequisites {
    Key(resource.0.clone())
  }

  type Implementation = CsrSymbol<StdCommandRunner, D, Rc<Path>, Rc<Path>>;
  fn create(
    resource: &Csr<D>,
    target: &<Csr<D> as Resource>::Artifact,
    key: <Self::Prerequisites as ToArtifact>::Artifact,
  ) -> Self::Implementation {
    CsrSymbol::new(
      StdCommandRunner,
      resource.0.clone(),
      key.clone_rc(),
      target.clone_rc(),
    )
  }
}

impl<D: Clone> ImplementationBuilder<Cert<D>> for DefaultBuilder {
  type Prerequisites = (
    Csr<D>,
    AcmeRootCert,
    AcmeAccountKey,
    AcmeChallengesDir,
    AcmeUser,
    DefaultServer,
  );
  fn prerequisites(resource: &Cert<D>) -> Self::Prerequisites {
    (
      Csr(resource.0.clone()),
      AcmeRootCert,
      AcmeAccountKey,
      AcmeChallengesDir,
      AcmeUser,
      DefaultServer,
    )
  }

  type Implementation =
    CertSymbol<SetuidCommandRunner<Rc<str>>, SetuidCommandRunner<Rc<str>>, D, Rc<Path>>;
  fn create(
    resource: &Cert<D>,
    target: &<Cert<D> as Resource>::Artifact,
    (csr, root_cert, account_key, challenges_dir, (user_name, _), _): <Self::Prerequisites as ToArtifact>::Artifact,
  ) -> Self::Implementation {
    CertSymbol::new(
      resource.0.clone(),
      SetuidCommandRunner::new(user_name.0),
      root_cert.clone_rc(),
      account_key.clone_rc(),
      challenges_dir.clone_rc(),
      csr.clone_rc(),
      target.clone_rc(),
    )
  }
}

impl<D: Clone> ImplementationBuilder<CertChain<D>> for DefaultBuilder {
  type Prerequisites = (Cert<D>, AcmeRootCert);
  fn prerequisites(resource: &CertChain<D>) -> Self::Prerequisites {
    (Cert(resource.0.clone()), AcmeRootCert)
  }

  type Implementation = ConcatSymbol<[Rc<Path>; 2], Rc<Path>, Rc<Path>>;
  fn create(
    _resource: &CertChain<D>,
    target: &<CertChain<D> as Resource>::Artifact,
    (cert, root_cert): <Self::Prerequisites as ToArtifact>::Artifact,
  ) -> Self::Implementation {
    ConcatSymbol::new([cert.clone_rc(), root_cert.clone_rc()], target.clone_rc())
  }
}

impl<D: Clone> ImplementationBuilder<KeyAndCertBundle<D>> for DefaultBuilder {
  type Prerequisites = (CertChain<D>, Key<D>);
  fn prerequisites(resource: &KeyAndCertBundle<D>) -> Self::Prerequisites {
    (CertChain(resource.0.clone()), Key(resource.0.clone()))
  }

  type Implementation = ConcatSymbol<[Rc<Path>; 2], Rc<Path>, Rc<Path>>;
  fn create(
    _resource: &KeyAndCertBundle<D>,
    target: &<KeyAndCertBundle<D> as Resource>::Artifact,
    (cert_chain, key): <Self::Prerequisites as ToArtifact>::Artifact,
  ) -> Self::Implementation {
    ConcatSymbol::new([key.clone_rc(), cert_chain.clone_rc()], target.clone_rc())
  }
}

impl<P: AsRef<Path> + Clone> ImplementationBuilder<File<P>> for DefaultBuilder {
  type Prerequisites = ();
  fn prerequisites(_resource: &File<P>) -> Self::Prerequisites {}

  type Implementation = FileSymbol<P, Rc<str>>;
  fn create(
    resource: &File<P>,
    _target: &<File<P> as Resource>::Artifact,
    (): <Self::Prerequisites as ToArtifact>::Artifact,
  ) -> Self::Implementation {
    FileSymbol::new(resource.0.clone(), resource.1.clone())
  }
}

impl<'a, P: AsRef<Path> + Clone> ImplementationBuilder<GitCheckout<'a, P>> for DefaultBuilder {
  type Prerequisites = ();
  fn prerequisites(_resource: &GitCheckout<'a, P>) -> Self::Prerequisites {}

  type Implementation = GitCheckoutSymbol<StdCommandRunner, StdCommandRunner, P, &'a str, &'a str>;
  fn create(
    resource: &GitCheckout<'a, P>,
    _target: &<GitCheckout<'a, P> as Resource>::Artifact,
    (): <Self::Prerequisites as ToArtifact>::Artifact,
  ) -> Self::Implementation {
    GitCheckoutSymbol::new(resource.0.clone(), resource.1, resource.2, StdCommandRunner)
  }
}

impl ImplementationBuilder<DefaultServer> for DefaultBuilder {
  type Prerequisites = AcmeChallengesNginxSnippet;
  fn prerequisites(_resource: &DefaultServer) -> Self::Prerequisites {
    AcmeChallengesNginxSnippet
  }

  type Implementation = (
    FileSymbol<Rc<Path>, Box<str>>,
    ReloadServiceSymbol<StdCommandRunner, StdCommandRunner, &'static str>,
  );
  fn create(
    _resource: &DefaultServer,
    target: &<DefaultServer as Resource>::Artifact,
    challenges_snippet_path: <Self::Prerequisites as ToArtifact>::Artifact,
  ) -> Self::Implementation {
    (
      FileSymbol::new(
        target.clone_rc(),
        nginx::default_server(challenges_snippet_path).into(),
      ),
      ReloadServiceSymbol::new(StdCommandRunner, "nginx"),
    )
  }
}

impl<D: AsRef<str> + Clone + Display> ImplementationBuilder<ServeCustom<D>> for DefaultBuilder {
  type Prerequisites = (CertChain<D>, Key<D>, AcmeChallengesNginxSnippet);
  fn prerequisites(resource: &ServeCustom<D>) -> Self::Prerequisites {
    (
      CertChain(resource.0.clone()),
      Key(resource.0.clone()),
      AcmeChallengesNginxSnippet,
    )
  }

  type Implementation = (
    FileSymbol<Rc<Path>, Box<str>>,
    ReloadServiceSymbol<StdCommandRunner, StdCommandRunner, &'static str>,
  );
  fn create(
    resource: &ServeCustom<D>,
    target: &<ServeCustom<D> as Resource>::Artifact,
    (cert, key, challenges_snippet_path): <Self::Prerequisites as ToArtifact>::Artifact,
  ) -> Self::Implementation {
    (
      FileSymbol::new(
        target.clone_rc(),
        nginx::server_config(&resource.0, cert, key, &resource.1, challenges_snippet_path).into(),
      ),
      ReloadServiceSymbol::new(StdCommandRunner, "nginx"),
    )
  }
}

impl<D: Clone + Display, P: AsRef<Path>, C: Clone + Into<PhpFpmPoolConfig>>
  ImplementationBuilder<ServePhp<D, P, C>> for DefaultBuilder
{
  type Prerequisites = (
    PhpFpmPool<D>,
    CertChain<D>,
    Key<D>,
    AcmeChallengesNginxSnippet,
  );
  fn prerequisites(resource: &ServePhp<D, P, C>) -> Self::Prerequisites {
    (
      PhpFpmPool(resource.0.clone(), resource.4.clone().into()),
      CertChain(resource.0.clone()),
      Key(resource.0.clone()),
      AcmeChallengesNginxSnippet,
    )
  }

  type Implementation = (
    FileSymbol<Rc<Path>, Box<str>>,
    ReloadServiceSymbol<StdCommandRunner, StdCommandRunner, &'static str>,
  );
  fn create(
    resource: &ServePhp<D, P, C>,
    target: &<ServePhp<D, P, C> as Resource>::Artifact,
    (pool, cert, key, challenges_snippet_path): <Self::Prerequisites as ToArtifact>::Artifact,
  ) -> Self::Implementation {
    (
      FileSymbol::new(
        target.clone_rc(),
        nginx::server_config(
          &resource.0,
          cert,
          key,
          nginx::php_snippet(resource.2, pool.0, &resource.1) + &resource.3,
          challenges_snippet_path,
        )
        .into(),
      ),
      ReloadServiceSymbol::new(StdCommandRunner, "nginx"),
    )
  }
}

impl<D: Clone + Display, P: Clone + AsRef<Path>> ImplementationBuilder<ServeService<D, P>>
  for DefaultBuilder
{
  type Prerequisites = (
    SystemdSocketService<D, P>,
    CertChain<D>,
    Key<D>,
    AcmeChallengesNginxSnippet,
  );
  fn prerequisites(resource: &ServeService<D, P>) -> Self::Prerequisites {
    (
      SystemdSocketService(
        resource.0.clone(),
        resource.1,
        resource.2.clone(),
        resource.4.clone(),
        resource.5,
      ),
      CertChain(resource.0.clone()),
      Key(resource.0.clone()),
      AcmeChallengesNginxSnippet,
    )
  }

  type Implementation = (
    FileSymbol<Rc<Path>, Box<str>>,
    ReloadServiceSymbol<StdCommandRunner, StdCommandRunner, &'static str>,
  );
  fn create(
    resource: &ServeService<D, P>,
    target: &<ServeService<D, P> as Resource>::Artifact,
    (socket, cert, key, challenges_snippet_path): <Self::Prerequisites as ToArtifact>::Artifact,
  ) -> Self::Implementation {
    (
      FileSymbol::new(
        target.clone_rc(),
        nginx::server_config(
          &resource.0,
          cert,
          key,
          nginx::proxy_snippet(&socket.0, &resource.3),
          challenges_snippet_path,
        )
        .into(),
      ),
      ReloadServiceSymbol::new(StdCommandRunner, "nginx"),
    )
  }
}

impl<D: AsRef<str> + Clone + Display> ImplementationBuilder<ServeRedir<D>> for DefaultBuilder {
  type Prerequisites = (CertChain<D>, Key<D>, AcmeChallengesNginxSnippet);
  fn prerequisites(resource: &ServeRedir<D>) -> Self::Prerequisites {
    (
      CertChain(resource.0.clone()),
      Key(resource.0.clone()),
      AcmeChallengesNginxSnippet,
    )
  }

  type Implementation = (
    FileSymbol<Rc<Path>, Box<str>>,
    ReloadServiceSymbol<StdCommandRunner, StdCommandRunner, &'static str>,
  );
  fn create(
    resource: &ServeRedir<D>,
    target: &<ServeRedir<D> as Resource>::Artifact,
    (cert, key, challenges_snippet_path): <Self::Prerequisites as ToArtifact>::Artifact,
  ) -> Self::Implementation {
    (
      FileSymbol::new(
        target.clone_rc(),
        nginx::server_config(
          &resource.0,
          cert,
          key,
          nginx::redir_snippet(resource.1.as_ref()),
          challenges_snippet_path,
        )
        .into(),
      ),
      ReloadServiceSymbol::new(StdCommandRunner, "nginx"),
    )
  }
}

impl<D: AsRef<str> + Clone + Display, P: AsRef<Path>> ImplementationBuilder<ServeStatic<D, P>>
  for DefaultBuilder
{
  type Prerequisites = (CertChain<D>, Key<D>, AcmeChallengesNginxSnippet);
  fn prerequisites(resource: &ServeStatic<D, P>) -> Self::Prerequisites {
    (
      CertChain(resource.0.clone()),
      Key(resource.0.clone()),
      AcmeChallengesNginxSnippet,
    )
  }

  type Implementation = (
    FileSymbol<Rc<Path>, Box<str>>,
    ReloadServiceSymbol<StdCommandRunner, StdCommandRunner, &'static str>,
  );
  fn create(
    resource: &ServeStatic<D, P>,
    target: &<ServeStatic<D, P> as Resource>::Artifact,
    (cert, key, challenges_snippet_path): <Self::Prerequisites as ToArtifact>::Artifact,
  ) -> Self::Implementation {
    (
      FileSymbol::new(
        target.clone_rc(),
        nginx::server_config(
          &resource.0,
          cert,
          key,
          nginx::static_snippet(resource.1.as_ref()),
          challenges_snippet_path,
        )
        .into(),
      ),
      ReloadServiceSymbol::new(StdCommandRunner, "nginx"),
    )
  }
}

impl<D: Clone> ImplementationBuilder<PhpFpmPool<D>> for DefaultBuilder {
  type Prerequisites = ();
  fn prerequisites(_resource: &PhpFpmPool<D>) -> Self::Prerequisites {}

  type Implementation = (
    FileSymbol<Rc<Path>, Box<str>>,
    ReloadServiceSymbol<StdCommandRunner, StdCommandRunner, Rc<str>>,
  );
  fn create(
    resource: &PhpFpmPool<D>,
    (socket_path, conf_path, user_name, service_name): &<PhpFpmPool<D> as Resource>::Artifact,
    (): <Self::Prerequisites as ToArtifact>::Artifact,
  ) -> Self::Implementation {
    (
      FileSymbol::new(
        conf_path.clone_rc(),
        php_fpm_pool_config(&user_name.0, socket_path, &resource.1).into(),
      ),
      ReloadServiceSymbol::new(StdCommandRunner, service_name.0.clone()),
    )
  }
}

impl<D, P: AsRef<Path>> ImplementationBuilder<SystemdSocketService<D, P>> for DefaultBuilder {
  type Prerequisites = ();
  fn prerequisites(_resource: &SystemdSocketService<D, P>) -> Self::Prerequisites {}

  type Implementation = (
    // First three could be parallel
    FileSymbol<Rc<Path>, Box<str>>,
    SystemdUserSessionSymbol<'static, Rc<str>, StdCommandRunner>,
    OwnerSymbol<StdCommandRunner, StdCommandRunner, Box<Path>, Rc<str>>,
    UserServiceSymbol<'static, Rc<Path>, Rc<str>>,
  );
  fn create(
    resource: &SystemdSocketService<D, P>,
    (socket_path, conf_path, user_name): &<SystemdSocketService<D, P> as Resource>::Artifact,
    (): <Self::Prerequisites as ToArtifact>::Artifact,
  ) -> Self::Implementation {
    (
      FileSymbol::new(
        conf_path.clone_rc(),
        if resource.4 {
          systemd_nodejs_service(&resource.2, socket_path, &resource.3)
        } else {
          systemd_socket_service(
            socket_path,
            resource.2.as_ref().to_str().unwrap(),
            &resource.3,
            "",
          )
        }
        .into(),
      ),
      SystemdUserSessionSymbol::new(user_name.0.clone(), &StdCommandRunner),
      OwnerSymbol::new(
        conf_path.as_ref().parent().unwrap().into(),
        user_name.0.clone(),
        StdCommandRunner,
      ),
      UserServiceSymbol::new(socket_path.clone_rc(), user_name.0.clone(), resource.1),
    )
  }
}

impl<P: Clone> ImplementationBuilder<Dir<P>> for DefaultBuilder {
  type Prerequisites = ();
  fn prerequisites(_resource: &Dir<P>) -> Self::Prerequisites {}

  type Implementation = DirSymbol<P>;
  fn create(
    resource: &Dir<P>,
    _target: &<Dir<P> as Resource>::Artifact,
    (): <Self::Prerequisites as ToArtifact>::Artifact,
  ) -> Self::Implementation {
    DirSymbol::new(resource.0.clone())
  }
}

impl<P: Clone + AsRef<Path>> ImplementationBuilder<NpmInstall<P>> for DefaultBuilder {
  type Prerequisites = ();
  fn prerequisites(_resource: &NpmInstall<P>) -> Self::Prerequisites {}

  type Implementation = NpmInstallSymbol<'static, P, StdCommandRunner>;
  fn create(
    resource: &NpmInstall<P>,
    _target: &<NpmInstall<P> as Resource>::Artifact,
    (): <Self::Prerequisites as ToArtifact>::Artifact,
  ) -> Self::Implementation {
    NpmInstallSymbol::new(resource.0.clone(), &StdCommandRunner)
  }
}

impl<P: Clone + AsRef<Path>> ImplementationBuilder<StoredDirectory<P>> for DefaultBuilder {
  type Prerequisites = ();
  fn prerequisites(_resource: &StoredDirectory<P>) -> Self::Prerequisites {}

  type Implementation = SavedDirectorySymbol<StdCommandRunner, StdCommandRunner, P, SimpleStorage>;
  fn create(
    resource: &StoredDirectory<P>,
    target: &<StoredDirectory<P> as Resource>::Artifact,
    (): <Self::Prerequisites as ToArtifact>::Artifact,
  ) -> Self::Implementation {
    SavedDirectorySymbol::new(
      resource.1.clone(),
      SimpleStorage::new(target.clone_rc()),
      StorageDirection::Store,
      StdCommandRunner,
    )
  }
}

impl<P: Clone + AsRef<Path>> ImplementationBuilder<LoadedDirectory<P>> for DefaultBuilder {
  type Prerequisites = ();
  fn prerequisites(_resource: &LoadedDirectory<P>) -> Self::Prerequisites {}

  type Implementation = SavedDirectorySymbol<StdCommandRunner, StdCommandRunner, P, SimpleStorage>;
  fn create(
    resource: &LoadedDirectory<P>,
    target: &<LoadedDirectory<P> as Resource>::Artifact,
    (): <Self::Prerequisites as ToArtifact>::Artifact,
  ) -> Self::Implementation {
    SavedDirectorySymbol::new(
      resource.1.clone(),
      SimpleStorage::new(target.clone_rc()),
      StorageDirection::Load,
      StdCommandRunner,
    )
  }
}

impl<D: Clone> ImplementationBuilder<UserForDomain<D>> for DefaultBuilder {
  type Prerequisites = ();
  fn prerequisites(_resource: &UserForDomain<D>) -> Self::Prerequisites {}

  type Implementation = UserSymbol<Rc<str>, Rc<Path>, StdCommandRunner>;
  fn create(
    _resource: &UserForDomain<D>,
    (user_name, home_path): &<UserForDomain<D> as Resource>::Artifact,
    (): <Self::Prerequisites as ToArtifact>::Artifact,
  ) -> Self::Implementation {
    UserSymbol::new(user_name.0.clone(), home_path.into(), StdCommandRunner)
  }
}

impl ImplementationBuilder<User> for DefaultBuilder {
  type Prerequisites = ();
  fn prerequisites(_resource: &User) -> Self::Prerequisites {}

  type Implementation = UserSymbol<Rc<str>, Rc<Path>, StdCommandRunner>;
  fn create(
    resource: &User,
    home_path: &<User as Resource>::Artifact,
    (): <Self::Prerequisites as ToArtifact>::Artifact,
  ) -> Self::Implementation {
    UserSymbol::new(resource.0.clone(), home_path.into(), StdCommandRunner)
  }
}

impl<P: AsRef<Path> + Clone> ImplementationBuilder<Owner<P>> for DefaultBuilder {
  type Prerequisites = ();
  fn prerequisites(_resource: &Owner<P>) -> Self::Prerequisites {}

  type Implementation = OwnerSymbol<StdCommandRunner, StdCommandRunner, P, Rc<str>>;
  fn create(
    resource: &Owner<P>,
    (): &<Owner<P> as Resource>::Artifact,
    (): <Self::Prerequisites as ToArtifact>::Artifact,
  ) -> Self::Implementation {
    OwnerSymbol::new(resource.1.clone(), resource.0.clone(), StdCommandRunner)
  }
}

impl ImplementationBuilder<AcmeUser> for DefaultBuilder {
  type Prerequisites = ();
  fn prerequisites(_resource: &AcmeUser) -> Self::Prerequisites {}

  type Implementation = UserSymbol<Rc<str>, Rc<Path>, StdCommandRunner>;
  fn create(
    _resource: &AcmeUser,
    (user_name, home_path): &<AcmeUser as Resource>::Artifact,
    (): <Self::Prerequisites as ToArtifact>::Artifact,
  ) -> Self::Implementation {
    UserSymbol::new(user_name.0.clone(), home_path.into(), StdCommandRunner)
  }
}

impl ImplementationBuilder<AcmeChallengesDir> for DefaultBuilder {
  type Prerequisites = AcmeUser;
  fn prerequisites(_resource: &AcmeChallengesDir) -> Self::Prerequisites {
    AcmeUser
  }

  type Implementation = (
    DirSymbol<Rc<Path>>,
    OwnerSymbol<StdCommandRunner, StdCommandRunner, Rc<Path>, Rc<str>>,
  );
  fn create(
    _resource: &AcmeChallengesDir,
    target: &<AcmeChallengesDir as Resource>::Artifact,
    (user_name, _): <Self::Prerequisites as ToArtifact>::Artifact,
  ) -> Self::Implementation {
    (
      DirSymbol::new(target.clone_rc()),
      OwnerSymbol::new(target.clone_rc(), user_name.0, StdCommandRunner),
    )
  }
}

impl ImplementationBuilder<AcmeChallengesNginxSnippet> for DefaultBuilder {
  type Prerequisites = AcmeChallengesDir;
  fn prerequisites(_resource: &AcmeChallengesNginxSnippet) -> Self::Prerequisites {
    AcmeChallengesDir
  }

  type Implementation = FileSymbol<Rc<Path>, Box<str>>;
  fn create(
    _resource: &AcmeChallengesNginxSnippet,
    target: &<AcmeChallengesNginxSnippet as Resource>::Artifact,
    challenges_dir: <Self::Prerequisites as ToArtifact>::Artifact,
  ) -> Self::Implementation {
    FileSymbol::new(
      target.clone_rc(),
      nginx::acme_challenges_snippet(challenges_dir).into(),
    )
  }
}

impl ImplementationBuilder<AcmeAccountKey> for DefaultBuilder {
  type Prerequisites = AcmeUser;
  fn prerequisites(_resource: &AcmeAccountKey) -> Self::Prerequisites {
    AcmeUser
  }

  type Implementation = (
    KeySymbol<StdCommandRunner, Rc<Path>>,
    OwnerSymbol<StdCommandRunner, StdCommandRunner, Rc<Path>, Rc<str>>,
  );
  fn create(
    _resource: &AcmeAccountKey,
    target: &<AcmeAccountKey as Resource>::Artifact,
    (user_name, _): <Self::Prerequisites as ToArtifact>::Artifact,
  ) -> Self::Implementation {
    (
      KeySymbol::new(StdCommandRunner, target.clone_rc()),
      OwnerSymbol::new(target.clone_rc(), user_name.0, StdCommandRunner),
    )
  }
}

impl ImplementationBuilder<AcmeRootCert> for DefaultBuilder {
  type Prerequisites = ();
  fn prerequisites(_resource: &AcmeRootCert) -> Self::Prerequisites {}

  type Implementation = FileSymbol<Rc<Path>, &'static str>;
  fn create(
    _resource: &AcmeRootCert,
    target: &<AcmeRootCert as Resource>::Artifact,
    (): <Self::Prerequisites as ToArtifact>::Artifact,
  ) -> Self::Implementation {
    FileSymbol::new(target.clone_rc(), LETS_ENCRYPT_R3)
  }
}

impl<D> ImplementationBuilder<MariaDbUser<D>> for DefaultBuilder {
  type Prerequisites = ();
  fn prerequisites(_resource: &MariaDbUser<D>) -> Self::Prerequisites {}

  type Implementation = MariaDbUserSymbol<'static, Rc<str>, StdCommandRunner>;
  fn create(
    _resource: &MariaDbUser<D>,
    user_name: &<MariaDbUser<D> as Resource>::Artifact,
    _: <Self::Prerequisites as ToArtifact>::Artifact,
  ) -> Self::Implementation {
    MariaDbUserSymbol::new(user_name.0.clone(), &StdCommandRunner)
  }
}

impl<D: Clone> ImplementationBuilder<MariaDbDatabase<D>> for DefaultBuilder {
  type Prerequisites = MariaDbUser<D>;
  fn prerequisites(resource: &MariaDbDatabase<D>) -> Self::Prerequisites {
    MariaDbUser(resource.0.clone())
  }

  type Implementation = (
    MariaDbDatabaseSymbol<'static, Rc<str>, SimpleStorage, StdCommandRunner>,
    MariaDbDumpSymbol<'static, Rc<str>, StdCommandRunner, SimpleStorage>,
  );
  fn create(
    _resource: &MariaDbDatabase<D>,
    (db_name, _, data_path): &<MariaDbDatabase<D> as Resource>::Artifact,
    _: <Self::Prerequisites as ToArtifact>::Artifact,
  ) -> Self::Implementation {
    let db_dump = SimpleStorage::new(data_path.clone_rc());
    (
      MariaDbDatabaseSymbol::new(db_name.0.clone(), db_dump.clone(), &StdCommandRunner),
      MariaDbDumpSymbol::new(db_name.0.clone(), db_dump, &StdCommandRunner),
    )
  }
}

impl<D: Clone> ImplementationBuilder<PostgresqlDatabase<D>> for DefaultBuilder {
  type Prerequisites = ();
  fn prerequisites(_: &PostgresqlDatabase<D>) -> Self::Prerequisites {}

  type Implementation = (PostgreSQLDatabaseSymbol<'static, Rc<str>, Rc<str>, StdCommandRunner>,);
  fn create(
    _resource: &PostgresqlDatabase<D>,
    (db_name, data_path): &<PostgresqlDatabase<D> as Resource>::Artifact,
    _: <Self::Prerequisites as ToArtifact>::Artifact,
  ) -> Self::Implementation {
    let db_dump = SimpleStorage::new(data_path.clone_rc());
    (PostgreSQLDatabaseSymbol::new(
      db_name.0.clone(),
      db_dump.read_filename().unwrap().to_str().unwrap().into(),
      &StdCommandRunner,
    ),)
  }
}

impl<P: Clone + AsRef<Path>> ImplementationBuilder<WordpressPlugin<P>> for DefaultBuilder {
  type Prerequisites = Dir<Rc<Path>>;
  fn prerequisites(resource: &WordpressPlugin<P>) -> Self::Prerequisites {
    Dir::new(resource.0.as_ref().join("wp-content/plugins"))
  }

  type Implementation = WordpressPluginSymbol<'static, P, &'static str, StdCommandRunner>;
  fn create(
    resource: &WordpressPlugin<P>,
    (): &<WordpressPlugin<P> as Resource>::Artifact,
    _: <Self::Prerequisites as ToArtifact>::Artifact,
  ) -> Self::Implementation {
    WordpressPluginSymbol::new(resource.0.clone(), resource.1, &StdCommandRunner)
  }
}

impl<P: AsRef<Path>> ImplementationBuilder<WordpressTranslation<P>> for DefaultBuilder {
  type Prerequisites = Dir<Rc<Path>>;
  fn prerequisites(resource: &WordpressTranslation<P>) -> Self::Prerequisites {
    Dir::new(resource.0.as_ref().join("wp-content/languages"))
  }

  type Implementation =
    WordpressTranslationSymbol<'static, &'static str, Box<Path>, StdCommandRunner>;
  fn create(
    resource: &WordpressTranslation<P>,
    (): &<WordpressTranslation<P> as Resource>::Artifact,
    _: <Self::Prerequisites as ToArtifact>::Artifact,
  ) -> Self::Implementation {
    WordpressTranslationSymbol::new(
      (*resource.0.as_ref().join("wp-content/languages")).into(),
      resource.1,
      resource.2,
      &StdCommandRunner,
    )
  }
}

impl<D: Clone> ImplementationBuilder<Cron<D>> for DefaultBuilder {
  type Prerequisites = UserForDomain<D>;
  fn prerequisites(resource: &Cron<D>) -> Self::Prerequisites {
    UserForDomain(resource.0.clone())
  }

  type Implementation = CronSymbol<'static, Box<[u8]>, Rc<str>, StdCommandRunner>;
  fn create(
    resource: &Cron<D>,
    (): &<Cron<D> as Resource>::Artifact,
    user_name: <Self::Prerequisites as ToArtifact>::Artifact,
  ) -> Self::Implementation {
    CronSymbol::new((user_name.0).0, &resource.1, &StdCommandRunner)
  }
}