bye bye alpha sdk

twoliter/src/cmd/build.rs

@@ -1,14 +1,11 @@
 use super::build_clean::BuildClean;
 use crate::cargo_make::CargoMake;
 use crate::common::fs;
-use crate::docker::DockerContainer;
-use crate::lock::Lock;
 use crate::project;
 use crate::tools::install_tools;
 use anyhow::{Context, Result};
 use clap::Parser;
-use log::debug;
-use std::path::{Path, PathBuf};
+use std::path::PathBuf;
 use tempfile::TempDir;
 
 #[derive(Debug, Parser)]
@@ -114,51 +111,15 @@ pub(crate) struct BuildVariant {
 impl BuildVariant {
     pub(super) async fn run(&self) -> Result<()> {
         let project = project::load_or_find_project(self.project_path.clone()).await?;
-        let token = project.token();
         let toolsdir = project.project_dir().join("build/tools");
         install_tools(&toolsdir).await?;
         let makefile_path = toolsdir.join("Makefile.toml");
-        let lock_file = Lock::load(&project).await?;
         // A temporary directory in the `build` directory
         let build_temp_dir = TempDir::new_in(project.project_dir())
             .context("Unable to create a tempdir for Twoliter's build")?;
         let packages_dir = build_temp_dir.path().join("sdk_rpms");
         fs::create_dir_all(&packages_dir).await?;
 
-        let sdk_container =
-            DockerContainer::new(format!("sdk-{}", token), lock_file.sdk.source).await?;
-        sdk_container
-            .cp_out(Path::new("twoliter/alpha/build/rpms"), &packages_dir)
-            .await?;
-
-        let rpms_dir = project.project_dir().join("build").join("rpms");
-        fs::create_dir_all(&rpms_dir).await?;
-        debug!("Moving rpms to build dir");
-        let rpms = packages_dir.join("rpms");
-        let mut read_dir = tokio::fs::read_dir(&rpms)
-            .await
-            .context(format!("Unable to read dir '{}'", rpms.display()))?;
-        while let Some(entry) = read_dir.next_entry().await.context(format!(
-            "Error while reading entries in dir '{}'",
-            rpms.display()
-        ))? {
-            debug!("Moving '{}'", entry.path().display());
-            fs::rename(entry.path(), rpms_dir.join(entry.file_name())).await?;
-        }
-
-        let sbkeys_dir = project.project_dir().join("sbkeys");
-        if !sbkeys_dir.is_dir() {
-            // Create a sbkeys directory in the main project
-            debug!("sbkeys dir not found. Creating a temporary directory");
-            fs::create_dir_all(&sbkeys_dir).await?;
-            sdk_container
-                .cp_out(
-                    Path::new("twoliter/alpha/sbkeys/generate-local-sbkeys"),
-                    &sbkeys_dir,
-                )
-                .await?;
-        };
-
         let mut optional_envs = Vec::new();
 
         if let Some(lookaside_cache) = &self.lookaside_cache {
@@ -176,7 +137,6 @@ impl BuildVariant {
             .env("TWOLITER_TOOLS_DIR", toolsdir.display().to_string())
             .env("BUILDSYS_ARCH", &self.arch)
             .env("BUILDSYS_VARIANT", &self.variant)
-            .env("BUILDSYS_SBKEYS_DIR", sbkeys_dir.display().to_string())
             .env("BUILDSYS_VERSION_IMAGE", project.release_version())
             .env("GO_MODULES", project.find_go_modules().await?.join(" "))
             .env(

twoliter/src/docker/mod.rs

@@ -1,6 +1,4 @@
 mod commands;
-mod container;
 mod image;
 
-pub(crate) use self::container::DockerContainer;
 pub(crate) use self::image::ImageUri;

twoliter/src/project.rs

@@ -11,7 +11,7 @@ use log::{debug, info, trace, warn};
 use semver::Version;
 use serde::de::Error;
 use serde::{Deserialize, Deserializer, Serialize, Serializer};
-use sha2::{Digest, Sha256, Sha512};
+use sha2::{Digest, Sha256};
 use std::collections::BTreeMap;
 use std::ffi::OsStr;
 use std::fmt::{Display, Formatter};
@@ -169,13 +169,6 @@ impl Project {
         }
     }
 
-    pub(crate) fn token(&self) -> String {
-        let mut d = Sha512::new();
-        d.update(self.filepath().display().to_string());
-        let digest = hex::encode(d.finalize());
-        (digest[..12]).to_string()
-    }
-
     /// Returns a list of the names of Go modules by searching the `sources` directory for `go.mod`
     /// files.
     pub(crate) async fn find_go_modules(&self) -> Result<Vec<String>> {