fix

routers/repo/branch.go

@@ -0,0 +1,28 @@
+// Copyright 2014 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 repo
+
+import (
+	"github.com/go-martini/martini"
+
+	"github.com/gogits/gogs/models"
+	"github.com/gogits/gogs/modules/middleware"
+)
+
+func Branches(ctx *middleware.Context, params martini.Params) {
+	brs, err := models.GetBranches(ctx.Repo.Owner.Name, ctx.Repo.Repository.Name)
+	if err != nil {
+		ctx.Handle(404, "repo.Branches", err)
+		return
+	} else if len(brs) == 0 {
+		ctx.Handle(404, "repo.Branches", nil)
+		return
+	}
+
+	ctx.Data["Branches"] = brs
+	ctx.Data["IsRepoToolbarBranches"] = true
+
+	ctx.HTML(200, "repo/branches")
+}

routers/repo/commit.go

@@ -0,0 +1,92 @@
+// Copyright 2014 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 repo
+
+import (
+	"container/list"
+	"path"
+
+	"github.com/go-martini/martini"
+
+	"github.com/gogits/gogs/models"
+	"github.com/gogits/gogs/modules/base"
+	"github.com/gogits/gogs/modules/middleware"
+)
+
+func Commits(ctx *middleware.Context, params martini.Params) {
+	userName := params["username"]
+	repoName := params["reponame"]
+	branchName := params["branchname"]
+
+	brs, err := models.GetBranches(userName, repoName)
+	if err != nil {
+		ctx.Handle(200, "repo.Commits", err)
+		return
+	} else if len(brs) == 0 {
+		ctx.Handle(404, "repo.Commits", nil)
+		return
+	}
+
+	var commits *list.List
+	if models.IsBranchExist(userName, repoName, branchName) {
+		commits, err = models.GetCommitsByBranch(userName, repoName, branchName)
+	} else {
+		commits, err = models.GetCommitsByCommitId(userName, repoName, branchName)
+	}
+
+	if err != nil {
+		ctx.Handle(404, "repo.Commits", err)
+		return
+	}
+
+	ctx.Data["Username"] = userName
+	ctx.Data["Reponame"] = repoName
+	ctx.Data["CommitCount"] = commits.Len()
+	ctx.Data["Commits"] = commits
+	ctx.Data["IsRepoToolbarCommits"] = true
+	ctx.HTML(200, "repo/commits")
+}
+
+func Diff(ctx *middleware.Context, params martini.Params) {
+	userName := ctx.Repo.Owner.Name
+	repoName := ctx.Repo.Repository.Name
+	branchName := ctx.Repo.BranchName
+	commitId := ctx.Repo.CommitId
+
+	commit := ctx.Repo.Commit
+
+	diff, err := models.GetDiff(models.RepoPath(userName, repoName), commitId)
+	if err != nil {
+		ctx.Handle(404, "repo.Diff", err)
+		return
+	}
+
+	isImageFile := func(name string) bool {
+		repoFile, err := models.GetTargetFile(userName, repoName,
+			branchName, commitId, name)
+
+		if err != nil {
+			return false
+		}
+
+		blob, err := repoFile.LookupBlob()
+		if err != nil {
+			return false
+		}
+
+		data := blob.Contents()
+		_, isImage := base.IsImageFile(data)
+		return isImage
+	}
+
+	ctx.Data["IsImageFile"] = isImageFile
+	ctx.Data["Title"] = commit.Message() + " · " + base.ShortSha(commitId)
+	ctx.Data["Commit"] = commit
+	ctx.Data["Diff"] = diff
+	ctx.Data["IsRepoToolbarCommits"] = true
+	ctx.Data["SourcePath"] = "/" + path.Join(userName, repoName, "src", commitId)
+	ctx.Data["RawPath"] = "/" + path.Join(userName, repoName, "raw", commitId)
+	ctx.HTML(200, "repo/diff")
+}

routers/repo/git.go

@@ -0,0 +1,55 @@
+package repo
+
+import (
+	"fmt"
+	"strings"
+)
+
+const advertise_refs = "--advertise-refs"
+
+func command(cmd string, opts ...string) string {
+	return fmt.Sprintf("git %s %s", cmd, strings.Join(opts, " "))
+}
+
+/*func upload_pack(repository_path string, opts ...string) string {
+	cmd = "upload-pack"
+	opts = append(opts, "--stateless-rpc", repository_path)
+	return command(cmd, opts...)
+}
+
+func receive_pack(repository_path string, opts ...string) string {
+	cmd = "receive-pack"
+	opts = append(opts, "--stateless-rpc", repository_path)
+	return command(cmd, opts...)
+}*/
+
+/*func update_server_info(repository_path, opts = {}, &block)
+      cmd = "update-server-info"
+      args = []
+      opts.each {|k,v| args << command_options[k] if command_options.has_key?(k) }
+      opts[:args] = args
+      Dir.chdir(repository_path) do # "git update-server-info" does not take a parameter to specify the repository, so set the working directory to the repository
+        self.command(cmd, opts, &block)
+      end
+    end
+
+    def get_config_setting(repository_path, key)
+      path = get_config_location(repository_path)
+      raise "Config file could not be found for repository in #{repository_path}." unless path
+      self.command("config", {:args => ["-f #{path}", key]}).chomp
+    end
+
+    def get_config_location(repository_path)
+      non_bare = File.join(repository_path,'.git') # This is where the config file will be if the repository is non-bare
+      if File.exists?(non_bare) then # The repository is non-bare
+        non_bare_config = File.join(non_bare, 'config')
+        return non_bare_config if File.exists?(non_bare_config)
+      else # We are dealing with a bare repository
+        bare_config = File.join(repository_path, "config")
+        return bare_config if File.exists?(bare_config)
+      end
+      return nil
+    end
+
+  end
+*/

routers/repo/http.go

