/brz/remove-bazaar

To get this branch, use:
bzr branch http://gegoxaren.bato24.eu/bzr/brz/remove-bazaar

« back to all changes in this revision

Viewing changes to breezy/plugins/propose/gitlabs.py

  • Committer: Jelmer Vernooij
  • Date: 2020-03-22 20:02:36 UTC
  • mto: (7490.7.7 work)
  • mto: This revision was merged to the branch mainline in revision 7501.
  • Revision ID: jelmer@jelmer.uk-20200322200236-fsbl91ktcn6fcbdd
Fix tests.

Show diffs side-by-side

added added

removed removed

Lines of Context:
breezy/plugins/propose/gitlabs.py
16
16
 
17
17
"""Support for GitLab."""
18
18
 
 
19
from __future__ import absolute_import
 
20
 
19
21
import json
20
22
import os
21
23
import time
28
30
    urlutils,
29
31
    )
30
32
from ...git.urls import git_url_to_bzr_url
 
33
from ...sixish import PY3
31
34
from ...trace import mutter
32
35
from ...transport import get_transport
33
36
 
97
100
        self.error = error
98
101
 
99
102
 
100
 
class GitLabConflict(errors.BzrError):
101
 
 
102
 
    _fmt = "Conflict during operation: %(reason)s"
103
 
 
104
 
    def __init__(self, reason):
105
 
        errors.BzrError(self, reason=reason)
106
 
 
107
 
 
108
 
class ForkingDisabled(errors.BzrError):
109
 
 
110
 
    _fmt = ("Forking on project %(project)s is disabled.")
111
 
 
112
 
    def __init__(self, project):
113
 
        self.project = project
114
 
 
115
 
 
116
103
class MergeRequestExists(Exception):
117
104
    """Raised when a merge requests already exists."""
118
105
 
182
169
        raise NotGitLabUrl(url)
183
170
    path = path.strip('/')
184
171
    parts = path.split('/')
185
 
    if len(parts) < 2:
186
 
        raise NotMergeRequestUrl(host, url)
187
172
    if parts[-2] != 'merge_requests':
188
173
        raise NotMergeRequestUrl(host, url)
189
 
    if parts[-3] == '-':
190
 
        project_name = '/'.join(parts[:-3])
191
 
    else:
192
 
        project_name = '/'.join(parts[:-2])
193
 
    return host, project_name, int(parts[-1])
 
174
    return host, '/'.join(parts[:-2]), int(parts[-1])
194
175
 
195
176
 
196
177
class GitLabMergeProposal(MergeProposal):
231
212
        return self._branch_url_from_project(
232
213
            self._mr['source_project_id'], self._mr['source_branch'])
233
214
 
234
 
    def get_source_revision(self):
235
 
        from breezy.git.mapping import default_mapping
236
 
        sha = self._mr['sha']
237
 
        if sha is None:
238
 
            return None
239
 
        return default_mapping.revision_id_foreign_to_bzr(sha.encode('ascii'))
240
 
 
241
215
    def get_target_branch_url(self):
242
216
        return self._branch_url_from_project(
243
217
            self._mr['target_project_id'], self._mr['target_branch'])
273
247
            return False
274
248
        elif self._mr['merge_status'] == 'can_be_merged':
275
249
            return True
276
 
        elif self._mr['merge_status'] in (
277
 
                'unchecked', 'cannot_be_merged_recheck'):
278
 
            # See https://gitlab.com/gitlab-org/gitlab/-/commit/7517105303c for
279
 
            # an explanation of the distinction between unchecked and
280
 
            # cannot_be_merged_recheck
281
 
            return None
282
250
        else:
283
251
            raise ValueError(self._mr['merge_status'])
284
252
 
295
263
        import iso8601
296
264
        return iso8601.parse_date(merged_at)
297
265
 
298
 
    def post_comment(self, body):
299
 
        kwargs = {'body': body}
300
 
        self.gl._post_merge_request_note(
301
 
            self._mr['project_id'], self._mr['iid'], kwargs)
302
 
 
303
266
 
304
267
def gitlab_url_to_bzr_url(url, name):
 
268
    if not PY3:
 
269
        name = name.encode('utf-8')
305
270
    return git_url_to_bzr_url(url, branch=name)
306
271
 
307
272
 
320
285
    def base_url(self):
321
286
        return self.transport.base
322
287
 
323
 
    @property
324
 
    def base_hostname(self):
325
 
        return urlutils.parse_url(self.base_url)[3]
326
 
 
327
288
    def _api_request(self, method, path, fields=None, body=None):
