feat(postgresql): add user and database authorization management (#14460)

* feat(postgresql): add user and database authorization management

* fix(postgresql): reuse existing roles during app recovery
This commit is contained in:
ssongliu
2026-11-18 09:53:22 +08:00
committed by GitHub
parent 6d8d3b25b1
commit 148e1981b0
46 changed files with 2113 additions and 366 deletions
+136
View File
@@ -232,3 +232,139 @@ func (b *BaseApi) DeletePostgresql(c *gin.Context) {
tx.Commit()
helper.Success(c)
}
func (b *BaseApi) ListPostgresqlUsers(c *gin.Context) {
var req dto.PostgresqlUserSearch
if err := helper.CheckBindAndValidate(&req, c); err != nil {
return
}
result, err := postgresqlService.ListUsers(req)
if err != nil {
helper.InternalServer(c, err)
return
}
helper.SuccessWithData(c, result)
}
// @Router /databases/pg/users [post]
// @x-panel-log {"bodyKeys":["database","username"],"paramKeys":[],"formatZH":"创建 PostgreSQL 实例 [database] 用户 [username]","formatEN":"create PostgreSQL instance [database] user [username]","BeforeFunctions":[]}
func (b *BaseApi) CreatePostgresqlUser(c *gin.Context) {
var req dto.PostgresqlUserCreate
if err := helper.CheckBindAndValidate(&req, c); err != nil {
return
}
password, err := base64.StdEncoding.DecodeString(req.Password)
if err != nil {
helper.BadRequest(c, err)
return
}
req.Password = string(password)
if err := postgresqlService.CreateUser(req); err != nil {
helper.InternalServer(c, err)
return
}
helper.Success(c)
}
// @Router /databases/pg/users/update [post]
// @x-panel-log {"bodyKeys":["database","username"],"paramKeys":[],"formatZH":"修改 PostgreSQL 实例 [database] 用户 [username]","formatEN":"update PostgreSQL instance [database] user [username]","BeforeFunctions":[]}
func (b *BaseApi) UpdatePostgresqlUser(c *gin.Context) {
var req dto.PostgresqlUserUpdate
if err := helper.CheckBindAndValidate(&req, c); err != nil {
return
}
if err := postgresqlService.UpdateUser(req); err != nil {
helper.InternalServer(c, err)
return
}
helper.Success(c)
}
// @Router /databases/pg/users/password [post]
// @x-panel-log {"bodyKeys":["database","username"],"paramKeys":[],"formatZH":"修改 PostgreSQL 实例 [database] 用户 [username] 密码","formatEN":"change PostgreSQL instance [database] user [username] password","BeforeFunctions":[]}
func (b *BaseApi) ChangePostgresqlUserPassword(c *gin.Context) {
var req dto.PostgresqlUserPassword
if err := helper.CheckBindAndValidate(&req, c); err != nil {
return
}
password, err := base64.StdEncoding.DecodeString(req.Password)
if err != nil {
helper.BadRequest(c, err)
return
}
req.Password = string(password)
if err := postgresqlService.ChangeUserPassword(req); err != nil {
helper.InternalServer(c, err)
return
}
helper.Success(c)
}
// @Tags Database PostgreSQL
// @Summary Save postgresql user password locally
// @Accept json
// @Param request body dto.PostgresqlUserPassword true "request"
// @Success 200
// @Security ApiKeyAuth
// @Security Timestamp
// @Router /databases/pg/users/password/save [post]
// @x-panel-log {"bodyKeys":["database","username"],"paramKeys":[],"BeforeFunctions":[],"formatZH":"补充 PostgreSQL 实例 [database] 用户 [username] 密码","formatEN":"save PostgreSQL instance [database] user [username] password locally"}
func (b *BaseApi) SavePostgresqlUserPassword(c *gin.Context) {
var req dto.PostgresqlUserPassword
if err := helper.CheckBindAndValidate(&req, c); err != nil {
return
}
password, err := base64.StdEncoding.DecodeString(req.Password)
if err != nil {
helper.BadRequest(c, err)
return
}
req.Password = string(password)
if err := postgresqlService.SaveUserPassword(req); err != nil {
helper.InternalServer(c, err)
return
}
helper.Success(c)
}
// @Router /databases/pg/users/del [post]
// @x-panel-log {"bodyKeys":["database","username"],"paramKeys":[],"formatZH":"删除 PostgreSQL 实例 [database] 用户 [username]","formatEN":"delete PostgreSQL instance [database] user [username]","BeforeFunctions":[]}
func (b *BaseApi) DeletePostgresqlUser(c *gin.Context) {
var req dto.PostgresqlUserDelete
if err := helper.CheckBindAndValidate(&req, c); err != nil {
return
}
if err := postgresqlService.DeleteUser(req); err != nil {
helper.InternalServer(c, err)
return
}
helper.Success(c)
}
// @Router /databases/pg/grants [post]
// @x-panel-log {"bodyKeys":["database","username","name"],"paramKeys":[],"formatZH":"绑定 PostgreSQL 实例 [database] 数据库 [name] 用户 [username]","formatEN":"bind PostgreSQL instance [database] database [name] user [username]","BeforeFunctions":[]}
func (b *BaseApi) GrantPostgresqlUser(c *gin.Context) {
var req dto.PostgresqlUserGrant
if err := helper.CheckBindAndValidate(&req, c); err != nil {
return
}
if err := postgresqlService.GrantUser(req); err != nil {
helper.InternalServer(c, err)
return
}
helper.Success(c)
}
// @Router /databases/pg/grants/del [post]
// @x-panel-log {"bodyKeys":["database","username","name"],"paramKeys":[],"formatZH":"撤销 PostgreSQL 实例 [database] 数据库 [name] 用户 [username] 绑定","formatEN":"revoke PostgreSQL instance [database] database [name] user [username] binding","BeforeFunctions":[]}
func (b *BaseApi) RevokePostgresqlUser(c *gin.Context) {
var req dto.PostgresqlUserGrant
if err := helper.CheckBindAndValidate(&req, c); err != nil {
return
}
if err := postgresqlService.RevokeUser(req); err != nil {
helper.InternalServer(c, err)
return
}
helper.Success(c)
}
+54 -8
View File
@@ -33,14 +33,15 @@ type PostgresqlOption struct {
}
type PostgresqlDBCreate struct {
Name string `json:"name" validate:"required"`
From string `json:"from" validate:"required,oneof=local remote"`
Database string `json:"database" validate:"required"`
Format string `json:"format"`
Username string `json:"username" validate:"required"`
Password string `json:"password" validate:"required"`
SuperUser bool `json:"superUser"`
Description string `json:"description"`
ExistingUser bool `json:"existingUser"`
Name string `json:"name" validate:"required"`
From string `json:"from" validate:"required,oneof=local remote"`
Database string `json:"database" validate:"required"`
Format string `json:"format"`
Username string `json:"username" validate:"required"`
Password string `json:"password"`
SuperUser bool `json:"superUser"`
Description string `json:"description"`
}
type PostgresqlBindUser struct {
@@ -77,3 +78,48 @@ type PostgresqlDBDelete struct {
ForceDelete bool `json:"forceDelete"`
DeleteBackup bool `json:"deleteBackup"`
}
type PostgresqlUserSearch struct {
Database string `json:"database" validate:"required"`
}
type PostgresqlUser struct {
Username string `json:"username"`
Password string `json:"password"`
Description string `json:"description"`
SuperUser bool `json:"superUser"`
Protected bool `json:"protected"`
Databases []string `json:"databases"`
}
type PostgresqlUserCreate struct {
Database string `json:"database" validate:"required"`
Username string `json:"username" validate:"required"`
Password string `json:"password" validate:"required"`
Description string `json:"description"`
SuperUser bool `json:"superUser"`
}
type PostgresqlUserUpdate struct {
Database string `json:"database" validate:"required"`
Username string `json:"username" validate:"required"`
Description string `json:"description"`
SuperUser bool `json:"superUser"`
}
type PostgresqlUserPassword struct {
Database string `json:"database" validate:"required"`
Username string `json:"username" validate:"required"`
Password string `json:"password" validate:"required"`
}
type PostgresqlUserDelete struct {
Database string `json:"database" validate:"required"`
Username string `json:"username" validate:"required"`
}
type PostgresqlUserGrant struct {
Database string `json:"database" validate:"required"`
Name string `json:"name" validate:"required"`
Username string `json:"username" validate:"required"`
}
+15
View File
@@ -20,6 +20,7 @@ type IPostgresqlRepo interface {
Create(ctx context.Context, postgresql *model.DatabasePostgresql) error
Delete(ctx context.Context, opts ...DBOption) error
Update(id uint, vars map[string]interface{}) error
SaveUserPassword(user *model.DatabaseUser) error
DeleteLocal(ctx context.Context) error
}
@@ -106,6 +107,20 @@ func (u *PostgresqlRepo) Update(id uint, vars map[string]interface{}) error {
return global.DB.Model(&model.DatabasePostgresql{}).Where("id = ?", id).Updates(vars).Error
}
func (u *PostgresqlRepo) SaveUserPassword(user *model.DatabaseUser) error {
password, err := encrypt.StringEncrypt(user.Password)
if err != nil {
return err
}
user.Password = password
return global.DB.Transaction(func(tx *gorm.DB) error {
if err := tx.Save(user).Error; err != nil {
return err
}
return tx.Model(&model.DatabasePostgresql{}).Where("postgresql_name = ? AND username = ?", user.Database, user.Username).Update("password", password).Error
})
}
func (u *PostgresqlRepo) WithByPostgresqlName(postgresqlName string) DBOption {
return func(g *gorm.DB) *gorm.DB {
return g.Where("postgresql_name = ?", postgresqlName)
+35 -5
View File
@@ -46,6 +46,7 @@ import (
"github.com/sirupsen/logrus"
"github.com/subosito/gotenv"
"gopkg.in/yaml.v3"
"gorm.io/gorm"
)
type DatabaseOp string
@@ -268,14 +269,14 @@ func createLink(ctx context.Context, installTask *task.Task, app model.App, appI
if dbConfig.DbName != "" && dbConfig.DbUser != "" && dbConfig.Password != "" {
switch database.Type {
case constant.AppPostgresql, constant.AppPostgres, constant.AppPostgresqlCluster:
oldPostgresqlDb, _ := postgresqlRepo.Get(repo.WithByName(dbConfig.DbName), repo.WithByFrom(constant.ResourceLocal))
if oldPostgresqlDb.ID == 0 {
oldPostgresqlDb, _ = postgresqlRepo.Get(repo.WithByName(dbConfig.DbName), postgresqlRepo.WithByPostgresqlName(dbConfig.DatabaseName), repo.WithByFrom(constant.AppResourceRemote))
oldPostgresqlDb, err := postgresqlRepo.Get(repo.WithByName(dbConfig.DbName), postgresqlRepo.WithByPostgresqlName(database.Name), repo.WithByFrom(database.From))
if err != nil && !errors.Is(err, gorm.ErrRecordNotFound) {
return err
}
resourceId = oldPostgresqlDb.ID
if oldPostgresqlDb.ID > 0 {
if oldPostgresqlDb.Username != dbConfig.DbUser || oldPostgresqlDb.Password != dbConfig.Password {
return buserr.New("ErrDbUserNotValid")
if err := ensureAppPostgresqlDBUser(database, dbConfig); err != nil {
return err
}
} else {
var createPostgresql dto.PostgresqlDBCreate
@@ -463,6 +464,9 @@ func deleteAppInstall(deleteReq request.AppInstallDelete) error {
case constant.AppMongodb:
_ = mongodbRepo.Delete(ctx, mongodbRepo.WithByMongodbName(install.Name))
case constant.AppPostgresql, constant.AppPostgresqlCluster:
if err := databaseUserRepo.DeleteBy(ctx, repo.WithByType("postgresql"), databaseUserRepo.WithByDatabase(install.Name)); err != nil {
return err
}
_ = postgresqlRepo.Delete(ctx, postgresqlRepo.WithByPostgresqlName(install.Name))
}
@@ -619,6 +623,32 @@ func ensureAppMysqlDBUser(database model.Database, dbConfig dto.AppDatabase) err
})
}
func ensureAppPostgresqlDBUser(database model.Database, dbConfig dto.AppDatabase) error {
pgService := NewIPostgresqlService()
users, err := pgService.ListUsers(dto.PostgresqlUserSearch{Database: database.Name})
if err != nil {
return err
}
for _, user := range users {
if user.Username != dbConfig.DbUser {
continue
}
if user.Password == "" || user.Password != dbConfig.Password {
return buserr.New("ErrDbUserNotValid")
}
if user.SuperUser {
return nil
}
for _, name := range user.Databases {
if name == dbConfig.DbName {
return nil
}
}
return pgService.GrantUser(dto.PostgresqlUserGrant{Database: database.Name, Name: dbConfig.DbName, Username: dbConfig.DbUser})
}
return buserr.New("ErrDbUserNotValid")
}
func deleteLink(del dto.DelAppLink) error {
install := del.Install
resources, _ := appInstallResourceRepo.GetBy(appInstallResourceRepo.WithAppInstallId(install.ID))
+75 -34
View File
@@ -11,6 +11,7 @@ import (
"time"
"github.com/1Panel-dev/1Panel/agent/app/repo"
"github.com/compose-spec/compose-go/v2/dotenv"
"github.com/subosito/gotenv"
"github.com/1Panel-dev/1Panel/agent/app/task"
@@ -538,27 +539,58 @@ func ensureMysqlDBUser(mysqlService IMysqlService, database model.Database, dbIn
func reCreatePostgresqlDB(dbID uint, database model.Database, envMap map[string]interface{}) (*model.DatabasePostgresql, error) {
postgresqlService := NewIPostgresqlService()
_ = postgresqlService.Delete(context.Background(), dto.PostgresqlDBDelete{
dbInfo := getDBCreateInfoFromEnv(envMap, "UTF8")
users, err := postgresqlService.ListUsers(dto.PostgresqlUserSearch{Database: database.Name})
if err != nil {
return nil, err
}
existingUser := false
for _, user := range users {
if user.Username != dbInfo.User {
continue
}
if user.Password == "" {
return nil, buserr.New("ErrDbUserNotValid")
}
dbInfo.Password = user.Password
existingUser = true
break
}
if err := postgresqlService.Delete(context.Background(), dto.PostgresqlDBDelete{
ID: dbID,
Type: database.Type,
Database: database.Name,
DeleteBackup: false,
ForceDelete: true,
})
ForceDelete: false,
}); err != nil {
return nil, err
}
dbInfo := getDBCreateInfoFromEnv(envMap, "UTF8")
createDB, err := postgresqlService.Create(context.Background(), dto.PostgresqlDBCreate{
Name: dbInfo.Name,
From: database.From,
Database: database.Name,
Format: dbInfo.Format,
Username: dbInfo.User,
Password: dbInfo.Password,
SuperUser: true,
ExistingUser: existingUser,
Name: dbInfo.Name,
From: database.From,
Database: database.Name,
Format: dbInfo.Format,
Username: dbInfo.User,
Password: dbInfo.Password,
SuperUser: true,
})
if err != nil {
return nil, err
}
oldPassword, _ := envMap["PANEL_DB_USER_PASSWORD"].(string)
if oldPassword != "" && oldPassword != dbInfo.Password {
if datasource, ok := envMap["CASDOOR_DATASOURCE_NAME"].(string); ok {
escape := strings.NewReplacer(`\`, `\\`, "'", `\'`)
password := "password='" + escape.Replace(dbInfo.Password) + "'"
envMap["CASDOOR_DATASOURCE_NAME"] = strings.NewReplacer(
"password='"+escape.Replace(oldPassword)+"'", password,
"password="+oldPassword, password,
).Replace(datasource)
}
}
envMap["PANEL_DB_USER_PASSWORD"] = dbInfo.Password
updateCronjobsDBRef(dbID, createDB.ID)
return createDB, nil
}
@@ -594,11 +626,12 @@ func updateCronjobsDBRef(oldDBID, newDBID uint) {
}
func buildRecoverEnv(appEnv string, backupEnvMap, installedEnvMap map[string]interface{}) (string, string, error) {
var appEnvMap map[string]interface{}
if err := json.Unmarshal([]byte(appEnv), &appEnvMap); err != nil {
return "", "", err
}
currentHostVal, hasCurrentHost := installedEnvMap["PANEL_DB_HOST"]
if hasCurrentHost && fmt.Sprintf("%v", currentHostVal) != "" {
backupHost := fmt.Sprintf("\"PANEL_DB_HOST\":\"%v\"", backupEnvMap["PANEL_DB_HOST"])
currentHost := fmt.Sprintf("\"PANEL_DB_HOST\":\"%v\"", currentHostVal)
appEnv = strings.ReplaceAll(appEnv, backupHost, currentHost)
if _, ok := backupEnvMap["CASDOOR_DATASOURCE_NAME"]; ok {
backupEnvMap["CASDOOR_DATASOURCE_NAME"] = strings.ReplaceAll(
fmt.Sprintf("%v", backupEnvMap["CASDOOR_DATASOURCE_NAME"]),
@@ -608,37 +641,45 @@ func buildRecoverEnv(appEnv string, backupEnvMap, installedEnvMap map[string]int
}
backupEnvMap["PANEL_DB_HOST"] = currentHostVal
}
if appEnvMap == nil {
return "", "", buserr.New("ErrInvalidParams")
}
for _, key := range []string{"PANEL_DB_HOST", "PANEL_DB_USER_PASSWORD", "CASDOOR_DATASOURCE_NAME"} {
if value, ok := backupEnvMap[key]; ok {
appEnvMap[key] = value
}
}
mergedAppEnv, err := json.Marshal(appEnvMap)
if err != nil {
return "", "", err
}
appEnv = string(mergedAppEnv)
newEnvMap := make(map[string]string, len(backupEnvMap))
MergeAppEnvironment(backupEnvMap, newEnvMap)
mergedEnvContent, err := gotenv.Marshal(newEnvMap)
if err != nil {
return appEnv, "", err
}
return appEnv, mergedEnvContent, nil
lines := strings.Split(mergedEnvContent, "\n")
for i, line := range lines {
for _, key := range []string{"PANEL_DB_USER_PASSWORD", "CASDOOR_DATASOURCE_NAME"} {
if strings.HasPrefix(line, key+"=") {
lines[i] = fmt.Sprintf("%s=%q", key, strings.ReplaceAll(newEnvMap[key], "$", "$$"))
break
}
}
}
return appEnv, strings.Join(lines, "\n"), nil
}
func getEnvMapByPath(envPath string) (map[string]interface{}, error) {
envMap := make(map[string]interface{})
envFile, err := os.ReadFile(envPath)
values, err := dotenv.ReadWithLookup(func(string) (string, bool) { return "", false }, envPath)
if err != nil {
return envMap, err
return nil, err
}
lines := strings.Split(string(envFile), "\n")
for _, line := range lines {
line = strings.TrimSpace(line)
if line == "" || strings.HasPrefix(line, "#") {
continue
}
parts := strings.SplitN(line, "=", 2)
if len(parts) == 2 {
value := strings.TrimSpace(parts[1])
if len(value) >= 2 {
if (value[0] == '"' && value[len(value)-1] == '"') || (value[0] == '\'' && value[len(value)-1] == '\'') {
value = value[1 : len(value)-1]
}
}
envMap[parts[0]] = value
}
envMap := make(map[string]interface{}, len(values))
for key, value := range values {
envMap[key] = value
}
return envMap, nil
}
+16 -5
View File
@@ -137,7 +137,7 @@ func (u *DatabaseService) CheckDatabase(req dto.DatabaseCreate) bool {
var err error
switch req.Type {
case constant.AppPostgresql:
_, err = postgresql.NewPostgresqlClient(pgclient.DBInfo{
pgClient, connectErr := postgresql.NewPostgresqlClient(pgclient.DBInfo{
From: "remote",
Address: req.Address,
Port: req.Port,
@@ -146,6 +146,10 @@ func (u *DatabaseService) CheckDatabase(req dto.DatabaseCreate) bool {
Password: req.Password,
Timeout: req.Timeout,
})
if connectErr == nil {
pgClient.Close()
}
err = connectErr
case constant.AppRedis:
_, err = redisclient.NewRedisClient(redisclient.DBInfo{
Address: req.Address,
@@ -200,7 +204,7 @@ func (u *DatabaseService) Create(req dto.DatabaseCreate) error {
}
switch req.Type {
case constant.AppPostgresql:
if _, err := postgresql.NewPostgresqlClient(pgclient.DBInfo{
pgClient, err := postgresql.NewPostgresqlClient(pgclient.DBInfo{
From: "remote",
Address: req.Address,
Port: req.Port,
@@ -208,9 +212,11 @@ func (u *DatabaseService) Create(req dto.DatabaseCreate) error {
Username: req.Username,
Password: req.Password,
Timeout: req.Timeout,
}); err != nil {
})
if err != nil {
return err
}
pgClient.Close()
case constant.AppRedis:
if _, err := redisclient.NewRedisClient(redisclient.DBInfo{
Address: req.Address,
@@ -302,6 +308,9 @@ func (u *DatabaseService) Delete(req dto.DatabaseDelete) error {
return err
}
} else {
if err := databaseUserRepo.Delete(repo.WithByType("postgresql"), databaseUserRepo.WithByDatabase(db.Name)); err != nil && !req.ForceDelete {
return err
}
if err := postgresqlRepo.Delete(context.Background(), postgresqlRepo.WithByPostgresqlName(db.Name)); err != nil && !req.ForceDelete {
return err
}
@@ -316,7 +325,7 @@ func (u *DatabaseService) Update(req dto.DatabaseUpdate) error {
}
switch req.Type {
case constant.AppPostgresql:
if _, err := postgresql.NewPostgresqlClient(pgclient.DBInfo{
pgClient, err := postgresql.NewPostgresqlClient(pgclient.DBInfo{
From: "remote",
Address: req.Address,
Port: req.Port,
@@ -324,9 +333,11 @@ func (u *DatabaseService) Update(req dto.DatabaseUpdate) error {
Username: req.Username,
Password: req.Password,
Timeout: req.Timeout,
}); err != nil {
})
if err != nil {
return err
}
pgClient.Close()
case constant.AppRedis:
if _, err := redisclient.NewRedisClient(redisclient.DBInfo{
Address: req.Address,
+135 -154
View File
@@ -2,6 +2,7 @@ package service
import (
"context"
"errors"
"fmt"
"os"
"path"
@@ -21,21 +22,30 @@ import (
"github.com/1Panel-dev/1Panel/agent/utils/postgresql/client"
_ "github.com/jackc/pgx/v5/stdlib"
"github.com/jinzhu/copier"
"gorm.io/gorm"
)
type PostgresqlService struct{}
type IPostgresqlService interface {
ListUsers(req dto.PostgresqlUserSearch) ([]dto.PostgresqlUser, error)
CreateUser(req dto.PostgresqlUserCreate) error
UpdateUser(req dto.PostgresqlUserUpdate) error
ChangeUserPassword(req dto.PostgresqlUserPassword) error
SaveUserPassword(req dto.PostgresqlUserPassword) error
DeleteUser(req dto.PostgresqlUserDelete) error
GrantUser(req dto.PostgresqlUserGrant) error
RevokeUser(req dto.PostgresqlUserGrant) error
SearchWithPage(search dto.PostgresqlDBSearch) (int64, interface{}, error)
ListDBOption() ([]dto.PostgresqlOption, error)
BindUser(req dto.PostgresqlBindUser) error
Create(ctx context.Context, req dto.PostgresqlDBCreate) (*model.DatabasePostgresql, error)
LoadFromRemote(database string) error
ChangePrivileges(req dto.PostgresqlPrivileges) error
ChangePassword(info dto.ChangeDBInfo) error
UpdateDescription(req dto.UpdateDescription) error
DeleteCheck(req dto.PostgresqlDBDeleteCheck) ([]dto.DBResource, error)
Delete(ctx context.Context, req dto.PostgresqlDBDelete) error
ChangePrivileges(req dto.PostgresqlPrivileges) error
ChangePassword(info dto.ChangeDBInfo) error
}
func NewIPostgresqlService() IPostgresqlService {
@@ -87,43 +97,30 @@ func (u *PostgresqlService) ListDBOption() ([]dto.PostgresqlOption, error) {
}
func (u *PostgresqlService) BindUser(req dto.PostgresqlBindUser) error {
if cmd.CheckIllegal(req.Name, req.Username, req.Password) || strings.Contains(req.Password, " ") {
return buserr.New("ErrCmdIllegal")
}
dbItem, err := postgresqlRepo.Get(postgresqlRepo.WithByPostgresqlName(req.Database), repo.WithByName(req.Name))
if err != nil {
return err
}
pgClient, err := LoadPostgresqlClientByFrom(req.Database)
if err := u.CreateUser(dto.PostgresqlUserCreate{Database: req.Database, Username: req.Username, Password: req.Password, SuperUser: req.SuperUser}); err != nil {
return err
}
if !req.SuperUser {
if err := u.GrantUser(dto.PostgresqlUserGrant{Database: req.Database, Name: req.Name, Username: req.Username}); err != nil {
return err
}
}
if dbItem.Username != "" {
return nil
}
password, err := encrypt.StringEncrypt(req.Password)
if err != nil {
return err
}
if err := pgClient.CreateUser(client.CreateInfo{
Name: req.Name,
Username: req.Username,
Password: req.Password,
SuperUser: req.SuperUser,
Timeout: 300,
}, false); err != nil {
return err
}
pass, err := encrypt.StringEncrypt(req.Password)
if err != nil {
return fmt.Errorf("decrypt database db password failed, err: %v", err)
}
if err := postgresqlRepo.Update(dbItem.ID, map[string]interface{}{
"username": req.Username,
"password": pass,
"super_user": req.SuperUser,
}); err != nil {
return err
}
return nil
return postgresqlRepo.Update(dbItem.ID, map[string]interface{}{"username": req.Username, "password": password, "super_user": req.SuperUser})
}
func (u *PostgresqlService) Create(ctx context.Context, req dto.PostgresqlDBCreate) (*model.DatabasePostgresql, error) {
if cmd.CheckIllegal(req.Name, req.Username, req.Password, req.Format) || strings.Contains(req.Password, " ") {
if cmd.CheckIllegal(req.Name, req.Format) || (!req.ExistingUser && (cmd.CheckIllegal(req.Username, req.Password) || strings.Contains(req.Password, " "))) {
return nil, buserr.New("ErrCmdIllegal")
}
@@ -132,6 +129,26 @@ func (u *PostgresqlService) Create(ctx context.Context, req dto.PostgresqlDBCrea
return nil, buserr.New("ErrRecordExist")
}
if req.ExistingUser {
users, err := u.ListUsers(dto.PostgresqlUserSearch{Database: req.Database})
if err != nil {
return nil, err
}
found := false
for _, user := range users {
if user.Username == req.Username {
req.Password, req.SuperUser = user.Password, user.SuperUser
found = true
break
}
}
if !found {
return nil, buserr.New("ErrRecordNotFound")
}
} else if req.Password == "" {
return nil, buserr.New("ErrInvalidParams")
}
var createItem model.DatabasePostgresql
if err := copier.Copy(&createItem, &req); err != nil {
return nil, buserr.WithDetail("ErrStructTransform", err.Error(), nil)
@@ -144,13 +161,13 @@ func (u *PostgresqlService) Create(ctx context.Context, req dto.PostgresqlDBCrea
defer cli.Close()
createItem.PostgresqlName = req.Database
defer cli.Close()
if err := cli.Create(client.CreateInfo{
Name: req.Name,
Username: req.Username,
Password: req.Password,
SuperUser: req.SuperUser,
Timeout: 300,
ExistingUser: req.ExistingUser,
Name: req.Name,
Username: req.Username,
Password: req.Password,
SuperUser: req.SuperUser,
Timeout: 300,
}); err != nil {
return nil, err
}
@@ -159,45 +176,18 @@ func (u *PostgresqlService) Create(ctx context.Context, req dto.PostgresqlDBCrea
if err := postgresqlRepo.Create(ctx, &createItem); err != nil {
return nil, err
}
return &createItem, nil
}
func LoadPostgresqlClientByFrom(database string) (postgresql.PostgresqlClient, error) {
var (
dbInfo client.DBInfo
err error
)
dbInfo.Timeout = 300
databaseItem, err := databaseRepo.Get(repo.WithByName(database))
if err != nil {
return nil, err
}
dbInfo.From = databaseItem.From
dbInfo.Database = database
if dbInfo.From != "local" {
dbInfo.Address = databaseItem.Address
dbInfo.Port = databaseItem.Port
dbInfo.Username = databaseItem.Username
dbInfo.Password = databaseItem.Password
dbInfo.InitialDB = databaseItem.InitialDB
} else {
app, err := appInstallRepo.LoadBaseInfo(databaseItem.Type, database)
if err != nil {
return nil, err
if !req.ExistingUser {
user, err := databaseUserRepo.GetEncryptedWithContext(ctx, repo.WithByType("postgresql"), databaseUserRepo.WithByDatabase(req.Database), databaseUserRepo.WithByUser(req.Username, ""))
if err != nil && !errors.Is(err, gorm.ErrRecordNotFound) {
return &createItem, err
}
user.Type, user.Database, user.Username, user.Host = "postgresql", req.Database, req.Username, ""
user.Password, user.Description, user.IsDelete = createItem.Password, "", false
if err := databaseUserRepo.SaveEncryptedWithContext(ctx, &user); err != nil {
return &createItem, err
}
dbInfo.From = "local"
dbInfo.Address = app.ContainerName
dbInfo.Username = app.UserName
dbInfo.Password = app.Password
dbInfo.Port = uint(app.Port)
}
cli, err := postgresql.NewPostgresqlClient(dbInfo)
if err != nil {
return nil, err
}
return cli, nil
return &createItem, nil
}
func (u *PostgresqlService) LoadFromRemote(database string) error {
@@ -302,8 +292,8 @@ func (u *PostgresqlService) DeleteCheck(req dto.PostgresqlDBDeleteCheck) ([]dto.
}
func (u *PostgresqlService) Delete(ctx context.Context, req dto.PostgresqlDBDelete) error {
db, err := postgresqlRepo.Get(repo.WithByID(req.ID))
if err != nil && !req.ForceDelete {
db, err := postgresqlRepo.Get(repo.WithByID(req.ID), postgresqlRepo.WithByPostgresqlName(req.Database))
if err != nil {
return err
}
cli, err := LoadPostgresqlClientByFrom(req.Database)
@@ -311,15 +301,26 @@ func (u *PostgresqlService) Delete(ctx context.Context, req dto.PostgresqlDBDele
return err
}
defer cli.Close()
if db.Username != "" {
user, err := databaseUserRepo.GetEncryptedWithContext(ctx, repo.WithByType("postgresql"), databaseUserRepo.WithByDatabase(req.Database), databaseUserRepo.WithByUser(db.Username, ""))
if errors.Is(err, gorm.ErrRecordNotFound) {
password, encryptErr := encrypt.StringEncrypt(db.Password)
if encryptErr != nil {
return encryptErr
}
user = model.DatabaseUser{Type: "postgresql", Database: req.Database, Username: db.Username, Password: password}
if err := databaseUserRepo.SaveEncryptedWithContext(ctx, &user); err != nil {
return err
}
} else if err != nil {
return err
}
}
if err := cli.Delete(client.DeleteInfo{
Name: db.Name,
Username: db.Username,
ForceDelete: req.ForceDelete,
Timeout: 300,
}); err != nil && !req.ForceDelete {
if strings.HasPrefix(err.Error(), "drop user") {
_ = postgresqlRepo.Update(db.ID, map[string]interface{}{"is_delete": true})
}
return err
}
@@ -336,101 +337,40 @@ func (u *PostgresqlService) Delete(ctx context.Context, req dto.PostgresqlDBDele
global.LOG.Infof("delete database %s-%s backups successful", req.Database, db.Name)
}
_ = postgresqlRepo.Delete(ctx, repo.WithByID(db.ID))
return nil
return postgresqlRepo.Delete(ctx, repo.WithByID(db.ID))
}
func (u *PostgresqlService) ChangePrivileges(req dto.PostgresqlPrivileges) error {
if cmd.CheckIllegal(req.Database, req.Username) {
return buserr.New("ErrCmdIllegal")
}
dbItem, err := postgresqlRepo.Get(postgresqlRepo.WithByPostgresqlName(req.Database), repo.WithByName(req.Name))
user, err := u.loadPostgresqlUser(req.Database, req.Username)
if err != nil {
return err
}
cli, err := LoadPostgresqlClientByFrom(req.Database)
if err != nil {
return err
}
defer cli.Close()
if err := cli.ChangePrivileges(client.Privileges{Username: req.Username, SuperUser: req.SuperUser, Timeout: 300}); err != nil {
return err
}
if err := postgresqlRepo.Update(dbItem.ID, map[string]interface{}{
"super_user": req.SuperUser,
}); err != nil {
return err
}
return nil
return u.UpdateUser(dto.PostgresqlUserUpdate{Database: req.Database, Username: req.Username, SuperUser: req.SuperUser, Description: user.Description})
}
func (u *PostgresqlService) ChangePassword(req dto.ChangeDBInfo) error {
if cmd.CheckIllegal(req.Value) || strings.Contains(req.Value, " ") {
return buserr.New("ErrCmdIllegal")
}
if req.ID != 0 {
db, err := postgresqlRepo.Get(repo.WithByID(req.ID), postgresqlRepo.WithByPostgresqlName(req.Database))
if err != nil {
return err
}
return u.ChangeUserPassword(dto.PostgresqlUserPassword{Database: req.Database, Username: db.Username, Password: req.Value})
}
cli, err := LoadPostgresqlClientByFrom(req.Database)
if err != nil {
return err
}
defer cli.Close()
var (
postgresqlData model.DatabasePostgresql
passwordInfo client.PasswordChangeInfo
)
passwordInfo.Password = req.Value
passwordInfo.Timeout = 300
if req.ID != 0 {
postgresqlData, err = postgresqlRepo.Get(repo.WithByID(req.ID))
if err != nil {
return err
}
passwordInfo.Username = postgresqlData.Username
} else {
dbItem, err := databaseRepo.Get(repo.WithByType(req.Type), repo.WithByFrom(req.From))
if err != nil {
return err
}
passwordInfo.Username = dbItem.Username
}
if err := cli.ChangePassword(passwordInfo); err != nil {
dbItem, err := databaseRepo.Get(repo.WithByName(req.Database))
if err != nil {
return err
}
if req.ID != 0 {
var appRess []model.AppInstallResource
if req.From == "local" {
app, err := appInstallRepo.LoadBaseInfo(req.Type, req.Database)
if err != nil {
return err
}
appRess, _ = appInstallResourceRepo.GetBy(appInstallResourceRepo.WithLinkId(app.ID), appInstallResourceRepo.WithResourceId(postgresqlData.ID))
} else {
appRess, _ = appInstallResourceRepo.GetBy(appInstallResourceRepo.WithResourceId(postgresqlData.ID))
}
for _, appRes := range appRess {
appInstall, err := appInstallRepo.GetFirst(repo.WithByID(appRes.AppInstallId))
if err != nil {
return err
}
appModel, err := appRepo.GetFirst(repo.WithByID(appInstall.AppId))
if err != nil {
return err
}
global.LOG.Infof("start to update postgresql password used by app %s-%s", appModel.Key, appInstall.Name)
if err := updateInstallInfoInDB(appModel.Key, appInstall.Name, "user-password", req.Value); err != nil {
return err
}
}
global.LOG.Info("execute password change sql successful")
pass, err := encrypt.StringEncrypt(req.Value)
if err != nil {
return fmt.Errorf("decrypt database db password failed, err: %v", err)
}
_ = postgresqlRepo.Update(postgresqlData.ID, map[string]interface{}{"password": pass})
return nil
passwordInfo := client.PasswordChangeInfo{Username: dbItem.Username, Password: req.Value, Timeout: 300}
if err := cli.ChangePassword(passwordInfo); err != nil {
return err
}
if err := updateInstallInfoInDB(req.Type, req.Database, "password", req.Value); err != nil {
@@ -449,3 +389,44 @@ func (u *PostgresqlService) ChangePassword(req dto.ChangeDBInfo) error {
}
return nil
}
func LoadPostgresqlClientByFrom(database string) (postgresql.PostgresqlClient, error) {
var (
dbInfo client.DBInfo
err error
)
dbInfo.Timeout = 300
databaseItem, err := databaseRepo.Get(repo.WithByName(database))
if err != nil {
return nil, err
}
if databaseItem.Type != constant.AppPostgresql && databaseItem.Type != constant.AppPostgresqlCluster && databaseItem.Type != constant.AppPostgres {
return nil, buserr.New("ErrInvalidParams")
}
dbInfo.From = databaseItem.From
dbInfo.Database = database
if dbInfo.From != "local" {
dbInfo.Address = databaseItem.Address
dbInfo.Port = databaseItem.Port
dbInfo.Username = databaseItem.Username
dbInfo.Password = databaseItem.Password
dbInfo.InitialDB = databaseItem.InitialDB
} else {
app, err := appInstallRepo.LoadBaseInfo(databaseItem.Type, database)
if err != nil {
return nil, err
}
dbInfo.From = "local"
dbInfo.Address = app.ContainerName
dbInfo.Username = app.UserName
dbInfo.Password = app.Password
dbInfo.Port = uint(app.Port)
}
cli, err := postgresql.NewPostgresqlClient(dbInfo)
if err != nil {
return nil, err
}
return cli, nil
}
@@ -0,0 +1,382 @@
package service
import (
"context"
"encoding/json"
"errors"
"fmt"
"strings"
"github.com/1Panel-dev/1Panel/agent/app/dto"
"github.com/1Panel-dev/1Panel/agent/app/model"
"github.com/1Panel-dev/1Panel/agent/app/repo"
"github.com/1Panel-dev/1Panel/agent/buserr"
"github.com/1Panel-dev/1Panel/agent/constant"
"github.com/1Panel-dev/1Panel/agent/utils/encrypt"
"github.com/1Panel-dev/1Panel/agent/utils/postgresql/client"
"gorm.io/gorm"
)
func (u *PostgresqlService) ListUsers(req dto.PostgresqlUserSearch) ([]dto.PostgresqlUser, error) {
cli, err := LoadPostgresqlClientByFrom(req.Database)
if err != nil {
return nil, err
}
defer cli.Close()
users, err := client.ListUsers(cli)
if err != nil {
return nil, err
}
metadata, err := databaseUserRepo.List(repo.WithByType("postgresql"), databaseUserRepo.WithByDatabase(req.Database))
if err != nil {
return nil, err
}
legacy, err := postgresqlRepo.List(postgresqlRepo.WithByPostgresqlName(req.Database))
if err != nil {
return nil, err
}
result := make([]dto.PostgresqlUser, 0, len(users))
for _, user := range users {
item := dto.PostgresqlUser{Username: user.Username, SuperUser: user.SuperUser, Protected: user.Protected, Databases: user.Databases}
passwords := make(map[string]struct{})
for _, db := range legacy {
if db.Username == user.Username && db.Password != "" {
passwords[db.Password] = struct{}{}
}
}
if len(passwords) == 1 {
for password := range passwords {
item.Password = password
}
}
for _, meta := range metadata {
if meta.Username == user.Username {
item.Password, item.Description = meta.Password, meta.Description
break
}
}
result = append(result, item)
}
return result, nil
}
func (u *PostgresqlService) CreateUser(req dto.PostgresqlUserCreate) error {
if strings.HasPrefix(req.Username, "pg_") || req.Username == "postgres" {
return buserr.New("ErrPgUserProtected")
}
if req.Username == "" || len(req.Username) > 63 || req.Password == "" || strings.ContainsAny(req.Username+req.Password, "\x00") {
return buserr.New("ErrInvalidParams")
}
cli, err := LoadPostgresqlClientByFrom(req.Database)
if err != nil {
return err
}
defer cli.Close()
if err := cli.CreateUser(client.CreateInfo{Username: req.Username, Password: req.Password, SuperUser: req.SuperUser, Timeout: 300}, false); err != nil {
return err
}
return saveDatabaseUserCredential("postgresql", req.Database, req.Username, "", req.Password, req.Description)
}
func (u *PostgresqlService) UpdateUser(req dto.PostgresqlUserUpdate) error {
user, err := u.loadPostgresqlUser(req.Database, req.Username)
if err != nil {
return err
}
if user.Protected {
return buserr.New("ErrPgUserProtected")
}
cli, err := LoadPostgresqlClientByFrom(req.Database)
if err != nil {
return err
}
defer cli.Close()
if err := cli.ChangePrivileges(client.Privileges{Username: req.Username, SuperUser: req.SuperUser, Timeout: 300}); err != nil {
return err
}
dbs, err := postgresqlRepo.List(postgresqlRepo.WithByPostgresqlName(req.Database))
if err != nil {
return err
}
for _, db := range dbs {
if db.Username == req.Username {
if err := postgresqlRepo.Update(db.ID, map[string]interface{}{"super_user": req.SuperUser}); err != nil {
return err
}
}
}
return saveDatabaseUserCredential("postgresql", req.Database, req.Username, "", user.Password, req.Description)
}
func (u *PostgresqlService) ChangeUserPassword(req dto.PostgresqlUserPassword) error {
user, err := u.loadPostgresqlUser(req.Database, req.Username)
if err != nil {
return err
}
if user.Protected {
return buserr.New("ErrPgUserProtected")
}
if req.Password == "" || strings.ContainsRune(req.Password, 0) {
return buserr.New("ErrInvalidParams")
}
targets, err := loadPostgresqlUserApps(req.Database, req.Username, "")
if err != nil {
return err
}
dbs, err := postgresqlRepo.List(postgresqlRepo.WithByPostgresqlName(req.Database))
if err != nil {
return err
}
password, err := encrypt.StringEncrypt(req.Password)
if err != nil {
return err
}
cli, err := LoadPostgresqlClientByFrom(req.Database)
if err != nil {
return err
}
defer cli.Close()
if err := cli.ChangePassword(client.PasswordChangeInfo{Username: req.Username, Password: req.Password, Timeout: 300}); err != nil {
return err
}
if err := saveDatabaseUserCredential("postgresql", req.Database, req.Username, "", req.Password, user.Description); err != nil {
return err
}
for _, db := range dbs {
if db.Username == req.Username {
if err := postgresqlRepo.Update(db.ID, map[string]interface{}{"password": password}); err != nil {
return err
}
}
}
var failures []string
for _, app := range targets {
if err := updateInstallInfoInDB(app.App.Key, app.Name, "user-password", req.Password); err != nil {
failures = append(failures, fmt.Sprintf("%s: %v", app.Name, err))
}
}
if len(failures) != 0 {
return buserr.WithDetail("ErrPgUserPasswordSync", strings.Join(failures, "; "), nil)
}
return nil
}
func (u *PostgresqlService) SaveUserPassword(req dto.PostgresqlUserPassword) error {
if req.Password == "" || strings.ContainsRune(req.Password, 0) {
return buserr.New("ErrInvalidParams")
}
user, err := u.loadPostgresqlUser(req.Database, req.Username)
if err != nil {
return err
}
if user.Protected {
return buserr.New("ErrPgUserProtected")
}
metadata, err := databaseUserRepo.Get(repo.WithByType("postgresql"), databaseUserRepo.WithByDatabase(req.Database), databaseUserRepo.WithByUser(req.Username, ""))
if err != nil && !errors.Is(err, gorm.ErrRecordNotFound) {
return err
}
metadata.Type, metadata.Database, metadata.Username, metadata.Host = "postgresql", req.Database, req.Username, ""
metadata.Password, metadata.Description, metadata.IsDelete = req.Password, user.Description, false
return postgresqlRepo.SaveUserPassword(&metadata)
}
func (u *PostgresqlService) DeleteUser(req dto.PostgresqlUserDelete) error {
user, err := u.loadPostgresqlUser(req.Database, req.Username)
if err != nil {
return err
}
if user.Protected {
return buserr.New("ErrPgUserProtected")
}
if err := checkPostgresqlUserUsage(req.Database, req.Username, ""); err != nil {
return err
}
if len(user.Databases) != 0 {
return buserr.New("ErrPgUserBound")
}
cli, err := LoadPostgresqlClientByFrom(req.Database)
if err != nil {
return err
}
defer cli.Close()
if err := cli.Delete(client.DeleteInfo{Username: req.Username, Timeout: 300}); err != nil {
return err
}
dbs, err := postgresqlRepo.List(postgresqlRepo.WithByPostgresqlName(req.Database))
if err != nil {
return err
}
for _, db := range dbs {
if db.Username == req.Username {
if err := postgresqlRepo.Update(db.ID, map[string]interface{}{"username": "", "password": "", "super_user": false}); err != nil {
return err
}
}
}
return databaseUserRepo.Delete(repo.WithByType("postgresql"), databaseUserRepo.WithByDatabase(req.Database), databaseUserRepo.WithByUser(req.Username, ""))
}
func (u *PostgresqlService) GrantUser(req dto.PostgresqlUserGrant) error {
user, err := u.loadPostgresqlUser(req.Database, req.Username)
if err != nil {
return err
}
if user.Protected {
return buserr.New("ErrPgUserProtected")
}
if user.SuperUser {
return buserr.New("ErrPgSuperUserGrant")
}
db, err := postgresqlRepo.Get(postgresqlRepo.WithByPostgresqlName(req.Database), repo.WithByName(req.Name))
if err != nil {
return err
}
cli, err := LoadPostgresqlClientByFrom(req.Database)
if err != nil {
return err
}
defer cli.Close()
if err := client.GrantUser(cli, req.Name, req.Username, false); err != nil {
return err
}
if db.Username == "" {
password, err := encrypt.StringEncrypt(user.Password)
if err != nil {
return err
}
return postgresqlRepo.Update(db.ID, map[string]interface{}{"username": req.Username, "password": password, "super_user": false})
}
return nil
}
func (u *PostgresqlService) RevokeUser(req dto.PostgresqlUserGrant) error {
user, err := u.loadPostgresqlUser(req.Database, req.Username)
if err != nil {
return err
}
if user.Protected {
return buserr.New("ErrPgUserProtected")
}
if user.SuperUser {
return buserr.New("ErrPgSuperUserGrant")
}
db, err := postgresqlRepo.Get(postgresqlRepo.WithByPostgresqlName(req.Database), repo.WithByName(req.Name))
if err != nil {
return err
}
if err := checkPostgresqlUserUsage(req.Database, req.Username, req.Name); err != nil {
return err
}
cli, err := LoadPostgresqlClientByFrom(req.Database)
if err != nil {
return err
}
defer cli.Close()
if err := saveDatabaseUserCredential("postgresql", req.Database, req.Username, "", user.Password, user.Description); err != nil {
return err
}
if err := client.GrantUser(cli, req.Name, req.Username, true); err != nil {
return err
}
if db.Username == req.Username {
return postgresqlRepo.Update(db.ID, map[string]interface{}{"username": "", "password": "", "super_user": false})
}
return nil
}
func (u *PostgresqlService) loadPostgresqlUser(database, username string) (dto.PostgresqlUser, error) {
users, err := u.ListUsers(dto.PostgresqlUserSearch{Database: database})
if err != nil {
return dto.PostgresqlUser{}, err
}
for _, user := range users {
if user.Username == username {
return user, nil
}
}
return dto.PostgresqlUser{}, buserr.New("ErrRecordNotFound")
}
func loadPostgresqlUserApps(database, username, dbName string) ([]model.AppInstall, error) {
instance, err := databaseRepo.Get(repo.WithByName(database))
if err != nil {
return nil, err
}
dbs, err := postgresqlRepo.List(postgresqlRepo.WithByPostgresqlName(database))
if err != nil {
return nil, err
}
ids := make([]uint, 0, len(dbs))
for _, db := range dbs {
if dbName == "" || db.Name == dbName {
ids = append(ids, db.ID)
}
}
if len(ids) == 0 {
return nil, nil
}
opts := []repo.DBOption{appInstallResourceRepo.WithResourceIds(ids), appRepo.WithKey(instance.Type)}
if instance.From == "local" {
app, err := appInstallRepo.LoadBaseInfo(instance.Type, database)
if err != nil {
return nil, err
}
opts = append(opts, appInstallResourceRepo.WithLinkId(app.ID))
}
resources, err := appInstallResourceRepo.GetBy(opts...)
if err != nil {
return nil, err
}
appIDs := make([]uint, 0, len(resources))
for _, resource := range resources {
appIDs = append(appIDs, resource.AppInstallId)
}
if len(appIDs) == 0 {
return nil, nil
}
apps, err := appInstallRepo.ListBy(context.Background(), repo.WithByIDs(appIDs))
if err != nil {
return nil, err
}
result := make([]model.AppInstall, 0, len(apps))
for _, app := range apps {
var env map[string]interface{}
if err := json.Unmarshal([]byte(app.Env), &env); err != nil {
return nil, err
}
if env["PANEL_DB_USER"] == username {
result = append(result, app)
}
}
return result, nil
}
func checkPostgresqlUserUsage(database, username, dbName string) error {
apps, err := loadPostgresqlUserApps(database, username, dbName)
if err != nil {
return err
}
if len(apps) != 0 {
return buserr.New("ErrPgUserUsed")
}
dbs, err := postgresqlRepo.List(postgresqlRepo.WithByPostgresqlName(database))
if err != nil {
return err
}
websites, err := websiteRepo.List(websiteRepo.WithDBTypes([]string{constant.AppPostgresql, constant.AppPostgresqlCluster}))
if err != nil {
return err
}
for _, db := range dbs {
if db.Username != username || (dbName != "" && db.Name != dbName) {
continue
}
for _, website := range websites {
if website.DbID == db.ID {
return buserr.New("ErrPgUserUsed")
}
}
}
return nil
}
+72
View File
@@ -2790,6 +2790,78 @@
"formatZH": "创建 postgresql 数据库 [name]",
"formatEN": "create postgresql database [name]"
},
"/databases/pg/users": {
"bodyKeys": [
"database",
"username"
],
"paramKeys": [],
"beforeFunctions": [],
"formatZH": "创建 PostgreSQL 实例 [database] 用户 [username]",
"formatEN": "create PostgreSQL instance [database] user [username]"
},
"/databases/pg/users/update": {
"bodyKeys": [
"database",
"username"
],
"paramKeys": [],
"beforeFunctions": [],
"formatZH": "修改 PostgreSQL 实例 [database] 用户 [username]",
"formatEN": "update PostgreSQL instance [database] user [username]"
},
"/databases/pg/users/password/save": {
"bodyKeys": [
"database",
"username"
],
"paramKeys": [],
"beforeFunctions": [],
"formatZH": "补充 PostgreSQL 实例 [database] 用户 [username] 密码",
"formatEN": "save PostgreSQL instance [database] user [username] password locally"
},
"/databases/pg/users/password": {
"bodyKeys": [
"database",
"username"
],
"paramKeys": [],
"beforeFunctions": [],
"formatZH": "修改 PostgreSQL 实例 [database] 用户 [username] 密码",
"formatEN": "change PostgreSQL instance [database] user [username] password"
},
"/databases/pg/users/del": {
"bodyKeys": [
"database",
"username"
],
"paramKeys": [],
"beforeFunctions": [],
"formatZH": "删除 PostgreSQL 实例 [database] 用户 [username]",
"formatEN": "delete PostgreSQL instance [database] user [username]"
},
"/databases/pg/grants": {
"bodyKeys": [
"database",
"username",
"name"
],
"paramKeys": [],
"beforeFunctions": [],
"formatZH": "绑定 PostgreSQL 实例 [database] 数据库 [name] 用户 [username]",
"formatEN": "bind PostgreSQL instance [database] database [name] user [username]"
},
"/databases/pg/grants/del": {
"bodyKeys": [
"database",
"username",
"name"
],
"paramKeys": [],
"beforeFunctions": [],
"formatZH": "撤销 PostgreSQL 实例 [database] 数据库 [name] 用户 [username] 绑定",
"formatEN": "revoke PostgreSQL instance [database] database [name] user [username] binding"
},
"/databases/pg/bind": {
"bodyKeys": [
"name",
+8 -1
View File
@@ -1,5 +1,5 @@
# base errors
ErrInvalidParams: 'Bad request: {{ .detail }}'
ErrInvalidParams: 'Bad request{{ if .detail }}: {{ .detail }}{{ end }}'
ErrMcpGatewayArgsParse: 'Invalid MCP custom argument format'
ErrMcpGatewayArgsConflict: 'Argument {{ .name }} is managed by 1Panel and cannot be set in custom arguments'
ErrTokenParse: 'Token error: {{ .detail }}'
@@ -292,6 +292,13 @@ RemoteBackup: 'Start local DB container with image {{ .name }} before backing up
RemoteRecover: 'Start local DB container with image {{ .name }} before restoring remote DB'
Arg: "Argument"
#PostgreSQL
ErrPgUserProtected: "System users and the current connection user are protected from this operation"
ErrPgSuperUserGrant: "Superusers can access all databases and do not require individual grants or revocations"
ErrPgUserUsed: "This user is used by linked applications or websites; update their connection accounts first"
ErrPgUserBound: "Revoke this user's database authorizations first"
ErrPgUserPasswordSync: "The user password was changed, but password synchronization failed for these applications: {{ .detail }}"
# Redis
ErrTypeOfRedis: 'Backup file type does not match current persistence mode'
+8 -1
View File
@@ -1,5 +1,5 @@
# errores básicos
ErrInvalidParams: 'Solicitud inválida: {{ .detail }}'
ErrInvalidParams: 'Solicitud inválida{{ if .detail }}: {{ .detail }}{{ end }}'
ErrMcpGatewayArgsParse: 'Formato de argumentos personalizados de MCP no válido'
ErrMcpGatewayArgsConflict: 'El argumento {{ .name }} está gestionado por 1Panel y no puede definirse en los argumentos personalizados'
ErrTokenParse: 'Token inválido: {{ .detail }}'
@@ -292,6 +292,13 @@ RemoteBackup: 'Para hacer una copia de seguridad de la base de datos remota, pri
RemoteRecover: 'Para restaurar la base de datos remota, primero debe iniciarse el servicio de base de datos del contenedor local utilizando la imagen {{ .name }}, espere...'
Arg: 'Argumento'
#PostgreSQL
ErrPgUserProtected: "Los usuarios del sistema y el usuario de conexión actual están protegidos frente a esta operación"
ErrPgSuperUserGrant: "Los superusuarios acceden a todas las bases de datos y no requieren autorizaciones ni revocaciones individuales"
ErrPgUserUsed: "Las aplicaciones o sitios web vinculados usan este usuario; cambie primero sus cuentas de conexión"
ErrPgUserBound: "Primero revoque las autorizaciones de base de datos de este usuario"
ErrPgUserPasswordSync: "La contraseña del usuario se cambió, pero no se pudo sincronizar en estas aplicaciones: {{ .detail }}"
# Redis
ErrTypeOfRedis: 'El tipo de archivo de recuperación no coincide con el método de persistencia actual, modifíquelo e intente'
+8 -1
View File
@@ -1,5 +1,5 @@
# خطاهای پایه
ErrInvalidParams: 'درخواست نامعتبر: {{ .detail }}'
ErrInvalidParams: 'درخواست نامعتبر{{ if .detail }}: {{ .detail }}{{ end }}'
ErrMcpGatewayArgsParse: 'قالب آرگومان‌های سفارشی MCP نامعتبر است'
ErrMcpGatewayArgsConflict: 'آرگومان {{ .name }} توسط 1Panel مدیریت می‌شود و نمی‌توان آن را در آرگومان‌های سفارشی تنظیم کرد'
ErrTokenParse: 'خطا در توکن: {{ .detail }}'
@@ -292,6 +292,13 @@ RemoteBackup: 'قبل از پشتیبان‌گیری از پایگاه داده
RemoteRecover: 'قبل از بازیابی پایگاه داده از راه دور، کانتینر پایگاه داده محلی را با تصویر {{ .name }} راه‌اندازی کنید'
Arg: "آرگومان"
#PostgreSQL
ErrPgUserProtected: "کاربران سیستم و کاربر اتصال فعلی در برابر این عملیات محافظت می‌شوند"
ErrPgSuperUserGrant: "ابرکاربران به همه پایگاه‌های داده دسترسی دارند و نیازی به اعطا یا لغو مجوز جداگانه ندارند"
ErrPgUserUsed: "برنامه‌ها یا وب‌سایت‌های پیوندشده از این کاربر استفاده می‌کنند؛ ابتدا حساب اتصال را تغییر دهید"
ErrPgUserBound: "ابتدا مجوزهای پایگاه داده این کاربر را لغو کنید"
ErrPgUserPasswordSync: "گذرواژه کاربر تغییر کرد، اما همگام‌سازی گذرواژه برای این برنامه‌ها ناموفق بود: {{ .detail }}"
# Redis
ErrTypeOfRedis: 'نوع فایل پشتیبان با حالت ماندگاری فعلی مطابقت ندارد'
+8 -1
View File
@@ -1,5 +1,5 @@
# 基本エラー
ErrInvalidParams: '不正なリクエスト: {{ .detail }}'
ErrInvalidParams: '不正なリクエスト{{ if .detail }}: {{ .detail }}{{ end }}'
ErrMcpGatewayArgsParse: 'MCP カスタム引数の形式が正しくありません'
ErrMcpGatewayArgsConflict: '引数 {{ .name }} は 1Panel によって管理されているため、カスタム引数には設定できません'
ErrTokenParse: 'トークンエラー: {{ .detail }}'
@@ -292,6 +292,13 @@ RemoteBackup: 'リモートデータベースをバックアップするには
RemoteRecover: 'リモートデータベースを復元するには、まずイメージ {{ .name }} を使用してローカルコンテナデータベースサービスを起動する必要があります。しばらくお待ちください...'
Arg: '引数'
#PostgreSQL
ErrPgUserProtected: "システムユーザーと現在の接続ユーザーは保護されているため、この操作は実行できません"
ErrPgSuperUserGrant: "スーパーユーザーは全データベースにアクセスでき、個別の権限付与や取り消しは不要です"
ErrPgUserUsed: "関連アプリまたはウェブサイトがこのユーザーを使用しています。先に接続アカウントを変更してください"
ErrPgUserBound: "先にこのユーザーのデータベース権限を取り消してください"
ErrPgUserPasswordSync: "ユーザーのパスワードは変更されましたが、次のアプリへのパスワード同期に失敗しました:{{ .detail }}"
# Redis
ErrTypeOfRedis: 'リカバリ ファイルの種類が現在の永続化方法と一致しません。変更して再試行してください'
+8 -1
View File
@@ -1,5 +1,5 @@
# 기본 오류
ErrInvalidParams: '잘못된 요청: {{ .detail }}'
ErrInvalidParams: '잘못된 요청{{ if .detail }}: {{ .detail }}{{ end }}'
ErrMcpGatewayArgsParse: 'MCP 사용자 지정 인수 형식이 잘못되었습니다'
ErrMcpGatewayArgsConflict: '{{ .name }} 인수는 1Panel에서 관리하므로 사용자 지정 인수에 설정할 수 없습니다'
ErrTokenParse: '토큰 오류: {{ .detail }}'
@@ -292,6 +292,13 @@ RemoteBackup: '원격 데이터베이스를 백업하려면 먼저 이미지 {{
RemoteRecover: '원격 데이터베이스를 복원하려면 먼저 이미지 {{ .name }}을(를) 사용하여 로컬 컨테이너 데이터베이스 서비스를 시작해야 합니다. 잠시만 기다려 주세요...'
Arg: '인수'
#PostgreSQL
ErrPgUserProtected: "시스템 사용자와 현재 연결 사용자는 보호되어 이 작업을 수행할 수 없습니다"
ErrPgSuperUserGrant: "슈퍼유저는 모든 데이터베이스에 접근할 수 있어 개별 권한 부여나 철회가 필요하지 않습니다"
ErrPgUserUsed: "연결된 앱 또는 웹사이트가 이 사용자를 사용 중입니다. 먼저 연결 계정을 변경하세요"
ErrPgUserBound: "먼저 이 사용자의 데이터베이스 권한을 철회하세요"
ErrPgUserPasswordSync: "사용자 비밀번호는 변경되었지만 다음 앱의 비밀번호 동기화에 실패했습니다: {{ .detail }}"
# Redis
ErrTypeOfRedis: '복구 파일 유형이 현재 지속성 방법과 일치하지 않습니다. 수정하고 다시 시도하세요'
+8 -1
View File
@@ -1,4 +1,4 @@
ErrInvalidParams: 'ຄຳຮ້ອງຂໍບໍ່ຖືກຕ້ອງ: {{ .detail }}'
ErrInvalidParams: 'ຄຳຮ້ອງຂໍບໍ່ຖືກຕ້ອງ{{ if .detail }}: {{ .detail }}{{ end }}'
ErrMcpGatewayArgsParse: 'ຮູບແບບອາກິວເມັນ MCP ກຳນົດເອງບໍ່ຖືກຕ້ອງ'
ErrMcpGatewayArgsConflict: 'ອາກິວເມັນ {{ .name }} ຖືກຈັດການໂດຍ 1Panel ແລະ ບໍ່ສາມາດຕັ້ງຄ່າໃນອາກິວເມັນກຳນົດເອງໄດ້'
ErrTokenParse: 'ໂທເຄັນຜິດພາດ: {{ .detail }}'
@@ -282,6 +282,13 @@ RemoteBackup: 'ກະລຸນາເລີ່ມຄອນເທນເນີຖ
RemoteRecover: 'ກະລຸນາເລີ່ມຄອນເທນເນີຖານຂໍ້ມູນພາຍໃນເຄື່ອງດ້ວຍຮູບພາບ {{ .name }} ກ່ອນທີ່ຈະກູ້ຄືນຖານຂໍ້ມູນທາງໄກ'
Arg: "ອາກິວເມນ"
#PostgreSQL
ErrPgUserProtected: "ຜູ້ໃຊ້ລະບົບແລະຜູ້ໃຊ້ເຊື່ອມຕໍ່ປັດຈຸບັນຖືກປົກປ້ອງຈາກການດຳເນີນການນີ້"
ErrPgSuperUserGrant: "ຜູ້ໃຊ້ຂັ້ນສູງເຂົ້າເຖິງທຸກຖານຂໍ້ມູນໄດ້ ໂດຍບໍ່ຕ້ອງໃຫ້ສິດຫຼືຍົກເລີກສິດແຍກຕ່າງຫາກ"
ErrPgUserUsed: "ແອັບຫຼືເວັບໄຊທີ່ຜູກຢູ່ກຳລັງໃຊ້ຜູ້ໃຊ້ນີ້; ກະລຸນາປ່ຽນບັນຊີເຊື່ອມຕໍ່ກ່ອນ"
ErrPgUserBound: "ກະລຸນາຍົກເລີກສິດຖານຂໍ້ມູນຂອງຜູ້ໃຊ້ນີ້ກ່ອນ"
ErrPgUserPasswordSync: "ລະຫັດຜ່ານຜູ້ໃຊ້ຖືກປ່ຽນແລ້ວ ແຕ່ການຊິງລະຫັດຜ່ານໃຫ້ແອັບຕໍ່ໄປນີ້ລົ້ມເຫຼວ: {{ .detail }}"
#redis
ErrTypeOfRedis: 'ປະເພດໄຟລ໌ສຳຮອງຂໍ້ມູນບໍ່ກົງກັບໂໝດ persistence ປັດຈຸບັນ'
+8 -1
View File
@@ -1,5 +1,5 @@
# ralat asas
ErrInvalidParams: 'Permintaan tidak sah: {{ .detail }}'
ErrInvalidParams: 'Permintaan tidak sah{{ if .detail }}: {{ .detail }}{{ end }}'
ErrMcpGatewayArgsParse: 'Format argumen tersuai MCP tidak sah'
ErrMcpGatewayArgsConflict: 'Argumen {{ .name }} diurus oleh 1Panel dan tidak boleh ditetapkan dalam argumen tersuai'
ErrTokenParse: 'Token tidak sah: {{ .detail }}'
@@ -292,6 +292,13 @@ RemoteBackup: 'Untuk menyandarkan pangkalan data jauh, perkhidmatan pangkalan da
RemoteRecover: 'Untuk memulihkan pangkalan data jauh, perkhidmatan pangkalan data bekas tempatan perlu dimulakan terlebih dahulu menggunakan imej {{ .name }}, sila tunggu...'
Arg: 'Hujah'
#PostgreSQL
ErrPgUserProtected: "Pengguna sistem dan pengguna sambungan semasa dilindungi daripada operasi ini"
ErrPgSuperUserGrant: "Pengguna super boleh mengakses semua pangkalan data dan tidak memerlukan pemberian atau pembatalan kebenaran individu"
ErrPgUserUsed: "Aplikasi atau laman web terpaut menggunakan pengguna ini; tukar akaun sambungan dahulu"
ErrPgUserBound: "Batalkan kebenaran pangkalan data pengguna ini dahulu"
ErrPgUserPasswordSync: "Kata laluan pengguna telah diubah, tetapi penyegerakan kata laluan gagal untuk aplikasi berikut: {{ .detail }}"
# Redis
ErrTypeOfRedis: 'Jenis fail pemulihan tidak sepadan dengan kaedah kegigihan semasa, sila ubah suai dan cuba lagi'
+8 -1
View File
@@ -1,5 +1,5 @@
# erros básicos
ErrInvalidParams: 'Requisição inválida: {{ .detail }}'
ErrInvalidParams: 'Requisição inválida{{ if .detail }}: {{ .detail }}{{ end }}'
ErrMcpGatewayArgsParse: 'Formato inválido dos argumentos personalizados do MCP'
ErrMcpGatewayArgsConflict: 'O argumento {{ .name }} é gerenciado pelo 1Panel e não pode ser definido nos argumentos personalizados'
ErrTokenParse: 'Erro de token: {{ .detail }}'
@@ -292,6 +292,13 @@ RemoteBackup: 'Para fazer backup do banco de dados remoto, o serviço de banco d
RemoteRecover: 'Para restaurar o banco de dados remoto, o serviço de banco de dados do contêiner local precisa ser iniciado primeiro usando a imagem {{ .name }} aguarde...'
Arg: 'Argumento'
#PostgreSQL
ErrPgUserProtected: "Usuários do sistema e o usuário da conexão atual estão protegidos contra esta operação"
ErrPgSuperUserGrant: "Superusuários acessam todos os bancos de dados e não precisam de concessões ou revogações individuais"
ErrPgUserUsed: "Aplicativos ou sites vinculados usam este usuário; altere primeiro suas contas de conexão"
ErrPgUserBound: "Primeiro revogue as autorizações de banco de dados deste usuário"
ErrPgUserPasswordSync: "A senha do usuário foi alterada, mas a sincronização falhou nestes aplicativos: {{ .detail }}"
# Redis
ErrTypeOfRedis: 'O tipo de arquivo de recuperação não corresponde ao método de persistência atual, modifique-o e'
+8 -1
View File
@@ -1,5 +1,5 @@
# базовые ошибки
ErrInvalidParams: 'Неверный запрос: {{ .detail }}'
ErrInvalidParams: 'Неверный запрос{{ if .detail }}: {{ .detail }}{{ end }}'
ErrMcpGatewayArgsParse: 'Неверный формат пользовательских аргументов MCP'
ErrMcpGatewayArgsConflict: 'Аргумент {{ .name }} управляется 1Panel и не может быть задан в пользовательских аргументах'
ErrTokenParse: 'Ошибка токена: {{ .detail }}'
@@ -292,6 +292,13 @@ RemoteBackup: 'Для резервного копирования удаленн
RemoteRecover: 'Для восстановления удаленной базы данных необходимо сначала запустить службу базы данных локального контейнера с помощью образа {{ .name }}, пожалуйста, подождите...'
Arg: 'Аргумент'
#PostgreSQL
ErrPgUserProtected: "Системные пользователи и пользователь текущего подключения защищены от этой операции"
ErrPgSuperUserGrant: "Суперпользователи имеют доступ ко всем базам данных и не требуют отдельной выдачи или отзыва прав"
ErrPgUserUsed: "Пользователь используется связанными приложениями или сайтами; сначала измените их учётные записи подключения"
ErrPgUserBound: "Сначала отзовите права этого пользователя на базы данных"
ErrPgUserPasswordSync: "Пароль пользователя изменён, но синхронизация пароля со следующими приложениями не удалась: {{ .detail }}"
# Redis
ErrTypeOfRedis: 'Тип файла восстановления не соответствует текущему методу сохранения. Измените его и повторите попытку'
+8 -1
View File
@@ -1,5 +1,5 @@
# temel hatalar
ErrInvalidParams: 'İstek geçersiz: {{ .detail }}'
ErrInvalidParams: 'İstek geçersiz{{ if .detail }}: {{ .detail }}{{ end }}'
ErrMcpGatewayArgsParse: 'MCP özel bağımsız değişken biçimi geçersiz'
ErrMcpGatewayArgsConflict: '{{ .name }} bağımsız değişkeni 1Panel tarafından yönetilir ve özel bağımsız değişkenlerde ayarlanamaz'
ErrTokenParse: 'Token hatası: {{ .detail }}'
@@ -292,6 +292,13 @@ RemoteBackup: 'Uzak veritabanını yedeklemek için önce {{ .name }} görüntü
RemoteRecover: 'Uzak veritabanını geri yüklemek için önce {{ .name }} görüntüsü kullanılarak yerel konteyner veritabanı hizmetinin başlatılması gerekiyor, lütfen bekleyin...'
Arg: 'Argüman'
#PostgreSQL
ErrPgUserProtected: "Sistem kullanıcıları ve mevcut bağlantı kullanıcısı bu işleme karşı korunur"
ErrPgSuperUserGrant: "Süper kullanıcılar tüm veritabanlarına erişebilir; ayrı yetki verme veya iptal işlemi gerektirmez"
ErrPgUserUsed: "Bağlı uygulamalar veya web siteleri bu kullanıcıyı kullanıyor; önce bağlantı hesaplarını değiştirin"
ErrPgUserBound: "Önce bu kullanıcının veritabanı yetkilerini iptal edin"
ErrPgUserPasswordSync: "Kullanıcı parolası değiştirildi ancak şu uygulamalarda parola eşitlemesi başarısız oldu: {{ .detail }}"
# Redis
ErrTypeOfRedis: 'Kurtarma dosyası türü mevcut kalıcılık yöntemiyle eşleşmiyor, lütfen değiştirin ve tekrar deneyin'
+8 -1
View File
@@ -1,5 +1,5 @@
# 基礎錯誤
ErrInvalidParams: '請求參數錯誤: {{ .detail }}'
ErrInvalidParams: '請求參數錯誤{{ if .detail }}: {{ .detail }}{{ end }}'
ErrMcpGatewayArgsParse: 'MCP 自訂參數格式錯誤'
ErrMcpGatewayArgsConflict: '參數 {{ .name }} 由 1Panel 管理,不能在自訂參數中設定'
ErrTokenParse: 'Token 產生錯誤: {{ .detail }}'
@@ -292,6 +292,13 @@ RemoteBackup: '備份遠端資料庫需要先使用映像 {{ .name }} 啟動本
RemoteRecover: '復原遠端資料庫需要先使用映像 {{ .name }} 啟動本機容器資料庫服務,請稍候...'
Arg: '參數'
#PostgreSQL
ErrPgUserProtected: "系統使用者或目前連線使用者受到保護,無法執行此操作"
ErrPgSuperUserGrant: "超級使用者可存取所有資料庫,無需單獨授權或撤銷授權"
ErrPgUserUsed: "關聯應用程式或網站正在使用此使用者,請先調整連線帳號"
ErrPgUserBound: "請先撤銷此使用者的資料庫授權"
ErrPgUserPasswordSync: "使用者密碼已修改,但以下應用程式的密碼同步失敗:{{ .detail }}"
# Redis
ErrTypeOfRedis: '復原檔案類型與目前持久化方式不符,請修改後重試'
+8 -1
View File
@@ -1,5 +1,5 @@
# 基础错误
ErrInvalidParams: "参数错误: {{ .detail }}"
ErrInvalidParams: "参数错误{{ if .detail }}: {{ .detail }}{{ end }}"
ErrMcpGatewayArgsParse: "MCP 自定义参数格式错误"
ErrMcpGatewayArgsConflict: "参数 {{ .name }} 由 1Panel 管理,不能在自定义参数中设置"
ErrTokenParse: "Token 错误: {{ .detail }}"
@@ -292,6 +292,13 @@ RemoteBackup: "备份远程数据库前需先用镜像 {{ .name }} 启动本地
RemoteRecover: "恢复远程数据库前需先用镜像 {{ .name }} 启动本地容器数据库服务,请稍候"
Arg: "参数"
#PostgreSQL
ErrPgUserProtected: "系统用户或当前连接用户受保护,无法执行此操作"
ErrPgSuperUserGrant: "超级用户可访问所有数据库,无需单独授权或撤销授权"
ErrPgUserUsed: "该用户正在被关联应用或网站使用,请先调整连接账号"
ErrPgUserBound: "请先撤销该用户的数据库授权"
ErrPgUserPasswordSync: "用户密码已修改,但以下应用的密码同步失败:{{ .detail }}"
# Redis
ErrTypeOfRedis: "恢复文件类型与当前持久化方式不符,请修改后重试"
+8
View File
@@ -58,6 +58,14 @@ func (s *DatabaseRouter) InitRouter(Router *gin.RouterGroup) {
cmdRouter.POST("/db/del/check", baseApi.DeleteCheckDatabase)
cmdRouter.POST("/db/del", baseApi.DeleteDatabase)
cmdRouter.POST("/pg/users/search", baseApi.ListPostgresqlUsers)
cmdRouter.POST("/pg/users", baseApi.CreatePostgresqlUser)
cmdRouter.POST("/pg/users/update", baseApi.UpdatePostgresqlUser)
cmdRouter.POST("/pg/users/password", baseApi.ChangePostgresqlUserPassword)
cmdRouter.POST("/pg/users/password/save", baseApi.SavePostgresqlUserPassword)
cmdRouter.POST("/pg/users/del", baseApi.DeletePostgresqlUser)
cmdRouter.POST("/pg/grants", baseApi.GrantPostgresqlUser)
cmdRouter.POST("/pg/grants/del", baseApi.RevokePostgresqlUser)
cmdRouter.POST("/pg", baseApi.CreatePostgresql)
cmdRouter.POST("/pg/search", baseApi.SearchPostgresql)
cmdRouter.POST("/pg/:database/load", baseApi.LoadPostgresqlDBFromRemote)
+4 -1
View File
@@ -14,6 +14,8 @@ import (
)
type PostgresqlClient interface {
ExecSQL(command string, timeout uint) error
ExecSQLForRows(command string, timeout uint) ([]string, error)
Create(info client.CreateInfo) error
CreateUser(info client.CreateInfo, withDeleteDB bool) error
Delete(info client.DeleteInfo) error
@@ -28,7 +30,7 @@ type PostgresqlClient interface {
func NewPostgresqlClient(conn client.DBInfo) (PostgresqlClient, error) {
if conn.From == "local" {
connArgs := []string{"exec", "-e", fmt.Sprintf("PGPASSWORD=%s", conn.Password), conn.Address, "psql", "-t", "-U", conn.Username, "-c"}
connArgs := []string{"exec", "-e", fmt.Sprintf("PGPASSWORD=%s", conn.Password), conn.Address, "psql", "-A", "-t", "-U", conn.Username, "-c"}
return client.NewLocal(connArgs, conn.Address, conn.Username, conn.Password, conn.Database), nil
}
escapedUsername := url.QueryEscape(conn.Username)
@@ -45,6 +47,7 @@ func NewPostgresqlClient(conn client.DBInfo) (PostgresqlClient, error) {
ctx, cancel := context.WithTimeout(context.Background(), time.Duration(conn.Timeout)*time.Second)
defer cancel()
if err := db.PingContext(ctx); err != nil {
_ = db.Close()
return nil, err
}
if errors.Is(ctx.Err(), context.DeadlineExceeded) {
+5 -4
View File
@@ -19,10 +19,11 @@ type DBInfo struct {
}
type CreateInfo struct {
Name string `json:"name"`
Username string `json:"userName"`
Password string `json:"password"`
SuperUser bool `json:"superUser"`
ExistingUser bool `json:"existingUser"`
Name string `json:"name"`
Username string `json:"userName"`
Password string `json:"password"`
SuperUser bool `json:"superUser"`
Timeout uint `json:"timeout"` // second
}
+30 -38
View File
@@ -31,19 +31,26 @@ func NewLocal(command []string, containerName, username, password, database stri
}
func (r *Local) Create(info CreateInfo) error {
createSql := fmt.Sprintf("CREATE DATABASE \"%s\"", info.Name)
if err := r.ExecSQL(createSql, info.Timeout); err != nil {
if err := r.ExecSQL("CREATE DATABASE "+QuoteIdentifier(info.Name), info.Timeout); err != nil {
if strings.Contains(strings.ToLower(err.Error()), "already exists") {
return buserr.New("ErrDatabaseIsExist")
}
return err
}
if err := r.CreateUser(info, true); err != nil {
_ = r.ExecSQL(fmt.Sprintf("DROP DATABASE \"%s\"", info.Name), info.Timeout)
var err error
if info.ExistingUser {
if !info.SuperUser {
err = GrantUser(r, info.Name, info.Username, false)
}
} else {
err = r.CreateUser(info, false)
}
if err != nil {
if cleanupErr := r.ExecSQL("DROP DATABASE "+QuoteIdentifier(info.Name), info.Timeout); cleanupErr != nil {
return fmt.Errorf("%w; cleanup database: %v", err, cleanupErr)
}
return err
}
return nil
}
@@ -52,48 +59,30 @@ func (r *Local) ChangePrivileges(info Privileges) error {
if !info.SuperUser {
super = "NOSUPERUSER"
}
changeSql := fmt.Sprintf("ALTER USER \"%s\" WITH %s", info.Username, super)
changeSql := "ALTER USER " + QuoteIdentifier(info.Username) + " WITH " + super
return r.ExecSQL(changeSql, info.Timeout)
}
func (r *Local) CreateUser(info CreateInfo, withDeleteDB bool) error {
createSql := fmt.Sprintf("CREATE USER \"%s\" WITH PASSWORD '%s'", info.Username, info.Password)
if err := r.ExecSQL(createSql, info.Timeout); err != nil {
privileges := "NOSUPERUSER"
if info.SuperUser {
privileges = "SUPERUSER"
}
statement := "CREATE USER " + QuoteIdentifier(info.Username) + " WITH " + privileges + " PASSWORD " + QuoteLiteral(info.Password)
if err := r.ExecSQL(statement, info.Timeout); err != nil {
if strings.Contains(strings.ToLower(err.Error()), "already exists") {
return buserr.New("ErrUserIsExist")
}
if withDeleteDB {
_ = r.Delete(DeleteInfo{
Name: info.Name,
Username: info.Username,
ForceDelete: true,
Timeout: 300})
}
return err
}
if info.SuperUser {
if err := r.ChangePrivileges(Privileges{SuperUser: true, Username: info.Username, Timeout: info.Timeout}); err != nil {
if withDeleteDB {
_ = r.Delete(DeleteInfo{
Name: info.Name,
Username: info.Username,
ForceDelete: true,
Timeout: 300})
if info.Name != "" && !info.SuperUser {
if err := GrantUser(r, info.Name, info.Username, false); err != nil {
if cleanupErr := r.ExecSQL("DROP USER "+QuoteIdentifier(info.Username), info.Timeout); cleanupErr != nil {
return fmt.Errorf("%w; cleanup user: %v", err, cleanupErr)
}
return err
}
}
grantStr := fmt.Sprintf("GRANT ALL PRIVILEGES ON DATABASE \"%s\" TO \"%s\"", info.Name, info.Username)
if err := r.ExecSQL(grantStr, info.Timeout); err != nil {
if withDeleteDB {
_ = r.Delete(DeleteInfo{
Name: info.Name,
Username: info.Username,
ForceDelete: true,
Timeout: 300})
}
return err
}
return nil
}
@@ -106,12 +95,15 @@ func (r *Local) Delete(info DeleteInfo) error {
if inUse && !info.ForceDelete {
return buserr.WithDetail("ErrInUsed", info.Name, nil)
}
dropSql := fmt.Sprintf("DROP DATABASE \"%s\"", info.Name)
dropSql := "DROP DATABASE " + QuoteIdentifier(info.Name)
if err := r.ExecSQL(dropSql, info.Timeout); err != nil && !info.ForceDelete {
return fmt.Errorf("drop database failed, err: %v", err)
}
}
dropSql := fmt.Sprintf("DROP USER \"%s\"", info.Username)
if info.Username == "" {
return nil
}
dropSql := "DROP USER " + QuoteIdentifier(info.Username)
if err := r.ExecSQL(dropSql, info.Timeout); err != nil && !info.ForceDelete {
return fmt.Errorf("drop user failed, err: %v", err)
}
@@ -119,7 +111,7 @@ func (r *Local) Delete(info DeleteInfo) error {
}
func (r *Local) ChangePassword(info PasswordChangeInfo) error {
changeSql := fmt.Sprintf("ALTER USER \"%s\" WITH PASSWORD '%s'", info.Username, info.Password)
changeSql := "ALTER USER " + QuoteIdentifier(info.Username) + " WITH PASSWORD " + QuoteLiteral(info.Password)
if err := r.ExecSQL(changeSql, info.Timeout); err != nil {
return err
}
+30 -36
View File
@@ -70,58 +70,49 @@ func NewRemote(db Remote) *Remote {
return &db
}
func (r *Remote) Create(info CreateInfo) error {
createSql := fmt.Sprintf("CREATE DATABASE \"%s\"", info.Name)
if err := r.ExecSQL(createSql, info.Timeout); err != nil {
if err := r.ExecSQL("CREATE DATABASE "+QuoteIdentifier(info.Name), info.Timeout); err != nil {
if strings.Contains(strings.ToLower(err.Error()), "already exists") {
return buserr.New("ErrDatabaseIsExist")
}
return err
}
if err := r.CreateUser(info, true); err != nil {
var err error
if info.ExistingUser {
if !info.SuperUser {
err = GrantUser(r, info.Name, info.Username, false)
}
} else {
err = r.CreateUser(info, false)
}
if err != nil {
if cleanupErr := r.ExecSQL("DROP DATABASE "+QuoteIdentifier(info.Name), info.Timeout); cleanupErr != nil {
return fmt.Errorf("%w; cleanup database: %v", err, cleanupErr)
}
return err
}
return nil
}
func (r *Remote) CreateUser(info CreateInfo, withDeleteDB bool) error {
createSql := fmt.Sprintf("CREATE USER \"%s\" WITH PASSWORD '%s'", info.Username, info.Password)
if err := r.ExecSQL(createSql, info.Timeout); err != nil {
privileges := "NOSUPERUSER"
if info.SuperUser {
privileges = "SUPERUSER"
}
statement := "CREATE USER " + QuoteIdentifier(info.Username) + " WITH " + privileges + " PASSWORD " + QuoteLiteral(info.Password)
if err := r.ExecSQL(statement, info.Timeout); err != nil {
if strings.Contains(strings.ToLower(err.Error()), "already exists") {
return buserr.New("ErrUserIsExist")
}
if withDeleteDB {
_ = r.Delete(DeleteInfo{
Name: info.Name,
Username: info.Username,
ForceDelete: true,
Timeout: 300})
}
return err
}
if info.SuperUser {
if err := r.ChangePrivileges(Privileges{SuperUser: true, Username: info.Username, Timeout: info.Timeout}); err != nil {
if withDeleteDB {
_ = r.Delete(DeleteInfo{
Name: info.Name,
Username: info.Username,
ForceDelete: true,
Timeout: 300})
if info.Name != "" && !info.SuperUser {
if err := GrantUser(r, info.Name, info.Username, false); err != nil {
if cleanupErr := r.ExecSQL("DROP USER "+QuoteIdentifier(info.Username), info.Timeout); cleanupErr != nil {
return fmt.Errorf("%w; cleanup user: %v", err, cleanupErr)
}
return err
}
}
grantSql := fmt.Sprintf("GRANT ALL PRIVILEGES ON DATABASE \"%s\" TO \"%s\"", info.Name, info.Username)
if err := r.ExecSQL(grantSql, info.Timeout); err != nil {
if withDeleteDB {
_ = r.Delete(DeleteInfo{
Name: info.Name,
Username: info.Username,
ForceDelete: true,
Timeout: 300})
}
return err
}
return nil
}
@@ -134,12 +125,15 @@ func (r *Remote) Delete(info DeleteInfo) error {
if inUse && !info.ForceDelete {
return buserr.WithDetail("ErrInUsed", info.Name, nil)
}
dropSql := fmt.Sprintf("DROP DATABASE \"%s\"", info.Name)
dropSql := "DROP DATABASE " + QuoteIdentifier(info.Name)
if err := r.ExecSQL(dropSql, info.Timeout); err != nil && !info.ForceDelete {
return fmt.Errorf("drop database failed, err: %v", err)
}
}
dropSql := fmt.Sprintf("DROP USER \"%s\"", info.Username)
if info.Username == "" {
return nil
}
dropSql := "DROP USER " + QuoteIdentifier(info.Username)
if err := r.ExecSQL(dropSql, info.Timeout); err != nil && !info.ForceDelete {
return fmt.Errorf("drop user failed, err: %v", err)
}
@@ -169,11 +163,11 @@ func (r *Remote) ChangePrivileges(info Privileges) error {
if !info.SuperUser {
super = "NOSUPERUSER"
}
return r.ExecSQL(fmt.Sprintf("ALTER USER \"%s\" WITH %s", info.Username, super), info.Timeout)
return r.ExecSQL("ALTER USER "+QuoteIdentifier(info.Username)+" WITH "+super, info.Timeout)
}
func (r *Remote) ChangePassword(info PasswordChangeInfo) error {
return r.ExecSQL(fmt.Sprintf("ALTER USER \"%s\" WITH ENCRYPTED PASSWORD '%s'", info.Username, info.Password), info.Timeout)
return r.ExecSQL("ALTER USER "+QuoteIdentifier(info.Username)+" WITH PASSWORD "+QuoteLiteral(info.Password), info.Timeout)
}
func (r *Remote) Backup(info BackupInfo) error {
+73
View File
@@ -0,0 +1,73 @@
package client
import (
"context"
"encoding/json"
"strings"
"time"
)
type UserInfo struct {
Username string `json:"username"`
SuperUser bool `json:"superUser"`
Protected bool `json:"protected"`
Databases []string `json:"databases"`
}
type UserClient interface {
ExecSQL(command string, timeout uint) error
ExecSQLForRows(command string, timeout uint) ([]string, error)
}
func ListUsers(cli UserClient) ([]UserInfo, error) {
rows, err := cli.ExecSQLForRows(`SELECT COALESCE(json_agg(u ORDER BY u.username), '[]'::json)::text FROM (
SELECT r.rolname AS username, r.rolsuper AS "superUser",
(r.rolname = current_user OR r.rolname = 'postgres' OR r.rolname LIKE 'pg\_%') AS protected,
COALESCE((SELECT json_agg(d.datname ORDER BY d.datname) FROM pg_database d
WHERE NOT d.datistemplate AND EXISTS (
SELECT 1 FROM aclexplode(d.datacl) a WHERE a.grantee = r.oid
)), '[]'::json) AS databases
FROM pg_roles r WHERE r.rolcanlogin
) u`, 300)
if err != nil {
return nil, err
}
var users []UserInfo
err = json.Unmarshal([]byte(strings.TrimSpace(strings.Join(rows, "\n"))), &users)
return users, err
}
func GrantUser(cli UserClient, database, username string, revoke bool) error {
statement := "GRANT ALL PRIVILEGES ON DATABASE " + QuoteIdentifier(database) + " TO " + QuoteIdentifier(username)
if revoke {
statement = "REVOKE ALL PRIVILEGES ON DATABASE " + QuoteIdentifier(database) + " FROM " + QuoteIdentifier(username)
}
return cli.ExecSQL(statement, 300)
}
func QuoteIdentifier(value string) string {
return `"` + strings.ReplaceAll(value, `"`, `""`) + `"`
}
func QuoteLiteral(value string) string {
return `E'` + strings.ReplaceAll(strings.ReplaceAll(value, `\`, `\\`), `'`, `''`) + `'`
}
func (r *Remote) ExecSQLForRows(command string, timeout uint) ([]string, error) {
ctx, cancel := context.WithTimeout(context.Background(), time.Duration(timeout)*time.Second)
defer cancel()
rows, err := r.Client.QueryContext(ctx, command)
if err != nil {
return nil, err
}
defer rows.Close()
var result []string
for rows.Next() {
var value string
if err := rows.Scan(&value); err != nil {
return nil, err
}
result = append(result, value)
}
return result, rows.Err()
}