sftpgo-mirror/dataprovider/sqlite.go

package dataprovider

import (
	"database/sql"
	"errors"
	"fmt"
	"os"
	"path/filepath"
)

// SQLiteProvider auth provider for SQLite database
type SQLiteProvider struct {
	dbHandle *sql.DB
}

func initializeSQLiteProvider(basePath string) error {
	var err error
	var connectionString string
	provider = SQLiteProvider{}
	if len(config.ConnectionString) == 0 {
		dbPath := config.Name
		if !filepath.IsAbs(dbPath) {
			dbPath = filepath.Join(basePath, dbPath)
		}
		fi, err := os.Stat(dbPath)
		if err != nil {
			provider.log(Warn, "sqlite database file does not exists, please be sure to create and initialize"+
				" a database before starting sftpgo")
			return err
		}
		if fi.Size() == 0 {
			return errors.New("sqlite database file is invalid, please be sure to create and initialize" +
				" a database before starting sftpgo")
		}
		connectionString = fmt.Sprintf("file:%v?cache=shared", dbPath)
	} else {
		connectionString = config.ConnectionString
	}
	dbHandle, err := sql.Open("sqlite3", connectionString)
	if err == nil {
		provider.log(Debug, "sqlite database handle created, connection string: %#v", connectionString)
		dbHandle.SetMaxOpenConns(1)
		provider = SQLiteProvider{dbHandle: dbHandle}
	} else {
		provider.log(Warn, "error creating sqlite database handler, connection string: %#v, error: %v", connectionString, err)
	}
	return err
}

func (p SQLiteProvider) validateUserAndPass(username string, password string) (User, error) {
	return sqlCommonValidateUserAndPass(username, password, p.dbHandle)
}

func (p SQLiteProvider) validateUserAndPubKey(username string, publicKey string) (User, string, error) {
	return sqlCommonValidateUserAndPubKey(username, publicKey, p.dbHandle)
}

func (p SQLiteProvider) getUserByID(ID int64) (User, error) {
	return sqlCommonGetUserByID(ID, p.dbHandle)
}

func (p SQLiteProvider) updateQuota(username string, filesAdd int, sizeAdd int64, reset bool) error {
	// we keep only 1 open connection (SetMaxOpenConns(1)) so a transaction is not needed and it could block
	// the database access since it will try to open a new connection
	return sqlCommonUpdateQuota(username, filesAdd, sizeAdd, reset, p.dbHandle)
}

func (p SQLiteProvider) getUsedQuota(username string) (int, int64, error) {
	return sqlCommonGetUsedQuota(username, p.dbHandle)
}

func (p SQLiteProvider) userExists(username string) (User, error) {
	return sqlCommonCheckUserExists(username, p.dbHandle)
}

func (p SQLiteProvider) addUser(user User) error {
	return sqlCommonAddUser(user, p.dbHandle)
}

func (p SQLiteProvider) updateUser(user User) error {
	return sqlCommonUpdateUser(user, p.dbHandle)
}

func (p SQLiteProvider) deleteUser(user User) error {
	return sqlCommonDeleteUser(user, p.dbHandle)
}

func (p SQLiteProvider) getUsers(limit int, offset int, order string, username string) ([]User, error) {
	return sqlCommonGetUsers(limit, offset, order, username, p.dbHandle)
}

func (p SQLiteProvider) log(level string, format string, v ...interface{}) {
	sqlCommonLog(level, p.providerName(), format, v...)
}

func (p SQLiteProvider) providerName() string {
	return SQLiteDataProviderName
}