autoschematic-connector-github 0.9.0

An Autoschematic connector for GitHub repository management
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

use crate::{GitHubConnector, addr::GitHubResourceAddress, op::GitHubConnectorOp, resource};
use autoschematic_core::{
    connector::{ConnectorOp, PlanResponseElement, ResourceAddress},
    connector_op,
    util::{RON, diff_ron_values},
};
use std::path::Path;

impl GitHubConnector {
    pub async fn do_plan(
        &self,
        addr: &Path,
        current: Option<Vec<u8>>,
        desired: Option<Vec<u8>>,
    ) -> anyhow::Result<Vec<PlanResponseElement>> {
        let addr = GitHubResourceAddress::from_path(addr)?;
        let mut res = Vec::new();

        match addr {
            GitHubResourceAddress::Config => {}
            GitHubResourceAddress::Repository { owner, repo } => match (current, desired) {
                (None, None) => {}
                (None, Some(desired_bytes)) => {
                    let desired_str = std::str::from_utf8(&desired_bytes)?;
                    let new_repo: resource::GitHubRepository = RON.from_str(desired_str)?;

                    res.push(connector_op!(
                        GitHubConnectorOp::CreateRepository(new_repo),
                        format!("Create GitHub repository {}/{}", owner, repo)
                    ));
                }
                (Some(_), None) => {
                    res.push(connector_op!(
                        GitHubConnectorOp::DeleteRepository,
                        format!("Delete GitHub repository {}/{}", owner, repo)
                    ));
                }
                (Some(current_bytes), Some(desired_bytes)) => {
                    if current_bytes != desired_bytes {
                        let current_str = std::str::from_utf8(&current_bytes)?;
                        let desired_str = std::str::from_utf8(&desired_bytes)?;
                        let old_repo: resource::GitHubRepository = RON.from_str(current_str)?;
                        let new_repo: resource::GitHubRepository = RON.from_str(desired_str)?;

                        let diff = diff_ron_values(&old_repo, &new_repo).unwrap_or_default();
                        res.push(connector_op!(
                            GitHubConnectorOp::UpdateRepository(old_repo, new_repo),
                            format!("Update GitHub repository {}/{}\n{}", owner, repo, diff)
                        ));
                    }
                }
            },
            GitHubResourceAddress::BranchProtection { owner, repo, branch } => match (current, desired) {
                (None, None) => {}
                (None, Some(desired_bytes)) => {
                    let desired_str = std::str::from_utf8(&desired_bytes)?;
                    let new_protection: resource::BranchProtection = RON.from_str(desired_str)?;

                    res.push(connector_op!(
                        GitHubConnectorOp::CreateBranchProtection(new_protection),
                        format!("Create branch protection for {}/{} branch {}", owner, repo, branch)
                    ));
                }
                (Some(_), None) => {
                    res.push(connector_op!(
                        GitHubConnectorOp::DeleteBranchProtection,
                        format!("Delete branch protection for {}/{} branch {}", owner, repo, branch)
                    ));
                }
                (Some(current_bytes), Some(desired_bytes)) => {
                    if current_bytes != desired_bytes {
                        let current_str = std::str::from_utf8(&current_bytes)?;
                        let desired_str = std::str::from_utf8(&desired_bytes)?;
                        let old_protection: resource::BranchProtection = RON.from_str(current_str)?;
                        let new_protection: resource::BranchProtection = RON.from_str(desired_str)?;
                        let diff = diff_ron_values(&old_protection, &new_protection).unwrap_or_default();

                        res.push(connector_op!(
                            GitHubConnectorOp::UpdateBranchProtection(old_protection, new_protection),
                            format!("Update branch protection for {}/{} branch {}\n{}", owner, repo, branch, diff)
                        ));
                    }
                }
            },
            GitHubResourceAddress::Collaborator { owner, repo, username } => match (current, desired) {
                (None, None) => {}
                (None, Some(desired_bytes)) => {
                    let desired_str = std::str::from_utf8(&desired_bytes)?;
                    let new_collaborator: resource::Collaborator = RON.from_str(desired_str)?;

                    res.push(connector_op!(
                        GitHubConnectorOp::AddCollaborator(new_collaborator),
                        format!("Add collaborator {} to {}/{}", username, owner, repo)
                    ));
                }
                (Some(_), None) => {
                    res.push(connector_op!(
                        GitHubConnectorOp::RemoveCollaborator,
                        format!("Remove collaborator {} from {}/{}", username, owner, repo)
                    ));
                }
                (Some(current_bytes), Some(desired_bytes)) => {
                    if current_bytes != desired_bytes {
                        let current_str = std::str::from_utf8(&current_bytes)?;
                        let desired_str = std::str::from_utf8(&desired_bytes)?;
                        let old_collaborator: resource::Collaborator = RON.from_str(current_str)?;
                        let new_collaborator: resource::Collaborator = RON.from_str(desired_str)?;

                        res.push(connector_op!(
                            GitHubConnectorOp::UpdateCollaboratorPermission(old_collaborator, new_collaborator),
                            format!("Update collaborator {} permissions for {}/{}", username, owner, repo)
                        ));
                    }
                }
            },
        }

        Ok(res)
    }
}