@@ -0,0 +1,471 @@
+package repo
+
+import (
+	"fmt"
+	"io"
+	"io/ioutil"
+	"log"
+	"net/http"
+	"os"
+	"os/exec"
+	"path"
+	"regexp"
+	"strconv"
+	"strings"
+	"time"
+
+	"github.com/go-martini/martini"
+	"github.com/gogits/gogs/models"
+	"github.com/gogits/gogs/modules/base"
+	"github.com/gogits/gogs/modules/middleware"
+)
+
+func Http(ctx *middleware.Context, params martini.Params) {
+	username := params["username"]
+	reponame := params["reponame"]
+	if strings.HasSuffix(reponame, ".git") {
+		reponame = reponame[:len(reponame)-4]
+	}
+
+	var isPull bool
+	service := ctx.Query("service")
+	if service == "git-receive-pack" ||
+		strings.HasSuffix(ctx.Req.URL.Path, "git-receive-pack") {
+		isPull = false
+	} else if service == "git-upload-pack" ||
+		strings.HasSuffix(ctx.Req.URL.Path, "git-upload-pack") {
+		isPull = true
+	} else {
+		isPull = (ctx.Req.Method == "GET")
+	}
+
+	repoUser, err := models.GetUserByName(username)
+	if err != nil {
+		ctx.Handle(500, "repo.GetUserByName", nil)
+		return
+	}
+
+	repo, err := models.GetRepositoryByName(repoUser.Id, reponame)
+	if err != nil {
+		ctx.Handle(500, "repo.GetRepositoryByName", nil)
+		return
+	}
+
+	// only public pull don't need auth
+	var askAuth = !(!repo.IsPrivate && isPull)
+
+	// check access
+	if askAuth {
+		baHead := ctx.Req.Header.Get("Authorization")
+		if baHead == "" {
+			// ask auth
+			authRequired(ctx)
+			return
+		}
+
+		auths := strings.Fields(baHead)
+		// currently check basic auth
+		// TODO: support digit auth
+		if len(auths) != 2 || auths[0] != "Basic" {
+			ctx.Handle(401, "no basic auth and digit auth", nil)
+			return
+		}
+		authUsername, passwd, err := basicDecode(auths[1])
+		if err != nil {
+			ctx.Handle(401, "no basic auth and digit auth", nil)
+			return
+		}
+
+		authUser, err := models.GetUserByName(authUsername)
+		if err != nil {
+			ctx.Handle(401, "no basic auth and digit auth", nil)
+			return
+		}
+
+		newUser := &models.User{Passwd: passwd, Salt: authUser.Salt}
+
+		newUser.EncodePasswd()
+		if authUser.Passwd != newUser.Passwd {
+			ctx.Handle(401, "no basic auth and digit auth", nil)
+			return
+		}
+
+		var tp = models.AU_WRITABLE
+		if isPull {
+			tp = models.AU_READABLE
+		}
+
+		has, err := models.HasAccess(authUsername, username+"/"+reponame, tp)
+		if err != nil {
+			ctx.Handle(401, "no basic auth and digit auth", nil)
+			return
+		} else if !has {
+			if tp == models.AU_READABLE {
+				has, err = models.HasAccess(authUsername, username+"/"+reponame, models.AU_WRITABLE)
+				if err != nil || !has {
+					ctx.Handle(401, "no basic auth and digit auth", nil)
+					return
+				}
+			} else {
+				ctx.Handle(401, "no basic auth and digit auth", nil)
+				return
+			}
+		}
+	}
+
+	config := Config{base.RepoRootPath, "git", true, true, func(rpc string, input []byte) {
+		//fmt.Println("rpc:", rpc)
+		//fmt.Println("input:", string(input))
+	}}
+
+	handler := HttpBackend(&config)
+	handler(ctx.ResponseWriter, ctx.Req)
+
+	/* Webdav
+	dir := models.RepoPath(username, reponame)
+
+	prefix := path.Join("/", username, params["reponame"])
+	server := webdav.NewServer(
+		dir, prefix, true)
+
+	server.ServeHTTP(ctx.ResponseWriter, ctx.Req)
+	*/
+}
+
+type route struct {
+	cr      *regexp.Regexp
+	method  string
+	handler func(handler)
+}
+
+type Config struct {
+	ReposRoot   string
+	GitBinPath  string
+	UploadPack  bool
+	ReceivePack bool
+	OnSucceed   func(rpc string, input []byte)
+}
+
+type handler struct {
+	*Config
+	w    http.ResponseWriter
+	r    *http.Request
+	Dir  string
+	File string
+}
+
+var routes = []route{
+	{regexp.MustCompile("(.*?)/git-upload-pack$"), "POST", serviceUploadPack},
+	{regexp.MustCompile("(.*?)/git-receive-pack$"), "POST", serviceReceivePack},
+	{regexp.MustCompile("(.*?)/info/refs$"), "GET", getInfoRefs},
+	{regexp.MustCompile("(.*?)/HEAD$"), "GET", getTextFile},
+	{regexp.MustCompile("(.*?)/objects/info/alternates$"), "GET", getTextFile},
+	{regexp.MustCompile("(.*?)/objects/info/http-alternates$"), "GET", getTextFile},
+	{regexp.MustCompile("(.*?)/objects/info/packs$"), "GET", getInfoPacks},
+	{regexp.MustCompile("(.*?)/objects/info/[^/]*$"), "GET", getTextFile},
+	{regexp.MustCompile("(.*?)/objects/[0-9a-f]{2}/[0-9a-f]{38}$"), "GET", getLooseObject},
+	{regexp.MustCompile("(.*?)/objects/pack/pack-[0-9a-f]{40}\\.pack$"), "GET", getPackFile},
+	{regexp.MustCompile("(.*?)/objects/pack/pack-[0-9a-f]{40}\\.idx$"), "GET", getIdxFile},
+}
+
+// Request handling function
+func HttpBackend(config *Config) http.HandlerFunc {
+	return func(w http.ResponseWriter, r *http.Request) {
+		//log.Printf("%s %s %s %s", r.RemoteAddr, r.Method, r.URL.Path, r.Proto)
+		for _, route := range routes {
+			if m := route.cr.FindStringSubmatch(r.URL.Path); m != nil {
+				if route.method != r.Method {
+					renderMethodNotAllowed(w, r)
+					return
+				}
+
+				file := strings.Replace(r.URL.Path, m[1]+"/", "", 1)
+				dir, err := getGitDir(config, m[1])
+
+				if err != nil {
+					log.Print(err)
+					renderNotFound(w)
+					return
+				}
+
+				hr := handler{config, w, r, dir, file}
+				route.handler(hr)
+				return
+			}
+		}
+		renderNotFound(w)
+		return
+	}
+}
+
+// Actual command handling functions
+
+func serviceUploadPack(hr handler) {
+	serviceRpc("upload-pack", hr)
+}
+
+func serviceReceivePack(hr handler) {
+	serviceRpc("receive-pack", hr)
+}
+
+func serviceRpc(rpc string, hr handler) {
+	w, r, dir := hr.w, hr.r, hr.Dir
+	access := hasAccess(r, hr.Config, dir, rpc, true)
+
+	if access == false {
+		renderNoAccess(w)
+		return
+	}
+
+	input, _ := ioutil.ReadAll(r.Body)
+
+	w.Header().Set("Content-Type", fmt.Sprintf("application/x-git-%s-result", rpc))
+	w.WriteHeader(http.StatusOK)
+
+	args := []string{rpc, "--stateless-rpc", dir}
+	cmd := exec.Command(hr.Config.GitBinPath, args...)
+	cmd.Dir = dir
+	in, err := cmd.StdinPipe()
+	if err != nil {
+		log.Print(err)
+		return
+	}
+
+	stdout, err := cmd.StdoutPipe()
+	if err != nil {
+		log.Print(err)
+		return
+	}
+
+	err = cmd.Start()
+	if err != nil {
+		log.Print(err)
+		return
+	}
+
+	in.Write(input)
+	io.Copy(w, stdout)
+	cmd.Wait()
+
+	if hr.Config.OnSucceed != nil {
+		hr.Config.OnSucceed(rpc, input)
+	}
+}
+
+func getInfoRefs(hr handler) {
+	w, r, dir := hr.w, hr.r, hr.Dir
+	serviceName := getServiceType(r)
+	access := hasAccess(r, hr.Config, dir, serviceName, false)
+
+	if access {
+		args := []string{serviceName, "--stateless-rpc", "--advertise-refs", "."}
+		refs := gitCommand(hr.Config.GitBinPath, dir, args...)
+
+		hdrNocache(w)
+		w.Header().Set("Content-Type", fmt.Sprintf("application/x-git-%s-advertisement", serviceName))
+		w.WriteHeader(http.StatusOK)
+		w.Write(packetWrite("# service=git-" + serviceName + "\n"))
+		w.Write(packetFlush())
+		w.Write(refs)
+	} else {
+		updateServerInfo(hr.Config.GitBinPath, dir)
+		hdrNocache(w)
+		sendFile("text/plain; charset=utf-8", hr)
+	}
+}
+
+func getInfoPacks(hr handler) {
+	hdrCacheForever(hr.w)
+	sendFile("text/plain; charset=utf-8", hr)
+}
+
+func getLooseObject(hr handler) {
+	hdrCacheForever(hr.w)
+	sendFile("application/x-git-loose-object", hr)
+}
+
+func getPackFile(hr handler) {
+	hdrCacheForever(hr.w)
+	sendFile("application/x-git-packed-objects", hr)
+}
+
+func getIdxFile(hr handler) {
+	hdrCacheForever(hr.w)
+	sendFile("application/x-git-packed-objects-toc", hr)
+}
+
+func getTextFile(hr handler) {
+	hdrNocache(hr.w)
+	sendFile("text/plain", hr)
+}
+
+// Logic helping functions
+
+func sendFile(contentType string, hr handler) {
+	w, r := hr.w, hr.r
+	reqFile := path.Join(hr.Dir, hr.File)
+
+	//fmt.Println("sendFile:", reqFile)
+
+	f, err := os.Stat(reqFile)
+	if os.IsNotExist(err) {
+		renderNotFound(w)
+		return
+	}
+
+	w.Header().Set("Content-Type", contentType)
+	w.Header().Set("Content-Length", fmt.Sprintf("%d", f.Size()))
+	w.Header().Set("Last-Modified", f.ModTime().Format(http.TimeFormat))
+	http.ServeFile(w, r, reqFile)
+}
+
+func getGitDir(config *Config, filePath string) (string, error) {
+	root := config.ReposRoot
+
+	if root == "" {
+		cwd, err := os.Getwd()
+
+		if err != nil {
+			log.Print(err)
+			return "", err
+		}
+
+		root = cwd
+	}
+
+	f := path.Join(root, filePath)
+	if _, err := os.Stat(f); os.IsNotExist(err) {
+		return "", err
+	}
+
+	return f, nil
+}
+
+func getServiceType(r *http.Request) string {
+	serviceType := r.FormValue("service")
+
+	if s := strings.HasPrefix(serviceType, "git-"); !s {
+		return ""
+	}
+
+	return strings.Replace(serviceType, "git-", "", 1)
+}
+
+func hasAccess(r *http.Request, config *Config, dir string, rpc string, checkContentType bool) bool {
+	if checkContentType {
+		if r.Header.Get("Content-Type") != fmt.Sprintf("application/x-git-%s-request", rpc) {
+			return false
+		}
+	}
+
+	if !(rpc == "upload-pack" || rpc == "receive-pack") {
+		return false
+	}
+	if rpc == "receive-pack" {
+		return config.ReceivePack
+	}
+	if rpc == "upload-pack" {
+		return config.UploadPack
+	}
+
+	return getConfigSetting(config.GitBinPath, rpc, dir)
+}
+
+func getConfigSetting(gitBinPath, serviceName string, dir string) bool {
+	serviceName = strings.Replace(serviceName, "-", "", -1)
+	setting := getGitConfig(gitBinPath, "http."+serviceName, dir)
+
+	if serviceName == "uploadpack" {
+		return setting != "false"
+	}
+
+	return setting == "true"
+}
+
+func getGitConfig(gitBinPath, configName string, dir string) string {
+	args := []string{"config", configName}
+	out := string(gitCommand(gitBinPath, dir, args...))
+	return out[0 : len(out)-1]
+}
+
+func updateServerInfo(gitBinPath, dir string) []byte {
+	args := []string{"update-server-info"}
+	return gitCommand(gitBinPath, dir, args...)
+}
+
+func gitCommand(gitBinPath, dir string, args ...string) []byte {
+	command := exec.Command(gitBinPath, args...)
+	command.Dir = dir
+	out, err := command.Output()
+
+	if err != nil {
+		log.Print(err)
+	}
+
+	return out
+}
+
+// HTTP error response handling functions
+
+func renderMethodNotAllowed(w http.ResponseWriter, r *http.Request) {
+	if r.Proto == "HTTP/1.1" {
+		w.WriteHeader(http.StatusMethodNotAllowed)
+		w.Write([]byte("Method Not Allowed"))
+	} else {
+		w.WriteHeader(http.StatusBadRequest)
+		w.Write([]byte("Bad Request"))
+	}
+}
+
+func renderNotFound(w http.ResponseWriter) {
+	w.WriteHeader(http.StatusNotFound)
+	w.Write([]byte("Not Found"))
+}
+
+func renderNoAccess(w http.ResponseWriter) {
+	w.WriteHeader(http.StatusForbidden)
+	w.Write([]byte("Forbidden"))
+}
+
+// Packet-line handling function
+
+func packetFlush() []byte {
+	return []byte("0000")
+}
+
+func packetWrite(str string) []byte {
+	s := strconv.FormatInt(int64(len(str)+4), 16)
+
+	if len(s)%4 != 0 {
+		s = strings.Repeat("0", 4-len(s)%4) + s
+	}
+
+	return []byte(s + str)
+}
+
+// Header writing functions
+
+func hdrNocache(w http.ResponseWriter) {
+	w.Header().Set("Expires", "Fri, 01 Jan 1980 00:00:00 GMT")
+	w.Header().Set("Pragma", "no-cache")
+	w.Header().Set("Cache-Control", "no-cache, max-age=0, must-revalidate")
+}
+
+func hdrCacheForever(w http.ResponseWriter) {
+	now := time.Now().Unix()
+	expires := now + 31536000
+	w.Header().Set("Date", fmt.Sprintf("%d", now))
+	w.Header().Set("Expires", fmt.Sprintf("%d", expires))
+	w.Header().Set("Cache-Control", "public, max-age=31536000")
+}
+
+// Main
+/*
+func main() {
+	http.HandleFunc("/", requestHandler())
+
+	err := http.ListenAndServe(":8080", nil)
+	if err != nil {
+		log.Fatal("ListenAndServe: ", err)
+	}
+}*/

