Skip to content
Snippets Groups Projects
Select Git revision
  • 53ce3cf4d6bc2995aa2f95fdeb473873f09f5e69
  • main default protected
  • next
  • chore/update-static-data
  • renovate/main-redis-5.x
  • feat/gnupg
  • fix/36615b-branch-reuse-no-cache
  • chore/punycode
  • refactor/pin-new-value
  • feat/36219--git-x509-signing
  • feat/structured-logger
  • hotfix/39.264.1
  • feat/skip-dangling
  • gh-readonly-queue/next/pr-36034-7a061c4ca1024a19e2c295d773d9642625d1c2be
  • hotfix/39.238.3
  • refactor/gitlab-auto-approve
  • feat/template-strings
  • gh-readonly-queue/next/pr-35654-137d934242c784e0c45d4b957362214f0eade1d7
  • fix/32307-global-extends-merging
  • fix/32307-global-extends-repositories
  • gh-readonly-queue/next/pr-35009-046ebf7cb84ab859f7fefceb5fa53a54ce9736f8
  • 41.55.3
  • 41.55.2
  • 41.55.1
  • 41.55.0
  • 41.54.0
  • 41.53.1
  • 41.53.0
  • 41.52.3
  • 41.52.2
  • 41.52.1
  • 41.52.0
  • 41.51.2
  • 41.51.1
  • 41.51.0
  • 41.50.0
  • 41.49.1
  • 41.49.0
  • 41.48.1
  • 41.48.0
  • 41.47.1
41 results

error.spec.ts

Blame
  • gitlab.go 3.78 KiB
    package provider
    
    import (
    	"errors"
    	"fmt"
    	"os"
    	"regexp"
    
    	"github.com/Masterminds/semver/v3"
    	"github.com/go-semantic-release/semantic-release/v2/pkg/provider"
    	"github.com/go-semantic-release/semantic-release/v2/pkg/semrel"
    	"github.com/xanzy/go-gitlab"
    )
    
    var PVERSION = "dev"
    
    type GitLabRepository struct {
    	projectID string
    	branch    string
    	client    *gitlab.Client
    }
    
    func (repo *GitLabRepository) Init(config map[string]string) error {
    	gitlabBaseUrl := config["gitlab_baseurl"]
    	if gitlabBaseUrl == "" {
    		gitlabBaseUrl = os.Getenv("CI_SERVER_URL")
    	}
    
    	token := config["token"]
    	if token == "" {
    		token = os.Getenv("GITLAB_TOKEN")
    	}
    	if token == "" {
    		return errors.New("gitlab token missing")
    	}
    
    	branch := config["gitlab_branch"]
    	if branch == "" {
    		branch = os.Getenv("CI_COMMIT_BRANCH")
    	}
    
    	projectID := config["gitlab_projectid"]
    	if projectID == "" {
    		projectID = os.Getenv("CI_PROJECT_ID")
    	}
    	if projectID == "" {
    		return fmt.Errorf("gitlab_projectid is required")
    	}
    
    	repo.projectID = projectID
    	repo.branch = branch
    
    	var (
    		client *gitlab.Client
    		err    error
    	)
    
    	if gitlabBaseUrl != "" {
    		client, err = gitlab.NewClient(token, gitlab.WithBaseURL(gitlabBaseUrl))
    	} else {
    		client, err = gitlab.NewClient(token)
    	}
    
    	if err != nil {
    		return fmt.Errorf("failed to create client: %w", err)
    	}
    
    	repo.client = client
    	return nil
    }
    
    func (repo *GitLabRepository) GetInfo() (*provider.RepositoryInfo, error) {
    	project, _, err := repo.client.Projects.GetProject(repo.projectID, nil)
    
    	if err != nil {
    		return nil, err
    	}
    	return &provider.RepositoryInfo{
    		Owner:         "",
    		Repo:          "",
    		DefaultBranch: project.DefaultBranch,
    		Private:       project.Visibility == gitlab.PrivateVisibility,
    	}, nil
    }
    
    func (repo *GitLabRepository) GetCommits(sha string) ([]*semrel.RawCommit, error) {
    	opts := &gitlab.ListCommitsOptions{
    		ListOptions: gitlab.ListOptions{
    			Page:    1,
    			PerPage: 100,
    		},
    		RefName: gitlab.String(fmt.Sprintf("%s...%s", repo.branch, sha)),
    		All:     gitlab.Bool(true),
    	}
    
    	allCommits := make([]*semrel.RawCommit, 0)
    
    	for {
    		commits, resp, err := repo.client.Commits.ListCommits(repo.projectID, opts)
    
    		if err != nil {
    			return nil, err
    		}
    
    		for _, commit := range commits {
    			allCommits = append(allCommits, &semrel.RawCommit{
    				SHA:        commit.ID,
    				RawMessage: commit.Message,
    			})
    		}
    
    		if resp.CurrentPage >= resp.TotalPages {
    			break
    		}
    
    		opts.Page = resp.NextPage
    	}
    
    	return allCommits, nil
    }
    
    func (repo *GitLabRepository) GetReleases(rawRe string) ([]*semrel.Release, error) {
    	re := regexp.MustCompile(rawRe)
    	allReleases := make([]*semrel.Release, 0)
    
    	opts := &gitlab.ListTagsOptions{
    		ListOptions: gitlab.ListOptions{
    			Page:    1,
    			PerPage: 100,
    		},
    	}
    
    	for {
    		tags, resp, err := repo.client.Tags.ListTags(repo.projectID, opts)
    		if err != nil {
    			return nil, err
    		}
    
    		for _, tag := range tags {
    			if rawRe != "" && !re.MatchString(tag.Name) {
    				continue
    			}
    
    			version, err := semver.NewVersion(tag.Name)
    			if err != nil {
    				continue
    			}
    
    			allReleases = append(allReleases, &semrel.Release{
    				SHA:     tag.Commit.ID,
    				Version: version.String(),
    			})
    		}
    
    		if resp.CurrentPage >= resp.TotalPages {
    			break
    		}
    
    		opts.Page = resp.NextPage
    	}
    
    	return allReleases, nil
    }
    
    func (repo *GitLabRepository) CreateRelease(release *provider.CreateReleaseConfig) error {
    	tag := fmt.Sprintf("v%s", release.NewVersion)
    
    	// Gitlab does not have any notion of pre-releases
    	_, _, err := repo.client.Releases.CreateRelease(repo.projectID, &gitlab.CreateReleaseOptions{
    		TagName: &tag,
    		Ref:     &release.SHA,
    		// TODO: this may been to be wrapped in ```
    		Description: &release.Changelog,
    	})
    
    	return err
    }
    
    func (repo *GitLabRepository) Name() string {
    	return "GitLab"
    }
    
    func (repo *GitLabRepository) Version() string {
    	return PVERSION
    }