.autocrate.yaml

@@ -16,13 +16,11 @@ api:
     type: github
     endpoint: https://github.com
     auth:
-      user: PlexSheep
+      user: myUserName
-      pass:
+      pass: token_superimportantsecret
-        env: TOKEN_GH
+  myserv:
-  cscherr:
+    type: gitea
-    type: forgejo
     endpoint: https://git.cscherr.de
     auth:
-      user: PlexSheep
+      user: myUserName
-      pass:
+      pass: importantsecrettoken
-        env: TOKEN_CSCHERR

.gitea/workflows/cargo.yaml

@@ -6,7 +6,7 @@ on:
       # - '!master'
 
 jobs:
-  format:
+  CI:
     name: cargo CI
     permissions:
       # Give the default GITHUB_TOKEN write permission to commit and push the
@@ -16,11 +16,9 @@ jobs:
       - name: get repo
         uses: actions/checkout@v4
       - name: install rust
-        uses: https://github.com/dtolnay/rust-toolchain@stable
+        uses: dtolnay/rust-toolchain@stable
       - name: install additional rust things
-        run: |
+        run: rustup component add rustfmt
-          rustup component add rustfmt
-          rustup component add clippy
       - name: config custom registry
         run: |
           mkdir -p ~/.cargo/
@@ -30,16 +28,16 @@ jobs:
           echo '[registries.cscherr]' >> ~/.cargo/config.toml
           echo 'index = "https://git.cscherr.de/PlexSheep/_cargo-index.git"' >> ~/.cargo/config.toml
           cat ~/.cargo/config.toml
-      - name: cargo clippy check
+      - name: cargo check
-        run: cargo clippy --all-features --all-targets
+        run: cargo check --all-features --all-targets
-      - name: cargo clippy fix
+      - name: cargo fix
-        run: cargo clippy --fix --all-features --all-targets
+        run: cargo fix --all-features --all-targets
       - name: cargo fmt
         run: cargo fmt --all
       - name: cargo test
         run: cargo test --all-features --all-targets
       - name: commit back to repository
-        uses: https://github.com/stefanzweifel/git-auto-commit-action@v5
+        uses: stefanzweifel/git-auto-commit-action@v5
         with:
           # Optional. Commit message for the created commit.
           # Defaults to "Apply automatic changes"

.github/workflows/cargo.yaml

@@ -19,9 +19,7 @@ jobs:
       - name: install rust
         uses: dtolnay/rust-toolchain@stable
       - name: install additional rust things
-        run: |
+        run: rustup component add rustfmt
-          rustup component add rustfmt
-          rustup component add clippy
       - name: config custom registry
         run: |
           mkdir -p ~/.cargo/
@@ -31,10 +29,10 @@ jobs:
           echo '[registries.cscherr]' >> ~/.cargo/config.toml
           echo 'index = "https://git.cscherr.de/PlexSheep/_cargo-index.git"' >> ~/.cargo/config.toml
           cat ~/.cargo/config.toml
-      - name: cargo clippy check
+      - name: cargo check
-        run: cargo clippy --all-features --all-targets
+        run: cargo check --all-features --all-targets
-      - name: cargo clippy fix
+      - name: cargo fix
-        run: cargo clippy --fix --all-features --all-targets
+        run: cargo fix --all-features --all-targets
       - name: cargo fmt
         run: cargo fmt --all
       - name: cargo test

Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "autocrate"
-version = "0.1.0-prealpha.2"
+version = "0.1.0-prealpha.1"
 edition = "2021"
 publish = true
 authors = ["Christoph J. Scherr <software@cscherr.de>"]