routers/repo/issue.go

@@ -0,0 +1,296 @@
+// Copyright 2014 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 repo
+
+import (
+	"fmt"
+	"net/url"
+	"strings"
+
+	"github.com/Unknwon/com"
+	"github.com/go-martini/martini"
+
+	"github.com/gogits/gogs/models"
+	"github.com/gogits/gogs/modules/auth"
+	"github.com/gogits/gogs/modules/base"
+	"github.com/gogits/gogs/modules/log"
+	"github.com/gogits/gogs/modules/mailer"
+	"github.com/gogits/gogs/modules/middleware"
+)
+
+func Issues(ctx *middleware.Context) {
+	ctx.Data["Title"] = "Issues"
+	ctx.Data["IsRepoToolbarIssues"] = true
+	ctx.Data["IsRepoToolbarIssuesList"] = true
+	ctx.Data["ViewType"] = "all"
+
+	milestoneId, _ := base.StrTo(ctx.Query("milestone")).Int()
+	page, _ := base.StrTo(ctx.Query("page")).Int()
+
+	ctx.Data["IssueCreatedCount"] = 0
+
+	var posterId int64 = 0
+	isCreatedBy := ctx.Query("type") == "created_by"
+	if isCreatedBy {
+		if !ctx.IsSigned {
+			ctx.SetCookie("redirect_to", "/"+url.QueryEscape(ctx.Req.RequestURI))
+			ctx.Redirect("/user/login/", 302)
+			return
+		}
+		ctx.Data["ViewType"] = "created_by"
+	}
+
+	// Get issues.
+	issues, err := models.GetIssues(0, ctx.Repo.Repository.Id, posterId, int64(milestoneId), page,
+		ctx.Query("state") == "closed", false, ctx.Query("labels"), ctx.Query("sortType"))
+	if err != nil {
+		ctx.Handle(200, "issue.Issues: %v", err)
+		return
+	}
+
+	if ctx.IsSigned {
+		posterId = ctx.User.Id
+	}
+	var createdByCount int
+
+	showIssues := make([]models.Issue, 0, len(issues))
+	// Get posters.
+	for i := range issues {
+		u, err := models.GetUserById(issues[i].PosterId)
+		if err != nil {
+			ctx.Handle(200, "issue.Issues(get poster): %v", err)
+			return
+		}
+		if isCreatedBy && u.Id != posterId {
+			continue
+		}
+		if u.Id == posterId {
+			createdByCount++
+		}
+		issues[i].Poster = u
+		showIssues = append(showIssues, issues[i])
+	}
+
+	ctx.Data["Issues"] = showIssues
+	ctx.Data["IssueCount"] = ctx.Repo.Repository.NumIssues
+	ctx.Data["OpenCount"] = ctx.Repo.Repository.NumOpenIssues
+	ctx.Data["ClosedCount"] = ctx.Repo.Repository.NumClosedIssues
+	ctx.Data["IssueCreatedCount"] = createdByCount
+	ctx.Data["IsShowClosed"] = ctx.Query("state") == "closed"
+	ctx.HTML(200, "issue/list")
+}
+
+func CreateIssue(ctx *middleware.Context, params martini.Params, form auth.CreateIssueForm) {
+	ctx.Data["Title"] = "Create issue"
+	ctx.Data["IsRepoToolbarIssues"] = true
+	ctx.Data["IsRepoToolbarIssuesList"] = false
+
+	if ctx.Req.Method == "GET" {
+		ctx.HTML(200, "issue/create")
+		return
+	}
+
+	if ctx.HasError() {
+		ctx.HTML(200, "issue/create")
+		return
+	}
+
+	issue, err := models.CreateIssue(ctx.User.Id, ctx.Repo.Repository.Id, form.MilestoneId, form.AssigneeId,
+		ctx.Repo.Repository.NumIssues, form.IssueName, form.Labels, form.Content, false)
+	if err != nil {
+		ctx.Handle(200, "issue.CreateIssue(CreateIssue)", err)
+		return
+	}
+
+	// Notify watchers.
+	if err = models.NotifyWatchers(&models.Action{ActUserId: ctx.User.Id, ActUserName: ctx.User.Name, ActEmail: ctx.User.Email,
+		OpType: models.OP_CREATE_ISSUE, Content: fmt.Sprintf("%d|%s", issue.Index, issue.Name),
+		RepoId: ctx.Repo.Repository.Id, RepoName: ctx.Repo.Repository.Name, RefName: ""}); err != nil {
+		ctx.Handle(200, "issue.CreateIssue(NotifyWatchers)", err)
+		return
+	}
+
+	// Mail watchers and mentions.
+	if base.Service.NotifyMail {
+		tos, err := mailer.SendIssueNotifyMail(ctx.User, ctx.Repo.Owner, ctx.Repo.Repository, issue)
+		if err != nil {
+			ctx.Handle(200, "issue.CreateIssue(SendIssueNotifyMail)", err)
+			return
+		}
+
+		tos = append(tos, ctx.User.LowerName)
+		ms := base.MentionPattern.FindAllString(issue.Content, -1)
+		newTos := make([]string, 0, len(ms))
+		for _, m := range ms {
+			if com.IsSliceContainsStr(tos, m[1:]) {
+				continue
+			}
+
+			newTos = append(newTos, m[1:])
+		}
+		if err = mailer.SendIssueMentionMail(ctx.User, ctx.Repo.Owner, ctx.Repo.Repository,
+			issue, models.GetUserEmailsByNames(newTos)); err != nil {
+			ctx.Handle(200, "issue.CreateIssue(SendIssueMentionMail)", err)
+			return
+		}
+	}
+
+	log.Trace("%d Issue created: %d", ctx.Repo.Repository.Id, issue.Id)
+	ctx.Redirect(fmt.Sprintf("/%s/%s/issues/%d", params["username"], params["reponame"], issue.Index))
+}
+
+func ViewIssue(ctx *middleware.Context, params martini.Params) {
+	index, err := base.StrTo(params["index"]).Int()
+	if err != nil {
+		ctx.Handle(404, "issue.ViewIssue", err)
+		return
+	}
+
+	issue, err := models.GetIssueByIndex(ctx.Repo.Repository.Id, int64(index))
+	if err != nil {
+		if err == models.ErrIssueNotExist {
+			ctx.Handle(404, "issue.ViewIssue", err)
+		} else {
+			ctx.Handle(200, "issue.ViewIssue", err)
+		}
+		return
+	}
+
+	// Get posters.
+	u, err := models.GetUserById(issue.PosterId)
+	if err != nil {
+		ctx.Handle(200, "issue.ViewIssue(get poster): %v", err)
+		return
+	}
+	issue.Poster = u
+	issue.RenderedContent = string(base.RenderMarkdown([]byte(issue.Content), ctx.Repo.RepoLink))
+
+	// Get comments.
+	comments, err := models.GetIssueComments(issue.Id)
+	if err != nil {
+		ctx.Handle(200, "issue.ViewIssue(get comments): %v", err)
+		return
+	}
+
+	// Get posters.
+	for i := range comments {
+		u, err := models.GetUserById(comments[i].PosterId)
+		if err != nil {
+			ctx.Handle(200, "issue.ViewIssue(get poster): %v", err)
+			return
+		}
+		comments[i].Poster = u
+		comments[i].Content = string(base.RenderMarkdown([]byte(comments[i].Content), ctx.Repo.RepoLink))
+	}
+
+	ctx.Data["Title"] = issue.Name
+	ctx.Data["Issue"] = issue
+	ctx.Data["Comments"] = comments
+	ctx.Data["IsIssueOwner"] = ctx.Repo.IsOwner || (ctx.IsSigned && issue.PosterId == ctx.User.Id)
+	ctx.Data["IsRepoToolbarIssues"] = true
+	ctx.Data["IsRepoToolbarIssuesList"] = false
+	ctx.HTML(200, "issue/view")
+}
+
+func UpdateIssue(ctx *middleware.Context, params martini.Params, form auth.CreateIssueForm) {
+	index, err := base.StrTo(params["index"]).Int()
+	if err != nil {
+		ctx.Handle(404, "issue.UpdateIssue", err)
+		return
+	}
+
+	issue, err := models.GetIssueByIndex(ctx.Repo.Repository.Id, int64(index))
+	if err != nil {
+		if err == models.ErrIssueNotExist {
+			ctx.Handle(404, "issue.UpdateIssue", err)
+		} else {
+			ctx.Handle(200, "issue.UpdateIssue(get issue)", err)
+		}
+		return
+	}
+
+	if ctx.User.Id != issue.PosterId && !ctx.Repo.IsOwner {
+		ctx.Handle(404, "issue.UpdateIssue", nil)
+		return
+	}
+
+	issue.Name = form.IssueName
+	issue.MilestoneId = form.MilestoneId
+	issue.AssigneeId = form.AssigneeId
+	issue.Labels = form.Labels
+	issue.Content = form.Content
+	if err = models.UpdateIssue(issue); err != nil {
+		ctx.Handle(200, "issue.UpdateIssue(update issue)", err)
+		return
+	}
+
+	ctx.JSON(200, map[string]interface{}{
+		"ok":      true,
+		"title":   issue.Name,
+		"content": string(base.RenderMarkdown([]byte(issue.Content), ctx.Repo.RepoLink)),
+	})
+}
+
+func Comment(ctx *middleware.Context, params martini.Params) {
+	index, err := base.StrTo(ctx.Query("issueIndex")).Int64()
+	if err != nil {
+		ctx.Handle(404, "issue.Comment(get index)", err)
+		return
+	}
+
+	issue, err := models.GetIssueByIndex(ctx.Repo.Repository.Id, index)
+	if err != nil {
+		if err == models.ErrIssueNotExist {
+			ctx.Handle(404, "issue.Comment", err)
+		} else {
+			ctx.Handle(200, "issue.Comment(get issue)", err)
+		}
+		return
+	}
+
+	// Check if issue owner changes the status of issue.
+	var newStatus string
+	if ctx.Repo.IsOwner || issue.PosterId == ctx.User.Id {
+		newStatus = ctx.Query("change_status")
+	}
+	if len(newStatus) > 0 {
+		if (strings.Contains(newStatus, "Reopen") && issue.IsClosed) ||
+			(strings.Contains(newStatus, "Close") && !issue.IsClosed) {
+			issue.IsClosed = !issue.IsClosed
+			if err = models.UpdateIssue(issue); err != nil {
+				ctx.Handle(200, "issue.Comment(update issue status)", err)
+				return
+			}
+
+			cmtType := models.IT_CLOSE
+			if !issue.IsClosed {
+				cmtType = models.IT_REOPEN
+			}
+
+			if err = models.CreateComment(ctx.User.Id, ctx.Repo.Repository.Id, issue.Id, 0, 0, cmtType, ""); err != nil {
+				ctx.Handle(200, "issue.Comment(create status change comment)", err)
+				return
+			}
+			log.Trace("%s Issue(%d) status changed: %v", ctx.Req.RequestURI, issue.Id, !issue.IsClosed)
+		}
+	}
+
+	content := ctx.Query("content")
+	if len(content) > 0 {
+		switch params["action"] {
+		case "new":
+			if err = models.CreateComment(ctx.User.Id, ctx.Repo.Repository.Id, issue.Id, 0, 0, models.IT_PLAIN, content); err != nil {
+				ctx.Handle(500, "issue.Comment(create comment)", err)
+				return
+			}
+			log.Trace("%s Comment created: %d", ctx.Req.RequestURI, issue.Id)
+		default:
+			ctx.Handle(404, "issue.Comment", err)
+			return
+		}
+	}
+
+	ctx.Redirect(fmt.Sprintf("/%s/%s/issues/%d", ctx.User.Name, ctx.Repo.Repository.Name, index))
+}

