|
| 1 | +#!/usr/bin/env python |
| 2 | +import sys |
| 3 | +import logging |
| 4 | +log = logging.getLogger('git_repo.gogs') |
| 5 | + |
| 6 | +from ..service import register_target, RepositoryService, os |
| 7 | +from ...exceptions import ResourceError, ResourceExistsError, ResourceNotFoundError |
| 8 | + |
| 9 | +from gogs_client import GogsApi, GogsRepo, Token, UsernamePassword, ApiFailure |
| 10 | +from requests import Session, HTTPError |
| 11 | +from urllib.parse import urlparse, urlunparse |
| 12 | +import functools |
| 13 | + |
| 14 | +from git import config as git_config |
| 15 | +from git.exc import GitCommandError |
| 16 | + |
| 17 | +class GogsClient(GogsApi): |
| 18 | + def __init__(self): |
| 19 | + self.session = Session() |
| 20 | + |
| 21 | + def setup(self, *args, **kwarg): |
| 22 | + super().__init__(*args, session=self.session, **kwarg) |
| 23 | + |
| 24 | + def set_token(self, token): |
| 25 | + self.auth = Token(token) |
| 26 | + |
| 27 | + def set_default_private(self, p): |
| 28 | + self.default_private = p |
| 29 | + |
| 30 | + def setup_session(self, ssl_config, proxy=dict()): |
| 31 | + self.session.verify = ssl_config |
| 32 | + self.session.proxies.update(proxy) |
| 33 | + |
| 34 | + @property |
| 35 | + def username(self): |
| 36 | + if not hasattr(self, '_username'): |
| 37 | + self._username = self.authenticated_user(self.auth).username |
| 38 | + return self._username |
| 39 | + |
| 40 | + def orgs(self): |
| 41 | + orgs = self._check_ok(self._get('/user/orgs', auth=self.auth)).json() |
| 42 | + #return [gogs_client.GogsUser.from_json(org) for org in orgs] |
| 43 | + return [org['username'] for org in orgs] |
| 44 | + |
| 45 | + def create_repository(self, user, repo): |
| 46 | + if user == self.username: |
| 47 | + repository = self.create_repo(self.auth, name=repo, private=self.default_private) |
| 48 | + elif user in self.orgs(): |
| 49 | + data = dict(name=repo, private=self.default_private) |
| 50 | + response = self._post('/org/{}/repos'.format(user), auth=self.auth, data=data) |
| 51 | + repository = GogsRepo.from_json(self._check_ok(response).json()) |
| 52 | + else: |
| 53 | + data = dict(name=repo, private=self.default_private) |
| 54 | + response = self._post('/admin/users/{}/repos'.format(user), auth=self.auth, data=data) |
| 55 | + repository = GogsRepo.from_json(self._check_ok(response).json()) |
| 56 | + |
| 57 | + def delete_repository(self, user, repo): |
| 58 | + return self.delete_repo(self.auth, user, repo) |
| 59 | + |
| 60 | + def repository(self, user, repo): |
| 61 | + return self.get_repo(self.auth, user, repo) |
| 62 | + |
| 63 | + def repositories(self, user): |
| 64 | + r = self._get('/user/repos', auth=self.auth) |
| 65 | + repositories = self._check_ok(r).json() |
| 66 | + repositories = [repo for repo in repositories if repo['owner']['username'] == user] |
| 67 | + return repositories |
| 68 | + |
| 69 | +@register_target('gg', 'gogs') |
| 70 | +class GogsService(RepositoryService): |
| 71 | + fqdn = 'try.gogs.io' |
| 72 | + |
| 73 | + def __init__(self, *args, **kwargs): |
| 74 | + self.gg = GogsClient() |
| 75 | + |
| 76 | + super().__init__(*args, **kwargs) |
| 77 | + |
| 78 | + self.gg.setup(self.url_ro) |
| 79 | + self.gg.set_token(self._privatekey) |
| 80 | + self.gg.set_default_private(self.default_create_private) |
| 81 | + self.gg.setup_session( |
| 82 | + self.session_certificate or not self.session_insecure, |
| 83 | + self.session_proxy) |
| 84 | + |
| 85 | + def connect(self): |
| 86 | + try: |
| 87 | + self.username = self.user # Call to self.gg.authenticated_user() |
| 88 | + except HTTPError as err: |
| 89 | + if err.response is not None and err.response.status_code == 401: |
| 90 | + if not self._privatekey: |
| 91 | + raise ConnectionError('Could not connect to GoGS. ' |
| 92 | + 'Please configure .gitconfig ' |
| 93 | + 'with your gogs private key.') from err |
| 94 | + else: |
| 95 | + raise ConnectionError('Could not connect to GoGS. ' |
| 96 | + 'Check your configuration and try again.') from err |
| 97 | + else: |
| 98 | + raise err |
| 99 | + |
| 100 | + @classmethod |
| 101 | + def get_auth_token(cls, login, password, prompt=None): |
| 102 | + import platform |
| 103 | + name = 'git-repo token used on {}'.format(platform.node()) |
| 104 | + gg = GogsApi(cls.build_url()) |
| 105 | + auth = UsernamePassword(login, password) |
| 106 | + tokens = gg.get_tokens(auth, login) |
| 107 | + tokens = dict((token.name, token.token) for token in tokens) |
| 108 | + if name in tokens: |
| 109 | + return tokens[name] |
| 110 | + if 'git-repo token' in tokens: |
| 111 | + return tokens['git-repo token'] |
| 112 | + token = gg.create_token(auth, name, login) |
| 113 | + return token.token |
| 114 | + |
| 115 | + @property |
| 116 | + def user(self): |
| 117 | + return self.gg.username |
| 118 | + |
| 119 | + def create(self, user, repo, add=False): |
| 120 | + try: |
| 121 | + self.gg.create_repository(user, repo) |
| 122 | + except ApiFailure as err: |
| 123 | + if err.status_code == 422: |
| 124 | + raise ResourceExistsError("Project already exists.") from err |
| 125 | + else: |
| 126 | + raise ResourceError("Unhandled error.") from err |
| 127 | + except Exception as err: |
| 128 | + raise ResourceError("Unhandled exception: {}".format(err)) from err |
| 129 | + if add: |
| 130 | + self.add(user=self.username, repo=repo, tracking=self.name) |
| 131 | + |
| 132 | + def fork(self, user, repo): |
| 133 | + raise NotImplementedError |
| 134 | + |
| 135 | + def delete(self, repo, user=None): |
| 136 | + if not user: |
| 137 | + user = self.username |
| 138 | + try: |
| 139 | + self.gg.delete_repository(user, repo) |
| 140 | + except ApiFailure as err: |
| 141 | + if err.status_code == 404: |
| 142 | + raise ResourceNotFoundError("Cannot delete: repository {}/{} does not exists.".format(user, repo)) from err |
| 143 | + elif err.status_code == 403: |
| 144 | + raise ResourcePermissionError("You don't have enough permissions for deleting the repository. Check the namespace or the private token's privileges") from err |
| 145 | + elif err.status_code == 422: |
| 146 | + raise ResourceNotFoundError("Cannot delete repository {}/{}: user {} does not exists.".format(user, repo, user)) from err |
| 147 | + raise ResourceError("Unhandled error: {}".format(err)) from err |
| 148 | + except Exception as err: |
| 149 | + raise ResourceError("Unhandled exception: {}".format(err)) from err |
| 150 | + |
| 151 | + def list(self, user, _long=False): |
| 152 | + import shutil, sys |
| 153 | + from datetime import datetime |
| 154 | + term_width = shutil.get_terminal_size((80, 20)).columns |
| 155 | + def col_print(lines, indent=0, pad=2): |
| 156 | + # prints a list of items in a fashion similar to the dir command |
| 157 | + # borrowed from https://gist.github.com/critiqjo/2ca84db26daaeb1715e1 |
| 158 | + n_lines = len(lines) |
| 159 | + if n_lines == 0: |
| 160 | + return |
| 161 | + col_width = max(len(line) for line in lines) |
| 162 | + n_cols = int((term_width + pad - indent)/(col_width + pad)) |
| 163 | + n_cols = min(n_lines, max(1, n_cols)) |
| 164 | + col_len = int(n_lines/n_cols) + (0 if n_lines % n_cols == 0 else 1) |
| 165 | + if (n_cols - 1) * col_len >= n_lines: |
| 166 | + n_cols -= 1 |
| 167 | + cols = [lines[i*col_len : i*col_len + col_len] for i in range(n_cols)] |
| 168 | + rows = list(zip(*cols)) |
| 169 | + rows_missed = zip(*[col[len(rows):] for col in cols[:-1]]) |
| 170 | + rows.extend(rows_missed) |
| 171 | + for row in rows: |
| 172 | + print(" "*indent + (" "*pad).join(line.ljust(col_width) for line in row)) |
| 173 | + |
| 174 | + repositories = self.gg.repositories(user) |
| 175 | + if user != self.username and not repositories and user not in self.orgs: |
| 176 | + raise ResourceNotFoundError("Unable to list namespace {} - only authenticated user and orgs available for listing.".format(user)) |
| 177 | + if not _long: |
| 178 | + col_print([repo['full_name'] for repo in repositories]) |
| 179 | + else: |
| 180 | + print('Status\tCommits\tReqs\tIssues\tForks\tCoders\tWatch\tLikes\tLang\tModif\t\t\t\tName', file=sys.stderr) |
| 181 | + for repo in repositories: |
| 182 | + status = ''.join([ |
| 183 | + 'F' if repo['fork'] else ' ', # is a fork? |
| 184 | + 'P' if repo['private'] else ' ', # is private? |
| 185 | + ]) |
| 186 | + try: |
| 187 | + issues = self.gg._check_ok(self.gg._get('/repos/{}/issues'.format(repo['full_name']), auth=self.auth)).json() |
| 188 | + except Exception: |
| 189 | + issues = [] |
| 190 | + print('\t'.join([ |
| 191 | + # status |
| 192 | + status, |
| 193 | + # stats |
| 194 | + str(len(list(()))), # number of commits |
| 195 | + str(len(list(()))), # number of pulls |
| 196 | + str(len(list(issues))), # number of issues |
| 197 | + str(repo.get('forks_count') or 0), # number of forks |
| 198 | + str(len(list(()))), # number of contributors |
| 199 | + str(repo.get('watchers_count') or 0), # number of subscribers |
| 200 | + str(repo.get('stars_count') or 0), # number of ♥ |
| 201 | + # info |
| 202 | + repo.get('language') or '?', # language |
| 203 | + repo['updated_at'], # date |
| 204 | + repo['full_name'], # name |
| 205 | + ])) |
| 206 | + |
| 207 | + def get_repository(self, user, repo): |
| 208 | + try: |
| 209 | + return self.gg.repository(user, repo) |
| 210 | + except ApiFailure as err: |
| 211 | + if err.status_code == 404: |
| 212 | + raise ResourceNotFoundError("Cannot get: repository {}/{} does not exists.".format(user, repo)) from err |
| 213 | + raise ResourceError("Unhandled error: {}".format(err)) from err |
| 214 | + except Exception as err: |
| 215 | + raise ResourceError("Unhandled exception: {}".format(err)) from err |
| 216 | + |
| 217 | + def gist_list(self, gist=None): |
| 218 | + raise NotImplementedError |
| 219 | + |
| 220 | + def gist_fetch(self, gist, fname=None): |
| 221 | + raise NotImplementedError |
| 222 | + |
| 223 | + def gist_clone(self, gist): |
| 224 | + raise NotImplementedError |
| 225 | + |
| 226 | + def gist_create(self, gist_pathes, description, secret=False): |
| 227 | + raise NotImplementedError |
| 228 | + |
| 229 | + def gist_delete(self, gist_id): |
| 230 | + raise NotImplementedError |
| 231 | + |
| 232 | + def request_create(self, user, repo, local_branch, remote_branch, title, description=None): |
| 233 | + raise NotImplementedError |
| 234 | + |
| 235 | + def request_list(self, user, repo): |
| 236 | + raise NotImplementedError |
| 237 | + |
| 238 | + def request_fetch(self, user, repo, request, pull=False): |
| 239 | + raise NotImplementedError |
0 commit comments