Limit repo size

models/migrations/migrations.go

@@ -442,6 +442,8 @@ var migrations = []Migration{
 	NewMigration("Add package cleanup rule table", v1_19.CreatePackageCleanupRuleTable),
 	// v235 -> v236
 	NewMigration("Add index for access_token", v1_19.AddIndexForAccessToken),
+	// to modify later
+	NewMigration("add size limit on repository", addSizeLimitOnRepo),
 }
 
 // GetCurrentDBVersion returns the current db version

models/migrations/v160.go

@@ -0,0 +1,15 @@
+// Copyright 2022 The Gitea Authors. All rights reserved.
+// SPDX-License-Identifier: MIT
+
+package migrations
+
+import "xorm.io/xorm"
+
+func addSizeLimitOnRepo(x *xorm.Engine) error {
+	type Repository struct {
+		ID        int64 `xorm:"pk autoincr"`
+		SizeLimit int64 `xorm:"NOT NULL DEFAULT 0"`
+	}
+
+	return x.Sync2(new(Repository))
+}

models/repo/repo.go

@@ -160,6 +160,7 @@ type Repository struct {
 	IsTemplate                      bool               `xorm:"INDEX NOT NULL DEFAULT false"`
 	TemplateID                      int64              `xorm:"INDEX"`
 	Size                            int64              `xorm:"NOT NULL DEFAULT 0"`
+	SizeLimit                       int64              `xorm:"NOT NULL DEFAULT 0"`
 	CodeIndexerStatus               *RepoIndexerStatus `xorm:"-"`
 	StatsIndexerStatus              *RepoIndexerStatus `xorm:"-"`
 	IsFsckEnabled                   bool               `xorm:"NOT NULL DEFAULT true"`
@@ -506,6 +507,45 @@ func (repo *Repository) IsOwnedBy(userID int64) bool {
 	return repo.OwnerID == userID
 }
 
+// TODO - DmitryFrolovTri Review every commented function and see if we need to reinstate it
+// func (repo *Repository) computeSize() (int64, error) {
+// 	size, err := util.GetDirectorySize(repo.RepoPath())
+// 	if err != nil {
+// 		return 0, fmt.Errorf("computeSize: %v", err)
+// 	}
+
+// 	objs, err := repo.GetLFSMetaObjects(repo.ID, -1, 0)
+// 	if err != nil {
+// 		return 0, fmt.Errorf("computeSize: GetLFSMetaObjects: %v", err)
+// 	}
+// 	for _, obj := range objs {
+// 		size += obj.Size
+// 	}
+
+// 	return size, nil
+// }
+
+// func (repo *Repository) updateSize(ctx context.Context Engine) error {
+// 	size, err := repo.computeSize()
+// 	if err != nil {
+// 		return fmt.Errorf("updateSize: %v", err)
+// 	}
+
+// 	repo.Size = size
+// 	_, err = e.ID(repo.ID).Cols("size").Update(repo)
+// 	return err
+// }
+
+// // UpdateSize updates the repository size, calculating it using util.GetDirectorySize
+// func (repo *Repository) UpdateSize(ctx DBContext) error {
+// 	return repo.updateSize(ctx.e)
+// }
+
+// RepoSizeIsOversized return if is over size limitation
+func (repo *Repository) RepoSizeIsOversized(additionalSize int64) bool {
+	return repo.SizeLimit > 0 && repo.Size+additionalSize > repo.SizeLimit
+}
+
 // CanCreateBranch returns true if repository meets the requirements for creating new branches.
 func (repo *Repository) CanCreateBranch() bool {
 	return !repo.IsMirror

modules/git/repo.go

@@ -256,6 +256,74 @@ func Push(ctx context.Context, repoPath string, opts PushOptions) error {
 	return err
 }
 
+// CountObject represents repository count objects report
+type CountObject struct {
+	Count       int64
+	Size        int64
+	InPack      int64
+	Packs       int64
+	SizePack    int64
+	PrunePack   int64
+	Garbage     int64
+	SizeGarbage int64
+}
+
+const (
+	statCount        = "count: "
+	statSize         = "size: "
+	statInpack       = "in-pack: "
+	statPacks        = "packs: "
+	statSizePack     = "size-pack: "
+	statPrunePackage = "prune-package: "
+	statGarbage      = "garbage: "
+	statSizeGarbage  = "size-garbage: "
+)
+
+// CountObjects returns the results of git count-objects on the repoPath
+func CountObjects(ctx context.Context, repoPath string) (*CountObject, error) {
+	return CountObjectsWithEnv(ctx, repoPath, nil)
+}
+
+// CountObjectsWithEnv returns the results of git count-objects on the repoPath with custom env setup
+func CountObjectsWithEnv(ctx context.Context, repoPath string, env []string) (*CountObject, error) {
+	cmd := NewCommand(ctx, "count-objects", "-v")
+	stdout, _, err := cmd.RunStdString(&RunOpts{Dir: repoPath, Env: env})
+	if err != nil {
+		return nil, err
+	}
+
+	return parseSize(stdout), nil
+}
+
+// parseSize parses the output from count-objects and return a CountObject
+func parseSize(objects string) *CountObject {
+	repoSize := new(CountObject)
+	for _, line := range strings.Split(objects, "\n") {
+		switch {
+		case strings.HasPrefix(line, statCount):
+			repoSize.Count, _ = strconv.ParseInt(line[7:], 10, 64)
+		case strings.HasPrefix(line, statSize):
+			number, _ := strconv.ParseInt(line[6:], 10, 64)
+			repoSize.Size = number * 1024
+		case strings.HasPrefix(line, statInpack):
+			repoSize.InPack, _ = strconv.ParseInt(line[9:], 10, 64)
+		case strings.HasPrefix(line, statPacks):
+			repoSize.Packs, _ = strconv.ParseInt(line[7:], 10, 64)
+		case strings.HasPrefix(line, statSizePack):
+			number, _ := strconv.ParseInt(line[11:], 10, 64)
+			repoSize.SizePack = number * 1024
+		case strings.HasPrefix(line, statPrunePackage):
+			repoSize.PrunePack, _ = strconv.ParseInt(line[16:], 10, 64)
+		case strings.HasPrefix(line, statGarbage):
+			repoSize.Garbage, _ = strconv.ParseInt(line[9:], 10, 64)
+		case strings.HasPrefix(line, statSizeGarbage):
+			number, _ := strconv.ParseInt(line[14:], 10, 64)
+			repoSize.SizeGarbage = number * 1024
+		}
+	}
+	return repoSize
+}
+
 // GetLatestCommitTime returns time for latest commit in repository (across all branches)
 func GetLatestCommitTime(ctx context.Context, repoPath string) (time.Time, error) {
 	cmd := NewCommand(ctx, "for-each-ref", "--sort=-committerdate", BranchPrefix, "--count", "1", "--format=%(committerdate)")

modules/repository/create.go

@@ -168,6 +168,7 @@ type CreateRepoOptions struct {
 	Status         repo_model.RepositoryStatus
 	TrustModel     repo_model.TrustModelType
 	MirrorInterval string
+	SizeLimit      int64
 }
 
 // CreateRepository creates a repository for the user/organization.
@@ -205,6 +206,7 @@ func CreateRepository(doer, u *user_model.User, opts CreateRepoOptions) (*repo_m
 		Status:                          opts.Status,
 		IsEmpty:                         !opts.AutoInit,
 		TrustModel:                      opts.TrustModel,
+		SizeLimit:                       opts.SizeLimit,
 		IsMirror:                        opts.IsMirror,
 	}
 

modules/structs/repo.go

@@ -132,6 +132,8 @@ type CreateRepoOption struct {
 	// TrustModel of the repository
 	// enum: default,collaborator,committer,collaboratorcommitter
 	TrustModel string `json:"trust_model"`
+	// SizeLimit of the repository
+	SizeLimit int64 `json:"size_limit"`
 }
 
 // EditRepoOption options when editing a repository's properties
@@ -188,6 +190,8 @@ type EditRepoOption struct {
 	DefaultMergeStyle *string `json:"default_merge_style,omitempty"`
 	// set to `true` to archive this repository.
 	Archived *bool `json:"archived,omitempty"`
+	// SizeLimit of the repository.
+	SizeLimit *int64 `json:"size_limit,omitempty"`
 	// set to a string like `8h30m0s` to set the mirror interval time
 	MirrorInterval *string `json:"mirror_interval,omitempty"`
 	// enable prune - remove obsolete remote-tracking references

options/locale/locale_en-US.ini

@@ -840,6 +840,7 @@ owner_helper = Some organizations may not show up in the dropdown due to a maxim
 repo_name = Repository Name
 repo_name_helper = Good repository names use short, memorable and unique keywords.
 repo_size = Repository Size
+repo_size_limit = Repository Size Limit
 template = Template
 template_select = Select a template.
 template_helper = Make repository a template
@@ -953,6 +954,8 @@ form.reach_limit_of_creation_1 = The owner has already reached the limit of %d r
 form.reach_limit_of_creation_n = The owner has already reached the limit of %d repositories.
 form.name_reserved = The repository name '%s' is reserved.
 form.name_pattern_not_allowed = The pattern '%s' is not allowed in a repository name.
+form.repo_size_limit_negative = Repository size limitation cannot be negative.
+form.repo_size_limit_only_by_admins = Only administrators can change the repository size limitation.
 
 need_auth = Authorization
 migrate_options = Migration Options

routers/api/v1/repo/repo.go

@@ -242,6 +242,7 @@ func CreateUserRepo(ctx *context.APIContext, owner *user_model.User, opt api.Cre
 		DefaultBranch: opt.DefaultBranch,
 		TrustModel:    repo_model.ToTrustModel(opt.TrustModel),
 		IsTemplate:    opt.Template,
+		SizeLimit:     opt.SizeLimit,
 	})
 	if err != nil {
 		if repo_model.IsErrRepoAlreadyExist(err) {
@@ -714,6 +715,10 @@ func updateBasicProperties(ctx *context.APIContext, opts api.EditRepoOption) err
 		repo.DefaultBranch = *opts.DefaultBranch
 	}
 
+	if opts.SizeLimit != nil {
+		repo.SizeLimit = *opts.SizeLimit
+	}
+
 	if err := repo_service.UpdateRepository(repo, visibilityChanged); err != nil {
 		ctx.Error(http.StatusInternalServerError, "UpdateRepository", err)
 		return err

routers/private/hook_pre_receive.go

@@ -113,12 +113,35 @@ func HookPreReceive(ctx *gitea_context.PrivateContext) {
 		opts:           opts,
 	}
 
+	repo := ourCtx.Repo.Repository
+
+	pushSize, err := git.CountObjectsWithEnv(ctx, repo.RepoPath(), ourCtx.env)
+	if err != nil {
+		log.Error("Unable to get repository size with env %v: %s Error: %v", repo.RepoPath(), ourCtx.env, err)
+		ctx.JSON(http.StatusInternalServerError, map[string]interface{}{
+			"err": err.Error(),
+		})
+		return
+	}
+	log.Trace("Push size %d", pushSize.Size)
+
 	// Iterate across the provided old commit IDs
 	for i := range opts.OldCommitIDs {
 		oldCommitID := opts.OldCommitIDs[i]
 		newCommitID := opts.NewCommitIDs[i]
 		refFullName := opts.RefFullNames[i]
 
+		// Check size
+		if newCommitID != git.EmptySHA && repo.RepoSizeIsOversized(pushSize.Size) { // Check next size if we are not deleting a reference
+			log.Warn("Forbidden: new repo size is over limitation: %d", repo.SizeLimit)
+			ctx.JSON(http.StatusForbidden, map[string]interface{}{
+				"err": fmt.Sprintf("new repo size is over limitation: %d", repo.SizeLimit),
+			})
+		}
+		// TODO investigate why on force push some git objects are not cleaned on server side.
+		// TODO corner-case force push and branch creation -> git.EmptySHA == oldCommitID
+		// TODO calculate pushed LFS objects size
+
 		switch {
 		case strings.HasPrefix(refFullName, git.BranchPrefix):
 			preReceiveBranch(ourCtx, oldCommitID, newCommitID, refFullName)

routers/web/repo/repo.go

@@ -267,6 +267,7 @@ func CreatePost(ctx *context.Context) {
 			AutoInit:      form.AutoInit,
 			IsTemplate:    form.Template,
 			TrustModel:    repo_model.ToTrustModel(form.TrustModel),
+			SizeLimit:     form.SizeLimit,
 		})
 		if err == nil {
 			log.Trace("Repository created [%d]: %s/%s", repo.ID, ctxUser.Name, repo.Name)

routers/web/repo/setting.go

@@ -68,6 +68,7 @@ func SettingsCtxData(ctx *context.Context) {
 	ctx.Data["DisableNewPushMirrors"] = setting.Mirror.DisableNewPush
 	ctx.Data["DefaultMirrorInterval"] = setting.Mirror.DefaultInterval
 	ctx.Data["MinimumMirrorInterval"] = setting.Mirror.MinInterval
+	ctx.Data["Err_RepoSize"] = ctx.Repo.Repository.RepoSizeIsOversized(ctx.Repo.Repository.SizeLimit / 10) // less than 10% left
 
 	signing, _ := asymkey_service.SigningKey(ctx, ctx.Repo.Repository.RepoPath())
 	ctx.Data["SigningKeyAvailable"] = len(signing) > 0
@@ -119,6 +120,7 @@ func SettingsPost(ctx *context.Context) {
 	ctx.Data["CodeIndexerEnabled"] = setting.Indexer.RepoIndexerEnabled
 
 	repo := ctx.Repo.Repository
+	ctx.Data["Err_RepoSize"] = repo.RepoSizeIsOversized(repo.SizeLimit / 10) // less than 10% left
 
 	switch ctx.FormString("action") {
 	case "update":
@@ -183,6 +185,19 @@ func SettingsPost(ctx *context.Context) {
 			return
 		}
 
+		if form.RepoSizeLimit < 0 {
+			ctx.Data["Err_RepoSizeLimit"] = true
+			ctx.RenderWithErr(ctx.Tr("repo.form.repo_size_limit_negative"), tplSettingsOptions, &form)
+			return
+		}
+
+		if !ctx.Doer.IsAdmin && repo.SizeLimit != form.RepoSizeLimit {
+			ctx.Data["Err_RepoSizeLimit"] = true
+			ctx.RenderWithErr(ctx.Tr("repo.form.repo_size_limit_only_by_admins"), tplSettingsOptions, &form)
+			return
+		}
+		repo.SizeLimit = form.RepoSizeLimit
+
 		repo.IsPrivate = form.Private
 		if err := repo_service.UpdateRepository(repo, visibilityChanged); err != nil {
 			ctx.ServerError("UpdateRepository", err)

services/forms/repo_form.go

@@ -50,6 +50,7 @@ type CreateRepoForm struct {
 	Avatar       bool
 	Labels       bool
 	TrustModel   string
+	SizeLimit    int64
 }
 
 // Validate validates the fields
@@ -132,6 +133,7 @@ type RepoSettingForm struct {
 	Private                bool
 	Template               bool
 	EnablePrune            bool
+	RepoSizeLimit          int64
 
 	// Advanced settings
 	EnableWiki                            bool

templates/repo/settings/options.tmpl

@@ -17,6 +17,12 @@
 					<input id="repo_name" name="repo_name" value="{{.Repository.Name}}" data-repo-name="{{.Repository.Name}}" autofocus required>
 				</div>
 				<div class="inline field">
+					<label>{{.i18n.Tr "repo.repo_size"}}</label>
+					<span {{if .Err_RepoSize}}class="ui text red"{{end}}>{{FileSize .Repository.Size}}{{if .Repository.SizeLimit}}/{{FileSize .Repository.SizeLimit}}{{end}}</span>
+				</div>
+				<div class="field {{if .Err_RepoSizeLimit}}error{{end}}" {{if not .IsAdmin}}style="display:none;"{{end}}>
+					<label for="repo_size_limit">{{.locale.Tr "repo.repo_size_limit"}}</label>
+					<input id="repo_size_limit" name="repo_size_limit" type="number" value="{{.Repository.SizeLimit}}" data-repo-size-limit="{{.Repository.SizeLimit}}">
 					<label>{{.locale.Tr "repo.repo_size"}}</label>
 					<span>{{FileSize .Repository.Size}}</span>
 				</div>

tests/integration/api_helper_for_declarative_test.go

@@ -461,3 +461,17 @@ func doAPIAddRepoToOrganizationTeam(ctx APITestContext, teamID int64, orgName, r
 		ctx.Session.MakeRequest(t, req, http.StatusNoContent)
 	}
 }
+
+func doAPISetRepoSizeLimit(ctx APITestContext, owner, repo string, size int64) func(*testing.T) {
+	return func(t *testing.T) {
+		urlStr := fmt.Sprintf("/api/v1/repos/%s/%s?token=%s",
+			owner, repo, ctx.Token)
+		req := NewRequestWithJSON(t, http.MethodPatch, urlStr, &api.EditRepoOption{SizeLimit: &size})
+
+		if ctx.ExpectedCode != 0 {
+			ctx.Session.MakeRequest(t, req, ctx.ExpectedCode)
+			return
+		}
+		ctx.Session.MakeRequest(t, req, 200)
+	}
+}