@@ -21,18 +21,15 @@ keywords = [
 
 [dependencies]
 anyhow = "1.0.79"
-async-trait = "0.1.77"
+cargo = "0.76.0"
-# cargo = "0.76.0"
 clap = { version = "4.4.18", features = ["derive", "help"] }
 clap-verbosity-flag = "2.1.2"
 git2 = "0.18.1"
 libpt = { version = "0.3.11", features = ["log"] }
-reqwest = "0.11.24"
 serde = { version = "1.0.195", features = ["derive"] }
 serde_yaml = "0.9.30"
 tempfile = "3.9.0"
 thiserror = "1.0.56"
-tokio = { version = "1.36.0", features = ["tokio-macros", "rt-multi-thread", "macros"] }
 url = { version = "2.5.0", features = ["serde"] }
 
 [[bin]]

README.md

@@ -66,7 +66,7 @@ Create a YAML file named `.autocrate.yml` (or `.yaml`) in the root of your Git
 repository. It should contain the following parameters (replace the placeholders):
 
 | Parent          | Key          | Value                                                                            | Explanation                                                                  |
-|----------------------|--------------|----------------------------------------------------------------------------------|------------------------------------------------------------------------------|
+|-----------------|--------------|----------------------------------------------------------------------------------|------------------------------------------------------------------------------|
 | (root)          | `changelog`  | list of keys with this as parent (`git-log` etc)                                 | information on how a changelog is generated                                  |
 | `changelog`     | `enable`     | `true`/`false`                                                                   | If false, no changelog will be generated                                     |
 | `changelog`     | `git-log`    | `true`/`false`                                                                   | should a changelog be generated with `git log`?                              |
@@ -79,10 +79,7 @@ repository. It should contain the following parameters (replace the placeholders
 | `api.NAME`      | `endpoint`   | Base URL of the target server                                                    | Let's us know which api type we are talking to                               |
 | `api.NAME`      | `auth`       | list of keys with this as parent (`user` and `pass`)                             | We probably need authentication on the target server                         |
 | `api.NAME.auth` | `user`       | a string                                                                         | Which user should we try to authenticate as                                  |
-| `api.NAME.auth`      | `pass`       | contains either of `text`, `env` or `file`                                       | sets the secret for authentication with this server                          |
+| `api.NAME.auth` | `pass`       | a string                                                                         | A secret for authentication o the server, probably a token                   |
-| `api.NAME.auth.pass` | `text`       | a authentication pass as clear text                                              | A secret for authentication of the server, probably a token                   |
-| `api.NAME.auth.pass` | `env`        | env var which contains the token                                                 | A secret for authentication of the server, probably a token                   |
-| `api.NAME.auth.pass` | `file`       | file var which contains the token                                                | A secret for authentication of the server, probably a token                   |
 
 An example `.autocrate.yaml` could look like this:
 
@@ -105,18 +102,16 @@ api:
     endpoint: https://github.com
     auth:
       user: PlexSheep
-      pass:
+      pass: token_superimportantsecret
-        text: token_superimportantsecret
   cscherr:
     type: gitea
     endpoint: https://git.cscherr.de
     auth:
       user: PlexSheep
-      pass:
+      pass: Bearer importantsecrettoken
-        file: secrettoken.txt
 ```
 
-After Autocrate has been bootstrapped, it will be released and published
+After Autocrate has been bootstrapped, you it will be released and published
 with itself, so you can take a look at this repositories
 [`.autocrate.yaml`](./.autocrate.yaml).
 

scripts/release.sh

@@ -7,7 +7,7 @@ BODY="
 $(git log $(git describe --tags --abbrev=0)..HEAD --pretty="- %s" --oneline --decorate)
 "
 USER=PlexSheep
-git tag "v$NEW_VERSION" || echo "could not tag"
+git tag "v$NEW_VERSION-test" || echo "could not tag"
 curl -X 'POST' \
 	'https://git.cscherr.de/api/v1/repos/PlexSheep/'$REPO'/releases' \
 	-H 'accept: application/json' \

src/changelog/mod.rs

@@ -28,7 +28,7 @@ impl Changelog {
         let out = cmd.output()?;
         // FIXME: this does not catch fancy colors, those are from the shell as it seems? I don't
         // get it.
-        let buf = String::from_utf8(out.stdout).map_err(ChangelogError::GitUTF8Error)?;
+        let buf = String::from_utf8(out.stdout).map_err(|err| ChangelogError::GitUTF8Error(err))?;
         if !out.status.success() {
             // TODO: get the stderr for error reporting
             // TODO: Make the error more understandable for the user
@@ -43,14 +43,14 @@ impl Changelog {
         let mut cmd = Command::new("git");
         cmd.arg("describe").arg("--tags").arg("--abbrev=0");
         let out = cmd.output()?;
-        let buf = String::from_utf8(out.stdout).map_err(ChangelogError::GitUTF8Error)?;
+        let buf = String::from_utf8(out.stdout).map_err(|err| ChangelogError::GitUTF8Error(err))?;
         if !out.status.success() {
             // TODO: get the stderr for error reporting
             // TODO: Make the error more understandable for the user
             return Err(ChangelogError::GitBadStatus(out.status, buf).into());
         }
-        let buf = buf.replace('\n', "");
+        let buf = buf.replace("\n", "");
-        Ok(buf)
+        return Ok(buf);
     }
 }
 

src/config/cli.rs

@@ -38,7 +38,6 @@ pub struct Cli {
 #[derive(Debug, Clone, Subcommand)]
 pub enum Commands {
     Changelog {},
-    /// Create a new release on the server
     Release {
         // FIXME: allow taking a message like this:
         // `autocrate changelog -m arg1 arg2 arg3`
@@ -53,29 +52,14 @@ pub enum Commands {
         //
         // TODO:
         // find a way to make this a global option but only usable with specific subcommands
-        //
-        // TODO:
-        // integrate a CHANGELOG.md file
-        //
-        /// Message body of the release
         #[arg(short, long)]
         message: Option<Vec<String>>,
-
-        /// generate and add a changelog
-        changelog: bool,
-
-        /// publish after releasing
-        publish: bool,
     },
-    /// Publish to a package registry
     Publish {
         // see Commands::Release { message }
         #[arg(short, long)]
         message: Option<Vec<String>>,
     },
-    ///
-    Version {},
-    Init {},
 }
 
 impl Display for Commands {
@@ -87,8 +71,6 @@ impl Display for Commands {
                 Self::Changelog { .. } => "Changelog",
                 Self::Release { .. } => "Release",
                 Self::Publish { .. } => "Publish",
-                Self::Version { .. } => "Version",
-                Self::Init { .. } => "Init",
             }
         )
     }
@@ -113,6 +95,6 @@ impl Cli {
             // less verbose version
             Logger::init_mini(Some(ll)).expect("could not initialize Logger");
         }
-        cli
+        return cli;
     }
 }

src/config/mod.rs

@@ -8,7 +8,6 @@ use url::Url;
 use crate::error::*;
 
 pub mod cli;
-pub mod packages;
 use cli::Cli;
 
 pub trait YamlConfigSection: Debug + Clone + for<'a> Deserialize<'a> {
@@ -49,60 +48,32 @@ impl YamlConfigSection for Uses {
     }
 }
 
-#[derive(Debug, Clone, Deserialize)]
-pub enum Pass {
-    /// pass specified as plainext
-    Text(String),
-    /// pass to be loaded from an env var
-    Env(String),
-    /// pass to be loaded from a file
-    File(PathBuf),
-}
-impl Pass {
-    /// Get the pass, extracting from the underlying source
-    pub fn get_pass(&self) -> Result<String> {
-        self.check()?;
-        Ok(match self {
-            Self::Text(pass) => pass.clone(),
-            Self::Env(key) => std::env::var(key).map_err(ConfigError::from)?,
-            Self::File(file) => std::fs::read_to_string(file)?,
-        })
-    }
-}
-impl YamlConfigSection for Pass {
-    fn check(&self) -> Result<()> {
-        match self {
-            Self::Text(_) => (),
-            Self::Env(envvar) => {
-                if !std::env::var(envvar).map_err(ConfigError::from)?.is_empty() {
-                } else {
-                    return Err(ConfigError::EnvNotSet(envvar.clone()).into());
-                }
-            }
-            Self::File(file) => {
-                if !file.exists() {
-                    return Err(ConfigError::PassFileDoesNotExist(file.clone()).into());
-                }
-            }
-        };
-        Ok(())
-    }
-}
 #[derive(Debug, Clone, Deserialize)]
 pub struct ApiAuth {
     pub user: String,
-    pub pass: Pass,
+    pub pass: Option<String>,
+    pub pass_file: Option<PathBuf>,
 }
 impl YamlConfigSection for ApiAuth {
     fn check(&self) -> Result<()> {
-        self.pass.check()?;
+        if self.pass.is_some() && self.pass_file.is_some() {
+            let err = ConfigError::YamlApiAuthBothPass(self.clone()).into();
+            error!("{err}");
+            return Err(err);
+        }
+        if self.pass_file.is_some() {
+            let file = self.pass_file.clone().unwrap();
+            if !file.exists() {
+                return Err(ConfigError::PassFileDoesNotExist(file).into());
+            }
+        }
         Ok(())
     }
 }
 
 #[derive(Debug, Clone, Deserialize)]
 pub struct Api {
-    pub server_type: ApiType,
+    pub r#type: ApiType,
     pub endpoint: Url,
     /// May be left empty if the Api does not need auth or the auth is part of the
     /// [endpoint](Api::endpoint) [Url].
@@ -110,7 +81,7 @@ pub struct Api {
 }
 impl YamlConfigSection for Api {
     fn check(&self) -> Result<()> {
-        self.server_type.check()?;
+        self.r#type.check()?;
         match self.endpoint.socket_addrs(|| None) {
             Ok(_) => (),
             Err(err) => return Err(err.into()),
@@ -130,8 +101,6 @@ pub enum ApiType {
     Gitlab,
     #[serde(alias = "github", alias = "GitHub")]
     Github,
-    #[serde(alias = "forgejo")]
-    Forgejo,
 }
 impl YamlConfigSection for ApiType {
     fn check(&self) -> Result<()> {
@@ -178,7 +147,7 @@ impl Debug for Config {
         write!(
             f,
             "{}",
-            format_args!(
+            format!(
                 "Config {{yaml: {:?}, repo_path: {:?}}}",
                 self.yaml, self.path
             )
@@ -187,7 +156,7 @@ impl Debug for Config {
 }
 
 impl Config {
-    pub fn load(cli: &Cli) -> Result<Self> {
+    pub fn load(cli: Cli) -> Result<Self> {
         let repo = match git2::Repository::open_from_env() {
             Ok(repo) => repo,
             Err(_err) => {
@@ -228,7 +197,7 @@ impl Config {
             yaml,
             repo,
             path,
-            cli: cli.clone(),
+            cli,
         })
     }
 }

src/config/packages.rs

@@ -1,3 +0,0 @@
-pub enum PackageType {
-    Cargo,
-}

src/error.rs

@@ -1,4 +1,4 @@
-use std::{env::VarError, path::PathBuf, process::ExitStatus, string::FromUtf8Error};
+use std::{path::PathBuf, process::ExitStatus, string::FromUtf8Error};
 
 use anyhow;
 use thiserror::Error;
@@ -20,18 +20,6 @@ pub enum Error {
     SerdeYaml(#[from] serde_yaml::Error),
     #[error("Could not generate the changelog")]
     ChangelogError(#[from] ChangelogError),
-    #[error("Server Api error")]
-    ServerApiError(#[from] ServerApiError),
-}
-
-#[derive(Error, Debug)]
-pub enum ServerApiError {
-    #[error(transparent)]
-    ParseUrl(#[from] url::ParseError),
-    #[error(transparent)]
-    InvalidHeaderValue(#[from] reqwest::header::InvalidHeaderValue),
-    #[error(transparent)]
-    ReqwestErr(#[from] reqwest::Error),
 }
 
 #[derive(Error, Debug)]
@@ -57,8 +45,4 @@ pub enum ConfigError {
     YamlApiAuthBothPass(ApiAuth),
     #[error("password provided as file, but does not exist: {0}")]
     PassFileDoesNotExist(PathBuf),
-    #[error("config requires environment variable {0}, but {0} is not set")]
-    EnvNotSet(String),
-    #[error("Bad value for environment variable: {0}")]
-    BadEnv(#[from] VarError),
 }

src/lib.rs

@@ -1,6 +1,3 @@
 pub mod changelog;
 pub mod config;
 pub mod error;
-pub mod publish;
-pub mod release;
-pub mod serverapi;

src/main.rs

@@ -5,37 +5,22 @@ use autocrate::{
         Config,
     },
     error::*,
-    publish::publish,
-    release::release,
-    serverapi::init_servers,
 };
 
-#[tokio::main]
+fn main() -> Result<()> {
-async fn main() -> Result<()> {
     let cli = Cli::cli_parse();
-    let cfg = Config::load(&cli)?;
+    let cfg = Config::load(cli.clone())?;
 
     match cli.command {
         Commands::Changelog { .. } => {
-            println!("{}", Changelog::build(&cfg)?);
+            println!("{}", Changelog::build(&cfg)?.to_string());
+            Ok(())
         }
         Commands::Release { .. } => {
-            let mut apis = init_servers(&cfg).await?;
+            todo!()
-            release(&cfg, &mut apis).await?;
         }
         Commands::Publish { .. } => {
-            publish(&cfg).await?;
-        }
-        Commands::Version {} => {
-            // TODO: version bump
-            // TODO: version select interactive
-            // TODO: version select automated
             todo!()
         }
-        Commands::Init { .. } => {
-            // TODO: create a basic autocrate yaml
-            todo!()
     }
-    };
-    Ok(())
 }

src/publish/mod.rs

@@ -1,7 +0,0 @@
-use crate::{config::Config, error::*};
-
-pub struct PublishContext;
-
-pub async fn publish(_cfg: &Config) -> Result<()> {
-    todo!()
-}

src/release/mod.rs

@@ -1,31 +0,0 @@
-use crate::{config::Config, error::*, serverapi::ApiCollection};
-
-pub struct ReleaseContext {
-    pub draft: bool,
-    pub prerelease: bool,
-    pub username: String,
-    pub repository: String,
-    pub text: String,
-    pub tag: String,
-    pub commit_sig: String,
-}
-
-pub async fn release(cfg: &Config, _apis: &mut ApiCollection) -> Result<()> {
-    // TODO: git tag
-    // TODO: push to each server
-
-    // TODO: release to each server
-    tag(cfg).await?;
-    todo!();
-
-    // TODO: check that the release is made
-    // TODO: generate artifacts
-    // TODO: upload artifacts
-    // TODO: upload artifact signatures
-
-    Ok(())
-}
-
-async fn tag(_cfg: &Config) -> Result<()> {
-    todo!()
-}

src/serverapi/forgejo.rs

@@ -1,83 +0,0 @@
-use crate::{
-    config::{Api, Config},
-    error::*,
-    serverapi::{PublishContext, ReleaseContext, ServerApi},
-};
-use async_trait::async_trait;
-use reqwest::{
-    header::{HeaderMap, HeaderValue},
-    Client, Url,
-};
-
-pub struct Forgejo {
-    cfg: Api,
-    client: Client,
-}
-
-impl Forgejo {
-    pub async fn build(api: &Api) -> Result<Self> {
-        let mut headers: HeaderMap = HeaderMap::new();
-        // may be left empty if we only do reads from publically accessible urls
-        if api.auth.is_some() {
-            let _ = headers.insert(
-                "Authorization",
-                HeaderValue::from_str(api.auth.clone().unwrap().pass.get_pass()?.as_str())
-                    .map_err(ServerApiError::from)?,
-            );
-        }
-        let client = super::client_builder()
-            .default_headers(headers)
-            .build()
-            .map_err(ServerApiError::from)?;
-        Ok(Self {
-            cfg: api.clone(),
-            client,
-        })
-    }
-}
-
-#[async_trait]
-impl ServerApi for Forgejo {
-    async fn init(&mut self, _cfg: &Config) -> Result<()> {
-        todo!()
-    }
-    async fn push_release(&mut self, rc: &ReleaseContext) -> Result<()> {
-        let raw_url = format!(
-            "{}/api/v1/repos/{}/{}/releases",
-            self.cfg.endpoint, rc.username, rc.repository
-        );
-        let url = Url::parse(&raw_url).map_err(ServerApiError::from)?;
-        let body = format!(
-            r#"
-        {{
-            "body": "{}",
-            "draft": {},
-            "name": "{}",
-            "prerelease": {},
-            "tag_name": "{}",
-            "target_commitish": "{}"
-        }}
-        "#,
-            rc.text, rc.draft, rc.tag, rc.prerelease, rc.tag, rc.commit_sig
-        );
-
-        let request = self
-            .client
-            .post(url)
-            .body(body)
-            .build()
-            .map_err(ServerApiError::from)?;
-        let _response = self
-            .client
-            .execute(request)
-            .await
-            .map_err(ServerApiError::from)?;
-        Ok(())
-    }
-    async fn push_release_artifact(&mut self, _rc: &ReleaseContext) -> Result<()> {
-        todo!()
-    }
-    async fn push_pkg(&mut self, _pc: &PublishContext) -> Result<()> {
-        todo!()
-    }
-}

src/serverapi/gitea.rs

@@ -1,32 +0,0 @@
-use async_trait::async_trait;
-
-use super::{PublishContext, ReleaseContext, ServerApi};
-use crate::{
-    config::{Api, Config},
-    error::*,
-};
-pub struct Gitea {
-    cfg: Api,
-}
-
-#[async_trait]
-impl ServerApi for Gitea {
-    async fn init(&mut self, _cfg: &Config) -> Result<()> {
-        todo!()
-    }
-    async fn push_release(&mut self, _rc: &ReleaseContext) -> Result<()> {
-        todo!()
-    }
-    async fn push_release_artifact(&mut self, _rc: &ReleaseContext) -> Result<()> {
-        todo!()
-    }
-    async fn push_pkg(&mut self, _pc: &PublishContext) -> Result<()> {
-        todo!()
-    }
-}
-
-impl Gitea {
-    pub async fn build(api: &Api) -> Result<Self> {
-        Ok(Self { cfg: api.clone() })
-    }
-}

src/serverapi/github.rs

@@ -1,32 +0,0 @@
-use async_trait::async_trait;
-
-use super::{PublishContext, ReleaseContext, ServerApi};
-use crate::{
-    config::{Api, Config},
-    error::*,
-};
-pub struct Github {
-    cfg: Api,
-}
-
-#[async_trait]
-impl ServerApi for Github {
-    async fn init(&mut self, _cfg: &Config) -> Result<()> {
-        todo!()
-    }
-    async fn push_release(&mut self, _rc: &ReleaseContext) -> Result<()> {
-        todo!()
-    }
-    async fn push_release_artifact(&mut self, _rc: &ReleaseContext) -> Result<()> {
-        todo!()
-    }
-    async fn push_pkg(&mut self, _pc: &PublishContext) -> Result<()> {
-        todo!()
-    }
-}
-
-impl Github {
-    pub async fn build(api: &Api) -> Result<Self> {
-        Ok(Self { cfg: api.clone() })
-    }
-}

src/serverapi/gitlab.rs

@@ -1,32 +0,0 @@
-use async_trait::async_trait;
-
-use super::{PublishContext, ReleaseContext, ServerApi};
-use crate::{
-    config::{Api, Config},
-    error::*,
-};
-pub struct Gitlab {
-    cfg: Api,
-}
-
-#[async_trait]
-impl ServerApi for Gitlab {
-    async fn init(&mut self, _cfg: &Config) -> Result<()> {
-        todo!()
-    }
-    async fn push_release(&mut self, _rc: &ReleaseContext) -> Result<()> {
-        todo!()
-    }
-    async fn push_release_artifact(&mut self, _rc: &ReleaseContext) -> Result<()> {
-        todo!()
-    }
-    async fn push_pkg(&mut self, _pc: &PublishContext) -> Result<()> {
-        todo!()
-    }
-}
-
-impl Gitlab {
-    pub async fn build(api: &Api) -> Result<Self> {
-        Ok(Self { cfg: api.clone() })
-    }
-}

src/serverapi/mod.rs

@@ -1,60 +0,0 @@
-use async_trait::async_trait;
-use reqwest::ClientBuilder;
-
-use crate::{
-    config::{ApiType, Config},
-    error::*,
-    publish::PublishContext,
-    release::ReleaseContext,
-};
-
-pub mod forgejo;
-pub mod gitea;
-pub mod github;
-pub mod gitlab;
-use forgejo::*;
-use gitea::*;
-use github::*;
-use gitlab::*;
-
-pub static USER_AGENT: &str = concat!(env!("CARGO_PKG_NAME"), "/", env!("CARGO_PKG_VERSION"),);
-pub type ApiCollection = Vec<Box<dyn ServerApi>>;
-
-// NOTE: in stable rust, traits can normally not contain async methods,
-// see [here](https://stackoverflow.com/questions/65921581/how-can-i-define-an-async-method-in-a-trait).
-// The `async_trait` crate can be used to work around this limitation.
-#[async_trait]
-pub trait ServerApi {
-    async fn init(&mut self, cfg: &Config) -> Result<()>;
-    async fn push_release(&mut self, rc: &ReleaseContext) -> Result<()>;
-    async fn push_release_artifact(&mut self, rc: &ReleaseContext) -> Result<()>;
-    async fn push_pkg(&mut self, pc: &PublishContext) -> Result<()>;
-}
-
-pub fn client_builder() -> ClientBuilder {
-    ClientBuilder::new().user_agent(USER_AGENT)
-}
-
-pub async fn init_servers(cfg: &Config) -> Result<ApiCollection> {
-    let mut collection: ApiCollection = ApiCollection::new();
-    for api in &cfg.yaml.api {
-        match api.1.server_type {
-            ApiType::Gitea => {
-                collection.push(Box::new(Gitea::build(api.1).await?));
-            }
-            ApiType::Gitlab => {
-                collection.push(Box::new(Gitlab::build(api.1).await?));
-            }
-            ApiType::Github => {
-                collection.push(Box::new(Github::build(api.1).await?));
-            }
-            ApiType::Forgejo => {
-                collection.push(Box::new(Forgejo::build(api.1).await?));
-            }
-        }
-    }
-    for api in collection.iter_mut() {
-        api.init(cfg).await?;
-    }
-    Ok(collection)
-}