2020-01-07 13:27:36 -05:00
|
|
|
// Copyright 2015 The Gogs Authors. All rights reserved.
|
|
|
|
// Copyright 2019 The Gitea Authors. All rights reserved.
|
[GITEA] Allow changing the repo Wiki branch to main
Previously, the repo wiki was hardcoded to use `master` as its branch,
this change makes it possible to use `main` (or something else, governed
by `[repository].DEFAULT_BRANCH`, a setting that already exists and
defaults to `main`).
The way it is done is that a new column is added to the `repository`
table: `wiki_branch`. The migration will make existing repositories
default to `master`, for compatibility's sake, even if they don't have a
Wiki (because it's easier to do that). Newly created repositories will
default to `[repository].DEFAULT_BRANCH` instead.
The Wiki service was updated to use the branch name stored in the
database, and fall back to the default if it is empty.
Old repositories with Wikis using the older `master` branch will have
the option to do a one-time transition to `main`, available via the
repository settings in the "Danger Zone". This option will only be
available for repositories that have the internal wiki enabled, it is
not empty, and the wiki branch is not `[repository].DEFAULT_BRANCH`.
When migrating a repository with a Wiki, Forgejo will use the same
branch name for the wiki as the source repository did. If that's not the
same as the default, the option to normalize it will be available after
the migration's done.
Additionally, the `/api/v1/{owner}/{repo}` endpoint was updated: it will
now include the wiki branch name in `GET` requests, and allow changing
the wiki branch via `PATCH`.
Signed-off-by: Gergely Nagy <forgejo@gergo.csillger.hu>
(cherry picked from commit d87c526d2a313fa45093ab49b78bb30322b33298)
2024-01-30 06:18:53 -05:00
|
|
|
// Copyright 2024 The Forgejo Authors c/o Codeberg e.V.. All rights reserved.
|
2022-11-27 13:20:29 -05:00
|
|
|
// SPDX-License-Identifier: MIT
|
2020-01-07 13:27:36 -05:00
|
|
|
|
|
|
|
package wiki
|
|
|
|
|
|
|
|
import (
|
2022-01-19 18:26:57 -05:00
|
|
|
"context"
|
2020-01-07 13:27:36 -05:00
|
|
|
"fmt"
|
|
|
|
"os"
|
|
|
|
"strings"
|
|
|
|
|
2021-12-09 20:27:50 -05:00
|
|
|
repo_model "code.gitea.io/gitea/models/repo"
|
2022-10-16 19:29:26 -04:00
|
|
|
system_model "code.gitea.io/gitea/models/system"
|
2021-11-09 14:57:58 -05:00
|
|
|
"code.gitea.io/gitea/models/unit"
|
2021-11-24 04:49:20 -05:00
|
|
|
user_model "code.gitea.io/gitea/models/user"
|
2020-01-07 13:27:36 -05:00
|
|
|
"code.gitea.io/gitea/modules/git"
|
2024-03-08 02:30:10 -05:00
|
|
|
"code.gitea.io/gitea/modules/gitrepo"
|
2020-01-07 13:27:36 -05:00
|
|
|
"code.gitea.io/gitea/modules/log"
|
2020-01-20 15:01:19 -05:00
|
|
|
repo_module "code.gitea.io/gitea/modules/repository"
|
2020-01-07 13:27:36 -05:00
|
|
|
"code.gitea.io/gitea/modules/sync"
|
2021-12-10 03:14:24 -05:00
|
|
|
asymkey_service "code.gitea.io/gitea/services/asymkey"
|
2020-01-07 13:27:36 -05:00
|
|
|
)
|
|
|
|
|
2023-04-19 13:50:10 -04:00
|
|
|
// TODO: use clustered lock (unique queue? or *abuse* cache)
|
|
|
|
var wikiWorkingPool = sync.NewExclusivePool()
|
2020-01-07 13:27:36 -05:00
|
|
|
|
2022-10-15 10:40:32 -04:00
|
|
|
const (
|
|
|
|
DefaultRemote = "origin"
|
|
|
|
)
|
|
|
|
|
2020-01-07 13:27:36 -05:00
|
|
|
// InitWiki initializes a wiki for repository,
|
|
|
|
// it does nothing when repository already has wiki.
|
2022-01-19 18:26:57 -05:00
|
|
|
func InitWiki(ctx context.Context, repo *repo_model.Repository) error {
|
2020-01-07 13:27:36 -05:00
|
|
|
if repo.HasWiki() {
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
[GITEA] Allow changing the repo Wiki branch to main
Previously, the repo wiki was hardcoded to use `master` as its branch,
this change makes it possible to use `main` (or something else, governed
by `[repository].DEFAULT_BRANCH`, a setting that already exists and
defaults to `main`).
The way it is done is that a new column is added to the `repository`
table: `wiki_branch`. The migration will make existing repositories
default to `master`, for compatibility's sake, even if they don't have a
Wiki (because it's easier to do that). Newly created repositories will
default to `[repository].DEFAULT_BRANCH` instead.
The Wiki service was updated to use the branch name stored in the
database, and fall back to the default if it is empty.
Old repositories with Wikis using the older `master` branch will have
the option to do a one-time transition to `main`, available via the
repository settings in the "Danger Zone". This option will only be
available for repositories that have the internal wiki enabled, it is
not empty, and the wiki branch is not `[repository].DEFAULT_BRANCH`.
When migrating a repository with a Wiki, Forgejo will use the same
branch name for the wiki as the source repository did. If that's not the
same as the default, the option to normalize it will be available after
the migration's done.
Additionally, the `/api/v1/{owner}/{repo}` endpoint was updated: it will
now include the wiki branch name in `GET` requests, and allow changing
the wiki branch via `PATCH`.
Signed-off-by: Gergely Nagy <forgejo@gergo.csillger.hu>
(cherry picked from commit d87c526d2a313fa45093ab49b78bb30322b33298)
2024-01-30 06:18:53 -05:00
|
|
|
branch := repo.GetWikiBranchName()
|
|
|
|
|
2023-12-17 06:56:08 -05:00
|
|
|
if err := git.InitRepository(ctx, repo.WikiPath(), true, repo.ObjectFormatName); err != nil {
|
2022-10-24 15:29:17 -04:00
|
|
|
return fmt.Errorf("InitRepository: %w", err)
|
2020-01-20 15:01:19 -05:00
|
|
|
} else if err = repo_module.CreateDelegateHooks(repo.WikiPath()); err != nil {
|
2022-10-24 15:29:17 -04:00
|
|
|
return fmt.Errorf("createDelegateHooks: %w", err)
|
[GITEA] Allow changing the repo Wiki branch to main
Previously, the repo wiki was hardcoded to use `master` as its branch,
this change makes it possible to use `main` (or something else, governed
by `[repository].DEFAULT_BRANCH`, a setting that already exists and
defaults to `main`).
The way it is done is that a new column is added to the `repository`
table: `wiki_branch`. The migration will make existing repositories
default to `master`, for compatibility's sake, even if they don't have a
Wiki (because it's easier to do that). Newly created repositories will
default to `[repository].DEFAULT_BRANCH` instead.
The Wiki service was updated to use the branch name stored in the
database, and fall back to the default if it is empty.
Old repositories with Wikis using the older `master` branch will have
the option to do a one-time transition to `main`, available via the
repository settings in the "Danger Zone". This option will only be
available for repositories that have the internal wiki enabled, it is
not empty, and the wiki branch is not `[repository].DEFAULT_BRANCH`.
When migrating a repository with a Wiki, Forgejo will use the same
branch name for the wiki as the source repository did. If that's not the
same as the default, the option to normalize it will be available after
the migration's done.
Additionally, the `/api/v1/{owner}/{repo}` endpoint was updated: it will
now include the wiki branch name in `GET` requests, and allow changing
the wiki branch via `PATCH`.
Signed-off-by: Gergely Nagy <forgejo@gergo.csillger.hu>
(cherry picked from commit d87c526d2a313fa45093ab49b78bb30322b33298)
2024-01-30 06:18:53 -05:00
|
|
|
} else if _, _, err = git.NewCommand(ctx, "symbolic-ref", "HEAD").AddDynamicArguments(git.BranchPrefix + branch).RunStdString(&git.RunOpts{Dir: repo.WikiPath()}); err != nil {
|
|
|
|
return fmt.Errorf("unable to set default wiki branch to %s: %w", branch, err)
|
2020-01-07 13:27:36 -05:00
|
|
|
}
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
[GITEA] Allow changing the repo Wiki branch to main
Previously, the repo wiki was hardcoded to use `master` as its branch,
this change makes it possible to use `main` (or something else, governed
by `[repository].DEFAULT_BRANCH`, a setting that already exists and
defaults to `main`).
The way it is done is that a new column is added to the `repository`
table: `wiki_branch`. The migration will make existing repositories
default to `master`, for compatibility's sake, even if they don't have a
Wiki (because it's easier to do that). Newly created repositories will
default to `[repository].DEFAULT_BRANCH` instead.
The Wiki service was updated to use the branch name stored in the
database, and fall back to the default if it is empty.
Old repositories with Wikis using the older `master` branch will have
the option to do a one-time transition to `main`, available via the
repository settings in the "Danger Zone". This option will only be
available for repositories that have the internal wiki enabled, it is
not empty, and the wiki branch is not `[repository].DEFAULT_BRANCH`.
When migrating a repository with a Wiki, Forgejo will use the same
branch name for the wiki as the source repository did. If that's not the
same as the default, the option to normalize it will be available after
the migration's done.
Additionally, the `/api/v1/{owner}/{repo}` endpoint was updated: it will
now include the wiki branch name in `GET` requests, and allow changing
the wiki branch via `PATCH`.
Signed-off-by: Gergely Nagy <forgejo@gergo.csillger.hu>
(cherry picked from commit d87c526d2a313fa45093ab49b78bb30322b33298)
2024-01-30 06:18:53 -05:00
|
|
|
// NormalizeWikiBranch renames a repository wiki's branch to `setting.Repository.DefaultBranch`
|
|
|
|
func NormalizeWikiBranch(ctx context.Context, repo *repo_model.Repository, to string) error {
|
|
|
|
from := repo.GetWikiBranchName()
|
|
|
|
|
|
|
|
if err := repo.MustNotBeArchived(); err != nil {
|
|
|
|
return err
|
|
|
|
}
|
|
|
|
|
|
|
|
updateDB := func() error {
|
|
|
|
repo.WikiBranch = to
|
|
|
|
return repo_model.UpdateRepositoryCols(ctx, repo, "wiki_branch")
|
|
|
|
}
|
|
|
|
|
|
|
|
if !repo.HasWiki() {
|
|
|
|
return updateDB()
|
|
|
|
}
|
|
|
|
|
|
|
|
if from == to {
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
|
|
|
gitRepo, err := git.OpenRepository(ctx, repo.WikiPath())
|
|
|
|
if err != nil {
|
|
|
|
return err
|
|
|
|
}
|
|
|
|
defer gitRepo.Close()
|
|
|
|
|
|
|
|
if gitRepo.IsBranchExist(to) {
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
|
|
|
if !gitRepo.IsBranchExist(from) {
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
|
|
|
if err := gitRepo.RenameBranch(from, to); err != nil {
|
|
|
|
return err
|
|
|
|
}
|
|
|
|
|
2024-03-08 02:30:10 -05:00
|
|
|
if err := gitrepo.SetDefaultBranch(ctx, repo, to); err != nil {
|
[GITEA] Allow changing the repo Wiki branch to main
Previously, the repo wiki was hardcoded to use `master` as its branch,
this change makes it possible to use `main` (or something else, governed
by `[repository].DEFAULT_BRANCH`, a setting that already exists and
defaults to `main`).
The way it is done is that a new column is added to the `repository`
table: `wiki_branch`. The migration will make existing repositories
default to `master`, for compatibility's sake, even if they don't have a
Wiki (because it's easier to do that). Newly created repositories will
default to `[repository].DEFAULT_BRANCH` instead.
The Wiki service was updated to use the branch name stored in the
database, and fall back to the default if it is empty.
Old repositories with Wikis using the older `master` branch will have
the option to do a one-time transition to `main`, available via the
repository settings in the "Danger Zone". This option will only be
available for repositories that have the internal wiki enabled, it is
not empty, and the wiki branch is not `[repository].DEFAULT_BRANCH`.
When migrating a repository with a Wiki, Forgejo will use the same
branch name for the wiki as the source repository did. If that's not the
same as the default, the option to normalize it will be available after
the migration's done.
Additionally, the `/api/v1/{owner}/{repo}` endpoint was updated: it will
now include the wiki branch name in `GET` requests, and allow changing
the wiki branch via `PATCH`.
Signed-off-by: Gergely Nagy <forgejo@gergo.csillger.hu>
(cherry picked from commit d87c526d2a313fa45093ab49b78bb30322b33298)
2024-01-30 06:18:53 -05:00
|
|
|
return err
|
|
|
|
}
|
|
|
|
|
|
|
|
return updateDB()
|
|
|
|
}
|
|
|
|
|
2023-04-19 13:50:10 -04:00
|
|
|
// prepareGitPath try to find a suitable file path with file name by the given raw wiki name.
|
2021-07-07 19:23:09 -04:00
|
|
|
// return: existence, prepared file path with name, error
|
[GITEA] Allow changing the repo Wiki branch to main
Previously, the repo wiki was hardcoded to use `master` as its branch,
this change makes it possible to use `main` (or something else, governed
by `[repository].DEFAULT_BRANCH`, a setting that already exists and
defaults to `main`).
The way it is done is that a new column is added to the `repository`
table: `wiki_branch`. The migration will make existing repositories
default to `master`, for compatibility's sake, even if they don't have a
Wiki (because it's easier to do that). Newly created repositories will
default to `[repository].DEFAULT_BRANCH` instead.
The Wiki service was updated to use the branch name stored in the
database, and fall back to the default if it is empty.
Old repositories with Wikis using the older `master` branch will have
the option to do a one-time transition to `main`, available via the
repository settings in the "Danger Zone". This option will only be
available for repositories that have the internal wiki enabled, it is
not empty, and the wiki branch is not `[repository].DEFAULT_BRANCH`.
When migrating a repository with a Wiki, Forgejo will use the same
branch name for the wiki as the source repository did. If that's not the
same as the default, the option to normalize it will be available after
the migration's done.
Additionally, the `/api/v1/{owner}/{repo}` endpoint was updated: it will
now include the wiki branch name in `GET` requests, and allow changing
the wiki branch via `PATCH`.
Signed-off-by: Gergely Nagy <forgejo@gergo.csillger.hu>
(cherry picked from commit d87c526d2a313fa45093ab49b78bb30322b33298)
2024-01-30 06:18:53 -05:00
|
|
|
func prepareGitPath(gitRepo *git.Repository, branch string, wikiPath WebPath) (bool, string, error) {
|
2023-04-19 13:50:10 -04:00
|
|
|
unescaped := string(wikiPath) + ".md"
|
|
|
|
gitPath := WebPathToGitPath(wikiPath)
|
2021-07-07 19:23:09 -04:00
|
|
|
|
|
|
|
// Look for both files
|
[GITEA] Allow changing the repo Wiki branch to main
Previously, the repo wiki was hardcoded to use `master` as its branch,
this change makes it possible to use `main` (or something else, governed
by `[repository].DEFAULT_BRANCH`, a setting that already exists and
defaults to `main`).
The way it is done is that a new column is added to the `repository`
table: `wiki_branch`. The migration will make existing repositories
default to `master`, for compatibility's sake, even if they don't have a
Wiki (because it's easier to do that). Newly created repositories will
default to `[repository].DEFAULT_BRANCH` instead.
The Wiki service was updated to use the branch name stored in the
database, and fall back to the default if it is empty.
Old repositories with Wikis using the older `master` branch will have
the option to do a one-time transition to `main`, available via the
repository settings in the "Danger Zone". This option will only be
available for repositories that have the internal wiki enabled, it is
not empty, and the wiki branch is not `[repository].DEFAULT_BRANCH`.
When migrating a repository with a Wiki, Forgejo will use the same
branch name for the wiki as the source repository did. If that's not the
same as the default, the option to normalize it will be available after
the migration's done.
Additionally, the `/api/v1/{owner}/{repo}` endpoint was updated: it will
now include the wiki branch name in `GET` requests, and allow changing
the wiki branch via `PATCH`.
Signed-off-by: Gergely Nagy <forgejo@gergo.csillger.hu>
(cherry picked from commit d87c526d2a313fa45093ab49b78bb30322b33298)
2024-01-30 06:18:53 -05:00
|
|
|
filesInIndex, err := gitRepo.LsTree(branch, unescaped, gitPath)
|
2021-07-07 19:23:09 -04:00
|
|
|
if err != nil {
|
[GITEA] Allow changing the repo Wiki branch to main
Previously, the repo wiki was hardcoded to use `master` as its branch,
this change makes it possible to use `main` (or something else, governed
by `[repository].DEFAULT_BRANCH`, a setting that already exists and
defaults to `main`).
The way it is done is that a new column is added to the `repository`
table: `wiki_branch`. The migration will make existing repositories
default to `master`, for compatibility's sake, even if they don't have a
Wiki (because it's easier to do that). Newly created repositories will
default to `[repository].DEFAULT_BRANCH` instead.
The Wiki service was updated to use the branch name stored in the
database, and fall back to the default if it is empty.
Old repositories with Wikis using the older `master` branch will have
the option to do a one-time transition to `main`, available via the
repository settings in the "Danger Zone". This option will only be
available for repositories that have the internal wiki enabled, it is
not empty, and the wiki branch is not `[repository].DEFAULT_BRANCH`.
When migrating a repository with a Wiki, Forgejo will use the same
branch name for the wiki as the source repository did. If that's not the
same as the default, the option to normalize it will be available after
the migration's done.
Additionally, the `/api/v1/{owner}/{repo}` endpoint was updated: it will
now include the wiki branch name in `GET` requests, and allow changing
the wiki branch via `PATCH`.
Signed-off-by: Gergely Nagy <forgejo@gergo.csillger.hu>
(cherry picked from commit d87c526d2a313fa45093ab49b78bb30322b33298)
2024-01-30 06:18:53 -05:00
|
|
|
if strings.Contains(err.Error(), "Not a valid object name "+branch) {
|
2023-04-19 13:50:10 -04:00
|
|
|
return false, gitPath, nil
|
2021-08-01 13:04:32 -04:00
|
|
|
}
|
2021-07-07 19:23:09 -04:00
|
|
|
log.Error("%v", err)
|
2023-04-19 13:50:10 -04:00
|
|
|
return false, gitPath, err
|
2021-07-07 19:23:09 -04:00
|
|
|
}
|
|
|
|
|
|
|
|
foundEscaped := false
|
|
|
|
for _, filename := range filesInIndex {
|
|
|
|
switch filename {
|
|
|
|
case unescaped:
|
|
|
|
// if we find the unescaped file return it
|
|
|
|
return true, unescaped, nil
|
2023-04-19 13:50:10 -04:00
|
|
|
case gitPath:
|
2021-07-07 19:23:09 -04:00
|
|
|
foundEscaped = true
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
// If not return whether the escaped file exists, and the escaped filename to keep backwards compatibility.
|
2023-04-19 13:50:10 -04:00
|
|
|
return foundEscaped, gitPath, nil
|
2021-07-07 19:23:09 -04:00
|
|
|
}
|
|
|
|
|
2022-09-04 15:54:23 -04:00
|
|
|
// updateWikiPage adds a new page or edits an existing page in repository wiki.
|
2023-04-19 13:50:10 -04:00
|
|
|
func updateWikiPage(ctx context.Context, doer *user_model.User, repo *repo_model.Repository, oldWikiName, newWikiName WebPath, content, message string, isNew bool) (err error) {
|
2023-09-21 19:43:29 -04:00
|
|
|
err = repo.MustNotBeArchived()
|
|
|
|
if err != nil {
|
|
|
|
return err
|
|
|
|
}
|
|
|
|
|
2023-04-19 13:50:10 -04:00
|
|
|
if err = validateWebPath(newWikiName); err != nil {
|
2020-01-07 13:27:36 -05:00
|
|
|
return err
|
|
|
|
}
|
2020-12-25 04:59:32 -05:00
|
|
|
wikiWorkingPool.CheckIn(fmt.Sprint(repo.ID))
|
|
|
|
defer wikiWorkingPool.CheckOut(fmt.Sprint(repo.ID))
|
2020-01-07 13:27:36 -05:00
|
|
|
|
2022-01-19 18:26:57 -05:00
|
|
|
if err = InitWiki(ctx, repo); err != nil {
|
2022-10-24 15:29:17 -04:00
|
|
|
return fmt.Errorf("InitWiki: %w", err)
|
2020-01-07 13:27:36 -05:00
|
|
|
}
|
|
|
|
|
[GITEA] Allow changing the repo Wiki branch to main
Previously, the repo wiki was hardcoded to use `master` as its branch,
this change makes it possible to use `main` (or something else, governed
by `[repository].DEFAULT_BRANCH`, a setting that already exists and
defaults to `main`).
The way it is done is that a new column is added to the `repository`
table: `wiki_branch`. The migration will make existing repositories
default to `master`, for compatibility's sake, even if they don't have a
Wiki (because it's easier to do that). Newly created repositories will
default to `[repository].DEFAULT_BRANCH` instead.
The Wiki service was updated to use the branch name stored in the
database, and fall back to the default if it is empty.
Old repositories with Wikis using the older `master` branch will have
the option to do a one-time transition to `main`, available via the
repository settings in the "Danger Zone". This option will only be
available for repositories that have the internal wiki enabled, it is
not empty, and the wiki branch is not `[repository].DEFAULT_BRANCH`.
When migrating a repository with a Wiki, Forgejo will use the same
branch name for the wiki as the source repository did. If that's not the
same as the default, the option to normalize it will be available after
the migration's done.
Additionally, the `/api/v1/{owner}/{repo}` endpoint was updated: it will
now include the wiki branch name in `GET` requests, and allow changing
the wiki branch via `PATCH`.
Signed-off-by: Gergely Nagy <forgejo@gergo.csillger.hu>
(cherry picked from commit d87c526d2a313fa45093ab49b78bb30322b33298)
2024-01-30 06:18:53 -05:00
|
|
|
hasMasterBranch := git.IsBranchExist(ctx, repo.WikiPath(), repo.GetWikiBranchName())
|
2020-01-07 13:27:36 -05:00
|
|
|
|
2022-05-08 12:46:32 -04:00
|
|
|
basePath, err := repo_module.CreateTemporaryPath("update-wiki")
|
2020-01-07 13:27:36 -05:00
|
|
|
if err != nil {
|
|
|
|
return err
|
|
|
|
}
|
|
|
|
defer func() {
|
2022-05-08 12:46:32 -04:00
|
|
|
if err := repo_module.RemoveTemporaryPath(basePath); err != nil {
|
2020-01-07 13:27:36 -05:00
|
|
|
log.Error("Merge: RemoveTemporaryPath: %s", err)
|
|
|
|
}
|
|
|
|
}()
|
|
|
|
|
|
|
|
cloneOpts := git.CloneRepoOptions{
|
|
|
|
Bare: true,
|
|
|
|
Shared: true,
|
|
|
|
}
|
|
|
|
|
|
|
|
if hasMasterBranch {
|
[GITEA] Allow changing the repo Wiki branch to main
Previously, the repo wiki was hardcoded to use `master` as its branch,
this change makes it possible to use `main` (or something else, governed
by `[repository].DEFAULT_BRANCH`, a setting that already exists and
defaults to `main`).
The way it is done is that a new column is added to the `repository`
table: `wiki_branch`. The migration will make existing repositories
default to `master`, for compatibility's sake, even if they don't have a
Wiki (because it's easier to do that). Newly created repositories will
default to `[repository].DEFAULT_BRANCH` instead.
The Wiki service was updated to use the branch name stored in the
database, and fall back to the default if it is empty.
Old repositories with Wikis using the older `master` branch will have
the option to do a one-time transition to `main`, available via the
repository settings in the "Danger Zone". This option will only be
available for repositories that have the internal wiki enabled, it is
not empty, and the wiki branch is not `[repository].DEFAULT_BRANCH`.
When migrating a repository with a Wiki, Forgejo will use the same
branch name for the wiki as the source repository did. If that's not the
same as the default, the option to normalize it will be available after
the migration's done.
Additionally, the `/api/v1/{owner}/{repo}` endpoint was updated: it will
now include the wiki branch name in `GET` requests, and allow changing
the wiki branch via `PATCH`.
Signed-off-by: Gergely Nagy <forgejo@gergo.csillger.hu>
(cherry picked from commit d87c526d2a313fa45093ab49b78bb30322b33298)
2024-01-30 06:18:53 -05:00
|
|
|
cloneOpts.Branch = repo.GetWikiBranchName()
|
2020-01-07 13:27:36 -05:00
|
|
|
}
|
|
|
|
|
2022-01-19 18:26:57 -05:00
|
|
|
if err := git.Clone(ctx, repo.WikiPath(), basePath, cloneOpts); err != nil {
|
2020-01-07 13:27:36 -05:00
|
|
|
log.Error("Failed to clone repository: %s (%v)", repo.FullName(), err)
|
2023-04-19 13:50:10 -04:00
|
|
|
return fmt.Errorf("failed to clone repository: %s (%w)", repo.FullName(), err)
|
2020-01-07 13:27:36 -05:00
|
|
|
}
|
|
|
|
|
2022-03-29 15:13:41 -04:00
|
|
|
gitRepo, err := git.OpenRepository(ctx, basePath)
|
2020-01-07 13:27:36 -05:00
|
|
|
if err != nil {
|
|
|
|
log.Error("Unable to open temporary repository: %s (%v)", basePath, err)
|
2023-04-19 13:50:10 -04:00
|
|
|
return fmt.Errorf("failed to open new temporary repository in: %s %w", basePath, err)
|
2020-01-07 13:27:36 -05:00
|
|
|
}
|
|
|
|
defer gitRepo.Close()
|
|
|
|
|
|
|
|
if hasMasterBranch {
|
|
|
|
if err := gitRepo.ReadTreeToIndex("HEAD"); err != nil {
|
|
|
|
log.Error("Unable to read HEAD tree to index in: %s %v", basePath, err)
|
2023-04-19 13:50:10 -04:00
|
|
|
return fmt.Errorf("fnable to read HEAD tree to index in: %s %w", basePath, err)
|
2020-01-07 13:27:36 -05:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
[GITEA] Allow changing the repo Wiki branch to main
Previously, the repo wiki was hardcoded to use `master` as its branch,
this change makes it possible to use `main` (or something else, governed
by `[repository].DEFAULT_BRANCH`, a setting that already exists and
defaults to `main`).
The way it is done is that a new column is added to the `repository`
table: `wiki_branch`. The migration will make existing repositories
default to `master`, for compatibility's sake, even if they don't have a
Wiki (because it's easier to do that). Newly created repositories will
default to `[repository].DEFAULT_BRANCH` instead.
The Wiki service was updated to use the branch name stored in the
database, and fall back to the default if it is empty.
Old repositories with Wikis using the older `master` branch will have
the option to do a one-time transition to `main`, available via the
repository settings in the "Danger Zone". This option will only be
available for repositories that have the internal wiki enabled, it is
not empty, and the wiki branch is not `[repository].DEFAULT_BRANCH`.
When migrating a repository with a Wiki, Forgejo will use the same
branch name for the wiki as the source repository did. If that's not the
same as the default, the option to normalize it will be available after
the migration's done.
Additionally, the `/api/v1/{owner}/{repo}` endpoint was updated: it will
now include the wiki branch name in `GET` requests, and allow changing
the wiki branch via `PATCH`.
Signed-off-by: Gergely Nagy <forgejo@gergo.csillger.hu>
(cherry picked from commit d87c526d2a313fa45093ab49b78bb30322b33298)
2024-01-30 06:18:53 -05:00
|
|
|
isWikiExist, newWikiPath, err := prepareGitPath(gitRepo, repo.GetWikiBranchName(), newWikiName)
|
2021-07-07 19:23:09 -04:00
|
|
|
if err != nil {
|
|
|
|
return err
|
|
|
|
}
|
|
|
|
|
2020-01-07 13:27:36 -05:00
|
|
|
if isNew {
|
2021-07-07 19:23:09 -04:00
|
|
|
if isWikiExist {
|
2022-08-24 22:31:57 -04:00
|
|
|
return repo_model.ErrWikiAlreadyExist{
|
2020-01-07 13:27:36 -05:00
|
|
|
Title: newWikiPath,
|
|
|
|
}
|
|
|
|
}
|
|
|
|
} else {
|
2021-07-07 19:23:09 -04:00
|
|
|
// avoid check existence again if wiki name is not changed since gitRepo.LsFiles(...) is not free.
|
|
|
|
isOldWikiExist := true
|
|
|
|
oldWikiPath := newWikiPath
|
|
|
|
if oldWikiName != newWikiName {
|
[GITEA] Allow changing the repo Wiki branch to main
Previously, the repo wiki was hardcoded to use `master` as its branch,
this change makes it possible to use `main` (or something else, governed
by `[repository].DEFAULT_BRANCH`, a setting that already exists and
defaults to `main`).
The way it is done is that a new column is added to the `repository`
table: `wiki_branch`. The migration will make existing repositories
default to `master`, for compatibility's sake, even if they don't have a
Wiki (because it's easier to do that). Newly created repositories will
default to `[repository].DEFAULT_BRANCH` instead.
The Wiki service was updated to use the branch name stored in the
database, and fall back to the default if it is empty.
Old repositories with Wikis using the older `master` branch will have
the option to do a one-time transition to `main`, available via the
repository settings in the "Danger Zone". This option will only be
available for repositories that have the internal wiki enabled, it is
not empty, and the wiki branch is not `[repository].DEFAULT_BRANCH`.
When migrating a repository with a Wiki, Forgejo will use the same
branch name for the wiki as the source repository did. If that's not the
same as the default, the option to normalize it will be available after
the migration's done.
Additionally, the `/api/v1/{owner}/{repo}` endpoint was updated: it will
now include the wiki branch name in `GET` requests, and allow changing
the wiki branch via `PATCH`.
Signed-off-by: Gergely Nagy <forgejo@gergo.csillger.hu>
(cherry picked from commit d87c526d2a313fa45093ab49b78bb30322b33298)
2024-01-30 06:18:53 -05:00
|
|
|
isOldWikiExist, oldWikiPath, err = prepareGitPath(gitRepo, repo.GetWikiBranchName(), oldWikiName)
|
2021-07-07 19:23:09 -04:00
|
|
|
if err != nil {
|
|
|
|
return err
|
|
|
|
}
|
2020-01-07 13:27:36 -05:00
|
|
|
}
|
|
|
|
|
2021-07-07 19:23:09 -04:00
|
|
|
if isOldWikiExist {
|
2020-01-07 13:27:36 -05:00
|
|
|
err := gitRepo.RemoveFilesFromIndex(oldWikiPath)
|
|
|
|
if err != nil {
|
|
|
|
log.Error("%v", err)
|
|
|
|
return err
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
// FIXME: The wiki doesn't have lfs support at present - if this changes need to check attributes here
|
|
|
|
|
|
|
|
objectHash, err := gitRepo.HashObject(strings.NewReader(content))
|
|
|
|
if err != nil {
|
|
|
|
log.Error("%v", err)
|
|
|
|
return err
|
|
|
|
}
|
|
|
|
|
|
|
|
if err := gitRepo.AddObjectToIndex("100644", objectHash, newWikiPath); err != nil {
|
|
|
|
log.Error("%v", err)
|
|
|
|
return err
|
|
|
|
}
|
|
|
|
|
|
|
|
tree, err := gitRepo.WriteTree()
|
|
|
|
if err != nil {
|
|
|
|
log.Error("%v", err)
|
|
|
|
return err
|
|
|
|
}
|
|
|
|
|
|
|
|
commitTreeOpts := git.CommitTreeOpts{
|
|
|
|
Message: message,
|
|
|
|
}
|
|
|
|
|
2020-09-19 12:44:55 -04:00
|
|
|
committer := doer.NewGitSig()
|
|
|
|
|
Simplify how git repositories are opened (#28937)
## Purpose
This is a refactor toward building an abstraction over managing git
repositories.
Afterwards, it does not matter anymore if they are stored on the local
disk or somewhere remote.
## What this PR changes
We used `git.OpenRepository` everywhere previously.
Now, we should split them into two distinct functions:
Firstly, there are temporary repositories which do not change:
```go
git.OpenRepository(ctx, diskPath)
```
Gitea managed repositories having a record in the database in the
`repository` table are moved into the new package `gitrepo`:
```go
gitrepo.OpenRepository(ctx, repo_model.Repo)
```
Why is `repo_model.Repository` the second parameter instead of file
path?
Because then we can easily adapt our repository storage strategy.
The repositories can be stored locally, however, they could just as well
be stored on a remote server.
## Further changes in other PRs
- A Git Command wrapper on package `gitrepo` could be created. i.e.
`NewCommand(ctx, repo_model.Repository, commands...)`. `git.RunOpts{Dir:
repo.RepoPath()}`, the directory should be empty before invoking this
method and it can be filled in the function only. #28940
- Remove the `RepoPath()`/`WikiPath()` functions to reduce the
possibility of mistakes.
---------
Co-authored-by: delvh <dev.lh@web.de>
2024-01-27 15:09:51 -05:00
|
|
|
sign, signingKey, signer, _ := asymkey_service.SignWikiCommit(ctx, repo, doer)
|
2020-01-07 13:27:36 -05:00
|
|
|
if sign {
|
|
|
|
commitTreeOpts.KeyID = signingKey
|
2021-12-09 20:27:50 -05:00
|
|
|
if repo.GetTrustModel() == repo_model.CommitterTrustModel || repo.GetTrustModel() == repo_model.CollaboratorCommitterTrustModel {
|
2020-09-19 12:44:55 -04:00
|
|
|
committer = signer
|
|
|
|
}
|
2020-01-07 13:27:36 -05:00
|
|
|
} else {
|
|
|
|
commitTreeOpts.NoGPGSign = true
|
|
|
|
}
|
|
|
|
if hasMasterBranch {
|
|
|
|
commitTreeOpts.Parents = []string{"HEAD"}
|
|
|
|
}
|
2020-09-19 12:44:55 -04:00
|
|
|
|
|
|
|
commitHash, err := gitRepo.CommitTree(doer.NewGitSig(), committer, tree, commitTreeOpts)
|
2020-01-07 13:27:36 -05:00
|
|
|
if err != nil {
|
|
|
|
log.Error("%v", err)
|
|
|
|
return err
|
|
|
|
}
|
|
|
|
|
2021-11-30 15:06:32 -05:00
|
|
|
if err := git.Push(gitRepo.Ctx, basePath, git.PushOptions{
|
2022-10-15 10:40:32 -04:00
|
|
|
Remote: DefaultRemote,
|
[GITEA] Allow changing the repo Wiki branch to main
Previously, the repo wiki was hardcoded to use `master` as its branch,
this change makes it possible to use `main` (or something else, governed
by `[repository].DEFAULT_BRANCH`, a setting that already exists and
defaults to `main`).
The way it is done is that a new column is added to the `repository`
table: `wiki_branch`. The migration will make existing repositories
default to `master`, for compatibility's sake, even if they don't have a
Wiki (because it's easier to do that). Newly created repositories will
default to `[repository].DEFAULT_BRANCH` instead.
The Wiki service was updated to use the branch name stored in the
database, and fall back to the default if it is empty.
Old repositories with Wikis using the older `master` branch will have
the option to do a one-time transition to `main`, available via the
repository settings in the "Danger Zone". This option will only be
available for repositories that have the internal wiki enabled, it is
not empty, and the wiki branch is not `[repository].DEFAULT_BRANCH`.
When migrating a repository with a Wiki, Forgejo will use the same
branch name for the wiki as the source repository did. If that's not the
same as the default, the option to normalize it will be available after
the migration's done.
Additionally, the `/api/v1/{owner}/{repo}` endpoint was updated: it will
now include the wiki branch name in `GET` requests, and allow changing
the wiki branch via `PATCH`.
Signed-off-by: Gergely Nagy <forgejo@gergo.csillger.hu>
(cherry picked from commit d87c526d2a313fa45093ab49b78bb30322b33298)
2024-01-30 06:18:53 -05:00
|
|
|
Branch: fmt.Sprintf("%s:%s%s", commitHash.String(), git.BranchPrefix, repo.GetWikiBranchName()),
|
2022-05-08 12:46:32 -04:00
|
|
|
Env: repo_module.FullPushingEnvironment(
|
2020-01-07 13:27:36 -05:00
|
|
|
doer,
|
|
|
|
doer,
|
|
|
|
repo,
|
|
|
|
repo.Name+".wiki",
|
|
|
|
0,
|
|
|
|
),
|
|
|
|
}); err != nil {
|
|
|
|
log.Error("%v", err)
|
2020-03-28 00:13:18 -04:00
|
|
|
if git.IsErrPushOutOfDate(err) || git.IsErrPushRejected(err) {
|
|
|
|
return err
|
|
|
|
}
|
2022-10-24 15:29:17 -04:00
|
|
|
return fmt.Errorf("Push: %w", err)
|
2020-01-07 13:27:36 -05:00
|
|
|
}
|
|
|
|
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
|
|
|
// AddWikiPage adds a new wiki page with a given wikiPath.
|
2023-04-19 13:50:10 -04:00
|
|
|
func AddWikiPage(ctx context.Context, doer *user_model.User, repo *repo_model.Repository, wikiName WebPath, content, message string) error {
|
2022-01-19 18:26:57 -05:00
|
|
|
return updateWikiPage(ctx, doer, repo, "", wikiName, content, message, true)
|
2020-01-07 13:27:36 -05:00
|
|
|
}
|
|
|
|
|
|
|
|
// EditWikiPage updates a wiki page identified by its wikiPath,
|
|
|
|
// optionally also changing wikiPath.
|
2023-04-19 13:50:10 -04:00
|
|
|
func EditWikiPage(ctx context.Context, doer *user_model.User, repo *repo_model.Repository, oldWikiName, newWikiName WebPath, content, message string) error {
|
2022-01-19 18:26:57 -05:00
|
|
|
return updateWikiPage(ctx, doer, repo, oldWikiName, newWikiName, content, message, false)
|
2020-01-07 13:27:36 -05:00
|
|
|
}
|
|
|
|
|
|
|
|
// DeleteWikiPage deletes a wiki page identified by its path.
|
2023-04-19 13:50:10 -04:00
|
|
|
func DeleteWikiPage(ctx context.Context, doer *user_model.User, repo *repo_model.Repository, wikiName WebPath) (err error) {
|
2023-09-21 19:43:29 -04:00
|
|
|
err = repo.MustNotBeArchived()
|
|
|
|
if err != nil {
|
|
|
|
return err
|
|
|
|
}
|
|
|
|
|
2020-12-25 04:59:32 -05:00
|
|
|
wikiWorkingPool.CheckIn(fmt.Sprint(repo.ID))
|
|
|
|
defer wikiWorkingPool.CheckOut(fmt.Sprint(repo.ID))
|
2020-01-07 13:27:36 -05:00
|
|
|
|
2022-01-19 18:26:57 -05:00
|
|
|
if err = InitWiki(ctx, repo); err != nil {
|
2022-10-24 15:29:17 -04:00
|
|
|
return fmt.Errorf("InitWiki: %w", err)
|
2020-01-07 13:27:36 -05:00
|
|
|
}
|
|
|
|
|
2022-05-08 12:46:32 -04:00
|
|
|
basePath, err := repo_module.CreateTemporaryPath("update-wiki")
|
2020-01-07 13:27:36 -05:00
|
|
|
if err != nil {
|
|
|
|
return err
|
|
|
|
}
|
|
|
|
defer func() {
|
2022-05-08 12:46:32 -04:00
|
|
|
if err := repo_module.RemoveTemporaryPath(basePath); err != nil {
|
2020-01-07 13:27:36 -05:00
|
|
|
log.Error("Merge: RemoveTemporaryPath: %s", err)
|
|
|
|
}
|
|
|
|
}()
|
|
|
|
|
2022-01-19 18:26:57 -05:00
|
|
|
if err := git.Clone(ctx, repo.WikiPath(), basePath, git.CloneRepoOptions{
|
2020-01-07 13:27:36 -05:00
|
|
|
Bare: true,
|
|
|
|
Shared: true,
|
[GITEA] Allow changing the repo Wiki branch to main
Previously, the repo wiki was hardcoded to use `master` as its branch,
this change makes it possible to use `main` (or something else, governed
by `[repository].DEFAULT_BRANCH`, a setting that already exists and
defaults to `main`).
The way it is done is that a new column is added to the `repository`
table: `wiki_branch`. The migration will make existing repositories
default to `master`, for compatibility's sake, even if they don't have a
Wiki (because it's easier to do that). Newly created repositories will
default to `[repository].DEFAULT_BRANCH` instead.
The Wiki service was updated to use the branch name stored in the
database, and fall back to the default if it is empty.
Old repositories with Wikis using the older `master` branch will have
the option to do a one-time transition to `main`, available via the
repository settings in the "Danger Zone". This option will only be
available for repositories that have the internal wiki enabled, it is
not empty, and the wiki branch is not `[repository].DEFAULT_BRANCH`.
When migrating a repository with a Wiki, Forgejo will use the same
branch name for the wiki as the source repository did. If that's not the
same as the default, the option to normalize it will be available after
the migration's done.
Additionally, the `/api/v1/{owner}/{repo}` endpoint was updated: it will
now include the wiki branch name in `GET` requests, and allow changing
the wiki branch via `PATCH`.
Signed-off-by: Gergely Nagy <forgejo@gergo.csillger.hu>
(cherry picked from commit d87c526d2a313fa45093ab49b78bb30322b33298)
2024-01-30 06:18:53 -05:00
|
|
|
Branch: repo.GetWikiBranchName(),
|
2020-01-07 13:27:36 -05:00
|
|
|
}); err != nil {
|
|
|
|
log.Error("Failed to clone repository: %s (%v)", repo.FullName(), err)
|
2023-04-19 13:50:10 -04:00
|
|
|
return fmt.Errorf("failed to clone repository: %s (%w)", repo.FullName(), err)
|
2020-01-07 13:27:36 -05:00
|
|
|
}
|
|
|
|
|
2022-03-29 15:13:41 -04:00
|
|
|
gitRepo, err := git.OpenRepository(ctx, basePath)
|
2020-01-07 13:27:36 -05:00
|
|
|
if err != nil {
|
|
|
|
log.Error("Unable to open temporary repository: %s (%v)", basePath, err)
|
2023-04-19 13:50:10 -04:00
|
|
|
return fmt.Errorf("failed to open new temporary repository in: %s %w", basePath, err)
|
2020-01-07 13:27:36 -05:00
|
|
|
}
|
|
|
|
defer gitRepo.Close()
|
|
|
|
|
|
|
|
if err := gitRepo.ReadTreeToIndex("HEAD"); err != nil {
|
|
|
|
log.Error("Unable to read HEAD tree to index in: %s %v", basePath, err)
|
2023-04-19 13:50:10 -04:00
|
|
|
return fmt.Errorf("unable to read HEAD tree to index in: %s %w", basePath, err)
|
2020-01-07 13:27:36 -05:00
|
|
|
}
|
|
|
|
|
[GITEA] Allow changing the repo Wiki branch to main
Previously, the repo wiki was hardcoded to use `master` as its branch,
this change makes it possible to use `main` (or something else, governed
by `[repository].DEFAULT_BRANCH`, a setting that already exists and
defaults to `main`).
The way it is done is that a new column is added to the `repository`
table: `wiki_branch`. The migration will make existing repositories
default to `master`, for compatibility's sake, even if they don't have a
Wiki (because it's easier to do that). Newly created repositories will
default to `[repository].DEFAULT_BRANCH` instead.
The Wiki service was updated to use the branch name stored in the
database, and fall back to the default if it is empty.
Old repositories with Wikis using the older `master` branch will have
the option to do a one-time transition to `main`, available via the
repository settings in the "Danger Zone". This option will only be
available for repositories that have the internal wiki enabled, it is
not empty, and the wiki branch is not `[repository].DEFAULT_BRANCH`.
When migrating a repository with a Wiki, Forgejo will use the same
branch name for the wiki as the source repository did. If that's not the
same as the default, the option to normalize it will be available after
the migration's done.
Additionally, the `/api/v1/{owner}/{repo}` endpoint was updated: it will
now include the wiki branch name in `GET` requests, and allow changing
the wiki branch via `PATCH`.
Signed-off-by: Gergely Nagy <forgejo@gergo.csillger.hu>
(cherry picked from commit d87c526d2a313fa45093ab49b78bb30322b33298)
2024-01-30 06:18:53 -05:00
|
|
|
found, wikiPath, err := prepareGitPath(gitRepo, repo.GetWikiBranchName(), wikiName)
|
2021-07-19 12:14:00 -04:00
|
|
|
if err != nil {
|
|
|
|
return err
|
2020-01-07 13:27:36 -05:00
|
|
|
}
|
|
|
|
if found {
|
|
|
|
err := gitRepo.RemoveFilesFromIndex(wikiPath)
|
|
|
|
if err != nil {
|
|
|
|
return err
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
return os.ErrNotExist
|
|
|
|
}
|
|
|
|
|
|
|
|
// FIXME: The wiki doesn't have lfs support at present - if this changes need to check attributes here
|
|
|
|
|
|
|
|
tree, err := gitRepo.WriteTree()
|
|
|
|
if err != nil {
|
|
|
|
return err
|
|
|
|
}
|
2023-04-19 13:50:10 -04:00
|
|
|
message := fmt.Sprintf("Delete page %q", wikiName)
|
2020-01-07 13:27:36 -05:00
|
|
|
commitTreeOpts := git.CommitTreeOpts{
|
|
|
|
Message: message,
|
|
|
|
Parents: []string{"HEAD"},
|
|
|
|
}
|
|
|
|
|
2020-09-19 12:44:55 -04:00
|
|
|
committer := doer.NewGitSig()
|
|
|
|
|
Simplify how git repositories are opened (#28937)
## Purpose
This is a refactor toward building an abstraction over managing git
repositories.
Afterwards, it does not matter anymore if they are stored on the local
disk or somewhere remote.
## What this PR changes
We used `git.OpenRepository` everywhere previously.
Now, we should split them into two distinct functions:
Firstly, there are temporary repositories which do not change:
```go
git.OpenRepository(ctx, diskPath)
```
Gitea managed repositories having a record in the database in the
`repository` table are moved into the new package `gitrepo`:
```go
gitrepo.OpenRepository(ctx, repo_model.Repo)
```
Why is `repo_model.Repository` the second parameter instead of file
path?
Because then we can easily adapt our repository storage strategy.
The repositories can be stored locally, however, they could just as well
be stored on a remote server.
## Further changes in other PRs
- A Git Command wrapper on package `gitrepo` could be created. i.e.
`NewCommand(ctx, repo_model.Repository, commands...)`. `git.RunOpts{Dir:
repo.RepoPath()}`, the directory should be empty before invoking this
method and it can be filled in the function only. #28940
- Remove the `RepoPath()`/`WikiPath()` functions to reduce the
possibility of mistakes.
---------
Co-authored-by: delvh <dev.lh@web.de>
2024-01-27 15:09:51 -05:00
|
|
|
sign, signingKey, signer, _ := asymkey_service.SignWikiCommit(ctx, repo, doer)
|
2020-01-07 13:27:36 -05:00
|
|
|
if sign {
|
|
|
|
commitTreeOpts.KeyID = signingKey
|
2021-12-09 20:27:50 -05:00
|
|
|
if repo.GetTrustModel() == repo_model.CommitterTrustModel || repo.GetTrustModel() == repo_model.CollaboratorCommitterTrustModel {
|
2020-09-19 12:44:55 -04:00
|
|
|
committer = signer
|
|
|
|
}
|
2020-01-07 13:27:36 -05:00
|
|
|
} else {
|
|
|
|
commitTreeOpts.NoGPGSign = true
|
|
|
|
}
|
|
|
|
|
2020-09-19 12:44:55 -04:00
|
|
|
commitHash, err := gitRepo.CommitTree(doer.NewGitSig(), committer, tree, commitTreeOpts)
|
2020-01-07 13:27:36 -05:00
|
|
|
if err != nil {
|
|
|
|
return err
|
|
|
|
}
|
|
|
|
|
2021-11-30 15:06:32 -05:00
|
|
|
if err := git.Push(gitRepo.Ctx, basePath, git.PushOptions{
|
2022-10-15 10:40:32 -04:00
|
|
|
Remote: DefaultRemote,
|
[GITEA] Allow changing the repo Wiki branch to main
Previously, the repo wiki was hardcoded to use `master` as its branch,
this change makes it possible to use `main` (or something else, governed
by `[repository].DEFAULT_BRANCH`, a setting that already exists and
defaults to `main`).
The way it is done is that a new column is added to the `repository`
table: `wiki_branch`. The migration will make existing repositories
default to `master`, for compatibility's sake, even if they don't have a
Wiki (because it's easier to do that). Newly created repositories will
default to `[repository].DEFAULT_BRANCH` instead.
The Wiki service was updated to use the branch name stored in the
database, and fall back to the default if it is empty.
Old repositories with Wikis using the older `master` branch will have
the option to do a one-time transition to `main`, available via the
repository settings in the "Danger Zone". This option will only be
available for repositories that have the internal wiki enabled, it is
not empty, and the wiki branch is not `[repository].DEFAULT_BRANCH`.
When migrating a repository with a Wiki, Forgejo will use the same
branch name for the wiki as the source repository did. If that's not the
same as the default, the option to normalize it will be available after
the migration's done.
Additionally, the `/api/v1/{owner}/{repo}` endpoint was updated: it will
now include the wiki branch name in `GET` requests, and allow changing
the wiki branch via `PATCH`.
Signed-off-by: Gergely Nagy <forgejo@gergo.csillger.hu>
(cherry picked from commit d87c526d2a313fa45093ab49b78bb30322b33298)
2024-01-30 06:18:53 -05:00
|
|
|
Branch: fmt.Sprintf("%s:%s%s", commitHash.String(), git.BranchPrefix, repo.GetWikiBranchName()),
|
2023-04-23 17:22:16 -04:00
|
|
|
Env: repo_module.FullPushingEnvironment(
|
|
|
|
doer,
|
|
|
|
doer,
|
|
|
|
repo,
|
|
|
|
repo.Name+".wiki",
|
|
|
|
0,
|
|
|
|
),
|
2020-01-07 13:27:36 -05:00
|
|
|
}); err != nil {
|
2020-03-28 00:13:18 -04:00
|
|
|
if git.IsErrPushOutOfDate(err) || git.IsErrPushRejected(err) {
|
|
|
|
return err
|
|
|
|
}
|
2022-10-24 15:29:17 -04:00
|
|
|
return fmt.Errorf("Push: %w", err)
|
2020-01-07 13:27:36 -05:00
|
|
|
}
|
|
|
|
|
|
|
|
return nil
|
|
|
|
}
|
2021-09-08 11:19:30 -04:00
|
|
|
|
|
|
|
// DeleteWiki removes the actual and local copy of repository wiki.
|
2022-01-19 18:26:57 -05:00
|
|
|
func DeleteWiki(ctx context.Context, repo *repo_model.Repository) error {
|
2024-01-22 10:07:17 -05:00
|
|
|
if err := repo_model.UpdateRepositoryUnits(ctx, repo, nil, []unit.Type{unit.TypeWiki}); err != nil {
|
2021-09-08 11:19:30 -04:00
|
|
|
return err
|
|
|
|
}
|
|
|
|
|
2022-10-16 19:29:26 -04:00
|
|
|
system_model.RemoveAllWithNotice(ctx, "Delete repository wiki", repo.WikiPath())
|
2021-09-08 11:19:30 -04:00
|
|
|
return nil
|
|
|
|
}
|