mirror of
https://gitea.com/gitea/tea.git
synced 2026-10-26 11:01:25 +01:00
210 lines
9.4 KiB
Go
210 lines
9.4 KiB
Go
// Copyright 2026 The Gitea Authors. All rights reserved.
|
|
// SPDX-License-Identifier: MIT
|
|
|
|
package app
|
|
|
|
import (
|
|
"cmp"
|
|
"errors"
|
|
"fmt"
|
|
"net/url"
|
|
"path"
|
|
"strings"
|
|
"time"
|
|
|
|
"gitea.dev/tea/internal/clierr"
|
|
"gitea.dev/tea/internal/services"
|
|
"gitea.dev/tea/internal/terminal"
|
|
"github.com/spf13/cobra"
|
|
)
|
|
|
|
func validateMigrationURL(raw string) error {
|
|
parsed, err := url.Parse(raw)
|
|
if err != nil || parsed.Hostname() == "" || parsed.User != nil || parsed.Fragment != "" || (parsed.Scheme != "http" && parsed.Scheme != "https" && parsed.Scheme != "git") {
|
|
return clierr.Wrap(clierr.Usage, errors.New("clone URL must be an HTTP(S) or git URL without embedded credentials; server filesystem paths are not supported"))
|
|
}
|
|
return nil
|
|
}
|
|
|
|
// migrationName derives a repository name from the last segment of a clone URL or server path.
|
|
func migrationName(source string) string {
|
|
if parsed, err := url.Parse(source); err == nil && parsed.Path != "" {
|
|
source = parsed.Path
|
|
}
|
|
name := strings.TrimSuffix(path.Base(strings.TrimRight(source, "/")), ".git")
|
|
if validateRepositoryName(name) != nil {
|
|
return ""
|
|
}
|
|
return name
|
|
}
|
|
|
|
func (a *application) repoMigrateCommand() *cobra.Command {
|
|
var opts services.RepositoryMigrationOptions
|
|
var passwordFile, tokenFile, serverPath string
|
|
command := &cobra.Command{
|
|
Use: "migrate [<clone-url>]",
|
|
Short: "Import a repository from another server",
|
|
Long: `Import a repository from a Git URL, or from another forge with --service (which needs an access
|
|
token and can also copy issues, pull requests, releases and more). --mirror creates a pull mirror
|
|
instead. The name defaults to the last segment of the URL.`,
|
|
Example: `# Import a public Git repository
|
|
$ tea repo migrate https://github.com/go-gitea/tea.git
|
|
|
|
# Mirror a repository into an organization every 8 hours
|
|
$ tea repo migrate https://github.com/go-gitea/tea.git --owner acme --mirror --mirror-interval 8h
|
|
|
|
# Import a GitHub repository with its issues and pull requests
|
|
$ tea repo migrate https://github.com/acme/tool --service github --issues --pull-requests --auth-token-file token.txt`,
|
|
Args: usageArgs(cobra.MaximumNArgs(1)),
|
|
RunE: func(cmd *cobra.Command, args []string) error {
|
|
if err := a.rejectRepoFlag(cmd, func(owner string) string { return "tea repo migrate URL --owner " + owner }); err != nil {
|
|
return err
|
|
}
|
|
if len(args) > 0 {
|
|
if cmd.Flags().Changed("clone-url") {
|
|
return clierr.Wrap(clierr.Usage, errors.New("supply clone URL as an argument or --clone-url, not both"))
|
|
}
|
|
opts.CloneURL = args[0]
|
|
}
|
|
if cmd.Flags().Changed("server-path") {
|
|
if cmd.Flags().Changed("clone-url") || len(args) > 0 {
|
|
return clierr.Wrap(clierr.Usage, errors.New("--server-path and clone URL inputs are mutually exclusive"))
|
|
}
|
|
if !path.IsAbs(serverPath) {
|
|
return clierr.Wrap(clierr.Usage, errors.New("--server-path must be an absolute path on the Gitea server"))
|
|
}
|
|
opts.CloneURL = serverPath
|
|
}
|
|
if err := validateMigrationFlags(cmd, opts, passwordFile, tokenFile); err != nil {
|
|
return err
|
|
}
|
|
validURL := validateMigrationURL
|
|
if cmd.Flags().Changed("server-path") {
|
|
validURL = nil
|
|
}
|
|
prompted, err := a.requireInput(cmd, &opts.CloneURL, "clone-url", "Clone URL", validURL)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
if validURL != nil {
|
|
if err := validURL(opts.CloneURL); err != nil {
|
|
return err
|
|
}
|
|
}
|
|
opts.Name = cmp.Or(opts.Name, migrationName(opts.CloneURL))
|
|
named, err := a.requireInput(cmd, &opts.Name, "name", "Repository name", validateRepositoryName)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
if err := validateRepositoryName(opts.Name); err != nil {
|
|
return err
|
|
}
|
|
for _, field := range []struct {
|
|
value *string
|
|
file, flag string
|
|
}{{&opts.AuthPassword, passwordFile, "auth-password"}, {&opts.AuthToken, tokenFile, "auth-token"}} {
|
|
value, err := a.readSecret(cmd, *field.value, field.file, field.flag, field.flag+"-file")
|
|
if err != nil {
|
|
return err
|
|
}
|
|
*field.value = value
|
|
}
|
|
if opts.AuthToken != "" && (opts.AuthUser != "" || opts.AuthPassword != "") {
|
|
return clierr.Wrap(clierr.Usage, errors.New("source token and username/password authentication are mutually exclusive"))
|
|
}
|
|
if opts.AuthPassword != "" && opts.AuthUser == "" {
|
|
return clierr.Wrap(clierr.Usage, errors.New("--auth-password requires --auth-user"))
|
|
}
|
|
if opts.Service != "git" && opts.AuthToken == "" {
|
|
return clierr.Wrap(clierr.Usage, fmt.Errorf("importing from %s needs --auth-token or --auth-token-file; use --service git to import only the Git data", opts.Service))
|
|
}
|
|
target, err := a.resolve(cmd.Context(), false)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
destination := cmp.Or(opts.Owner, target.User) + "/" + opts.Name
|
|
if prompted || named {
|
|
if err := a.confirmAction(cmd, terminal.Confirmation{Prompt: fmt.Sprintf("Import %s into %s on %s?", opts.CloneURL, destination, target.Host), DefaultYes: true}); err != nil {
|
|
return err
|
|
}
|
|
}
|
|
item, err := (services.Repositories{Client: target.client}).Migrate(cmd.Context(), opts)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
detail := ""
|
|
switch {
|
|
case item.Mirror && opts.MirrorInterval != "":
|
|
detail = " (pull mirror, every " + opts.MirrorInterval + ")"
|
|
case item.Mirror:
|
|
detail = " (pull mirror)"
|
|
}
|
|
a.done(cmd, "Imported %s into %s%s", opts.CloneURL, item.FullName, detail)
|
|
return a.created(cmd, item, item.URL)
|
|
},
|
|
}
|
|
flags := command.Flags()
|
|
flags.DurationVar(&opts.Timeout, "timeout", 10*time.Minute, "Maximum migration request duration; Gitea may continue an import after cancellation")
|
|
flags.StringVar(&opts.Name, "name", "", "Destination repository name (default: the source's name)")
|
|
flags.StringVar(&opts.Owner, "owner", "", "Destination user or organization (default: your account)")
|
|
flags.StringVar(&serverPath, "server-path", "", "Absolute source Git repository path on the Gitea server (requires server permission)")
|
|
_ = command.MarkFlagDirname("server-path")
|
|
flags.StringVar(&opts.CloneURL, "clone-url", "", "Remote repository URL")
|
|
_ = flags.MarkHidden("clone-url")
|
|
enumFlag(command, &opts.Service, "service", "", "git", "Source service", "git", "gitea", "gitlab", "gogs", "github")
|
|
flags.StringVarP(&opts.Description, "description", "d", "", "Repository description")
|
|
flags.BoolVar(&opts.Mirror, "mirror", false, "Create a pull mirror")
|
|
flags.BoolVar(&opts.Private, "private", false, "Make the imported repository private")
|
|
flags.BoolVar(&opts.Wiki, "wiki", false, "Copy wiki")
|
|
flags.BoolVar(&opts.Issues, "issues", false, "Copy issues")
|
|
flags.BoolVar(&opts.Labels, "labels", false, "Copy labels")
|
|
flags.BoolVar(&opts.PullRequests, "pull-requests", false, "Copy pull requests")
|
|
flags.BoolVar(&opts.Releases, "releases", false, "Copy releases")
|
|
flags.BoolVar(&opts.Milestones, "milestones", false, "Copy milestones")
|
|
flags.StringVar(&opts.MirrorInterval, "mirror-interval", "", "Mirror interval, for example 8h")
|
|
flags.BoolVar(&opts.LFS, "lfs", false, "Copy LFS objects")
|
|
flags.StringVar(&opts.LFSEndpoint, "lfs-endpoint", "", "Source LFS endpoint")
|
|
flags.StringVar(&opts.AuthUser, "auth-user", "", "Source authentication username")
|
|
flags.StringVar(&opts.AuthPassword, "auth-password", "", "Source password (prefer file input)")
|
|
flags.StringVar(&passwordFile, "auth-password-file", "", "Read source password from file or -")
|
|
flags.StringVar(&opts.AuthToken, "auth-token", "", "Source API token (prefer file input)")
|
|
flags.StringVar(&tokenFile, "auth-token-file", "", "Read source API token from file or -")
|
|
_ = command.RegisterFlagCompletionFunc("owner", a.completeOrgs())
|
|
return command
|
|
}
|
|
|
|
// validateMigrationFlags rejects combinations of repo migrate flags that cannot work, before any
|
|
// prompt or request.
|
|
func validateMigrationFlags(cmd *cobra.Command, opts services.RepositoryMigrationOptions, passwordFile, tokenFile string) error {
|
|
changed := cmd.Flags().Changed
|
|
metadata := opts.Issues || opts.Milestones || opts.Labels || opts.PullRequests || opts.Releases
|
|
switch {
|
|
case changed("server-path") && (opts.Service != "git" || opts.AuthUser != "" || changed("auth-password") || changed("auth-password-file") || changed("auth-token") || changed("auth-token-file")):
|
|
return clierr.Wrap(clierr.Usage, errors.New("server path imports use --service git without remote credentials"))
|
|
case opts.Timeout <= 0:
|
|
return clierr.Wrap(clierr.Usage, errors.New("--timeout must be positive"))
|
|
case len(opts.Description) > 2048:
|
|
return clierr.Wrap(clierr.Usage, errors.New("description cannot exceed 2048 bytes"))
|
|
case opts.LFSEndpoint != "" && !opts.LFS:
|
|
return clierr.Wrap(clierr.Usage, errors.New("--lfs-endpoint requires --lfs"))
|
|
case opts.Mirror && metadata:
|
|
return clierr.Wrap(clierr.Usage, errors.New("mirrors cannot copy issues, milestones, labels, pull requests, or releases"))
|
|
case opts.Service == "git" && metadata:
|
|
return clierr.Wrap(clierr.Usage, errors.New("plain Git migration cannot copy forge metadata; select the source --service"))
|
|
case passwordFile == "-" && tokenFile == "-":
|
|
return clierr.Wrap(clierr.Usage, errors.New("stdin can supply only one source credential"))
|
|
}
|
|
if opts.LFSEndpoint != "" {
|
|
if err := validateMigrationURL(opts.LFSEndpoint); err != nil {
|
|
return err
|
|
}
|
|
}
|
|
if opts.MirrorInterval != "" {
|
|
interval, err := time.ParseDuration(opts.MirrorInterval)
|
|
if err != nil || interval <= 0 || !opts.Mirror {
|
|
return clierr.Wrap(clierr.Usage, errors.New("--mirror-interval requires --mirror and a positive duration"))
|
|
}
|
|
}
|
|
return nil
|
|
}
|