2020-08-17 23:23:45 -05:00
// Copyright 2020 The Gitea Authors. All rights reserved.
2022-11-27 13:20:29 -05:00
// SPDX-License-Identifier: MIT
2020-08-17 23:23:45 -05:00
package storage
import (
2020-10-12 22:58:34 -05:00
"context"
2023-03-21 15:02:49 -05:00
"fmt"
2020-08-17 23:23:45 -05:00
"io"
"net/url"
"os"
"path/filepath"
2020-10-15 22:51:06 -05:00
"code.gitea.io/gitea/modules/log"
2020-08-17 23:23:45 -05:00
"code.gitea.io/gitea/modules/util"
)
2022-01-20 12:46:10 -05:00
var _ ObjectStorage = & LocalStorage { }
2020-08-17 23:23:45 -05:00
2020-10-12 22:58:34 -05:00
// LocalStorageType is the type descriptor for local storage
const LocalStorageType Type = "local"
// LocalStorageConfig represents the configuration for a local storage
type LocalStorageConfig struct {
2021-03-05 08:19:17 -05:00
Path string ` ini:"PATH" `
TemporaryPath string ` ini:"TEMPORARY_PATH" `
2020-10-12 22:58:34 -05:00
}
2020-08-17 23:23:45 -05:00
// LocalStorage represents a local files storage
type LocalStorage struct {
2021-03-05 08:19:17 -05:00
ctx context . Context
dir string
tmpdir string
2020-08-17 23:23:45 -05:00
}
// NewLocalStorage returns a local files
2020-10-12 22:58:34 -05:00
func NewLocalStorage ( ctx context . Context , cfg interface { } ) ( ObjectStorage , error ) {
configInterface , err := toConfig ( LocalStorageConfig { } , cfg )
if err != nil {
return nil , err
}
config := configInterface . ( LocalStorageConfig )
2023-03-21 15:02:49 -05:00
if ! filepath . IsAbs ( config . Path ) {
return nil , fmt . Errorf ( "LocalStorageConfig.Path should have been prepared by setting/storage.go and should be an absolute path, but not: %q" , config . Path )
}
2020-10-15 22:51:06 -05:00
log . Info ( "Creating new Local Storage at %s" , config . Path )
2020-10-12 22:58:34 -05:00
if err := os . MkdirAll ( config . Path , os . ModePerm ) ; err != nil {
2020-08-17 23:23:45 -05:00
return nil , err
}
2021-03-05 08:19:17 -05:00
if config . TemporaryPath == "" {
2023-03-21 15:02:49 -05:00
config . TemporaryPath = filepath . Join ( config . Path , "tmp" )
}
if ! filepath . IsAbs ( config . TemporaryPath ) {
return nil , fmt . Errorf ( "LocalStorageConfig.TemporaryPath should be an absolute path, but not: %q" , config . TemporaryPath )
2021-03-05 08:19:17 -05:00
}
2020-08-17 23:23:45 -05:00
return & LocalStorage {
2021-03-05 08:19:17 -05:00
ctx : ctx ,
dir : config . Path ,
tmpdir : config . TemporaryPath ,
2020-08-17 23:23:45 -05:00
} , nil
}
2022-03-22 16:02:26 -05:00
func ( l * LocalStorage ) buildLocalPath ( p string ) string {
2023-03-21 15:02:49 -05:00
return util . FilePathJoinAbs ( l . dir , p )
2022-03-22 16:02:26 -05:00
}
2020-08-17 23:23:45 -05:00
// Open a file
2020-09-08 10:45:10 -05:00
func ( l * LocalStorage ) Open ( path string ) ( Object , error ) {
2022-03-22 16:02:26 -05:00
return os . Open ( l . buildLocalPath ( path ) )
2020-08-17 23:23:45 -05:00
}
// Save a file
2021-04-03 11:19:59 -05:00
func ( l * LocalStorage ) Save ( path string , r io . Reader , size int64 ) ( int64 , error ) {
2022-03-22 16:02:26 -05:00
p := l . buildLocalPath ( path )
2020-08-17 23:23:45 -05:00
if err := os . MkdirAll ( filepath . Dir ( p ) , os . ModePerm ) ; err != nil {
return 0 , err
}
2021-03-05 08:19:17 -05:00
// Create a temporary file to save to
if err := os . MkdirAll ( l . tmpdir , os . ModePerm ) ; err != nil {
2020-08-17 23:23:45 -05:00
return 0 , err
}
2021-09-22 00:38:34 -05:00
tmp , err := os . CreateTemp ( l . tmpdir , "upload-*" )
2021-03-05 08:19:17 -05:00
if err != nil {
return 0 , err
}
tmpRemoved := false
defer func ( ) {
if ! tmpRemoved {
_ = util . Remove ( tmp . Name ( ) )
}
} ( )
2020-08-17 23:23:45 -05:00
2021-03-05 08:19:17 -05:00
n , err := io . Copy ( tmp , r )
2020-08-17 23:23:45 -05:00
if err != nil {
return 0 , err
}
2021-03-05 08:19:17 -05:00
if err := tmp . Close ( ) ; err != nil {
return 0 , err
}
2021-07-15 10:46:07 -05:00
if err := util . Rename ( tmp . Name ( ) , p ) ; err != nil {
2021-03-05 08:19:17 -05:00
return 0 , err
}
2022-09-24 08:04:14 -05:00
// Golang's tmp file (os.CreateTemp) always have 0o600 mode, so we need to change the file to follow the umask (as what Create/MkDir does)
2022-12-18 19:50:36 -05:00
// but we don't want to make these files executable - so ensure that we mask out the executable bits
if err := util . ApplyUmask ( p , os . ModePerm & 0 o666 ) ; err != nil {
2022-09-24 08:04:14 -05:00
return 0 , err
}
2021-03-05 08:19:17 -05:00
tmpRemoved = true
return n , nil
2020-08-17 23:23:45 -05:00
}
2020-09-08 10:45:10 -05:00
// Stat returns the info of the file
2020-09-29 04:05:13 -05:00
func ( l * LocalStorage ) Stat ( path string ) ( os . FileInfo , error ) {
2022-03-22 16:02:26 -05:00
return os . Stat ( l . buildLocalPath ( path ) )
2022-03-14 10:18:27 -05:00
}
2020-08-17 23:23:45 -05:00
// Delete delete a file
func ( l * LocalStorage ) Delete ( path string ) error {
2022-03-22 16:02:26 -05:00
return util . Remove ( l . buildLocalPath ( path ) )
2020-08-17 23:23:45 -05:00
}
// URL gets the redirect URL to a file
func ( l * LocalStorage ) URL ( path , name string ) ( * url . URL , error ) {
return nil , ErrURLNotSupported
}
2020-09-29 04:05:13 -05:00
// IterateObjects iterates across the objects in the local storage
2023-05-13 17:33:25 -05:00
func ( l * LocalStorage ) IterateObjects ( dirName string , fn func ( path string , obj Object ) error ) error {
dir := l . buildLocalPath ( dirName )
2023-03-13 05:23:51 -05:00
return filepath . WalkDir ( dir , func ( path string , d os . DirEntry , err error ) error {
2020-09-29 04:05:13 -05:00
if err != nil {
return err
}
2020-10-12 22:58:34 -05:00
select {
case <- l . ctx . Done ( ) :
return l . ctx . Err ( )
default :
}
2020-09-29 04:05:13 -05:00
if path == l . dir {
return nil
}
2023-01-16 11:21:44 -05:00
if d . IsDir ( ) {
2020-09-29 04:05:13 -05:00
return nil
}
relPath , err := filepath . Rel ( l . dir , path )
if err != nil {
return err
}
obj , err := os . Open ( path )
if err != nil {
return err
}
defer obj . Close ( )
return fn ( relPath , obj )
} )
}
2020-10-12 22:58:34 -05:00
func init ( ) {
RegisterStorageType ( LocalStorageType , NewLocalStorage )
}