routers/repo/pull.go

@@ -0,0 +1,16 @@
+// Copyright 2014 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 repo
+
+import (
+	"github.com/go-martini/martini"
+
+	"github.com/gogits/gogs/modules/middleware"
+)
+
+func Pulls(ctx *middleware.Context, params martini.Params) {
+	ctx.Data["IsRepoToolbarPulls"] = true
+	ctx.HTML(200, "repo/pulls")
+}

routers/repo/release.go

@@ -0,0 +1,30 @@
+// Copyright 2014 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 repo
+
+import (
+	"github.com/gogits/gogs/models"
+	"github.com/gogits/gogs/modules/middleware"
+)
+
+func Releases(ctx *middleware.Context) {
+	ctx.Data["Title"] = "Releases"
+	ctx.Data["IsRepoToolbarReleases"] = true
+	ctx.Data["IsRepoReleaseNew"] = false
+	tags, err := models.GetTags(ctx.Repo.Owner.Name, ctx.Repo.Repository.Name)
+	if err != nil {
+		ctx.Handle(404, "repo.Releases(GetTags)", err)
+		return
+	}
+	ctx.Data["Releases"] = tags
+	ctx.HTML(200, "release/list")
+}
+
+func ReleasesNew(ctx *middleware.Context) {
+	ctx.Data["Title"] = "New Release"
+	ctx.Data["IsRepoToolbarReleases"] = true
+	ctx.Data["IsRepoReleaseNew"] = true
+	ctx.HTML(200, "release/new")
+}

