mirrors/nginx-ui
1
0
Fork 0
mirror of https://github.com/0xJacky/nginx-ui.git synced 2025-05-12 02:45:49 +02:00
Code Issues Projects Releases Packages Wiki Activity Actions 6

wip: modify config file name

Browse source
This commit is contained in:
0xJacky 2022-12-25 23:31:23 +08:00
parent 7d4999f83a
commit f6a5f350ad
No known key found for this signature in database
GPG key ID: B6E4A6E4A561BAF0
2 changed files with 290 additions and 233 deletions
Download patch file Download diff file Expand all files Collapse all files

19
frontend/src/views/domain/DomainEdit.vue
View file

@ -4,8 +4,8 @@ import CodeEditor from '@/components/CodeEditor/CodeEditor.vue'
import NgxConfigEditor from '@/views/domain/ngx_conf/NgxConfigEditor' import NgxConfigEditor from '@/views/domain/ngx_conf/NgxConfigEditor'
import {useGettext} from 'vue3-gettext' import {useGettext} from 'vue3-gettext'
import {reactive, ref} from 'vue' import {reactive, ref, watch} from 'vue'
import {useRoute} from 'vue-router' import {useRoute, useRouter} from 'vue-router'
import domain from '@/api/domain' import domain from '@/api/domain'
import ngx from '@/api/ngx' import ngx from '@/api/ngx'
import {message} from 'ant-design-vue' import {message} from 'ant-design-vue'
@ -14,8 +14,13 @@ import {message} from 'ant-design-vue'
const {$gettext, interpolate} = useGettext() const {$gettext, interpolate} = useGettext()
const route = useRoute() const route = useRoute()
const router = useRouter()
const name = ref(route.params.name.toString()) const name = ref(route.params.name.toString())
watch(route, () => {
name.value = route.params.name.toString()
})
const update = ref(0) const update = ref(0)
const ngx_config = reactive({ const ngx_config = reactive({
@ -32,6 +37,7 @@ const configText = ref('')
const ok = ref(false) const ok = ref(false)
const advance_mode = ref(false) const advance_mode = ref(false)
const saving = ref(false) const saving = ref(false)
const filename = ref('')
init() init()
@ -40,7 +46,7 @@ function handle_response(r: any) {
Object.keys(cert_info_map).forEach(v => { Object.keys(cert_info_map).forEach(v => {
delete cert_info_map[v] delete cert_info_map[v]
}) })
filename.value = r.name
configText.value = r.config configText.value = r.config
enabled.value = r.enabled enabled.value = r.enabled
auto_cert.value = r.auto_cert auto_cert.value = r.auto_cert
@ -85,9 +91,9 @@ const save = async () => {
await build_config() await build_config()
} }
domain.save(name.value, {content: configText.value}).then(r => { domain.save(name.value, {name: filename.value, content: configText.value}).then(r => {
handle_response(r) handle_response(r)
router.push('/domain/' + filename.value)
message.success($gettext('Saved successfully')) message.success($gettext('Saved successfully'))
}).catch((e: any) => { }).catch((e: any) => {
@ -159,6 +165,9 @@ function on_change_enabled(checked: boolean) {
<a-form-item :label="$gettext('Enabled')"> <a-form-item :label="$gettext('Enabled')">
<a-switch v-model:checked="enabled" @change="on_change_enabled"/> <a-switch v-model:checked="enabled" @change="on_change_enabled"/>
</a-form-item> </a-form-item>
<a-form-item :label="$gettext('Name')">
<a-input v-model:value="filename"/>
</a-form-item>
<ngx-config-editor <ngx-config-editor
ref="ngx_config_editor" ref="ngx_config_editor"
:ngx_config="ngx_config" :ngx_config="ngx_config"

504
server/api/domain.go
View file

@ -1,310 +1,358 @@
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/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"
"path/filepath" "path/filepath"
"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.GetNginxConfPath("sites-available")) configFiles, err := os.ReadDir(nginx.GetNginxConfPath("sites-available"))
if err != nil { if err != nil {
ErrHandler(c, err) ErrHandler(c, err)
return return
} }
enabledConfig, err := os.ReadDir(filepath.Join(nginx.GetNginxConfPath("sites-enabled"))) enabledConfig, err := os.ReadDir(filepath.Join(nginx.GetNginxConfPath("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) {
name := c.Param("name") rewriteName, ok := c.Get("rewriteConfigFileName")
path := filepath.Join(nginx.GetNginxConfPath("sites-available"), name)
enabled := true name := c.Param("name")
if _, err := os.Stat(filepath.Join(nginx.GetNginxConfPath("sites-enabled"), name)); os.IsNotExist(err) {
enabled = false
}
config, err := nginx.ParseNgxConfig(path) // for modify filename
if ok {
name = rewriteName.(string)
}
if err != nil { path := filepath.Join(nginx.GetNginxConfPath("sites-available"), name)
ErrHandler(c, err)
return
}
certInfoMap := make(map[int]CertificateInfo) enabled := true
for serverIdx, server := range config.Servers { if _, err := os.Stat(filepath.Join(nginx.GetNginxConfPath("sites-enabled"), name)); os.IsNotExist(err) {
for _, directive := range server.Directives { enabled = false
if directive.Directive == "ssl_certificate" { }
pubKey, err := cert.GetCertInfo(directive.Params) config, err := nginx.ParseNgxConfig(path)
if err != nil { if err != nil {
log.Println("Failed to get certificate information", err) ErrHandler(c, err)
break return
} }
certInfoMap[serverIdx] = CertificateInfo{ certInfoMap := make(map[int]CertificateInfo)
SubjectName: pubKey.Subject.CommonName, for serverIdx, server := range config.Servers {
IssuerName: pubKey.Issuer.CommonName, for _, directive := range server.Directives {
NotAfter: pubKey.NotAfter, if directive.Directive == "ssl_certificate" {
NotBefore: pubKey.NotBefore,
}
break pubKey, err := cert.GetCertInfo(directive.Params)
}
}
}
_, err = model.FirstCert(name) if err != nil {
log.Println("Failed to get certificate information", err)
break
}
c.JSON(http.StatusOK, gin.H{ certInfoMap[serverIdx] = CertificateInfo{
"enabled": enabled, SubjectName: pubKey.Subject.CommonName,
"name": name, IssuerName: pubKey.Issuer.CommonName,
"config": config.BuildConfig(), NotAfter: pubKey.NotAfter,
"tokenized": config, NotBefore: pubKey.NotBefore,
"auto_cert": err == nil, }
"cert_info": certInfoMap,
}) break
}
}
}
_, err = model.FirstCert(name)
c.JSON(http.StatusOK, gin.H{
"enabled": enabled,
"name": name,
"config": config.BuildConfig(),
"tokenized": config,
"auto_cert": err == nil,
"cert_info": certInfoMap,
})
} }
func EditDomain(c *gin.Context) { func EditDomain(c *gin.Context) {
var err error name := c.Param("name")
name := c.Param("name")
request := make(gin.H)
err = c.BindJSON(&request)
path := filepath.Join(nginx.GetNginxConfPath("sites-available"), name)
err = os.WriteFile(path, []byte(request["content"].(string)), 0644) if name == "" {
if err != nil { c.JSON(http.StatusNotAcceptable, gin.H{
ErrHandler(c, err) "message": "param name is empty",
return })
} return
}
enabledConfigFilePath := filepath.Join(nginx.GetNginxConfPath("sites-enabled"), name) var json struct {
if _, err = os.Stat(enabledConfigFilePath); err == nil { Name string `json:"name" binding:"required"`
// Test nginx configuration Content string `json:"content"`
err = nginx.TestNginxConf() }
if err != nil {
c.JSON(http.StatusInternalServerError, gin.H{
"message": err.Error(),
})
return
}
output := nginx.ReloadNginx() if !BindAndValid(c, &json) {
return
}
if output != "" && strings.Contains(output, "error") { path := filepath.Join(nginx.GetNginxConfPath("sites-available"), name)
c.JSON(http.StatusInternalServerError, gin.H{
"message": output,
})
return
}
}
GetDomain(c) err := os.WriteFile(path, []byte(json.Content), 0644)
if err != nil {
ErrHandler(c, err)
return
}
enabledConfigFilePath := filepath.Join(nginx.GetNginxConfPath("sites-enabled"), name)
// rename the config file if needed
if name != json.Name {
newPath := filepath.Join(nginx.GetNginxConfPath("sites-available"), json.Name)
// recreate soft link
log.Println(enabledConfigFilePath)
if _, err = os.Stat(enabledConfigFilePath); err == nil {
log.Println(enabledConfigFilePath)
_ = os.Remove(enabledConfigFilePath)
enabledConfigFilePath = filepath.Join(nginx.GetNginxConfPath("sites-enabled"), json.Name)
err = os.Symlink(newPath, enabledConfigFilePath)
if err != nil {
ErrHandler(c, err)
return
}
}
err = os.Rename(path, newPath)
if err != nil {
ErrHandler(c, err)
return
}
name = json.Name
c.Set("rewriteConfigFileName", name)
}
enabledConfigFilePath = filepath.Join(nginx.GetNginxConfPath("sites-enabled"), name)
if _, err = os.Stat(enabledConfigFilePath); err == nil {
// Test nginx configuration
err = nginx.TestNginxConf()
if err != nil {
c.JSON(http.StatusInternalServerError, gin.H{
"message": err.Error(),
})
return
}
output := nginx.ReloadNginx()
if output != "" && strings.Contains(output, "error") {
c.JSON(http.StatusInternalServerError, gin.H{
"message": output,
})
return
}
}
GetDomain(c)
} }
func EnableDomain(c *gin.Context) { func EnableDomain(c *gin.Context) {
configFilePath := filepath.Join(nginx.GetNginxConfPath("sites-available"), c.Param("name")) configFilePath := filepath.Join(nginx.GetNginxConfPath("sites-available"), c.Param("name"))
enabledConfigFilePath := filepath.Join(nginx.GetNginxConfPath("sites-enabled"), c.Param("name")) enabledConfigFilePath := filepath.Join(nginx.GetNginxConfPath("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 rollback. // Test nginx config, if not pass then rollback.
err = nginx.TestNginxConf() err = nginx.TestNginxConf()
if err != nil { if err != nil {
_ = os.Remove(enabledConfigFilePath) _ = os.Remove(enabledConfigFilePath)
c.JSON(http.StatusInternalServerError, gin.H{ c.JSON(http.StatusInternalServerError, gin.H{
"message": err.Error(), "message": err.Error(),
}) })
return return
} }
output := nginx.ReloadNginx() output := nginx.ReloadNginx()
if output != "" && strings.Contains(output, "error") { if output != "" && strings.Contains(output, "error") {
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 := filepath.Join(nginx.GetNginxConfPath("sites-enabled"), c.Param("name")) enabledConfigFilePath := filepath.Join(nginx.GetNginxConfPath("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.ReloadNginx() output := nginx.ReloadNginx()
if output != "" { if output != "" {
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 := filepath.Join(nginx.GetNginxConfPath("sites-available"), name) availablePath := filepath.Join(nginx.GetNginxConfPath("sites-available"), name)
enabledPath := filepath.Join(nginx.GetNginxConfPath("sites-enabled"), name) enabledPath := filepath.Join(nginx.GetNginxConfPath("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")
certModel, err := model.FirstOrCreateCert(domain) certModel, err := model.FirstOrCreateCert(domain)
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) {
certModel := model.Cert{ certModel := model.Cert{
Domain: c.Param("domain"), Domain: c.Param("domain"),
} }
err := certModel.Remove() err := certModel.Remove()
if err != nil { if err != nil {
ErrHandler(c, err) ErrHandler(c, err)
return return
} }
c.JSON(http.StatusOK, nil) c.JSON(http.StatusOK, nil)
} }