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
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
|
# Copyright (C) 2016-2019 Codethink Limited
#
# This program is free software; you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation; version 2 of the License.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License along
# with this program; if not, write to the Free Software Foundation, Inc.,
# 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
'''
Run commands on a GitLab instance.
This uses the python wrapper around the GitLab API.
Use of the API requires the private token of a user with master access
to the targetted group.
'''
import logging
import re
import urllib.parse
try:
import gitlab
except ImportError:
gitlab = None
from . import hosts
class MissingGitlabModuleError(Exception):
pass
def _init_gitlab(host, token):
if gitlab:
url = "http://" + host
return gitlab.Gitlab(url, token)
else:
raise MissingGitlabModuleError('gitlab module missing\n'
'\tpython-gitlab is required with GitLab as the git server')
class GitlabDownstream(hosts.DownstreamHost):
@staticmethod
def add_app_settings(app_settings):
app_settings.string(
['gitlab-private-token'],
'private token for GitLab API access')
@staticmethod
def check_app_settings(app_settings):
if not app_settings['gitlab-private-token']:
logging.error('A private token must be provided to create '
'repositories on a GitLab instance.')
app_settings.require('gitlab-private-token')
def __init__(self, app_settings):
# XXX This needs to be configurable
host = 'localhost'
self.gl = _init_gitlab(host, app_settings['gitlab-private-token'])
def _has_project(self, repo_path):
try:
self.gl.projects.get(repo_path)
return True
except gitlab.GitlabGetError:
return False
def prepare_repo(self, repo_path, metadata):
# TODO: set metadata
if self._has_project(repo_path):
logging.info('Project %s exists in local GitLab already.',
repo_path)
return
path_comps = repo_path.split('/')
if len(path_comps) < 2:
raise ValueError('cannot create GitLab project outside a group')
# Create hierarchy of groups as necessary
parent_group = None
for group_name in path_comps[:-1]:
if parent_group is None:
group_path = group_name
else:
group_path = parent_group.full_path + '/' + group_name
try:
group = self.gl.groups.get(group_path)
except gitlab.GitlabGetError as e:
if e.response_code != 404:
raise
data = {'name': group_name, 'path': group_name}
if parent_group is not None:
data['parent_id'] = parent_group.id
group = self.gl.groups.create(data)
parent_group = group
project = {
'name': path_comps[-1],
'public': True,
'merge_requests_enabled': False,
'namespace_id': group.id,
}
self.gl.projects.create(project)
logging.info('Created %s project in local GitLab.', repo_path)
class GitlabUpstream(hosts.UpstreamHost):
@staticmethod
def check_host_type_params(validator, section):
validator.check_has_required_fields(section, ['private-token'])
@staticmethod
def get_host_type_params(section):
return {'private-token': section['private-token']}
def __init__(self, host_info):
self._protocol = host_info['protocol']
self.gl = _init_gitlab(host_info['host'],
host_info['type_params']['private-token'])
def list_repos(self):
'''List projects on a GitLab instance.'''
return [x.path_with_namespace for x in self.gl.projects.list()]
def get_repo_url(self, repo_path):
'''Return the clone url for a GitLab project.
Depending on the protocol specified, will return a suitable clone url.
If 'ssh', a url in the format 'git@host:group/project.git' will be
returned.
If 'http' or 'https', the http_url_to_repo from the GitLab API is split
with urlparse into its constituent parts: the protocol (http by
default), the host, and the path ('group/project.git'). This is then
rejoined, replacing the protocol with what is specified. The resulting
format matching 'http(s)://host/group/project.git'.
'''
project = self.gl.projects.get(repo_path)
if self._protocol == 'ssh':
return project.ssh_url_to_repo
elif self._protocol in ('http', 'https'):
split = urllib.parse.urlsplit(project.http_url_to_repo)
return urllib.parse.urlunsplit((
self._protocol, split.netloc, split.path, '', ''))
def get_repo_metadata(self, repo_path):
# TODO
return {}
|