328
289
        return self.transport.request(
329
290
            method, urlutils.join(self.base_url, 'api', 'v4', path),
341
302
            raise KeyError('no such user %s' % username)
342
303
        if response.status == 200:
343
304
            return json.loads(response.data)
344
 
        raise errors.UnexpectedHttpStatus(path, response.status)
 
305
        raise errors.InvalidHttpResponse(path, response.text)
345
306
 
346
307
    def _get_user_by_email(self, email):
347
308
        path = 'users?search=%s' % urlutils.quote(str(email), '')
353
314
            if len(ret) != 1:
354
315
                raise ValueError('unexpected number of results; %r' % ret)
355
316
            return ret[0]
356
 
        raise errors.UnexpectedHttpStatus(path, response.status)
 
317
        raise errors.InvalidHttpResponse(path, response.text)
357
318
 
358
319
    def _get_project(self, project_name):
359
320
        path = 'projects/%s' % urlutils.quote(str(project_name), '')
362
323
            raise NoSuchProject(project_name)
363
324
        if response.status == 200:
364
325
            return json.loads(response.data)
365
 
        raise errors.UnexpectedHttpStatus(path, response.status)
 
326
        raise errors.InvalidHttpResponse(path, response.text)
366
327
 
367
 
    def _fork_project(self, project_name, timeout=50, interval=5, owner=None):
 
328
    def _fork_project(self, project_name, timeout=50, interval=5):
368
329
        path = 'projects/%s/fork' % urlutils.quote(str(project_name), '')
369
 
        fields = {}
370
 
        if owner is not None:
371
 
            fields['namespace'] = owner
372
 
        response = self._api_request('POST', path, fields=fields)
373
 
        if response.status == 404:
374
 
            raise ForkingDisabled(project_name)
375
 
        if response.status == 409:
376
 
            resp = json.loads(response.data)
377
 
            raise GitLabConflict(resp.get('message'))
 
330
        response = self._api_request('POST', path)
378
331
        if response.status not in (200, 201):
379
 
            raise errors.UnexpectedHttpStatus(path, response.status)
 
332
            raise errors.InvalidHttpResponse(path, response.text)
380
333
        # The response should be valid JSON, but let's ignore it
381
334
        project = json.loads(response.data)
382
335
        # Spin and wait until import_status for new project
390
343
            project = self._get_project(project['path_with_namespace'])
391
344
        return project
392
345
 
393
 
    def get_current_user(self):
 
346
    def _get_logged_in_username(self):
394
347
        return self._current_user['username']
395
348
 
396
 
    def get_user_url(self, username):
397
 
        return urlutils.join(self.base_url, username)
398
 
 
399
349
    def _list_paged(self, path, parameters=None, per_page=None):
400
350
        if parameters is None:
401
351
            parameters = {}
412
362
            if response.status == 403:
413
363
                raise errors.PermissionDenied(response.text)
414
364
            if response.status != 200:
415
 
                raise errors.UnexpectedHttpStatus(path, response.status)
 
365
                raise errors.InvalidHttpResponse(path, response.text)
416
366
            page = response.getheader("X-Next-Page")
417
367
            for entry in json.loads(response.data):
418
368
                yield entry
429
379
            parameters['owner_id'] = urlutils.quote(owner, '')
430
380
        return self._list_paged(path, parameters, per_page=DEFAULT_PAGE_SIZE)
431
381
 
432
 
    def _get_merge_request(self, project, merge_id):
433
 
        path = 'projects/%s/merge_requests/%d' % (urlutils.quote(str(project), ''), merge_id)
434
 
        response = self._api_request('GET', path)
435
 
        if response.status == 403:
436
 
            raise errors.PermissionDenied(response.text)
437
 
        if response.status != 200:
438
 
            raise errors.UnexpectedHttpStatus(path, response.status)
439
 
        return json.loads(response.data)
440
 
 
441
382
    def _list_projects(self, owner):
442
383
        path = 'users/%s/projects' % urlutils.quote(str(owner), '')
443
384
        parameters = {}
449
390
        response = self._api_request('PUT', path, fields=mr)
450
391
        if response.status == 200:
451
392
            return json.loads(response.data)
452
 
        raise errors.UnexpectedHttpStatus(path, response.status)
453
 
 
454
 
    def _post_merge_request_note(self, project_id, iid, kwargs):
455
 
        path = 'projects/%s/merge_requests/%s/notes' % (
456
 
            urlutils.quote(str(project_id), ''), iid)
457
 
        response = self._api_request('POST', path, fields=kwargs)
458
 
        if response.status == 201:
459
 
            json.loads(response.data)
460
 
            return
461
 
        raise errors.UnexpectedHttpStatus(path, response.status)
 
393
        raise errors.InvalidHttpResponse(path, response.text)
462
394
 
463
395
    def _create_mergerequest(
464
396
            self, title, source_project_id, target_project_id,
465
397
            source_branch_name, target_branch_name, description,
466
 
            labels=None, allow_collaboration=False):
 
398
            labels=None):
467
399
        path = 'projects/%s/merge_requests' % source_project_id
