pixi 0.15.2

A package management and workflow tool
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122

use clap::Parser;
use miette::IntoDiagnostic;
use rattler_networking::{Authentication, AuthenticationStorage};

#[derive(Parser, Debug)]
pub struct LoginArgs {
    /// The host to authenticate with (e.g. repo.prefix.dev)
    host: String,

    /// The token to use (for authentication with prefix.dev)
    #[clap(long)]
    token: Option<String>,

    /// The username to use (for basic HTTP authentication)
    #[clap(long)]
    username: Option<String>,

    /// The password to use (for basic HTTP authentication)
    #[clap(long)]
    password: Option<String>,

    /// The token to use on anaconda.org / quetz authentication
    #[clap(long)]
    conda_token: Option<String>,
}

#[derive(Parser, Debug)]
struct LogoutArgs {
    /// The host to remove authentication for
    host: String,
}

#[derive(Parser, Debug)]
enum Subcommand {
    /// Store authentication information for a given host
    Login(LoginArgs),
    /// Remove authentication information for a given host
    Logout(LogoutArgs),
}

/// Login to prefix.dev or anaconda.org servers to access private channels
#[derive(Parser, Debug)]
pub struct Args {
    #[clap(subcommand)]
    subcommand: Subcommand,
}

fn get_url(url: &str) -> miette::Result<String> {
    // parse as url and extract host without scheme or port
    let host = if url.contains("://") {
        url::Url::parse(url)
            .into_diagnostic()?
            .host_str()
            .unwrap()
            .to_string()
    } else {
        url.to_string()
    };

    let host = if host.matches('.').count() == 1 {
        // use wildcard for top-level domains
        format!("*.{}", host)
    } else {
        host
    };

    Ok(host)
}

fn login(args: LoginArgs, storage: AuthenticationStorage) -> miette::Result<()> {
    let host = get_url(&args.host)?;
    println!("Authenticating with {}", host);

    let auth = if let Some(conda_token) = args.conda_token {
        Authentication::CondaToken(conda_token)
    } else if let Some(username) = args.username {
        if args.password.is_none() {
            miette::bail!("Password must be provided when using basic authentication");
        }
        let password = args.password.unwrap();
        Authentication::BasicHTTP { username, password }
    } else if let Some(token) = args.token {
        Authentication::BearerToken(token)
    } else {
        miette::bail!("No authentication method provided");
    };

    if host.contains("prefix.dev") && !matches!(auth, Authentication::BearerToken(_)) {
        miette::bail!(
            "Authentication with prefix.dev requires a token. Use `--token` to provide one."
        );
    }

    if host.contains("anaconda.org") && !matches!(auth, Authentication::CondaToken(_)) {
        miette::bail!("Authentication with anaconda.org requires a conda token. Use `--conda-token` to provide one.");
    }

    storage
        .store(&host, &auth)
        .map_err(|e| miette::miette!(e.to_string()))?;
    Ok(())
}

fn logout(args: LogoutArgs, storage: AuthenticationStorage) -> miette::Result<()> {
    let host = get_url(&args.host)?;

    println!("Removing authentication for {}", host);

    storage
        .delete(&host)
        .map_err(|e| miette::miette!(e.to_string()))?;
    Ok(())
}

pub async fn execute(args: Args) -> miette::Result<()> {
    let storage = AuthenticationStorage::default();

    match args.subcommand {
        Subcommand::Login(args) => login(args, storage),
        Subcommand::Logout(args) => logout(args, storage),
    }
}