gitea/models/wiki.go

176 lines
5.5 KiB
Go
Raw Normal View History

2015-11-26 23:33:45 +01:00
// Copyright 2015 The Gogs 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 models
import (
"fmt"
2015-11-27 06:24:24 +01:00
"io/ioutil"
2016-03-04 19:32:17 +01:00
"net/url"
2015-11-27 07:50:38 +01:00
"os"
2015-11-27 06:24:24 +01:00
"path"
2015-11-26 23:33:45 +01:00
"path/filepath"
"strings"
2015-11-26 23:33:45 +01:00
"github.com/Unknwon/com"
2015-12-15 23:25:45 +01:00
"github.com/gogits/git-module"
2015-11-27 06:24:24 +01:00
"github.com/gogits/gogs/modules/setting"
"github.com/gogits/gogs/modules/sync"
2015-11-26 23:33:45 +01:00
)
var wikiWorkingPool = sync.NewSingleInstancePool()
2015-11-27 06:24:24 +01:00
// ToWikiPageURL formats a string to corresponding wiki URL name.
func ToWikiPageURL(name string) string {
return url.QueryEscape(strings.Replace(name, " ", "-", -1))
2015-11-26 23:33:45 +01:00
}
// ToWikiPageName formats a URL back to corresponding wiki page name,
// and removes leading characters './' to prevent changing files
// that are not belong to wiki repository.
2015-12-20 21:13:12 +01:00
func ToWikiPageName(urlString string) string {
name, _ := url.QueryUnescape(strings.Replace(urlString, "-", " ", -1))
return strings.Replace(strings.TrimLeft(name, "./"), "/", " ", -1)
2015-11-27 06:24:24 +01:00
}
2015-12-01 02:45:55 +01:00
// WikiCloneLink returns clone URLs of repository wiki.
func (repo *Repository) WikiCloneLink() (cl *CloneLink) {
return repo.cloneLink(true)
}
2015-11-26 23:33:45 +01:00
// WikiPath returns wiki data path by given user and repository name.
func WikiPath(userName, repoName string) string {
return filepath.Join(UserPath(userName), strings.ToLower(repoName)+".wiki.git")
}
func (repo *Repository) WikiPath() string {
return WikiPath(repo.MustOwner().Name, repo.Name)
}
// HasWiki returns true if repository has wiki.
func (repo *Repository) HasWiki() bool {
return com.IsDir(repo.WikiPath())
}
// InitWiki initializes a wiki for repository,
// it does nothing when repository already has wiki.
func (repo *Repository) InitWiki() error {
if repo.HasWiki() {
return nil
}
if err := git.InitRepository(repo.WikiPath(), true); err != nil {
return fmt.Errorf("InitRepository: %v", err)
2016-08-11 19:53:51 +02:00
} else if err = createUpdateHook(repo.WikiPath()); err != nil {
return fmt.Errorf("createUpdateHook: %v", err)
2015-11-26 23:33:45 +01:00
}
return nil
}
2015-11-27 06:24:24 +01:00
func (repo *Repository) LocalWikiPath() string {
return path.Join(setting.AppDataPath, "tmp/local-wiki", com.ToStr(repo.ID))
}
// UpdateLocalWiki makes sure the local copy of repository wiki is up-to-date.
func (repo *Repository) UpdateLocalWiki() error {
// Don't pass branch name here because it fails to clone and
// checkout to a specific branch when wiki is an empty repository.
return UpdateLocalCopyBranch(repo.WikiPath(), repo.LocalWikiPath(), "")
2015-11-27 06:24:24 +01:00
}
2016-03-04 19:32:17 +01:00
func discardLocalWikiChanges(localPath string) error {
return discardLocalRepoBranchChanges(localPath, "master")
2016-03-04 19:32:17 +01:00
}
2015-11-27 07:50:38 +01:00
// updateWikiPage adds new page to repository wiki.
func (repo *Repository) updateWikiPage(doer *User, oldTitle, title, content, message string, isNew bool) (err error) {
2015-11-27 06:24:24 +01:00
wikiWorkingPool.CheckIn(com.ToStr(repo.ID))
defer wikiWorkingPool.CheckOut(com.ToStr(repo.ID))
2015-11-26 23:33:45 +01:00
if err = repo.InitWiki(); err != nil {
return fmt.Errorf("InitWiki: %v", err)
}
2015-11-27 06:24:24 +01:00
localPath := repo.LocalWikiPath()
2016-03-04 19:32:17 +01:00
if err = discardLocalWikiChanges(localPath); err != nil {
return fmt.Errorf("discardLocalWikiChanges: %v", err)
} else if err = repo.UpdateLocalWiki(); err != nil {
2015-11-27 06:24:24 +01:00
return fmt.Errorf("UpdateLocalWiki: %v", err)
}
title = ToWikiPageName(title)
2015-11-27 06:24:24 +01:00
filename := path.Join(localPath, title+".md")
2015-11-27 07:50:38 +01:00
// If not a new file, show perform update not create.
if isNew {
if com.IsExist(filename) {
return ErrWikiAlreadyExist{filename}
}
} else {
os.Remove(path.Join(localPath, oldTitle+".md"))
}
// SECURITY: if new file is a symlink to non-exist critical file,
// attack content can be written to the target file (e.g. authorized_keys2)
// as a new page operation.
// So we want to make sure the symlink is removed before write anything.
// The new file we created will be in normal text format.
os.Remove(filename)
2015-11-27 06:24:24 +01:00
if err = ioutil.WriteFile(filename, []byte(content), 0666); err != nil {
return fmt.Errorf("WriteFile: %v", err)
}
if len(message) == 0 {
message = "Update page '" + title + "'"
}
if err = git.AddChanges(localPath, true); err != nil {
return fmt.Errorf("AddChanges: %v", err)
} else if err = git.CommitChanges(localPath, message, doer.NewGitSig()); err != nil {
return fmt.Errorf("CommitChanges: %v", err)
} else if err = git.Push(localPath, "origin", "master"); err != nil {
return fmt.Errorf("Push: %v", err)
}
2015-11-26 23:33:45 +01:00
return nil
}
2015-11-27 07:50:38 +01:00
func (repo *Repository) AddWikiPage(doer *User, title, content, message string) error {
return repo.updateWikiPage(doer, "", title, content, message, true)
}
func (repo *Repository) EditWikiPage(doer *User, oldTitle, title, content, message string) error {
return repo.updateWikiPage(doer, oldTitle, title, content, message, false)
}
func (repo *Repository) DeleteWikiPage(doer *User, title string) (err error) {
wikiWorkingPool.CheckIn(com.ToStr(repo.ID))
defer wikiWorkingPool.CheckOut(com.ToStr(repo.ID))
localPath := repo.LocalWikiPath()
2016-03-04 19:32:17 +01:00
if err = discardLocalWikiChanges(localPath); err != nil {
return fmt.Errorf("discardLocalWikiChanges: %v", err)
} else if err = repo.UpdateLocalWiki(); err != nil {
return fmt.Errorf("UpdateLocalWiki: %v", err)
}
title = ToWikiPageName(title)
filename := path.Join(localPath, title+".md")
os.Remove(filename)
message := "Delete page '" + title + "'"
if err = git.AddChanges(localPath, true); err != nil {
return fmt.Errorf("AddChanges: %v", err)
} else if err = git.CommitChanges(localPath, message, doer.NewGitSig()); err != nil {
return fmt.Errorf("CommitChanges: %v", err)
} else if err = git.Push(localPath, "origin", "master"); err != nil {
return fmt.Errorf("Push: %v", err)
}
return nil
}