468
400
        fields = {
469
401
            'title': title,
471
403
            'target_branch': target_branch_name,
472
404
            'target_project_id': target_project_id,
473
405
            'description': description,
474
 
            'allow_collaboration': allow_collaboration,
475
406
            }
476
407
        if labels:
477
408
            fields['labels'] = labels
481
412
        if response.status == 409:
482
413
            raise MergeRequestExists()
483
414
        if response.status != 201:
484
 
            raise errors.UnexpectedHttpStatus(path, response.status)
 
415
            raise errors.InvalidHttpResponse(path, response.text)
485
416
        return json.loads(response.data)
486
417
 
487
418
    def get_push_url(self, branch):
495
426
                        allow_lossy=True, tag_selector=None):
496
427
        (host, base_project, base_branch_name) = parse_gitlab_branch_url(base_branch)
497
428
        if owner is None:
498
 
            owner = self.get_current_user()
 
429
            owner = self._get_logged_in_username()
499
430
        if project is None:
500
431
            project = self._get_project(base_project)['path']
501
432
        try:
502
433
            target_project = self._get_project('%s/%s' % (owner, project))
503
434
        except NoSuchProject:
504
 
            target_project = self._fork_project(base_project, owner=owner)
 
435
            target_project = self._fork_project(base_project)
505
436
        remote_repo_url = git_url_to_bzr_url(target_project['ssh_url_to_repo'])
506
437
        remote_dir = controldir.ControlDir.open(remote_repo_url)
507
438
        try:
521
452
    def get_derived_branch(self, base_branch, name, project=None, owner=None):
522
453
        (host, base_project, base_branch_name) = parse_gitlab_branch_url(base_branch)
523
454
        if owner is None:
524
 
            owner = self.get_current_user()
 
455
            owner = self._get_logged_in_username()
525
456
        if project is None:
526
457
            project = self._get_project(base_project)['path']
527
458
        try:
558
489
            (host, project, branch_name) = parse_gitlab_branch_url(branch)
559
490
        except NotGitLabUrl:
560
491
            return False
561
 
        return self.base_hostname == host
 
492
        return (self.base_url == ('https://%s' % host))
562
493
 
563
494
    def check(self):
564
495
        response = self._api_request('GET', 'user')
570
501
                raise GitLabLoginMissing()
571
502
            else:
572
503
                raise GitlabLoginError(response.text)
573
 
        raise UnsupportedHoster(self.base_url)
 
504
        raise UnsupportedHoster(url)
574
505
 
575
506
    @classmethod
576
507
    def probe_from_url(cls, url, possible_transports=None):
597
528
    def iter_my_proposals(self, status='open'):
598
529
        state = mp_status_to_status(status)
599
530
        for mp in self._list_merge_requests(
600
 
                owner=self.get_current_user(), state=state):
 
531
                owner=self._get_logged_in_username(), state=state):
601
532
            yield GitLabMergeProposal(self, mp)
602
533
 
603
534
    def iter_my_forks(self):
604
 
        for project in self._list_projects(owner=self.get_current_user()):
 
535
        for project in self._list_projects(owner=self._get_logged_in_username()):
605
536
            base_project = project.get('forked_from_project')
606
537
            if not base_project:
607
538
                continue
613
544
        except NotGitLabUrl:
614
545
            raise UnsupportedHoster(url)
615
546
        except NotMergeRequestUrl as e:
616
 
            if self.base_hostname == e.host:
 
547
            if self.base_url == ('https://%s' % e.host):
617
548
                raise
618
549
            else:
619
550
                raise UnsupportedHoster(url)
620
 
        if self.base_hostname != host:
 
551
        if self.base_url != ('https://%s' % host):
621
552
            raise UnsupportedHoster(url)
622
553
        project = self._get_project(project)
623
 
        mr = self._get_merge_request(project['path_with_namespace'], merge_id)
624
 
        return GitLabMergeProposal(self, mr)
 
554
        mr = project.mergerequests.get(merge_id)
 
555
        return GitLabMergeProposal(mr)
625
556
 
626
557
    def delete_project(self, project):
627
558
        path = 'projects/%s' % urlutils.quote(str(project), '')
629
560
        if response.status == 404:
630
561
            raise NoSuchProject(project)
631
562
        if response.status != 202:
632
 
            raise errors.UnexpectedHttpStatus(path, response.status)
 
563
            raise errors.InvalidHttpResponse(path, response.text)
633
564
 
634
565
 
635
566
class GitlabMergeProposalBuilder(MergeProposalBuilder):
697
628
        try:
698
629
            merge_request = self.gl._create_mergerequest(**kwargs)
699
630
        except MergeRequestExists:
700
 
            raise MergeProposalExists(self.source_branch.user_url)
 
631
            raise ProposalExists(self.source_branch.user_url)
701
632
        return GitLabMergeProposal(self.gl, merge_request)
702
633
 
703
634