Add support to migrate from gogs

go.mod

@@ -46,6 +46,7 @@ require (
 	github.com/gobwas/glob v0.2.3
 	github.com/gogs/chardet v0.0.0-20191104214054-4b6791f73a28
 	github.com/gogs/cron v0.0.0-20171120032916-9f6c956d3e14
+	github.com/gogs/go-gogs-client v0.0.0-20200905025246-8bb8a50cb355
 	github.com/google/go-github/v32 v32.1.0
 	github.com/google/uuid v1.1.2
 	github.com/gorilla/context v1.1.1

modules/migrations/base/milestone.go

@@ -15,5 +15,5 @@ type Milestone struct {
 	Created     time.Time
 	Updated     *time.Time
 	Closed      *time.Time
-	State       string
+	State       string // open, closed
 }

modules/migrations/error.go

@@ -19,6 +19,11 @@ var (
 	ErrRepoNotCreated = errors.New("repository is not created yet")
 )
 
+// IsErrNotSupported returns true if the err is ErrNotSupported
+func IsErrNotSupported(err error) bool {
+	return err == ErrNotSupported
+}
+
 // IsRateLimitError returns true if the err is github.RateLimitError
 func IsRateLimitError(err error) bool {
 	_, ok := err.(*github.RateLimitError)

modules/migrations/gitea_uploader.go

@@ -87,19 +87,22 @@ func (g *GiteaLocalUploader) MaxBatchInsertSize(tp string) int {
 }
 
 func fullURL(opts base.MigrateOptions, remoteAddr string) (string, error) {
-	var fullRemoteAddr = remoteAddr
 	if len(opts.AuthToken) > 0 || len(opts.AuthUsername) > 0 {
 		u, err := url.Parse(remoteAddr)
 		if err != nil {
 			return "", err
 		}
 		u.User = url.UserPassword(opts.AuthUsername, opts.AuthPassword)
 		if len(opts.AuthToken) > 0 {
-			u.User = url.UserPassword("oauth2", opts.AuthToken)
+			if opts.GitServiceType == structs.GogsService {
+				u.User = url.UserPassword(opts.AuthToken, "")
+			} else {
+				u.User = url.UserPassword("oauth2", opts.AuthToken)
+			}
 		}
-		fullRemoteAddr = u.String()
+		return u.String(), nil
 	}
-	return fullRemoteAddr, nil
+	return remoteAddr, nil
 }
 
 // CreateRepo creates a repository

modules/migrations/gogs.go

@@ -0,0 +1,263 @@
+// Copyright 2019 The Gitea Authors. All rights reserved.
+// Use of this source code is governed by a MIT-style
+// license that can be found in the LICENSE file.
+
+package migrations
+
+import (
+	"context"
+	"fmt"
+	"net/http"
+	"net/url"
+	"strings"
+	"time"
+
+	"code.gitea.io/gitea/modules/log"
+	"code.gitea.io/gitea/modules/migrations/base"
+	"code.gitea.io/gitea/modules/structs"
+
+	"github.com/gogs/go-gogs-client"
+)
+
+var (
+	_ base.Downloader        = &GogsDownloader{}
+	_ base.DownloaderFactory = &GogsDownloaderFactory{}
+)
+
+func init() {
+	RegisterDownloaderFactory(&GogsDownloaderFactory{})
+}
+
+// GogsDownloaderFactory defines a gogs downloader factory
+type GogsDownloaderFactory struct {
+}
+
+// New returns a Downloader related to this factory according MigrateOptions
+func (f *GogsDownloaderFactory) New(ctx context.Context, opts base.MigrateOptions) (base.Downloader, error) {
+	u, err := url.Parse(opts.CloneAddr)
+	if err != nil {
+		return nil, err
+	}
+
+	baseURL := u.Scheme + "://" + u.Host
+	fields := strings.Split(u.Path, "/")
+	oldOwner := fields[1]
+	oldName := strings.TrimSuffix(fields[2], ".git")
+
+	log.Trace("Create gogs downloader: %s/%s", oldOwner, oldName)
+
+	return NewGogsDownloader(ctx, baseURL, opts.AuthUsername, opts.AuthPassword, opts.AuthToken, oldOwner, oldName), nil
+}
+
+// GitServiceType returns the type of git service
+func (f *GogsDownloaderFactory) GitServiceType() structs.GitServiceType {
+	return structs.GogsService
+}
+
+// GogsDownloader implements a Downloader interface to get repository informations
+// from gogs via API
+type GogsDownloader struct {
+	ctx       context.Context
+	client    *gogs.Client
+	baseURL   string
+	repoOwner string
+	repoName  string
+	userName  string
+	password  string
+}
+
+func (g *GogsDownloader) SetContext(ctx context.Context) {
+	g.ctx = ctx
+}
+
+// NewGogsDownloader creates a gogs Downloader via gogs API
+func NewGogsDownloader(ctx context.Context, baseURL, userName, password, token, repoOwner, repoName string) *GogsDownloader {
+	var downloader = GogsDownloader{
+		ctx:       ctx,
+		baseURL:   baseURL,
+		userName:  userName,
+		password:  password,
+		repoOwner: repoOwner,
+		repoName:  repoName,
+	}
+
+	var client *gogs.Client
+	if len(token) != 0 {
+		client = gogs.NewClient(baseURL, token)
+		downloader.userName = token
+	} else {
+		client = gogs.NewClient(baseURL, "")
+		client.SetHTTPClient(&http.Client{
+			Transport: &http.Transport{
+				Proxy: func(req *http.Request) (*url.URL, error) {
+					req.SetBasicAuth(userName, password)
+					return nil, nil
+				},
+			},
+		})
+	}
+
+	downloader.client = client
+	return &downloader
+}
+
+// GetRepoInfo returns a repository information
+func (g *GogsDownloader) GetRepoInfo() (*base.Repository, error) {
+	gr, err := g.client.GetRepo(g.repoOwner, g.repoName)
+	if err != nil {
+		return nil, err
+	}
+
+	// convert gogs repo to stand Repo
+	return &base.Repository{
+		Owner:         g.repoOwner,
+		Name:          g.repoName,
+		IsPrivate:     gr.Private,
+		Description:   gr.Description,
+		CloneURL:      gr.CloneURL,
+		OriginalURL:   gr.HTMLURL,
+		DefaultBranch: gr.DefaultBranch,
+	}, nil
+}
+
+// GetMilestones returns milestones
+func (g *GogsDownloader) GetMilestones() ([]*base.Milestone, error) {
+	var perPage = 100
+	var milestones = make([]*base.Milestone, 0, perPage)
+
+	ms, err := g.client.ListRepoMilestones(g.repoOwner, g.repoName)
+	if err != nil {
+		return nil, err
+	}
+
+	t := time.Now()
+
+	for _, m := range ms {
+		milestones = append(milestones, &base.Milestone{
+			Title:       m.Title,
+			Description: m.Description,
+			Deadline:    m.Deadline,
+			State:       string(m.State),
+			Created:     t,
+			Updated:     &t,
+			Closed:      m.Closed,
+		})
+	}
+
+	return milestones, nil
+}
+
+// GetLabels returns labels
+func (g *GogsDownloader) GetLabels() ([]*base.Label, error) {
+	var perPage = 100
+	var labels = make([]*base.Label, 0, perPage)
+	ls, err := g.client.ListRepoLabels(g.repoOwner, g.repoName)
+	if err != nil {
+		return nil, err
+	}
+
+	for _, label := range ls {
+		labels = append(labels, convertGogsLabel(label))
+	}
+
+	return labels, nil
+}
+
+// GetIssues returns issues according start and limit, perPage is not supported
+func (g *GogsDownloader) GetIssues(page, perPage int) ([]*base.Issue, bool, error) {
+	var allIssues = make([]*base.Issue, 0, perPage)
+
+	issues, err := g.client.ListRepoIssues(g.repoOwner, g.repoName, gogs.ListIssueOption{
+		Page: page,
+	})
+	if err != nil {
+		return nil, false, fmt.Errorf("error while listing repos: %v", err)
+	}
+	for _, issue := range issues {
+		if issue.PullRequest != nil {
+			continue
+		}
+
+		allIssues = append(allIssues, convertGogsIssue(issue))
+	}
+
+	return allIssues, len(issues) == 0, nil
+}
+
+// GetComments returns comments according issueNumber
+func (g *GogsDownloader) GetComments(issueNumber int64) ([]*base.Comment, error) {
+	var allComments = make([]*base.Comment, 0, 100)
+
+	comments, err := g.client.ListIssueComments(g.repoOwner, g.repoName, issueNumber)
+	if err != nil {
+		return nil, fmt.Errorf("error while listing repos: %v", err)
+	}
+	for _, comment := range comments {
+		allComments = append(allComments, &base.Comment{
+			PosterName:  comment.Poster.Login,
+			PosterEmail: comment.Poster.Email,
+			Content:     comment.Body,
+			Created:     comment.Created,
+			Updated:     comment.Updated,
+		})
+	}
+
+	return allComments, nil
+}
+
+func convertGogsIssue(issue *gogs.Issue) *base.Issue {
+	var milestone string
+	if issue.Milestone != nil {
+		milestone = issue.Milestone.Title
+	}
+	var labels = make([]*base.Label, 0, len(issue.Labels))
+	for _, l := range issue.Labels {
+		labels = append(labels, convertGogsLabel(l))
+	}
+
+	var closed *time.Time
+	if issue.State == gogs.STATE_CLOSED {
+		// gogs client haven't provide closed, so we use updated instead
+		closed = &issue.Updated
+	}
+
+	return &base.Issue{
+		Title:       issue.Title,
+		Number:      issue.Index,
+		PosterName:  issue.Poster.Login,
+		PosterEmail: issue.Poster.Email,
+		Content:     issue.Body,
+		Milestone:   milestone,
+		State:       string(issue.State),
+		Created:     issue.Created,
+		Labels:      labels,
+		Closed:      closed,
+	}
+}
+
+func convertGogsLabel(label *gogs.Label) *base.Label {
+	return &base.Label{
+		Name:  label.Name,
+		Color: label.Color,
+	}
+}
+
+// GetReleases returns releases
+// FIXME: gogs API haven't support get releases
+func (g *GogsDownloader) GetReleases() ([]*base.Release, error) {
+	return nil, ErrNotSupported
+}
+
+// GetTopics return gogs topics
+func (g *GogsDownloader) GetTopics() ([]string, error) {
+	return nil, ErrNotSupported
+}
+
+// GetPullRequests returns pull requests according page and perPage
+func (g *GogsDownloader) GetPullRequests(_, _ int) ([]*base.PullRequest, bool, error) {
+	return nil, false, ErrNotSupported
+}
+
+func (g *GogsDownloader) GetReviews(_ int64) ([]*base.Review, error) {
+	return nil, ErrNotSupported
+}