mirrors/nginx-ui
1
0
Fork 0
mirror of https://github.com/0xJacky/nginx-ui.git synced 2025-05-11 02:15:48 +02:00
Code Issues Projects Releases Packages Wiki Activity Actions 4

feat: duplicate site #80

Browse source
This commit is contained in:
0xJacky 2023-02-13 19:36:40 +08:00
parent 566a5c725e
commit a3dfc7af4a
No known key found for this signature in database
GPG key ID: B6E4A6E4A561BAF0
3 changed files with 432 additions and 338 deletions
Download patch file Download diff file Expand all files Collapse all files

45
frontend/src/views/domain/DomainList.vue
View file

@ -10,6 +10,7 @@ import domain from '@/api/domain'
import {Badge, message} from 'ant-design-vue' import {Badge, message} from 'ant-design-vue'
import {h, ref} from 'vue' import {h, ref} from 'vue'
import {input} from '@/components/StdDataEntry' import {input} from '@/components/StdDataEntry'
import SiteDuplicate from '@/views/domain/SiteDuplicate.vue'
const columns = [{ const columns = [{
title: () => $gettext('Name'), title: () => $gettext('Name'),
@ -25,7 +26,7 @@ const columns = [{
dataIndex: 'enabled', dataIndex: 'enabled',
customRender: (args: customRender) => { customRender: (args: customRender) => {
const template: any = [] const template: any = []
const {text, column} = args const {text} = args
if (text === true || text > 0) { if (text === true || text > 0) {
template.push(<Badge status="success"/>) template.push(<Badge status="success"/>)
template.push($gettext('Enabled')) template.push($gettext('Enabled'))
@ -83,6 +84,15 @@ function destroy(site_name: any) {
message.error(e?.message ?? $gettext('Server error')) message.error(e?.message ?? $gettext('Server error'))
}) })
} }
const show_duplicator = ref(false)
const target = ref('')
function handle_click_duplicate(name: string) {
show_duplicator.value = true
target.value = name
}
</script> </script>
<template> <template>
@ -99,25 +109,30 @@ function destroy(site_name: any) {
> >
<template #actions="{record}"> <template #actions="{record}">
<a-divider type="vertical"/> <a-divider type="vertical"/>
<a v-if="record.enabled" @click="disable(record.name)"> <a-button type="link" size="small" v-if="record.enabled" @click="disable(record.name)">
{{ $gettext('Disabled') }} {{ $gettext('Disabled') }}
</a> </a-button>
<a v-else @click="enable(record.name)"> <a-button type="link" size="small" v-else @click="enable(record.name)">
{{ $gettext('Enabled') }} {{ $gettext('Enabled') }}
</a> </a-button>
<template v-if="!record.enabled"> <a-divider type="vertical"/>
<a-divider type="vertical"/> <a-button type="link" size="small" @click="handle_click_duplicate(record.name)">
<a-popconfirm {{ $gettext('Duplicate') }}
:cancelText="$gettext('No')" </a-button>
:okText="$gettext('OK')" <a-divider type="vertical"/>
:title="$gettext('Are you sure you want to delete?')" <a-popconfirm
@confirm="destroy(record['name'])"> :cancelText="$gettext('No')"
<a v-translate>Delete</a> :okText="$gettext('OK')"
</a-popconfirm> :title="$gettext('Are you sure you want to delete?')"
</template> @confirm="destroy(record['name'])">
<a-button type="link" size="small" :disabled="record.enabled">
{{ $gettext('Delete') }}
</a-button>
</a-popconfirm>
</template> </template>
</std-table> </std-table>
</a-card> </a-card>
<site-duplicate v-model:visible="show_duplicator" :name="target" @duplicated="table.get_list()"/>
</template> </template>
<style scoped> <style scoped>

79
frontend/src/views/domain/SiteDuplicate.vue Normal file
View file

@ -0,0 +1,79 @@
<script setup lang="ts">
import {computed, nextTick, reactive, ref, watch} from 'vue'
import {useGettext} from 'vue3-gettext'
import {Form, message} from 'ant-design-vue'
import gettext from '@/gettext'
import domain from '@/api/domain'
const {$gettext} = useGettext()
const props = defineProps(['visible', 'name'])
const emit = defineEmits(['update:visible', 'duplicated'])
const show = computed({
get() {
return props.visible
},
set(v) {
emit('update:visible', v)
}
})
const modelRef = reactive({name: ''})
const rulesRef = reactive({
name: [
{
required: true,
message: () => $gettext('Please input name, ' +
'this will be used as the filename of the new configuration!')
}
]
})
const {validate, validateInfos, clearValidate} = Form.useForm(modelRef, rulesRef)
const loading = ref(false)
function onSubmit() {
validate().then(async () => {
loading.value = true
domain.duplicate(props.name, {name: modelRef.name}).then(() => {
message.success($gettext('Duplicated successfully'))
show.value = false
emit('duplicated')
}).catch((e: any) => {
message.error($gettext(e?.message ?? 'Server error'))
})
loading.value = false
})
}
watch(() => props.visible, (v) => {
if (v) {
modelRef.name = ''
nextTick(() => clearValidate())
}
})
watch(() => gettext.current, () => {
clearValidate()
})
</script>
<template>
<a-modal :title="$gettext('Duplicate')" v-model:visible="show" @ok="onSubmit"
:confirm-loading="loading">
<a-form layout="vertical">
<a-form-item :label="$gettext('Name')" v-bind="validateInfos.name">
<a-input v-model:value="modelRef.name"/>
</a-form-item>
</a-form>
</a-modal>
</template>
<style lang="less" scoped>
</style>

646
server/api/domain.go
View file

@ -1,435 +1,435 @@
package api package api
import ( import (
"github.com/0xJacky/Nginx-UI/server/model" "github.com/0xJacky/Nginx-UI/server/model"
"github.com/0xJacky/Nginx-UI/server/pkg/cert" "github.com/0xJacky/Nginx-UI/server/pkg/cert"
"github.com/0xJacky/Nginx-UI/server/pkg/config_list" "github.com/0xJacky/Nginx-UI/server/pkg/config_list"
"github.com/0xJacky/Nginx-UI/server/pkg/helper" "github.com/0xJacky/Nginx-UI/server/pkg/helper"
"github.com/0xJacky/Nginx-UI/server/pkg/nginx" "github.com/0xJacky/Nginx-UI/server/pkg/nginx"
"github.com/gin-gonic/gin" "github.com/gin-gonic/gin"
"log" "log"
"net/http" "net/http"
"os" "os"
"strings" "strings"
"time" "time"
) )
func GetDomains(c *gin.Context) { func GetDomains(c *gin.Context) {
name := c.Query("name") name := c.Query("name")
orderBy := c.Query("order_by") orderBy := c.Query("order_by")
sort := c.DefaultQuery("sort", "desc") sort := c.DefaultQuery("sort", "desc")
mySort := map[string]string{ mySort := map[string]string{
"enabled": "bool", "enabled": "bool",
"name": "string", "name": "string",
"modify": "time", "modify": "time",
} }
configFiles, err := os.ReadDir(nginx.GetConfPath("sites-available")) configFiles, err := os.ReadDir(nginx.GetConfPath("sites-available"))
if err != nil { if err != nil {
ErrHandler(c, err) ErrHandler(c, err)
return return
} }
enabledConfig, err := os.ReadDir(nginx.GetConfPath("sites-enabled")) enabledConfig, err := os.ReadDir(nginx.GetConfPath("sites-enabled"))
if err != nil { if err != nil {
ErrHandler(c, err) ErrHandler(c, err)
return return
} }
enabledConfigMap := make(map[string]bool) enabledConfigMap := make(map[string]bool)
for i := range enabledConfig { for i := range enabledConfig {
enabledConfigMap[enabledConfig[i].Name()] = true enabledConfigMap[enabledConfig[i].Name()] = true
} }
var configs []gin.H var configs []gin.H
for i := range configFiles { for i := range configFiles {
file := configFiles[i] file := configFiles[i]
fileInfo, _ := file.Info() fileInfo, _ := file.Info()
if !file.IsDir() { if !file.IsDir() {
if name != "" && !strings.Contains(file.Name(), name) { if name != "" && !strings.Contains(file.Name(), name) {
continue continue
} }
configs = append(configs, gin.H{ configs = append(configs, gin.H{
"name": file.Name(), "name": file.Name(),
"size": fileInfo.Size(), "size": fileInfo.Size(),
"modify": fileInfo.ModTime(), "modify": fileInfo.ModTime(),
"enabled": enabledConfigMap[file.Name()], "enabled": enabledConfigMap[file.Name()],
}) })
} }
} }
configs = config_list.Sort(orderBy, sort, mySort[orderBy], configs) configs = config_list.Sort(orderBy, sort, mySort[orderBy], configs)
c.JSON(http.StatusOK, gin.H{ c.JSON(http.StatusOK, gin.H{
"data": configs, "data": configs,
}) })
} }
type CertificateInfo struct { type CertificateInfo struct {
SubjectName string `json:"subject_name"` SubjectName string `json:"subject_name"`
IssuerName string `json:"issuer_name"` IssuerName string `json:"issuer_name"`
NotAfter time.Time `json:"not_after"` NotAfter time.Time `json:"not_after"`
NotBefore time.Time `json:"not_before"` NotBefore time.Time `json:"not_before"`
} }
func GetDomain(c *gin.Context) { func GetDomain(c *gin.Context) {
rewriteName, ok := c.Get("rewriteConfigFileName") rewriteName, ok := c.Get("rewriteConfigFileName")
name := c.Param("name") name := c.Param("name")
// for modify filename // for modify filename
if ok { if ok {
name = rewriteName.(string) name = rewriteName.(string)
} }
path := nginx.GetConfPath("sites-available", name) path := nginx.GetConfPath("sites-available", name)
enabled := true enabled := true
if _, err := os.Stat(nginx.GetConfPath("sites-enabled", name)); os.IsNotExist(err) { if _, err := os.Stat(nginx.GetConfPath("sites-enabled", name)); os.IsNotExist(err) {
enabled = false enabled = false
} }
c.Set("maybe_error", "nginx_config_syntax_error") c.Set("maybe_error", "nginx_config_syntax_error")
config, err := nginx.ParseNgxConfig(path) config, err := nginx.ParseNgxConfig(path)
if err != nil { if err != nil {
ErrHandler(c, err) ErrHandler(c, err)
return return
} }
c.Set("maybe_error", "") c.Set("maybe_error", "")
certInfoMap := make(map[int]CertificateInfo) certInfoMap := make(map[int]CertificateInfo)
var serverName string var serverName string
for serverIdx, server := range config.Servers { for serverIdx, server := range config.Servers {
for _, directive := range server.Directives { for _, directive := range server.Directives {
if directive.Directive == "server_name" { if directive.Directive == "server_name" {
serverName = strings.ReplaceAll(directive.Params, " ", "_") serverName = strings.ReplaceAll(directive.Params, " ", "_")
continue continue
} }
if directive.Directive == "ssl_certificate" { if directive.Directive == "ssl_certificate" {
pubKey, err := cert.GetCertInfo(directive.Params) pubKey, err := cert.GetCertInfo(directive.Params)
if err != nil { if err != nil {
log.Println("Failed to get certificate information", err) log.Println("Failed to get certificate information", err)
break break
} }
certInfoMap[serverIdx] = CertificateInfo{ certInfoMap[serverIdx] = CertificateInfo{
SubjectName: pubKey.Subject.CommonName, SubjectName: pubKey.Subject.CommonName,
IssuerName: pubKey.Issuer.CommonName, IssuerName: pubKey.Issuer.CommonName,
NotAfter: pubKey.NotAfter, NotAfter: pubKey.NotAfter,
NotBefore: pubKey.NotBefore, NotBefore: pubKey.NotBefore,
} }
break break
} }
} }
} }
certModel, _ := model.FirstCert(serverName) certModel, _ := model.FirstCert(serverName)
c.Set("maybe_error", "nginx_config_syntax_error") c.Set("maybe_error", "nginx_config_syntax_error")
c.JSON(http.StatusOK, gin.H{ c.JSON(http.StatusOK, gin.H{
"enabled": enabled, "enabled": enabled,
"name": name, "name": name,
"config": config.FmtCode(), "config": config.FmtCode(),
"tokenized": config, "tokenized": config,
"auto_cert": certModel.AutoCert == model.AutoCertEnabled, "auto_cert": certModel.AutoCert == model.AutoCertEnabled,
"cert_info": certInfoMap, "cert_info": certInfoMap,
}) })
} }
func SaveDomain(c *gin.Context) { func SaveDomain(c *gin.Context) {
name := c.Param("name") name := c.Param("name")
if name == "" { if name == "" {
c.JSON(http.StatusNotAcceptable, gin.H{ c.JSON(http.StatusNotAcceptable, gin.H{
"message": "param name is empty", "message": "param name is empty",
}) })
return return
} }
var json struct { var json struct {
Name string `json:"name" binding:"required"` Name string `json:"name" binding:"required"`
Content string `json:"content" binding:"required"` Content string `json:"content" binding:"required"`
Overwrite bool `json:"overwrite"` Overwrite bool `json:"overwrite"`
} }
if !BindAndValid(c, &json) { if !BindAndValid(c, &json) {
return return
} }
path := nginx.GetConfPath("sites-available", name) path := nginx.GetConfPath("sites-available", name)
if !json.Overwrite && helper.FileExists(path) { if !json.Overwrite && helper.FileExists(path) {
c.JSON(http.StatusNotAcceptable, gin.H{ c.JSON(http.StatusNotAcceptable, gin.H{
"message": "File exists", "message": "File exists",
}) })
return return
} }
err := os.WriteFile(path, []byte(json.Content), 0644) err := os.WriteFile(path, []byte(json.Content), 0644)
if err != nil { if err != nil {
ErrHandler(c, err) ErrHandler(c, err)
return return
} }
enabledConfigFilePath := nginx.GetConfPath("sites-enabled", name) enabledConfigFilePath := nginx.GetConfPath("sites-enabled", name)
// rename the config file if needed // rename the config file if needed
if name != json.Name { if name != json.Name {
newPath := nginx.GetConfPath("sites-available", json.Name) newPath := nginx.GetConfPath("sites-available", json.Name)
// check if dst file exists, do not rename // check if dst file exists, do not rename
if helper.FileExists(newPath) { if helper.FileExists(newPath) {
c.JSON(http.StatusNotAcceptable, gin.H{ c.JSON(http.StatusNotAcceptable, gin.H{
"message": "File exists", "message": "File exists",
}) })
return return
} }
// recreate soft link // recreate soft link
if helper.FileExists(enabledConfigFilePath) { if helper.FileExists(enabledConfigFilePath) {
_ = os.Remove(enabledConfigFilePath) _ = os.Remove(enabledConfigFilePath)
enabledConfigFilePath = nginx.GetConfPath("sites-enabled", json.Name) enabledConfigFilePath = nginx.GetConfPath("sites-enabled", json.Name)
err = os.Symlink(newPath, enabledConfigFilePath) err = os.Symlink(newPath, enabledConfigFilePath)
if err != nil { if err != nil {
ErrHandler(c, err) ErrHandler(c, err)
return return
} }
} }
err = os.Rename(path, newPath) err = os.Rename(path, newPath)
if err != nil { if err != nil {
ErrHandler(c, err) ErrHandler(c, err)
return return
} }
name = json.Name name = json.Name
c.Set("rewriteConfigFileName", name) c.Set("rewriteConfigFileName", name)
} }
enabledConfigFilePath = nginx.GetConfPath("sites-enabled", name) enabledConfigFilePath = nginx.GetConfPath("sites-enabled", name)
if helper.FileExists(enabledConfigFilePath) { if helper.FileExists(enabledConfigFilePath) {
// Test nginx configuration // Test nginx configuration
output := nginx.TestConf() output := nginx.TestConf()
if nginx.GetLogLevel(output) >= nginx.Warn { if nginx.GetLogLevel(output) >= nginx.Warn {
c.JSON(http.StatusInternalServerError, gin.H{ c.JSON(http.StatusInternalServerError, gin.H{
"message": output, "message": output,
"error": "nginx_config_syntax_error", "error": "nginx_config_syntax_error",
}) })
return return
} }
output = nginx.Reload() output = nginx.Reload()
if nginx.GetLogLevel(output) >= nginx.Warn { if nginx.GetLogLevel(output) >= nginx.Warn {
c.JSON(http.StatusInternalServerError, gin.H{ c.JSON(http.StatusInternalServerError, gin.H{
"message": output, "message": output,
}) })
return return
} }
} }
GetDomain(c) GetDomain(c)
} }
func EnableDomain(c *gin.Context) { func EnableDomain(c *gin.Context) {
configFilePath := nginx.GetConfPath("sites-available", c.Param("name")) configFilePath := nginx.GetConfPath("sites-available", c.Param("name"))
enabledConfigFilePath := nginx.GetConfPath("sites-enabled", c.Param("name")) enabledConfigFilePath := nginx.GetConfPath("sites-enabled", c.Param("name"))
_, err := os.Stat(configFilePath) _, err := os.Stat(configFilePath)
if err != nil { if err != nil {
ErrHandler(c, err) ErrHandler(c, err)
return return
} }
if _, err = os.Stat(enabledConfigFilePath); os.IsNotExist(err) { if _, err = os.Stat(enabledConfigFilePath); os.IsNotExist(err) {
err = os.Symlink(configFilePath, enabledConfigFilePath) err = os.Symlink(configFilePath, enabledConfigFilePath)
if err != nil { if err != nil {
ErrHandler(c, err) ErrHandler(c, err)
return return
} }
} }
// Test nginx config, if not pass then disable the site. // Test nginx config, if not pass then disable the site.
output := nginx.TestConf() output := nginx.TestConf()
if nginx.GetLogLevel(output) >= nginx.Warn { if nginx.GetLogLevel(output) >= nginx.Warn {
_ = os.Remove(enabledConfigFilePath) _ = os.Remove(enabledConfigFilePath)
c.JSON(http.StatusInternalServerError, gin.H{ c.JSON(http.StatusInternalServerError, gin.H{
"message": output, "message": output,
}) })
return return
} }
output = nginx.Reload() output = nginx.Reload()
if nginx.GetLogLevel(output) >= nginx.Warn { if nginx.GetLogLevel(output) >= nginx.Warn {
c.JSON(http.StatusInternalServerError, gin.H{ c.JSON(http.StatusInternalServerError, gin.H{
"message": output, "message": output,
}) })
return return
} }
c.JSON(http.StatusOK, gin.H{ c.JSON(http.StatusOK, gin.H{
"message": "ok", "message": "ok",
}) })
} }
func DisableDomain(c *gin.Context) { func DisableDomain(c *gin.Context) {
enabledConfigFilePath := nginx.GetConfPath("sites-enabled", c.Param("name")) enabledConfigFilePath := nginx.GetConfPath("sites-enabled", c.Param("name"))
_, err := os.Stat(enabledConfigFilePath) _, err := os.Stat(enabledConfigFilePath)
if err != nil { if err != nil {
ErrHandler(c, err) ErrHandler(c, err)
return return
} }
err = os.Remove(enabledConfigFilePath) err = os.Remove(enabledConfigFilePath)
if err != nil { if err != nil {
ErrHandler(c, err) ErrHandler(c, err)
return return
} }
// delete auto cert record // delete auto cert record
certModel := model.Cert{Domain: c.Param("name")} certModel := model.Cert{Domain: c.Param("name")}
err = certModel.Remove() err = certModel.Remove()
if err != nil { if err != nil {
ErrHandler(c, err) ErrHandler(c, err)
return return
} }
output := nginx.Reload() output := nginx.Reload()
if nginx.GetLogLevel(output) >= nginx.Warn { if nginx.GetLogLevel(output) >= nginx.Warn {
c.JSON(http.StatusInternalServerError, gin.H{ c.JSON(http.StatusInternalServerError, gin.H{
"message": output, "message": output,
}) })
return return
} }
c.JSON(http.StatusOK, gin.H{ c.JSON(http.StatusOK, gin.H{
"message": "ok", "message": "ok",
}) })
} }
func DeleteDomain(c *gin.Context) { func DeleteDomain(c *gin.Context) {
var err error var err error
name := c.Param("name") name := c.Param("name")
availablePath := nginx.GetConfPath("sites-available", name) availablePath := nginx.GetConfPath("sites-available", name)
enabledPath := nginx.GetConfPath("sites-enabled", name) enabledPath := nginx.GetConfPath("sites-enabled", name)
if _, err = os.Stat(availablePath); os.IsNotExist(err) { if _, err = os.Stat(availablePath); os.IsNotExist(err) {
c.JSON(http.StatusNotFound, gin.H{ c.JSON(http.StatusNotFound, gin.H{
"message": "site not found", "message": "site not found",
}) })
return return
} }
if _, err = os.Stat(enabledPath); err == nil { if _, err = os.Stat(enabledPath); err == nil {
c.JSON(http.StatusNotAcceptable, gin.H{ c.JSON(http.StatusNotAcceptable, gin.H{
"message": "site is enabled", "message": "site is enabled",
}) })
return return
} }
certModel := model.Cert{Domain: name} certModel := model.Cert{Domain: name}
_ = certModel.Remove() _ = certModel.Remove()
err = os.Remove(availablePath) err = os.Remove(availablePath)
if err != nil { if err != nil {
ErrHandler(c, err) ErrHandler(c, err)
return return
} }
c.JSON(http.StatusOK, gin.H{ c.JSON(http.StatusOK, gin.H{
"message": "ok", "message": "ok",
}) })
} }
func AddDomainToAutoCert(c *gin.Context) { func AddDomainToAutoCert(c *gin.Context) {
domain := c.Param("domain") domain := c.Param("domain")
domain = strings.ReplaceAll(domain, " ", "_") domain = strings.ReplaceAll(domain, " ", "_")
certModel, err := model.FirstOrCreateCert(domain) certModel, err := model.FirstOrCreateCert(domain)
if err != nil { if err != nil {
ErrHandler(c, err) ErrHandler(c, err)
return return
} }
err = certModel.Updates(&model.Cert{ err = certModel.Updates(&model.Cert{
AutoCert: model.AutoCertEnabled, AutoCert: model.AutoCertEnabled,
}) })
if err != nil { if err != nil {
ErrHandler(c, err) ErrHandler(c, err)
return return
} }
c.JSON(http.StatusOK, certModel) c.JSON(http.StatusOK, certModel)
} }
func RemoveDomainFromAutoCert(c *gin.Context) { func RemoveDomainFromAutoCert(c *gin.Context) {
domain := c.Param("domain") domain := c.Param("domain")
domain = strings.ReplaceAll(domain, " ", "_") domain = strings.ReplaceAll(domain, " ", "_")
certModel := model.Cert{ certModel := model.Cert{
Domain: domain, Domain: domain,
} }
err := certModel.Updates(&model.Cert{ err := certModel.Updates(&model.Cert{
AutoCert: model.AutoCertDisabled, AutoCert: model.AutoCertDisabled,
}) })
if err != nil { if err != nil {
ErrHandler(c, err) ErrHandler(c, err)
return return
} }
c.JSON(http.StatusOK, nil) c.JSON(http.StatusOK, nil)
} }
func DuplicateSite(c *gin.Context) { func DuplicateSite(c *gin.Context) {
name := c.Param("name") name := c.Param("name")
var json struct { var json struct {
Name string `json:"name"` Name string `json:"name" binding:"required"`
} }
if !BindAndValid(c, &json) { if !BindAndValid(c, &json) {
return return
} }
src := nginx.GetConfPath("sites-available", name) src := nginx.GetConfPath("sites-available", name)
dst := nginx.GetConfPath("sites-available", json.Name) dst := nginx.GetConfPath("sites-available", json.Name)
if helper.FileExists(dst) { if helper.FileExists(dst) {
c.JSON(http.StatusNotAcceptable, gin.H{ c.JSON(http.StatusNotAcceptable, gin.H{
"message": "file exists", "message": "File exists",
}) })
return return
} }
_, err := helper.CopyFile(src, dst) _, err := helper.CopyFile(src, dst)
if err != nil { if err != nil {
ErrHandler(c, err) ErrHandler(c, err)
return return
} }
c.JSON(http.StatusOK, gin.H{ c.JSON(http.StatusOK, gin.H{
"dst": dst, "dst": dst,
}) })
} }