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    #[tracing::instrument(
92        name = "interprex.provider.code_hosting.repository",
93        skip_all,
94        fields(interprex.provider.name = "github")
95    )]
96    async fn repository(&self, repository: &Repository) -> Result<RepositoryFacts> {
97        let response: GithubRepository = self
98            .user()?
99            .get(format!("/repos/{repository}"), None::<&()>)
100            .await
101            .map_err(|error| read_error("read repository", repository.to_string(), error))?;
102        response.try_into().map(|(facts, _)| facts)
103    }
104
105    #[tracing::instrument(
106        name = "interprex.provider.code_hosting.settings",
107        skip_all,
108        fields(interprex.provider.name = "github")
109    )]
110    async fn settings(&self, repository: &Repository) -> Result<RepositorySettings> {
111        let response: GithubRepository = self
112            .user()?
113            .get(format!("/repos/{repository}"), None::<&()>)
114            .await
115            .map_err(|error| {
116                read_error("read repository settings", repository.to_string(), error)
117            })?;
118        response.try_into().map(|(_, settings)| settings)
119    }
120
121    #[tracing::instrument(
122        name = "interprex.provider.code_hosting.apply_settings",
123        skip_all,
124        fields(interprex.provider.name = "github")
125    )]
126    async fn apply_settings(
127        &self,
128        repository: &Repository,
129        settings: &RepositorySettings,
130    ) -> Result<RepositorySettings> {
131        let body = GithubRepositorySettings::from(settings);
132        let response: GithubRepository = self
133            .user()?
134            .patch(format!("/repos/{repository}"), Some(&body))
135            .await
136            .map_err(|error| external("apply repository settings", error))?;
137        response.try_into().map(|(_, settings)| settings)
138    }
139
140    #[tracing::instrument(
141        name = "interprex.provider.code_hosting.put_secret",
142        skip_all,
143        fields(interprex.provider.name = "github")
144    )]
145    async fn put_secret(
146        &self,
147        repository: &Repository,
148        name: &str,
149        value: SecretString,
150    ) -> Result<()> {
151        #[derive(Deserialize)]
152        struct Key {
153            key_id: String,
154            key: String,
155        }
156        let key: Key = self
157            .user()?
158            .get(
159                format!("/repos/{repository}/actions/secrets/public-key"),
160                None::<&()>,
161            )
162            .await
163            .map_err(|error| external("read repository secret public key", error))?;
164        let decoded = STANDARD
165            .decode(key.key)
166            .map_err(|error| external("decode repository secret public key", error))?;
167        let public_key = PublicKey::from_slice(&decoded)
168            .map_err(|error| external("parse repository secret public key", error))?;
169        let encrypted = public_key
170            .seal(&mut OsRng, value.expose_secret().as_bytes())
171            .map_err(|error| external("encrypt repository secret", error))?;
172        let _: serde_json::Value = self
173            .user()?
174            .put(
175                format!("/repos/{repository}/actions/secrets/{name}"),
176                Some(
177                    &json!({ "encrypted_value": STANDARD.encode(encrypted), "key_id": key.key_id }),
178                ),
179            )
180            .await
181            .map_err(|error| external("write repository secret", error))?;
182        Ok(())
183    }
184}
185
186#[cfg(test)]
187mod tests {
188    use super::GithubRepository;
189
190    #[test]
191    fn repository_fixture_normalizes_only_contract_facts() {
192        let fixture = include_str!("../tests/fixtures/repository.json");
193        let response: GithubRepository = serde_json::from_str(fixture).expect("fixture");
194        let (facts, settings) = response.try_into().expect("normalizes");
195        assert_eq!(
196            facts.repository.to_string(),
197            "civitas-forge/interprex-sandbox"
198        );
199        assert!(settings.allow_squash_merge);
200        assert!(!settings.allow_merge_commit);
201    }
202}