routers/repo/repo.go

@@ -0,0 +1,426 @@
+// Copyright 2014 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 repo
+
+import (
+	"encoding/base64"
+	"errors"
+	"fmt"
+	"path"
+	"path/filepath"
+	"strings"
+
+	"github.com/go-martini/martini"
+
+	"github.com/gogits/gogs/models"
+	"github.com/gogits/gogs/modules/auth"
+	"github.com/gogits/gogs/modules/base"
+	"github.com/gogits/gogs/modules/log"
+	"github.com/gogits/gogs/modules/middleware"
+)
+
+func Create(ctx *middleware.Context, form auth.CreateRepoForm) {
+	ctx.Data["Title"] = "Create repository"
+	ctx.Data["PageIsNewRepo"] = true // For navbar arrow.
+	ctx.Data["LanguageIgns"] = models.LanguageIgns
+	ctx.Data["Licenses"] = models.Licenses
+
+	if ctx.Req.Method == "GET" {
+		ctx.HTML(200, "repo/create")
+		return
+	}
+
+	if ctx.HasError() {
+		ctx.HTML(200, "repo/create")
+		return
+	}
+
+	_, err := models.CreateRepository(ctx.User, form.RepoName, form.Description,
+		form.Language, form.License, form.Visibility == "private", form.InitReadme == "on")
+	if err == nil {
+		log.Trace("%s Repository created: %s/%s", ctx.Req.RequestURI, ctx.User.LowerName, form.RepoName)
+		ctx.Redirect("/" + ctx.User.Name + "/" + form.RepoName)
+		return
+	} else if err == models.ErrRepoAlreadyExist {
+		ctx.RenderWithErr("Repository name has already been used", "repo/create", &form)
+		return
+	} else if err == models.ErrRepoNameIllegal {
+		ctx.RenderWithErr(models.ErrRepoNameIllegal.Error(), "repo/create", &form)
+		return
+	}
+	ctx.Handle(200, "repo.Create", err)
+}
+
+func Mirror(ctx *middleware.Context, form auth.CreateRepoForm) {
+	ctx.Data["Title"] = "Mirror repository"
+	ctx.Data["PageIsNewRepo"] = true // For navbar arrow.
+
+	if ctx.Req.Method == "GET" {
+		ctx.HTML(200, "repo/mirror")
+		return
+	}
+
+	if ctx.HasError() {
+		ctx.HTML(200, "repo/mirror")
+		return
+	}
+
+	_, err := models.CreateRepository(ctx.User, form.RepoName, form.Description,
+		"", form.License, form.Visibility == "private", false)
+	if err == nil {
+		log.Trace("%s Repository created: %s/%s", ctx.Req.RequestURI, ctx.User.LowerName, form.RepoName)
+		ctx.Redirect("/" + ctx.User.Name + "/" + form.RepoName)
+		return
+	} else if err == models.ErrRepoAlreadyExist {
+		ctx.RenderWithErr("Repository name has already been used", "repo/mirror", &form)
+		return
+	} else if err == models.ErrRepoNameIllegal {
+		ctx.RenderWithErr(models.ErrRepoNameIllegal.Error(), "repo/mirror", &form)
+		return
+	}
+	ctx.Handle(200, "repo.Mirror", err)
+}
+
+func Single(ctx *middleware.Context, params martini.Params) {
+	branchName := ctx.Repo.BranchName
+	commitId := ctx.Repo.CommitId
+	userName := ctx.Repo.Owner.Name
+	repoName := ctx.Repo.Repository.Name
+
+	repoLink := ctx.Repo.RepoLink
+	branchLink := ctx.Repo.RepoLink + "/src/" + branchName
+	rawLink := ctx.Repo.RepoLink + "/raw/" + branchName
+
+	// Get tree path
+	treename := params["_1"]
+
+	if len(treename) > 0 && treename[len(treename)-1] == '/' {
+		ctx.Redirect(repoLink + "/src/" + branchName + "/" + treename[:len(treename)-1])
+		return
+	}
+
+	ctx.Data["IsRepoToolbarSource"] = true
+
+	// Branches.
+	brs, err := models.GetBranches(userName, repoName)
+	if err != nil {
+		ctx.Handle(404, "repo.Single(GetBranches)", err)
+		return
+	}
+
+	ctx.Data["Branches"] = brs
+
+	isViewBranch := ctx.Repo.IsBranch
+	ctx.Data["IsViewBranch"] = isViewBranch
+
+	repoFile, err := models.GetTargetFile(userName, repoName,
+		branchName, commitId, treename)
+
+	if err != nil && err != models.ErrRepoFileNotExist {
+		ctx.Handle(404, "repo.Single(GetTargetFile)", err)
+		return
+	}
+
+	if len(treename) != 0 && repoFile == nil {
+		ctx.Handle(404, "repo.Single", nil)
+		return
+	}
+
+	if repoFile != nil && repoFile.IsFile() {
+		if blob, err := repoFile.LookupBlob(); err != nil {
+			ctx.Handle(404, "repo.Single(repoFile.LookupBlob)", err)
+		} else {
+			ctx.Data["FileSize"] = repoFile.Size
+			ctx.Data["IsFile"] = true
+			ctx.Data["FileName"] = repoFile.Name
+			ext := path.Ext(repoFile.Name)
+			if len(ext) > 0 {
+				ext = ext[1:]
+			}
+			ctx.Data["FileExt"] = ext
+			ctx.Data["FileLink"] = rawLink + "/" + treename
+
+			data := blob.Contents()
+			_, isTextFile := base.IsTextFile(data)
+			_, isImageFile := base.IsImageFile(data)
+			ctx.Data["FileIsText"] = isTextFile
+
+			if isImageFile {
+				ctx.Data["IsImageFile"] = true
+			} else {
+				readmeExist := base.IsMarkdownFile(repoFile.Name) || base.IsReadmeFile(repoFile.Name)
+				ctx.Data["ReadmeExist"] = readmeExist
+				if readmeExist {
+					ctx.Data["FileContent"] = string(base.RenderMarkdown(data, ""))
+				} else {
+					if isTextFile {
+						ctx.Data["FileContent"] = string(data)
+					}
+				}
+			}
+		}
+
+	} else {
+		// Directory and file list.
+		files, err := models.GetReposFiles(userName, repoName, ctx.Repo.CommitId, treename)
+		if err != nil {
+			ctx.Handle(404, "repo.Single(GetReposFiles)", err)
+			return
+		}
+
+		ctx.Data["Files"] = files
+
+		var readmeFile *models.RepoFile
+
+		for _, f := range files {
+			if !f.IsFile() || !base.IsReadmeFile(f.Name) {
+				continue
+			} else {
+				readmeFile = f
+				break
+			}
+		}
+
+		if readmeFile != nil {
+			ctx.Data["ReadmeInSingle"] = true
+			ctx.Data["ReadmeExist"] = true
+			if blob, err := readmeFile.LookupBlob(); err != nil {
+				ctx.Handle(404, "repo.Single(readmeFile.LookupBlob)", err)
+				return
+			} else {
+				ctx.Data["FileSize"] = readmeFile.Size
+				ctx.Data["FileLink"] = rawLink + "/" + treename
+				data := blob.Contents()
+				_, isTextFile := base.IsTextFile(data)
+				ctx.Data["FileIsText"] = isTextFile
+				ctx.Data["FileName"] = readmeFile.Name
+				if isTextFile {
+					ctx.Data["FileContent"] = string(base.RenderMarkdown(data, branchLink))
+				}
+			}
+		}
+	}
+
+	ctx.Data["Username"] = userName
+	ctx.Data["Reponame"] = repoName
+
+	var treenames []string
+	Paths := make([]string, 0)
+
+	if len(treename) > 0 {
+		treenames = strings.Split(treename, "/")
+		for i, _ := range treenames {
+			Paths = append(Paths, strings.Join(treenames[0:i+1], "/"))
+		}
+
+		ctx.Data["HasParentPath"] = true
+		if len(Paths)-2 >= 0 {
+			ctx.Data["ParentPath"] = "/" + Paths[len(Paths)-2]
+		}
+	}
+
+	ctx.Data["LastCommit"] = ctx.Repo.Commit
+	ctx.Data["Paths"] = Paths
+	ctx.Data["Treenames"] = treenames
+	ctx.Data["BranchLink"] = branchLink
+	ctx.HTML(200, "repo/single")
+}
+
+func SingleDownload(ctx *middleware.Context, params martini.Params) {
+	// Get tree path
+	treename := params["_1"]
+
+	branchName := params["branchname"]
+	userName := params["username"]
+	repoName := params["reponame"]
+
+	var commitId string
+	if !models.IsBranchExist(userName, repoName, branchName) {
+		commitId = branchName
+		branchName = ""
+	}
+
+	repoFile, err := models.GetTargetFile(userName, repoName,
+		branchName, commitId, treename)
+
+	if err != nil {
+		ctx.Handle(404, "repo.SingleDownload(GetTargetFile)", err)
+		return
+	}
+
+	blob, err := repoFile.LookupBlob()
+	if err != nil {
+		ctx.Handle(404, "repo.SingleDownload(LookupBlob)", err)
+		return
+	}
+
+	data := blob.Contents()
+	contentType, isTextFile := base.IsTextFile(data)
+	_, isImageFile := base.IsImageFile(data)
+	ctx.Res.Header().Set("Content-Type", contentType)
+	if !isTextFile && !isImageFile {
+		ctx.Res.Header().Set("Content-Disposition", "attachment; filename="+filepath.Base(treename))
+		ctx.Res.Header().Set("Content-Transfer-Encoding", "binary")
+	}
+	ctx.Res.Write(data)
+}
+
+func basicEncode(username, password string) string {
+	auth := username + ":" + password
+	return base64.StdEncoding.EncodeToString([]byte(auth))
+}
+
+func basicDecode(encoded string) (user string, name string, err error) {
+	var s []byte
+	s, err = base64.StdEncoding.DecodeString(encoded)
+	if err != nil {
+		return
+	}
+
+	a := strings.Split(string(s), ":")
+	if len(a) == 2 {
+		user, name = a[0], a[1]
+	} else {
+		err = errors.New("decode failed")
+	}
+	return
+}
+
+func authRequired(ctx *middleware.Context) {
+	ctx.ResponseWriter.Header().Set("WWW-Authenticate", "Basic realm=\".\"")
+	ctx.Data["ErrorMsg"] = "no basic auth and digit auth"
+	ctx.HTML(401, fmt.Sprintf("status/401"))
+}
+
+func Setting(ctx *middleware.Context, params martini.Params) {
+	if !ctx.Repo.IsOwner {
+		ctx.Handle(404, "repo.Setting", nil)
+		return
+	}
+
+	ctx.Data["IsRepoToolbarSetting"] = true
+
+	var title string
+	if t, ok := ctx.Data["Title"].(string); ok {
+		title = t
+	}
+
+	ctx.Data["Title"] = title + " - settings"
+	ctx.HTML(200, "repo/setting")
+}
+
+func SettingPost(ctx *middleware.Context) {
+	if !ctx.Repo.IsOwner {
+		ctx.Error(404)
+		return
+	}
+
+	switch ctx.Query("action") {
+	case "update":
+		isNameChanged := false
+		newRepoName := ctx.Query("name")
+		// Check if repository name has been changed.
+		if ctx.Repo.Repository.Name != newRepoName {
+			isExist, err := models.IsRepositoryExist(ctx.Repo.Owner, newRepoName)
+			if err != nil {
+				ctx.Handle(404, "repo.SettingPost(update: check existence)", err)
+				return
+			} else if isExist {
+				ctx.RenderWithErr("Repository name has been taken in your repositories.", "repo/setting", nil)
+				return
+			} else if err = models.ChangeRepositoryName(ctx.Repo.Owner.Name, ctx.Repo.Repository.Name, newRepoName); err != nil {
+				ctx.Handle(404, "repo.SettingPost(change repository name)", err)
+				return
+			}
+			log.Trace("%s Repository name changed: %s/%s -> %s", ctx.Req.RequestURI, ctx.User.Name, ctx.Repo.Repository.Name, newRepoName)
+
+			isNameChanged = true
+			ctx.Repo.Repository.Name = newRepoName
+		}
+
+		ctx.Repo.Repository.Description = ctx.Query("desc")
+		ctx.Repo.Repository.Website = ctx.Query("site")
+		ctx.Repo.Repository.IsGoget = ctx.Query("goget") == "on"
+		if err := models.UpdateRepository(ctx.Repo.Repository); err != nil {
+			ctx.Handle(404, "repo.SettingPost(update)", err)
+			return
+		}
+
+		ctx.Data["IsSuccess"] = true
+		if isNameChanged {
+			ctx.Redirect(fmt.Sprintf("/%s/%s/settings", ctx.Repo.Owner.Name, ctx.Repo.Repository.Name))
+		} else {
+			ctx.HTML(200, "repo/setting")
+		}
+		log.Trace("%s Repository updated: %s/%s", ctx.Req.RequestURI, ctx.Repo.Owner.Name, ctx.Repo.Repository.Name)
+	case "transfer":
+		if len(ctx.Repo.Repository.Name) == 0 || ctx.Repo.Repository.Name != ctx.Query("repository") {
+			ctx.RenderWithErr("Please make sure you entered repository name is correct.", "repo/setting", nil)
+			return
+		}
+
+		newOwner := ctx.Query("owner")
+		// Check if new owner exists.
+		isExist, err := models.IsUserExist(newOwner)
+		if err != nil {
+			ctx.Handle(404, "repo.SettingPost(transfer: check existence)", err)
+			return
+		} else if !isExist {
+			ctx.RenderWithErr("Please make sure you entered owner name is correct.", "repo/setting", nil)
+			return
+		} else if err = models.TransferOwnership(ctx.User, newOwner, ctx.Repo.Repository); err != nil {
+			ctx.Handle(404, "repo.SettingPost(transfer repository)", err)
+			return
+		}
+		log.Trace("%s Repository transfered: %s/%s -> %s", ctx.Req.RequestURI, ctx.User.Name, ctx.Repo.Repository.Name, newOwner)
+
+		ctx.Redirect("/")
+		return
+	case "delete":
+		if len(ctx.Repo.Repository.Name) == 0 || ctx.Repo.Repository.Name != ctx.Query("repository") {
+			ctx.RenderWithErr("Please make sure you entered repository name is correct.", "repo/setting", nil)
+			return
+		}
+
+		if err := models.DeleteRepository(ctx.User.Id, ctx.Repo.Repository.Id, ctx.User.LowerName); err != nil {
+			ctx.Handle(200, "repo.Delete", err)
+			return
+		}
+
+		log.Trace("%s Repository deleted: %s/%s", ctx.Req.RequestURI, ctx.User.LowerName, ctx.Repo.Repository.LowerName)
+		ctx.Redirect("/")
+	}
+}
+
+func Action(ctx *middleware.Context, params martini.Params) {
+	var err error
+	switch params["action"] {
+	case "watch":
+		err = models.WatchRepo(ctx.User.Id, ctx.Repo.Repository.Id, true)
+	case "unwatch":
+		err = models.WatchRepo(ctx.User.Id, ctx.Repo.Repository.Id, false)
+	case "desc":
+		if !ctx.Repo.IsOwner {
+			ctx.Error(404)
+			return
+		}
+
+		ctx.Repo.Repository.Description = ctx.Query("desc")
+		ctx.Repo.Repository.Website = ctx.Query("site")
+		err = models.UpdateRepository(ctx.Repo.Repository)
+	}
+
+	if err != nil {
+		log.Error("repo.Action(%s): %v", params["action"], err)
+		ctx.JSON(200, map[string]interface{}{
+			"ok":  false,
+			"err": err.Error(),
+		})
+		return
+	}
+	ctx.JSON(200, map[string]interface{}{
+		"ok": true,
+	})
+}