Skip to main content

interprex_github/
code_hosting.rs

1//! Repository settings and secret transport owned by code hosting.
2//!
3//! Secret values are sealed with the repository public key before the write
4//! and are never retained by the provider.
5
6use async_trait::async_trait;
7use base64::{Engine as _, engine::general_purpose::STANDARD};
8use crypto_box::{PublicKey, aead::OsRng};
9use interprex::{
10    CodeHostingProvider, ProviderError, Repository, RepositoryFacts, RepositorySettings, Result,
11};
12use secrecy::{ExposeSecret, SecretString};
13use serde::{Deserialize, Serialize};
14use serde_json::json;
15
16use crate::{
17    GithubProvider,
18    client::{external, read_error},
19};
20
21#[derive(Deserialize)]
22struct GithubRepository {
23    owner: GithubOwner,
24    name: String,
25    default_branch: String,
26    private: bool,
27    archived: bool,
28    allow_squash_merge: bool,
29    allow_merge_commit: bool,
30    allow_rebase_merge: bool,
31    delete_branch_on_merge: bool,
32}
33
34#[derive(Deserialize)]
35struct GithubOwner {
36    login: String,
37}
38
39#[derive(Serialize)]
40struct GithubRepositorySettings {
41    #[serde(rename = "allow_squash_merge")]
42    squash_merge: bool,
43    #[serde(rename = "allow_merge_commit")]
44    merge_commit: bool,
45    #[serde(rename = "allow_rebase_merge")]
46    rebase_merge: bool,
47    #[serde(rename = "delete_branch_on_merge")]
48    delete_branch_after_merge: bool,
49}
50
51impl From<&RepositorySettings> for GithubRepositorySettings {
52    fn from(value: &RepositorySettings) -> Self {
53        Self {
54            squash_merge: value.allow_squash_merge,
55            merge_commit: value.allow_merge_commit,
56            rebase_merge: value.allow_rebase_merge,
57            delete_branch_after_merge: value.delete_branch_on_merge,
58        }
59    }
60}
61
62impl TryFrom<GithubRepository> for (RepositoryFacts, RepositorySettings) {
63    type Error = ProviderError;
64
65    fn try_from(value: GithubRepository) -> Result<Self> {
66        let repository = Repository::new(value.owner.login, value.name).map_err(|error| {
67            ProviderError::Unrepresentable {
68                provider: "github",
69                fact: error.to_string(),
70            }
71        })?;
72        Ok((
73            RepositoryFacts {
74                repository,
75                default_branch: value.default_branch,
76                private: value.private,
77                archived: value.archived,
78            },
79            RepositorySettings {
80                allow_squash_merge: value.allow_squash_merge,
81                allow_merge_commit: value.allow_merge_commit,
82                allow_rebase_merge: value.allow_rebase_merge,
83                delete_branch_on_merge: value.delete_branch_on_merge,
84            },
85        ))
86    }
87}
88
89#[async_trait]
90impl CodeHostingProvider for GithubProvider {
91    async fn repository(&self, repository: &Repository) -> Result<RepositoryFacts> {
92        let response: GithubRepository = self
93            .user()?
94            .get(format!("/repos/{repository}"), None::<&()>)
95            .await
96            .map_err(|error| read_error("read repository", repository.to_string(), error))?;
97        response.try_into().map(|(facts, _)| facts)
98    }
99
100    async fn settings(&self, repository: &Repository) -> Result<RepositorySettings> {
101        let response: GithubRepository = self
102            .user()?
103            .get(format!("/repos/{repository}"), None::<&()>)
104            .await
105            .map_err(|error| {
106                read_error("read repository settings", repository.to_string(), error)
107            })?;
108        response.try_into().map(|(_, settings)| settings)
109    }
110
111    async fn apply_settings(
112        &self,
113        repository: &Repository,
114        settings: &RepositorySettings,
115    ) -> Result<RepositorySettings> {
116        let body = GithubRepositorySettings::from(settings);
117        let response: GithubRepository = self
118            .user()?
119            .patch(format!("/repos/{repository}"), Some(&body))
120            .await
121            .map_err(|error| external("apply repository settings", error))?;
122        response.try_into().map(|(_, settings)| settings)
123    }
124
125    async fn put_secret(
126        &self,
127        repository: &Repository,
128        name: &str,
129        value: SecretString,
130    ) -> Result<()> {
131        #[derive(Deserialize)]
132        struct Key {
133            key_id: String,
134            key: String,
135        }
136        let key: Key = self
137            .user()?
138            .get(
139                format!("/repos/{repository}/actions/secrets/public-key"),
140                None::<&()>,
141            )
142            .await
143            .map_err(|error| external("read repository secret public key", error))?;
144        let decoded = STANDARD
145            .decode(key.key)
146            .map_err(|error| external("decode repository secret public key", error))?;
147        let public_key = PublicKey::from_slice(&decoded)
148            .map_err(|error| external("parse repository secret public key", error))?;
149        let encrypted = public_key
150            .seal(&mut OsRng, value.expose_secret().as_bytes())
151            .map_err(|error| external("encrypt repository secret", error))?;
152        let _: serde_json::Value = self
153            .user()?
154            .put(
155                format!("/repos/{repository}/actions/secrets/{name}"),
156                Some(
157                    &json!({ "encrypted_value": STANDARD.encode(encrypted), "key_id": key.key_id }),
158                ),
159            )
160            .await
161            .map_err(|error| external("write repository secret", error))?;
162        Ok(())
163    }
164}
165
166#[cfg(test)]
167mod tests {
168    use super::GithubRepository;
169
170    #[test]
171    fn repository_fixture_normalizes_only_contract_facts() {
172        let fixture = include_str!("../tests/fixtures/repository.json");
173        let response: GithubRepository = serde_json::from_str(fixture).expect("fixture");
174        let (facts, settings) = response.try_into().expect("normalizes");
175        assert_eq!(
176            facts.repository.to_string(),
177            "civitas-forge/interprex-sandbox"
178        );
179        assert!(settings.allow_squash_merge);
180        assert!(!settings.allow_merge_commit);
181    }
182}