code.gitea.io/gitea@v1.19.3/modules/setting/packages.go (about)

     1  // Copyright 2022 The Gitea Authors. All rights reserved.
     2  // SPDX-License-Identifier: MIT
     3  
     4  package setting
     5  
     6  import (
     7  	"math"
     8  	"net/url"
     9  	"os"
    10  	"path/filepath"
    11  
    12  	"code.gitea.io/gitea/modules/log"
    13  
    14  	"github.com/dustin/go-humanize"
    15  	ini "gopkg.in/ini.v1"
    16  )
    17  
    18  // Package registry settings
    19  var (
    20  	Packages = struct {
    21  		Storage
    22  		Enabled           bool
    23  		ChunkedUploadPath string
    24  		RegistryHost      string
    25  
    26  		LimitTotalOwnerCount int64
    27  		LimitTotalOwnerSize  int64
    28  		LimitSizeCargo       int64
    29  		LimitSizeChef        int64
    30  		LimitSizeComposer    int64
    31  		LimitSizeConan       int64
    32  		LimitSizeConda       int64
    33  		LimitSizeContainer   int64
    34  		LimitSizeGeneric     int64
    35  		LimitSizeHelm        int64
    36  		LimitSizeMaven       int64
    37  		LimitSizeNpm         int64
    38  		LimitSizeNuGet       int64
    39  		LimitSizePub         int64
    40  		LimitSizePyPI        int64
    41  		LimitSizeRubyGems    int64
    42  		LimitSizeVagrant     int64
    43  	}{
    44  		Enabled:              true,
    45  		LimitTotalOwnerCount: -1,
    46  	}
    47  )
    48  
    49  func loadPackagesFrom(rootCfg ConfigProvider) {
    50  	sec := rootCfg.Section("packages")
    51  	if err := sec.MapTo(&Packages); err != nil {
    52  		log.Fatal("Failed to map Packages settings: %v", err)
    53  	}
    54  
    55  	Packages.Storage = getStorage(rootCfg, "packages", "", nil)
    56  
    57  	appURL, _ := url.Parse(AppURL)
    58  	Packages.RegistryHost = appURL.Host
    59  
    60  	Packages.ChunkedUploadPath = filepath.ToSlash(sec.Key("CHUNKED_UPLOAD_PATH").MustString("tmp/package-upload"))
    61  	if !filepath.IsAbs(Packages.ChunkedUploadPath) {
    62  		Packages.ChunkedUploadPath = filepath.ToSlash(filepath.Join(AppDataPath, Packages.ChunkedUploadPath))
    63  	}
    64  
    65  	if err := os.MkdirAll(Packages.ChunkedUploadPath, os.ModePerm); err != nil {
    66  		log.Error("Unable to create chunked upload directory: %s (%v)", Packages.ChunkedUploadPath, err)
    67  	}
    68  
    69  	Packages.LimitTotalOwnerSize = mustBytes(sec, "LIMIT_TOTAL_OWNER_SIZE")
    70  	Packages.LimitSizeCargo = mustBytes(sec, "LIMIT_SIZE_CARGO")
    71  	Packages.LimitSizeChef = mustBytes(sec, "LIMIT_SIZE_CHEF")
    72  	Packages.LimitSizeComposer = mustBytes(sec, "LIMIT_SIZE_COMPOSER")
    73  	Packages.LimitSizeConan = mustBytes(sec, "LIMIT_SIZE_CONAN")
    74  	Packages.LimitSizeConda = mustBytes(sec, "LIMIT_SIZE_CONDA")
    75  	Packages.LimitSizeContainer = mustBytes(sec, "LIMIT_SIZE_CONTAINER")
    76  	Packages.LimitSizeGeneric = mustBytes(sec, "LIMIT_SIZE_GENERIC")
    77  	Packages.LimitSizeHelm = mustBytes(sec, "LIMIT_SIZE_HELM")
    78  	Packages.LimitSizeMaven = mustBytes(sec, "LIMIT_SIZE_MAVEN")
    79  	Packages.LimitSizeNpm = mustBytes(sec, "LIMIT_SIZE_NPM")
    80  	Packages.LimitSizeNuGet = mustBytes(sec, "LIMIT_SIZE_NUGET")
    81  	Packages.LimitSizePub = mustBytes(sec, "LIMIT_SIZE_PUB")
    82  	Packages.LimitSizePyPI = mustBytes(sec, "LIMIT_SIZE_PYPI")
    83  	Packages.LimitSizeRubyGems = mustBytes(sec, "LIMIT_SIZE_RUBYGEMS")
    84  	Packages.LimitSizeVagrant = mustBytes(sec, "LIMIT_SIZE_VAGRANT")
    85  }
    86  
    87  func mustBytes(section *ini.Section, key string) int64 {
    88  	const noLimit = "-1"
    89  
    90  	value := section.Key(key).MustString(noLimit)
    91  	if value == noLimit {
    92  		return -1
    93  	}
    94  	bytes, err := humanize.ParseBytes(value)
    95  	if err != nil || bytes > math.MaxInt64 {
    96  		return -1
    97  	}
    98  	return int64(bytes)
    99  }