repo-backup 0.2.2

A program for backing up your GitHub and GitLab repos.
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

use failure::{Error, ResultExt};
use gitlab::{Gitlab as Client, Project};

use config::GitLabConfig;
use {Provider, Repo, SyncResult};

/// A provider which queries the GitLab API.
#[derive(Debug)]
pub struct GitLab {
    client: Client,
    cfg: GitLabConfig,
}

impl GitLab {
    /// Create a new `GitLab` provider using its config.
    pub fn with_config(cfg: GitLabConfig) -> Result<GitLab, Error> {
        let client = Client::new(&cfg.host, cfg.api_key.reveal_str())
            .sync()
            .context("Invalid API key")?;

        Ok(GitLab { client, cfg })
    }

    fn get_owned(&self) -> Result<Vec<Repo>, Error> {
        debug!("Fetching owned repos");
        let owned = self.client.owned_projects().sync()?;

        let repos: Vec<Repo> = owned
            .into_iter()
            .map(|p| self.gitlab_project_to_repo(p))
            .collect();

        debug!("Found {} owned projects", repos.len());

        Ok(repos)
    }

    fn get_organisation_repos(&self) -> Result<Vec<Repo>, Error> {
        debug!("Fetching organisation repos");

        let current_user = self
            .client
            .current_user()
            .sync()
            .context("Unable to get the name of the current user")?
            .username;
        trace!("Current GitLab user is {}", current_user);

        let all_repos = self.client.projects().sync()?;

        let org_repos: Vec<Repo> = all_repos
            .into_iter()
            .map(|p| self.gitlab_project_to_repo(p))
            .filter(|r| r.owner != current_user)
            .collect();

        debug!(
            "Found {} repos owned by organisations you are a part of",
            org_repos.len()
        );
        Ok(org_repos)
    }

    fn gitlab_project_to_repo(&self, project: Project) -> Repo {
        let mut split = project.path_with_namespace.split("/");
        let owner = split.next().expect("Namespaces always have an owner");
        let name = split.next().expect("unreachable");

        Repo {
            owner: owner.to_string(),
            name: name.to_string(),
            url: project.ssh_url_to_repo,
            provider: self.name().to_string(),
        }
    }
}

impl Provider for GitLab {
    fn name(&self) -> &str {
        "gitlab"
    }

    fn repositories(&self) -> Result<Vec<Repo>, Error> {
        let mut repos = Vec::new();

        if self.cfg.owned {
            let owned =
                self.get_owned().context("Unable to get owned repos")?;
            repos.extend(owned);
        }

        if self.cfg.organisations {
            let org_repos = self.get_organisation_repos().context(
                "Unable to get repos owned by organisations you are a part of",
            )?;
            repos.extend(org_repos);
        }

        Ok(repos)
    }
}