code.gitea.io/gitea@v1.22.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  	"fmt"
     8  	"math"
     9  	"os"
    10  	"path/filepath"
    11  
    12  	"github.com/dustin/go-humanize"
    13  )
    14  
    15  // Package registry settings
    16  var (
    17  	Packages = struct {
    18  		Storage           *Storage
    19  		Enabled           bool
    20  		ChunkedUploadPath string
    21  
    22  		LimitTotalOwnerCount int64
    23  		LimitTotalOwnerSize  int64
    24  		LimitSizeAlpine      int64
    25  		LimitSizeCargo       int64
    26  		LimitSizeChef        int64
    27  		LimitSizeComposer    int64
    28  		LimitSizeConan       int64
    29  		LimitSizeConda       int64
    30  		LimitSizeContainer   int64
    31  		LimitSizeCran        int64
    32  		LimitSizeDebian      int64
    33  		LimitSizeGeneric     int64
    34  		LimitSizeGo          int64
    35  		LimitSizeHelm        int64
    36  		LimitSizeMaven       int64
    37  		LimitSizeNpm         int64
    38  		LimitSizeNuGet       int64
    39  		LimitSizePub         int64
    40  		LimitSizePyPI        int64
    41  		LimitSizeRpm         int64
    42  		LimitSizeRubyGems    int64
    43  		LimitSizeSwift       int64
    44  		LimitSizeVagrant     int64
    45  	}{
    46  		Enabled:              true,
    47  		LimitTotalOwnerCount: -1,
    48  	}
    49  )
    50  
    51  func loadPackagesFrom(rootCfg ConfigProvider) (err error) {
    52  	sec, _ := rootCfg.GetSection("packages")
    53  	if sec == nil {
    54  		Packages.Storage, err = getStorage(rootCfg, "packages", "", nil)
    55  		return err
    56  	}
    57  
    58  	if err = sec.MapTo(&Packages); err != nil {
    59  		return fmt.Errorf("failed to map Packages settings: %v", err)
    60  	}
    61  
    62  	Packages.Storage, err = getStorage(rootCfg, "packages", "", sec)
    63  	if err != nil {
    64  		return err
    65  	}
    66  
    67  	Packages.ChunkedUploadPath = filepath.ToSlash(sec.Key("CHUNKED_UPLOAD_PATH").MustString("tmp/package-upload"))
    68  	if !filepath.IsAbs(Packages.ChunkedUploadPath) {
    69  		Packages.ChunkedUploadPath = filepath.ToSlash(filepath.Join(AppDataPath, Packages.ChunkedUploadPath))
    70  	}
    71  
    72  	if HasInstallLock(rootCfg) {
    73  		if err := os.MkdirAll(Packages.ChunkedUploadPath, os.ModePerm); err != nil {
    74  			return fmt.Errorf("unable to create chunked upload directory: %s (%v)", Packages.ChunkedUploadPath, err)
    75  		}
    76  	}
    77  
    78  	Packages.LimitTotalOwnerSize = mustBytes(sec, "LIMIT_TOTAL_OWNER_SIZE")
    79  	Packages.LimitSizeAlpine = mustBytes(sec, "LIMIT_SIZE_ALPINE")
    80  	Packages.LimitSizeCargo = mustBytes(sec, "LIMIT_SIZE_CARGO")
    81  	Packages.LimitSizeChef = mustBytes(sec, "LIMIT_SIZE_CHEF")
    82  	Packages.LimitSizeComposer = mustBytes(sec, "LIMIT_SIZE_COMPOSER")
    83  	Packages.LimitSizeConan = mustBytes(sec, "LIMIT_SIZE_CONAN")
    84  	Packages.LimitSizeConda = mustBytes(sec, "LIMIT_SIZE_CONDA")
    85  	Packages.LimitSizeContainer = mustBytes(sec, "LIMIT_SIZE_CONTAINER")
    86  	Packages.LimitSizeCran = mustBytes(sec, "LIMIT_SIZE_CRAN")
    87  	Packages.LimitSizeDebian = mustBytes(sec, "LIMIT_SIZE_DEBIAN")
    88  	Packages.LimitSizeGeneric = mustBytes(sec, "LIMIT_SIZE_GENERIC")
    89  	Packages.LimitSizeGo = mustBytes(sec, "LIMIT_SIZE_GO")
    90  	Packages.LimitSizeHelm = mustBytes(sec, "LIMIT_SIZE_HELM")
    91  	Packages.LimitSizeMaven = mustBytes(sec, "LIMIT_SIZE_MAVEN")
    92  	Packages.LimitSizeNpm = mustBytes(sec, "LIMIT_SIZE_NPM")
    93  	Packages.LimitSizeNuGet = mustBytes(sec, "LIMIT_SIZE_NUGET")
    94  	Packages.LimitSizePub = mustBytes(sec, "LIMIT_SIZE_PUB")
    95  	Packages.LimitSizePyPI = mustBytes(sec, "LIMIT_SIZE_PYPI")
    96  	Packages.LimitSizeRpm = mustBytes(sec, "LIMIT_SIZE_RPM")
    97  	Packages.LimitSizeRubyGems = mustBytes(sec, "LIMIT_SIZE_RUBYGEMS")
    98  	Packages.LimitSizeSwift = mustBytes(sec, "LIMIT_SIZE_SWIFT")
    99  	Packages.LimitSizeVagrant = mustBytes(sec, "LIMIT_SIZE_VAGRANT")
   100  	return nil
   101  }
   102  
   103  func mustBytes(section ConfigSection, key string) int64 {
   104  	const noLimit = "-1"
   105  
   106  	value := section.Key(key).MustString(noLimit)
   107  	if value == noLimit {
   108  		return -1
   109  	}
   110  	bytes, err := humanize.ParseBytes(value)
   111  	if err != nil || bytes > math.MaxInt64 {
   112  		return -1
   113  	}
   114  	return int64(bytes)
   115  }