bastion/nginx-proxy-manager
2
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

- Added upstream objects

Browse Source 
- Renamed host templates to nginx templates
- Generate upstream templates
- Better nginx error reporting when reloading
- Use tparse for golang test reporting
This commit is contained in:
Jamie Curnow
2023-01-04 15:36:56 +10:00
parent b3ae2f4dbb
commit 5e5f0de0e2
82 changed files with 2209 additions and 294 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
backend/internal/acme/acmesh.go
View File

@ -104,7 +104,7 @@ func shExec(args []string, envs []string) (string, error) {
c := exec.Command(acmeSh, args...)
c.Env = append(getCommonEnvVars(), envs...)
b, e := c.Output()
b, e := c.CombinedOutput()
if e != nil {
logger.Error("AcmeShError", fmt.Errorf("Command error: %s -- %v\n%+v", acmeSh, args, e))

9
backend/internal/acme/acmesh_test.go
View File

@ -11,15 +11,6 @@ import (
"github.com/stretchr/testify/assert"
)
// Tear up/down
/*
func TestMain(m *testing.M) {
config.Init(&version, &commit, &sentryDSN)
code := m.Run()
os.Exit(code)
}
*/
// TODO configurable
const acmeLogFile = "/data/logs/acme.sh.log"

32
backend/internal/api/handler/hosts.go
View File

@ -1,6 +1,7 @@
package handler
import (
"database/sql"
"encoding/json"
"fmt"
"net/http"
@ -45,13 +46,16 @@ func GetHost() func(http.ResponseWriter, *http.Request) {
return
}
hostObject, err := host.GetByID(hostID)
if err != nil {
h.ResultErrorJSON(w, r, http.StatusBadRequest, err.Error(), nil)
} else {
item, err := host.GetByID(hostID)
switch err {
case sql.ErrNoRows:
h.ResultErrorJSON(w, r, http.StatusNotFound, "Not found", nil)
case nil:
// nolint: errcheck,gosec
hostObject.Expand(getExpandFromContext(r))
h.ResultResponseJSON(w, r, http.StatusOK, hostObject)
item.Expand(getExpandFromContext(r))
h.ResultResponseJSON(w, r, http.StatusOK, item)
default:
h.ResultErrorJSON(w, r, http.StatusBadRequest, err.Error(), nil)
}
}
}
@ -111,6 +115,11 @@ func UpdateHost() func(http.ResponseWriter, *http.Request) {
return
}
if err = validator.ValidateHost(hostObject); err != nil {
h.ResultErrorJSON(w, r, http.StatusBadRequest, err.Error(), nil)
return
}
if err = hostObject.Save(false); err != nil {
h.ResultErrorJSON(w, r, http.StatusBadRequest, err.Error(), nil)
return
@ -137,11 +146,14 @@ func DeleteHost() func(http.ResponseWriter, *http.Request) {
return
}
host, err := host.GetByID(hostID)
if err != nil {
item, err := host.GetByID(hostID)
switch err {
case sql.ErrNoRows:
h.ResultErrorJSON(w, r, http.StatusNotFound, "Not found", nil)
case nil:
h.ResultResponseJSON(w, r, http.StatusOK, item.Delete())
default:
h.ResultErrorJSON(w, r, http.StatusBadRequest, err.Error(), nil)
} else {
h.ResultResponseJSON(w, r, http.StatusOK, host.Delete())
}
}
}

80
backend/internal/api/handler/host_templates.go → backend/internal/api/handler/nginx_templates.go
View File

@ -1,6 +1,7 @@
package handler
import (
"database/sql"
"encoding/json"
"fmt"
"net/http"
@ -8,13 +9,12 @@ import (
c "npm/internal/api/context"
h "npm/internal/api/http"
"npm/internal/api/middleware"
"npm/internal/entity/host"
"npm/internal/entity/hosttemplate"
"npm/internal/entity/nginxtemplate"
)
// GetHostTemplates will return a list of Host Templates
// Route: GET /host-templates
func GetHostTemplates() func(http.ResponseWriter, *http.Request) {
// GetNginxTemplates will return a list of Nginx Templates
// Route: GET /nginx-templates
func GetNginxTemplates() func(http.ResponseWriter, *http.Request) {
return func(w http.ResponseWriter, r *http.Request) {
pageInfo, err := getPageInfoFromRequest(r)
if err != nil {
@ -22,18 +22,18 @@ func GetHostTemplates() func(http.ResponseWriter, *http.Request) {
return
}
hosts, err := hosttemplate.List(pageInfo, middleware.GetFiltersFromContext(r))
items, err := nginxtemplate.List(pageInfo, middleware.GetFiltersFromContext(r))
if err != nil {
h.ResultErrorJSON(w, r, http.StatusBadRequest, err.Error(), nil)
} else {
h.ResultResponseJSON(w, r, http.StatusOK, hosts)
h.ResultResponseJSON(w, r, http.StatusOK, items)
}
}
}
// GetHostTemplate will return a single Host Template
// Route: GET /host-templates/{templateID}
func GetHostTemplate() func(http.ResponseWriter, *http.Request) {
// GetNginxTemplate will return a single Nginx Template
// Route: GET /nginx-templates/{templateID}
func GetNginxTemplate() func(http.ResponseWriter, *http.Request) {
return func(w http.ResponseWriter, r *http.Request) {
var err error
var templateID int
@ -42,23 +42,26 @@ func GetHostTemplate() func(http.ResponseWriter, *http.Request) {
return
}
host, err := hosttemplate.GetByID(templateID)
if err != nil {
item, err := nginxtemplate.GetByID(templateID)
switch err {
case sql.ErrNoRows:
h.ResultErrorJSON(w, r, http.StatusNotFound, "Not found", nil)
case nil:
h.ResultResponseJSON(w, r, http.StatusOK, item)
default:
h.ResultErrorJSON(w, r, http.StatusBadRequest, err.Error(), nil)
} else {
h.ResultResponseJSON(w, r, http.StatusOK, host)
}
}
}
// CreateHostTemplate will create a Host Template
// Route: POST /host-templates
func CreateHostTemplate() func(http.ResponseWriter, *http.Request) {
// CreateNginxTemplate will create a Nginx Template
// Route: POST /nginx-templates
func CreateNginxTemplate() func(http.ResponseWriter, *http.Request) {
return func(w http.ResponseWriter, r *http.Request) {
bodyBytes, _ := r.Context().Value(c.BodyCtxKey).([]byte)
var newHostTemplate hosttemplate.Model
err := json.Unmarshal(bodyBytes, &newHostTemplate)
var newNginxTemplate nginxtemplate.Model
err := json.Unmarshal(bodyBytes, &newNginxTemplate)
if err != nil {
h.ResultErrorJSON(w, r, http.StatusBadRequest, h.ErrInvalidPayload.Error(), nil)
return
@ -66,20 +69,20 @@ func CreateHostTemplate() func(http.ResponseWriter, *http.Request) {
// Get userID from token
userID, _ := r.Context().Value(c.UserIDCtxKey).(int)
newHostTemplate.UserID = userID
newNginxTemplate.UserID = userID
if err = newHostTemplate.Save(); err != nil {
h.ResultErrorJSON(w, r, http.StatusBadRequest, fmt.Sprintf("Unable to save Host Template: %s", err.Error()), nil)
if err = newNginxTemplate.Save(); err != nil {
h.ResultErrorJSON(w, r, http.StatusBadRequest, fmt.Sprintf("Unable to save Nginx Template: %s", err.Error()), nil)
return
}
h.ResultResponseJSON(w, r, http.StatusOK, newHostTemplate)
h.ResultResponseJSON(w, r, http.StatusOK, newNginxTemplate)
}
}
// UpdateHostTemplate updates a host template
// Route: PUT /host-templates/{templateID}
func UpdateHostTemplate() func(http.ResponseWriter, *http.Request) {
// UpdateNginxTemplate updates a nginx template
// Route: PUT /nginx-templates/{templateID}
func UpdateNginxTemplate() func(http.ResponseWriter, *http.Request) {
return func(w http.ResponseWriter, r *http.Request) {
var err error
var templateID int
@ -90,30 +93,30 @@ func UpdateHostTemplate() func(http.ResponseWriter, *http.Request) {
// reconfigure, _ := getQueryVarBool(r, "reconfigure", false, false)
hostTemplate, err := hosttemplate.GetByID(templateID)
nginxTemplate, err := nginxtemplate.GetByID(templateID)
if err != nil {
h.ResultErrorJSON(w, r, http.StatusBadRequest, err.Error(), nil)
} else {
bodyBytes, _ := r.Context().Value(c.BodyCtxKey).([]byte)
err := json.Unmarshal(bodyBytes, &hostTemplate)
err := json.Unmarshal(bodyBytes, &nginxTemplate)
if err != nil {
h.ResultErrorJSON(w, r, http.StatusBadRequest, h.ErrInvalidPayload.Error(), nil)
return
}
if err = hostTemplate.Save(); err != nil {
if err = nginxTemplate.Save(); err != nil {
h.ResultErrorJSON(w, r, http.StatusBadRequest, err.Error(), nil)
return
}
h.ResultResponseJSON(w, r, http.StatusOK, hostTemplate)
h.ResultResponseJSON(w, r, http.StatusOK, nginxTemplate)
}
}
}
// DeleteHostTemplate removes a host template
// Route: DELETE /host-templates/{templateID}
func DeleteHostTemplate() func(http.ResponseWriter, *http.Request) {
// DeleteNginxTemplate removes a nginx template
// Route: DELETE /nginx-templates/{templateID}
func DeleteNginxTemplate() func(http.ResponseWriter, *http.Request) {
return func(w http.ResponseWriter, r *http.Request) {
var err error
var templateID int
@ -122,11 +125,14 @@ func DeleteHostTemplate() func(http.ResponseWriter, *http.Request) {
return
}
hostTemplate, err := host.GetByID(templateID)
if err != nil {
item, err := nginxtemplate.GetByID(templateID)
switch err {
case sql.ErrNoRows:
h.ResultErrorJSON(w, r, http.StatusNotFound, "Not found", nil)
case nil:
h.ResultResponseJSON(w, r, http.StatusOK, item.Delete())
default:
h.ResultErrorJSON(w, r, http.StatusBadRequest, err.Error(), nil)
} else {
h.ResultResponseJSON(w, r, http.StatusOK, hostTemplate.Delete())
}
}
}

6
backend/internal/api/handler/schema.go
View File

@ -95,8 +95,8 @@ func replaceIncomingSchemas(swaggerSchema []byte) []byte {
str = strings.ReplaceAll(str, `"{{schema.CreateHost}}"`, schema.CreateHost())
str = strings.ReplaceAll(str, `"{{schema.UpdateHost}}"`, schema.UpdateHost())
str = strings.ReplaceAll(str, `"{{schema.CreateHostTemplate}}"`, schema.CreateHostTemplate())
str = strings.ReplaceAll(str, `"{{schema.UpdateHostTemplate}}"`, schema.UpdateHostTemplate())
str = strings.ReplaceAll(str, `"{{schema.CreateNginxTemplate}}"`, schema.CreateNginxTemplate())
str = strings.ReplaceAll(str, `"{{schema.UpdateNginxTemplate}}"`, schema.UpdateNginxTemplate())
str = strings.ReplaceAll(str, `"{{schema.CreateStream}}"`, schema.CreateStream())
str = strings.ReplaceAll(str, `"{{schema.UpdateStream}}"`, schema.UpdateStream())
@ -104,5 +104,7 @@ func replaceIncomingSchemas(swaggerSchema []byte) []byte {
str = strings.ReplaceAll(str, `"{{schema.CreateDNSProvider}}"`, schema.CreateDNSProvider())
str = strings.ReplaceAll(str, `"{{schema.UpdateDNSProvider}}"`, schema.UpdateDNSProvider())
str = strings.ReplaceAll(str, `"{{schema.CreateUpstream}}"`, schema.CreateUpstream())
return []byte(str)
}

129
backend/internal/api/handler/upstreams.go Normal file
View File

@ -0,0 +1,129 @@
package handler
import (
"database/sql"
"encoding/json"
"fmt"
"net/http"
c "npm/internal/api/context"
h "npm/internal/api/http"
"npm/internal/api/middleware"
"npm/internal/entity/upstream"
"npm/internal/jobqueue"
"npm/internal/logger"
"npm/internal/nginx"
"npm/internal/validator"
)
// GetUpstreams will return a list of Upstreams
// Route: GET /upstreams
func GetUpstreams() func(http.ResponseWriter, *http.Request) {
return func(w http.ResponseWriter, r *http.Request) {
pageInfo, err := getPageInfoFromRequest(r)
if err != nil {
h.ResultErrorJSON(w, r, http.StatusBadRequest, err.Error(), nil)
return
}
items, err := upstream.List(pageInfo, middleware.GetFiltersFromContext(r), getExpandFromContext(r))
if err != nil {
h.ResultErrorJSON(w, r, http.StatusBadRequest, err.Error(), nil)
} else {
h.ResultResponseJSON(w, r, http.StatusOK, items)
}
}
}
// GetUpstream will return a single Upstream
// Route: GET /upstreams/{upstreamID}
func GetUpstream() func(http.ResponseWriter, *http.Request) {
return func(w http.ResponseWriter, r *http.Request) {
var err error
var upstreamID int
if upstreamID, err = getURLParamInt(r, "upstreamID"); err != nil {
h.ResultErrorJSON(w, r, http.StatusBadRequest, err.Error(), nil)
return
}
item, err := upstream.GetByID(upstreamID)
switch err {
case sql.ErrNoRows:
h.ResultErrorJSON(w, r, http.StatusNotFound, "Not found", nil)
case nil:
// nolint: errcheck,gosec
item.Expand(getExpandFromContext(r))
h.ResultResponseJSON(w, r, http.StatusOK, item)
default:
h.ResultErrorJSON(w, r, http.StatusBadRequest, err.Error(), nil)
}
}
}
// CreateUpstream will create a Upstream
// Route: POST /upstreams
func CreateUpstream() func(http.ResponseWriter, *http.Request) {
return func(w http.ResponseWriter, r *http.Request) {
bodyBytes, _ := r.Context().Value(c.BodyCtxKey).([]byte)
var newUpstream upstream.Model
err := json.Unmarshal(bodyBytes, &newUpstream)
if err != nil {
h.ResultErrorJSON(w, r, http.StatusBadRequest, h.ErrInvalidPayload.Error(), nil)
return
}
// Get userID from token
userID, _ := r.Context().Value(c.UserIDCtxKey).(int)
newUpstream.UserID = userID
if err = validator.ValidateUpstream(newUpstream); err != nil {
h.ResultErrorJSON(w, r, http.StatusBadRequest, err.Error(), nil)
return
}
if err = newUpstream.Save(false); err != nil {
h.ResultErrorJSON(w, r, http.StatusBadRequest, fmt.Sprintf("Unable to save Upstream: %s", err.Error()), nil)
return
}
configureUpstream(newUpstream)
h.ResultResponseJSON(w, r, http.StatusOK, newUpstream)
}
}
// DeleteUpstream removes a upstream
// Route: DELETE /upstreams/{upstreamID}
func DeleteUpstream() func(http.ResponseWriter, *http.Request) {
return func(w http.ResponseWriter, r *http.Request) {
var err error
var upstreamID int
if upstreamID, err = getURLParamInt(r, "upstreamID"); err != nil {
h.ResultErrorJSON(w, r, http.StatusBadRequest, err.Error(), nil)
return
}
item, err := upstream.GetByID(upstreamID)
switch err {
case sql.ErrNoRows:
h.ResultErrorJSON(w, r, http.StatusNotFound, "Not found", nil)
case nil:
h.ResultResponseJSON(w, r, http.StatusOK, item.Delete())
default:
h.ResultErrorJSON(w, r, http.StatusBadRequest, err.Error(), nil)
}
}
}
func configureUpstream(u upstream.Model) {
err := jobqueue.AddJob(jobqueue.Job{
Name: "NginxConfigureUpstream",
Action: func() error {
return nginx.ConfigureUpstream(u)
},
})
if err != nil {
logger.Error("ConfigureUpstreamError", err)
}
}

33
backend/internal/api/router.go
View File

@ -12,9 +12,10 @@ import (
"npm/internal/entity/certificateauthority"
"npm/internal/entity/dnsprovider"
"npm/internal/entity/host"
"npm/internal/entity/hosttemplate"
"npm/internal/entity/nginxtemplate"
"npm/internal/entity/setting"
"npm/internal/entity/stream"
"npm/internal/entity/upstream"
"npm/internal/entity/user"
"npm/internal/logger"
@ -169,16 +170,16 @@ func applyRoutes(r chi.Router) chi.Router {
Put("/{hostID:[0-9]+}", handler.UpdateHost())
})
// Host Templates
r.With(middleware.EnforceSetup(true)).Route("/host-templates", func(r chi.Router) {
r.With(middleware.Enforce(user.CapabilityHostTemplatesView), middleware.Filters(hosttemplate.GetFilterSchema())).
Get("/", handler.GetHostTemplates())
r.With(middleware.Enforce(user.CapabilityHostTemplatesView)).Get("/{templateID:[0-9]+}", handler.GetHostTemplates())
r.With(middleware.Enforce(user.CapabilityHostTemplatesManage)).Delete("/{templateID:[0-9]+}", handler.DeleteHostTemplate())
r.With(middleware.Enforce(user.CapabilityHostTemplatesManage)).With(middleware.EnforceRequestSchema(schema.CreateHostTemplate())).
Post("/", handler.CreateHostTemplate())
r.With(middleware.Enforce(user.CapabilityHostTemplatesManage)).With(middleware.EnforceRequestSchema(schema.UpdateHostTemplate())).
Put("/{templateID:[0-9]+}", handler.UpdateHostTemplate())
// Nginx Templates
r.With(middleware.EnforceSetup(true)).Route("/nginx-templates", func(r chi.Router) {
r.With(middleware.Enforce(user.CapabilityNginxTemplatesView), middleware.Filters(nginxtemplate.GetFilterSchema())).
Get("/", handler.GetNginxTemplates())
r.With(middleware.Enforce(user.CapabilityNginxTemplatesView)).Get("/{templateID:[0-9]+}", handler.GetNginxTemplates())
r.With(middleware.Enforce(user.CapabilityNginxTemplatesManage)).Delete("/{templateID:[0-9]+}", handler.DeleteNginxTemplate())
r.With(middleware.Enforce(user.CapabilityNginxTemplatesManage)).With(middleware.EnforceRequestSchema(schema.CreateNginxTemplate())).
Post("/", handler.CreateNginxTemplate())
r.With(middleware.Enforce(user.CapabilityNginxTemplatesManage)).With(middleware.EnforceRequestSchema(schema.UpdateNginxTemplate())).
Put("/{templateID:[0-9]+}", handler.UpdateNginxTemplate())
})
// Streams
@ -192,6 +193,16 @@ func applyRoutes(r chi.Router) chi.Router {
r.With(middleware.Enforce(user.CapabilityStreamsManage)).With(middleware.EnforceRequestSchema(schema.UpdateStream())).
Put("/{hostID:[0-9]+}", handler.UpdateStream())
})
// Upstreams
r.With(middleware.EnforceSetup(true)).Route("/upstreams", func(r chi.Router) {
r.With(middleware.Enforce(user.CapabilityHostsView), middleware.Filters(upstream.GetFilterSchema())).
Get("/", handler.GetUpstreams())
r.With(middleware.Enforce(user.CapabilityHostsView)).Get("/{upstreamID:[0-9]+}", handler.GetUpstream())
r.With(middleware.Enforce(user.CapabilityHostsManage)).Delete("/{upstreamID:[0-9]+}", handler.DeleteUpstream())
r.With(middleware.Enforce(user.CapabilityHostsManage)).With(middleware.EnforceRequestSchema(schema.CreateUpstream())).
Post("/", handler.CreateUpstream())
})
})
return r

7
backend/internal/api/schema/create_host.go
View File

@ -17,14 +17,14 @@ func CreateHost() string {
"required": [
"type",
"domain_names",
"host_template_id"
"nginx_template_id"
],
"properties": {
"type": {
"type": "string",
"pattern": "^proxy$"
},
"host_template_id": {
"nginx_template_id": {
"type": "integer",
"minimum": 1
},
@ -63,9 +63,6 @@ func CreateHost() string {
"paths": {
"type": "string"
},
"upstream_options": {
"type": "string"
},
"advanced_config": {
"type": "string"
},

10
backend/internal/api/schema/create_host_template.go → backend/internal/api/schema/create_nginx_template.go
View File

@ -1,14 +1,14 @@
package schema
// CreateHostTemplate is the schema for incoming data validation
func CreateHostTemplate() string {
// CreateNginxTemplate is the schema for incoming data validation
func CreateNginxTemplate() string {
return `
{
"type": "object",
"additionalProperties": false,
"required": [
"name",
"host_type",
"type",
"template"
],
"properties": {
@ -16,9 +16,9 @@ func CreateHostTemplate() string {
"type": "string",
"minLength": 1
},
"host_type": {
"type": {
"type": "string",
"pattern": "^proxy|redirect|dead|stream$"
"pattern": "^proxy|redirect|dead|stream|upstream$"
},
"template": {
"type": "string",

73
backend/internal/api/schema/create_upstream.go Normal file
View File

@ -0,0 +1,73 @@
package schema
import "fmt"
// CreateUpstream is the schema for incoming data validation
func CreateUpstream() string {
return fmt.Sprintf(`
{
"type": "object",
"additionalProperties": false,
"required": [
"name",
"servers",
"nginx_template_id"
],
"properties": {
"name": %s,
"nginx_template_id": {
"type": "integer",
"minimum": 1
},
"advanced_config": %s,
"ip_hash": {
"type": "boolean"
},
"ntlm": {
"type": "boolean"
},
"keepalive": {
"type": "integer"
},
"keepalive_requests": {
"type": "integer"
},
"keepalive_time": {
"type": "string"
},
"keepalive_timeout": {
"type": "string"
},
"servers": {
"type": "array",
"minItems": 1,
"items": {
"type": "object",
"additionalProperties": false,
"required": [
"server"
],
"properties": {
"server": %s,
"weight": {
"type": "integer"
},
"max_conns": {
"type": "integer"
},
"max_fails": {
"type": "integer"
},
"fail_timeout": {
"type": "integer"
},
"backup": {
"type": "boolean"
}
}
}
}
}
}
`, stringMinMax(1, 100), stringMinMax(0, 1024), stringMinMax(2, 255))
}

2
backend/internal/api/schema/update_host.go
View File

@ -10,7 +10,7 @@ func UpdateHost() string {
"additionalProperties": false,
"minProperties": 1,
"properties": {
"host_template_id": {
"nginx_template_id": {
"type": "integer",
"minimum": 1
},

2
backend/internal/api/schema/update_host_template.go → backend/internal/api/schema/update_nginx_template.go
View File

@ -1,7 +1,7 @@
package schema
// UpdateHostTemplate is the schema for incoming data validation
func UpdateHostTemplate() string {
func UpdateNginxTemplate() string {
return `
{
"type": "object",

1
backend/internal/config/folders.go
View File

@ -19,6 +19,7 @@ func createDataFolders() {
"nginx/hosts",
"nginx/streams",
"nginx/temp",
"nginx/upstreams",
}
for _, folder := range folders {

2
backend/internal/entity/certificate/methods.go
View File

@ -127,7 +127,7 @@ func List(pageInfo model.PageInfo, filters []model.Filter) (ListResponse, error)
}
// Get rows
var items []Model
items := make([]Model, 0)
query, params = entity.ListQueryBuilder(exampleModel, tableName, &pageInfo, defaultSort, filters, getFilterMapFunctions(), false)
err := db.Select(&items, query, params...)
if err != nil {

9
backend/internal/entity/certificate/model.go
View File

@ -267,9 +267,14 @@ func (m *Model) Request() error {
// GetTemplate will convert the Model to a Template
func (m *Model) GetTemplate() Template {
if m.ID == 0 {
// No or empty certificate object, happens when the host has no cert
return Template{}
}
domainNames, _ := m.DomainNames.AsStringArray()
t := Template{
return Template{
ID: m.ID,
CreatedOn: m.CreatedOn.Time.String(),
ModifiedOn: m.ModifiedOn.Time.String(),
@ -288,8 +293,6 @@ func (m *Model) GetTemplate() Template {
IsProvided: m.ID > 0 && m.Status == StatusProvided,
Folder: m.GetFolder(),
}
return t
}
// GetFolder returns the folder where these certs should exist

2
backend/internal/entity/certificateauthority/methods.go
View File

@ -112,7 +112,7 @@ func List(pageInfo model.PageInfo, filters []model.Filter) (ListResponse, error)
}
// Get rows
var items []Model
items := make([]Model, 0)
query, params = entity.ListQueryBuilder(exampleModel, tableName, &pageInfo, defaultSort, filters, getFilterMapFunctions(), false)
err := db.Select(&items, query, params...)
if err != nil {

2
backend/internal/entity/dnsprovider/methods.go
View File

@ -112,7 +112,7 @@ func List(pageInfo model.PageInfo, filters []model.Filter) (ListResponse, error)
}
// Get rows
var items []Model
items := make([]Model, 0)
query, params = entity.ListQueryBuilder(exampleModel, tableName, &pageInfo, defaultSort, filters, getFilterMapFunctions(), false)
err := db.Select(&items, query, params...)
if err != nil {

11
backend/internal/entity/host/methods.go
View File

@ -34,7 +34,7 @@ func create(host *Model) (int, error) {
modified_on,
user_id,
type,
host_template_id,
nginx_template_id,
listen_interface,
domain_names,
upstream_id,
@ -48,7 +48,6 @@ func create(host *Model) (int, error) {
hsts_enabled,
hsts_subdomains,
paths,
upstream_options,
advanced_config,
status,
error_message,
@ -59,7 +58,7 @@ func create(host *Model) (int, error) {
:modified_on,
:user_id,
:type,
:host_template_id,
:nginx_template_id,
:listen_interface,
:domain_names,
:upstream_id,
@ -73,7 +72,6 @@ func create(host *Model) (int, error) {
:hsts_enabled,
:hsts_subdomains,
:paths,
:upstream_options,
:advanced_config,
:status,
:error_message,
@ -110,7 +108,7 @@ func update(host *Model) error {
modified_on = :modified_on,
user_id = :user_id,
type = :type,
host_template_id = :host_template_id,
nginx_template_id = :nginx_template_id,
listen_interface = :listen_interface,
domain_names = :domain_names,
upstream_id = :upstream_id,
@ -124,7 +122,6 @@ func update(host *Model) error {
hsts_enabled = :hsts_enabled,
hsts_subdomains = :hsts_subdomains,
paths = :paths,
upstream_options = :upstream_options,
advanced_config = :advanced_config,
status = :status,
error_message = :error_message,
@ -163,7 +160,7 @@ func List(pageInfo model.PageInfo, filters []model.Filter, expand []string) (Lis
}
// Get rows
var items []Model
items := make([]Model, 0)
query, params = entity.ListQueryBuilder(exampleModel, tableName, &pageInfo, defaultSort, filters, getFilterMapFunctions(), false)
err := db.Select(&items, query, params...)
if err != nil {

40
backend/internal/entity/host/model.go
View File

@ -6,8 +6,10 @@ import (
"npm/internal/database"
"npm/internal/entity/certificate"
"npm/internal/entity/hosttemplate"
"npm/internal/entity/nginxtemplate"
"npm/internal/entity/upstream"
"npm/internal/entity/user"
"npm/internal/status"
"npm/internal/types"
"npm/internal/util"
)
@ -21,12 +23,6 @@ const (
RedirectionHostType = "redirection"
// DeadHostType is self explanatory
DeadHostType = "dead"
// StatusReady means a host is ready to configure
StatusReady = "ready"
// StatusOK means a host is configured within Nginx
StatusOK = "ok"
// StatusError is self explanatory
StatusError = "error"
)
// Model is the user model
@ -36,7 +32,7 @@ type Model struct {
ModifiedOn types.DBDate `json:"modified_on" db:"modified_on" filter:"modified_on,integer"`
UserID int `json:"user_id" db:"user_id" filter:"user_id,integer"`
Type string `json:"type" db:"type" filter:"type,string"`
HostTemplateID int `json:"host_template_id" db:"host_template_id" filter:"host_template_id,integer"`
NginxTemplateID int `json:"nginx_template_id" db:"nginx_template_id" filter:"nginx_template_id,integer"`
ListenInterface string `json:"listen_interface" db:"listen_interface" filter:"listen_interface,string"`
DomainNames types.JSONB `json:"domain_names" db:"domain_names" filter:"domain_names,string"`
UpstreamID int `json:"upstream_id" db:"upstream_id" filter:"upstream_id,integer"`
@ -50,16 +46,16 @@ type Model struct {
HSTSEnabled bool `json:"hsts_enabled" db:"hsts_enabled" filter:"hsts_enabled,boolean"`
HSTSSubdomains bool `json:"hsts_subdomains" db:"hsts_subdomains" filter:"hsts_subdomains,boolean"`
Paths string `json:"paths" db:"paths" filter:"paths,string"`
UpstreamOptions string `json:"upstream_options" db:"upstream_options" filter:"upstream_options,string"`
AdvancedConfig string `json:"advanced_config" db:"advanced_config" filter:"advanced_config,string"`
Status string `json:"status" db:"status" filter:"status,string"`
ErrorMessage string `json:"error_message" db:"error_message" filter:"error_message,string"`
IsDisabled bool `json:"is_disabled" db:"is_disabled" filter:"is_disabled,boolean"`
IsDeleted bool `json:"is_deleted,omitempty" db:"is_deleted"`
// Expansions
Certificate *certificate.Model `json:"certificate,omitempty"`
HostTemplate *hosttemplate.Model `json:"host_template,omitempty"`
User *user.Model `json:"user,omitempty"`
Certificate *certificate.Model `json:"certificate,omitempty"`
NginxTemplate *nginxtemplate.Model `json:"nginx_template,omitempty"`
User *user.Model `json:"user,omitempty"`
Upstream *upstream.Model `json:"upstream,omitempty"`
}
func (m *Model) getByQuery(query string, params []interface{}) error {
@ -93,7 +89,7 @@ func (m *Model) Save(skipConfiguration bool) error {
if !skipConfiguration {
// Set this host as requiring reconfiguration
m.Status = StatusReady
m.Status = status.StatusReady
}
if m.ID == 0 {
@ -119,6 +115,13 @@ func (m *Model) Delete() bool {
func (m *Model) Expand(items []string) error {
var err error
// Always expand the upstream
if m.UpstreamID > 0 {
var u upstream.Model
u, err = upstream.GetByID(m.UpstreamID)
m.Upstream = &u
}
if util.SliceContainsItem(items, "user") && m.ID > 0 {
var usr user.Model
usr, err = user.GetByID(m.UserID)
@ -131,10 +134,10 @@ func (m *Model) Expand(items []string) error {
m.Certificate = &cert
}
if util.SliceContainsItem(items, "hosttemplate") && m.HostTemplateID > 0 {
var templ hosttemplate.Model
templ, err = hosttemplate.GetByID(m.HostTemplateID)
m.HostTemplate = &templ
if util.SliceContainsItem(items, "nginxtemplate") && m.NginxTemplateID > 0 {
var templ nginxtemplate.Model
templ, err = nginxtemplate.GetByID(m.NginxTemplateID)
m.NginxTemplate = &templ
}
return err
@ -150,7 +153,7 @@ func (m *Model) GetTemplate() Template {
ModifiedOn: m.ModifiedOn.Time.String(),
UserID: m.UserID,
Type: m.Type,
HostTemplateID: m.HostTemplateID,
NginxTemplateID: m.NginxTemplateID,
ListenInterface: m.ListenInterface,
DomainNames: domainNames,
UpstreamID: m.UpstreamID,
@ -164,7 +167,6 @@ func (m *Model) GetTemplate() Template {
HSTSEnabled: m.HSTSEnabled,
HSTSSubdomains: m.HSTSSubdomains,
Paths: m.Paths,
UpstreamOptions: m.UpstreamOptions,
AdvancedConfig: m.AdvancedConfig,
Status: m.Status,
ErrorMessage: m.ErrorMessage,

13
backend/internal/entity/host/template.go
View File

@ -1,5 +1,14 @@
package host
type TemplateUpstream struct {
Hostname string
Port int
BalanceMethod string
MaxFails int
FailTimeout int
AdvancedConfig string
}
// Template is the model given to the template parser, converted from the Model
type Template struct {
ID int
@ -7,7 +16,7 @@ type Template struct {
ModifiedOn string
UserID int
Type string
HostTemplateID int
NginxTemplateID int
ListenInterface string
DomainNames []string
UpstreamID int
@ -22,8 +31,8 @@ type Template struct {
HSTSSubdomains bool
IsDisabled bool
Paths string
UpstreamOptions string
AdvancedConfig string
Status string
ErrorMessage string
Upstreams []TemplateUpstream
}

25
backend/internal/entity/nginxtemplate/filters.go Normal file
View File

@ -0,0 +1,25 @@
package nginxtemplate
import (
"npm/internal/entity"
)
var filterMapFunctions = make(map[string]entity.FilterMapFunction)
// getFilterMapFunctions is a map of functions that should be executed
// during the filtering process, if a field is defined here then the value in
// the filter will be given to the defined function and it will return a new
// value for use in the sql query.
func getFilterMapFunctions() map[string]entity.FilterMapFunction {
// if len(filterMapFunctions) == 0 {
// TODO: See internal/model/file_item.go:620 for an example
// }
return filterMapFunctions
}
// GetFilterSchema returns filter schema
func GetFilterSchema() string {
var m Model
return entity.GetFilterSchema(m)
}

4
backend/internal/entity/hosttemplate/methods.go → backend/internal/entity/nginxtemplate/methods.go
View File

@ -1,4 +1,4 @@
package hosttemplate
package nginxtemplate
import (
"database/sql"
@ -108,7 +108,7 @@ func List(pageInfo model.PageInfo, filters []model.Filter) (ListResponse, error)
}
// Get rows
var items []Model
items := make([]Model, 0)
query, params = entity.ListQueryBuilder(exampleModel, tableName, &pageInfo, defaultSort, filters, getFilterMapFunctions(), false)
err := db.Select(&items, query, params...)
if err != nil {

8
backend/internal/entity/hosttemplate/model.go → backend/internal/entity/nginxtemplate/model.go
View File

@ -1,4 +1,4 @@
package hosttemplate
package nginxtemplate
import (
"fmt"
@ -9,7 +9,7 @@ import (
)
const (
tableName = "host_template"
tableName = "nginx_template"
)
// Model is the user model
@ -19,7 +19,7 @@ type Model struct {
ModifiedOn types.DBDate `json:"modified_on" db:"modified_on" filter:"modified_on,integer"`
UserID int `json:"user_id" db:"user_id" filter:"user_id,integer"`
Name string `json:"name" db:"name" filter:"name,string"`
Type string `json:"host_type" db:"host_type" filter:"host_type,string"`
Type string `json:"type" db:"type" filter:"type,string"`
Template string `json:"template" db:"template" filter:"template,string"`
IsDeleted bool `json:"is_deleted,omitempty" db:"is_deleted"`
}
@ -62,7 +62,7 @@ func (m *Model) Save() error {
return err
}
// Delete will mark a host as deleted
// Delete will mark a template as deleted
func (m *Model) Delete() bool {
m.Touch(false)
m.IsDeleted = true

15
backend/internal/entity/nginxtemplate/structs.go Normal file
View File

@ -0,0 +1,15 @@
package nginxtemplate
import (
"npm/internal/model"
)
// ListResponse is the JSON response for this list
type ListResponse struct {
Total int `json:"total"`
Offset int `json:"offset"`
Limit int `json:"limit"`
Sort []model.Sort `json:"sort"`
Filter []model.Filter `json:"filter,omitempty"`
Items []Model `json:"items,omitempty"`
}

2
backend/internal/entity/setting/methods.go
View File

@ -106,7 +106,7 @@ func List(pageInfo model.PageInfo, filters []model.Filter) (ListResponse, error)
}
// Get rows
var items []Model
items := make([]Model, 0)
query, params = entity.ListQueryBuilder(exampleModel, tableName, &pageInfo, defaultSort, filters, getFilterMapFunctions(), false)
err := db.Select(&items, query, params...)
if err != nil {

2
backend/internal/entity/stream/methods.go
View File

@ -114,7 +114,7 @@ func List(pageInfo model.PageInfo, filters []model.Filter) (ListResponse, error)
}
// Get rows
var items []Model
items := make([]Model, 0)
query, params = entity.ListQueryBuilder(exampleModel, tableName, &pageInfo, defaultSort, filters, getFilterMapFunctions(), false)
err := db.Select(&items, query, params...)
if err != nil {

2
backend/internal/entity/hosttemplate/filters.go → backend/internal/entity/upstream/filters.go
View File

@ -1,4 +1,4 @@
package hosttemplate
package upstream
import (
"npm/internal/entity"

162
backend/internal/entity/upstream/methods.go Normal file
View File

@ -0,0 +1,162 @@
package upstream
import (
"database/sql"
goerrors "errors"
"fmt"
"npm/internal/database"
"npm/internal/entity"
"npm/internal/errors"
"npm/internal/logger"
"npm/internal/model"
)
// GetByID finds a Upstream by ID
func GetByID(id int) (Model, error) {
var m Model
err := m.LoadByID(id)
return m, err
}
// create will create a Upstream from this model
func create(u *Model) (int, error) {
if u.ID != 0 {
return 0, goerrors.New("Cannot create upstream when model already has an ID")
}
u.Touch(true)
db := database.GetInstance()
// nolint: gosec
result, err := db.NamedExec(`INSERT INTO `+fmt.Sprintf("`%s`", tableName)+` (
created_on,
modified_on,
user_id,
name,
nginx_template_id,
ip_hash,
ntlm,
keepalive,
keepalive_requests,
keepalive_time,
keepalive_timeout,
advanced_config,
status,
error_message,
is_deleted
) VALUES (
:created_on,
:modified_on,
:user_id,
:name,
:nginx_template_id,
:ip_hash,
:ntlm,
:keepalive,
:keepalive_requests,
:keepalive_time,
:keepalive_timeout,
:advanced_config,
:status,
:error_message,
:is_deleted
)`, u)
if err != nil {
return 0, err
}
last, lastErr := result.LastInsertId()
if lastErr != nil {
return 0, lastErr
}
logger.Debug("Created Upstream: %+v", u)
return int(last), nil
}
// update will Update a Upstream from this model
func update(u *Model) error {
if u.ID == 0 {
return goerrors.New("Cannot update upstream when model doesn't have an ID")
}
u.Touch(false)
db := database.GetInstance()
// nolint: gosec
_, err := db.NamedExec(`UPDATE `+fmt.Sprintf("`%s`", tableName)+` SET
created_on = :created_on,
modified_on = :modified_on,
user_id = :user_id,
name = :name,
nginx_template_id = :nginx_template_id,
ip_hash = :ip_hash,
ntlm = :ntlm,
keepalive = :keepalive,
keepalive_requests = :keepalive_requests,
keepalive_time = :keepalive_time,
advanced_config = :advanced_config,
status = :status,
error_message = :error_message,
is_deleted = :is_deleted
WHERE id = :id`, u)
logger.Debug("Updated Upstream: %+v", u)
return err
}
// List will return a list of Upstreams
func List(pageInfo model.PageInfo, filters []model.Filter, expand []string) (ListResponse, error) {
var result ListResponse
var exampleModel Model
defaultSort := model.Sort{
Field: "name",
Direction: "ASC",
}
db := database.GetInstance()
if db == nil {
return result, errors.ErrDatabaseUnavailable
}
// Get count of items in this search
query, params := entity.ListQueryBuilder(exampleModel, tableName, &pageInfo, defaultSort, filters, getFilterMapFunctions(), true)
countRow := db.QueryRowx(query, params...)
var totalRows int
queryErr := countRow.Scan(&totalRows)
if queryErr != nil && queryErr != sql.ErrNoRows {
logger.Debug("%s -- %+v", query, params)
return result, queryErr
}
// Get rows
items := make([]Model, 0)
query, params = entity.ListQueryBuilder(exampleModel, tableName, &pageInfo, defaultSort, filters, getFilterMapFunctions(), false)
err := db.Select(&items, query, params...)
if err != nil {
logger.Debug("%s -- %+v", query, params)
return result, err
}
// Expand to get servers, at a minimum
for idx := range items {
// nolint: errcheck, gosec
items[idx].Expand(expand)
}
result = ListResponse{
Items: items,
Total: totalRows,
Limit: pageInfo.Limit,
Offset: pageInfo.Offset,
Sort: pageInfo.Sort,
Filter: filters,
}
return result, nil
}

127
backend/internal/entity/upstream/model.go Normal file
View File

@ -0,0 +1,127 @@
package upstream
import (
"fmt"
"time"
"npm/internal/database"
"npm/internal/entity/nginxtemplate"
"npm/internal/entity/upstreamserver"
"npm/internal/status"
"npm/internal/types"
"npm/internal/util"
)
const (
tableName = "upstream"
)
// Model is the Upstream model
// See: http://nginx.org/en/docs/http/ngx_http_upstream_module.html#upstream
type Model struct {
ID int `json:"id" db:"id" filter:"id,integer"`
CreatedOn types.DBDate `json:"created_on" db:"created_on" filter:"created_on,integer"`
ModifiedOn types.DBDate `json:"modified_on" db:"modified_on" filter:"modified_on,integer"`
UserID int `json:"user_id" db:"user_id" filter:"user_id,integer"`
Name string `json:"name" db:"name" filter:"name,string"`
NginxTemplateID int `json:"nginx_template_id" db:"nginx_template_id" filter:"nginx_template_id,integer"`
IPHash bool `json:"ip_hash" db:"ip_hash" filter:"ip_hash,boolean"`
NTLM bool `json:"ntlm" db:"ntlm" filter:"ntlm,boolean"`
Keepalive int `json:"keepalive" db:"keepalive" filter:"keepalive,integer"`
KeepaliveRequests int `json:"keepalive_requests" db:"keepalive_requests" filter:"keepalive_requests,integer"`
KeepaliveTime string `json:"keepalive_time" db:"keepalive_time" filter:"keepalive_time,string"`
KeepaliveTimeout string `json:"keepalive_timeout" db:"keepalive_timeout" filter:"keepalive_timeout,string"`
AdvancedConfig string `json:"advanced_config" db:"advanced_config" filter:"advanced_config,string"`
Status string `json:"status" db:"status" filter:"status,string"`
ErrorMessage string `json:"error_message" db:"error_message" filter:"error_message,string"`
IsDeleted bool `json:"is_deleted,omitempty" db:"is_deleted"`
// Expansions
Servers []upstreamserver.Model `json:"servers"`
NginxTemplate *nginxtemplate.Model `json:"nginx_template,omitempty"`
}
func (m *Model) getByQuery(query string, params []interface{}) error {
return database.GetByQuery(m, query, params)
}
// LoadByID will load from an ID
func (m *Model) LoadByID(id int) error {
query := fmt.Sprintf("SELECT * FROM `%s` WHERE id = ? AND is_deleted = ? LIMIT 1", tableName)
params := []interface{}{id, 0}
err := m.getByQuery(query, params)
if err == nil {
err = m.Expand(nil)
}
return err
}
// Touch will update model's timestamp(s)
func (m *Model) Touch(created bool) {
var d types.DBDate
d.Time = time.Now()
if created {
m.CreatedOn = d
}
m.ModifiedOn = d
}
// Save will save this model to the DB
func (m *Model) Save(skipConfiguration bool) error {
var err error
if m.UserID == 0 {
return fmt.Errorf("User ID must be specified")
}
if !skipConfiguration {
// Set this upstream as requiring reconfiguration
m.Status = status.StatusReady
}
if m.ID == 0 {
m.ID, err = create(m)
} else {
err = update(m)
}
// Save Servers
if err == nil {
for idx := range m.Servers {
// Continue if previous iteration didn't cause an error
if err == nil {
m.Servers[idx].UpstreamID = m.ID
err = m.Servers[idx].Save()
}
}
}
return err
}
// Delete will mark a upstream as deleted
func (m *Model) Delete() bool {
m.Touch(false)
m.IsDeleted = true
if err := m.Save(false); err != nil {
return false
}
return true
}
// Expand will fill in more properties
func (m *Model) Expand(items []string) error {
var err error
// Always expand servers, if not done already
if len(m.Servers) == 0 {
m.Servers, err = upstreamserver.GetByUpstreamID(m.ID)
}
if util.SliceContainsItem(items, "nginxtemplate") && m.NginxTemplateID > 0 {
var templ nginxtemplate.Model
templ, err = nginxtemplate.GetByID(m.NginxTemplateID)
m.NginxTemplate = &templ
}
return err
}

2
backend/internal/entity/hosttemplate/structs.go → backend/internal/entity/upstream/structs.go
View File

@ -1,4 +1,4 @@
package hosttemplate
package upstream
import (
"npm/internal/model"

25
backend/internal/entity/upstreamserver/filters.go Normal file
View File

@ -0,0 +1,25 @@
package upstreamserver
import (
"npm/internal/entity"
)
var filterMapFunctions = make(map[string]entity.FilterMapFunction)
// getFilterMapFunctions is a map of functions that should be executed
// during the filtering process, if a field is defined here then the value in
// the filter will be given to the defined function and it will return a new
// value for use in the sql query.
func getFilterMapFunctions() map[string]entity.FilterMapFunction {
// if len(filterMapFunctions) == 0 {
// TODO: See internal/model/file_item.go:620 for an example
// }
return filterMapFunctions
}
// GetFilterSchema returns filter schema
func GetFilterSchema() string {
var m Model
return entity.GetFilterSchema(m)
}

154
backend/internal/entity/upstreamserver/methods.go Normal file
View File

@ -0,0 +1,154 @@
package upstreamserver
import (
"database/sql"
goerrors "errors"
"fmt"
"npm/internal/database"
"npm/internal/entity"
"npm/internal/errors"
"npm/internal/logger"
"npm/internal/model"
)
// GetByID finds a Upstream Server by ID
func GetByID(id int) (Model, error) {
var m Model
err := m.LoadByID(id)
return m, err
}
// GetByUpstreamID finds all servers in the upstream
func GetByUpstreamID(upstreamID int) ([]Model, error) {
items := make([]Model, 0)
query := `SELECT * FROM ` + fmt.Sprintf("`%s`", tableName) + ` WHERE upstream_id = ? ORDER BY server`
db := database.GetInstance()
err := db.Select(&items, query, upstreamID)
if err != nil {
logger.Debug("%s -- %d", query, upstreamID)
}
return items, err
}
// create will create a Upstream Server from this model
func create(u *Model) (int, error) {
if u.ID != 0 {
return 0, goerrors.New("Cannot create upstream server when model already has an ID")
}
u.Touch(true)
db := database.GetInstance()
// nolint: gosec
result, err := db.NamedExec(`INSERT INTO `+fmt.Sprintf("`%s`", tableName)+` (
created_on,
modified_on,
upstream_id,
server,
weight,
max_conns,
max_fails,
fail_timeout,
backup,
is_deleted
) VALUES (
:created_on,
:modified_on,
:upstream_id,
:server,
:weight,
:max_conns,
:max_fails,
:fail_timeout,
:backup,
:is_deleted
)`, u)
if err != nil {
return 0, err
}
last, lastErr := result.LastInsertId()
if lastErr != nil {
return 0, lastErr
}
logger.Debug("Created Upstream Server: %+v", u)
return int(last), nil
}
// update will Update a Upstream from this model
func update(u *Model) error {
if u.ID == 0 {
return goerrors.New("Cannot update upstream server when model doesn't have an ID")
}
u.Touch(false)
db := database.GetInstance()
// nolint: gosec
_, err := db.NamedExec(`UPDATE `+fmt.Sprintf("`%s`", tableName)+` SET
created_on = :created_on,
modified_on = :modified_on,
upstream_id = :upstream_id,
server = :server,
weight = :weight,
max_conns = :max_conns,
max_fails = :max_fails,
fail_timeout = :fail_timeout,
backup = :backup,
is_deleted = :is_deleted
WHERE id = :id`, u)
logger.Debug("Updated Upstream Server: %+v", u)
return err
}
// List will return a list of Upstreams
func List(pageInfo model.PageInfo, filters []model.Filter) (ListResponse, error) {
var result ListResponse
var exampleModel Model
defaultSort := model.Sort{
Field: "server",
Direction: "ASC",
}
db := database.GetInstance()
if db == nil {
return result, errors.ErrDatabaseUnavailable
}
// Get count of items in this search
query, params := entity.ListQueryBuilder(exampleModel, tableName, &pageInfo, defaultSort, filters, getFilterMapFunctions(), true)
countRow := db.QueryRowx(query, params...)
var totalRows int
queryErr := countRow.Scan(&totalRows)
if queryErr != nil && queryErr != sql.ErrNoRows {
logger.Debug("%s -- %+v", query, params)
return result, queryErr
}
// Get rows
items := make([]Model, 0)
query, params = entity.ListQueryBuilder(exampleModel, tableName, &pageInfo, defaultSort, filters, getFilterMapFunctions(), false)
err := db.Select(&items, query, params...)
if err != nil {
logger.Debug("%s -- %+v", query, params)
return result, err
}
result = ListResponse{
Items: items,
Total: totalRows,
Limit: pageInfo.Limit,
Offset: pageInfo.Offset,
Sort: pageInfo.Sort,
Filter: filters,
}
return result, nil
}

76
backend/internal/entity/upstreamserver/model.go Normal file
View File

@ -0,0 +1,76 @@
package upstreamserver
import (
"fmt"
"time"
"npm/internal/database"
"npm/internal/types"
)
const (
tableName = "upstream_server"
)
// Model is the upstream model
type Model struct {
ID int `json:"id" db:"id" filter:"id,integer"`
CreatedOn types.DBDate `json:"created_on" db:"created_on" filter:"created_on,integer"`
ModifiedOn types.DBDate `json:"modified_on" db:"modified_on" filter:"modified_on,integer"`
UpstreamID int `json:"upstream_id" db:"upstream_id" filter:"upstream_id,integer"`
Server string `json:"server" db:"server" filter:"server,string"`
Weight int `json:"weight" db:"weight" filter:"weight,integer"`
MaxConns int `json:"max_conns" db:"max_conns" filter:"max_conns,integer"`
MaxFails int `json:"max_fails" db:"max_fails" filter:"max_fails,integer"`
FailTimeout int `json:"fail_timeout" db:"fail_timeout" filter:"fail_timeout,integer"`
Backup bool `json:"backup" db:"backup" filter:"backup,boolean"`
IsDeleted bool `json:"is_deleted,omitempty" db:"is_deleted"`
}
func (m *Model) getByQuery(query string, params []interface{}) error {
return database.GetByQuery(m, query, params)
}
// LoadByID will load from an ID
func (m *Model) LoadByID(id int) error {
query := fmt.Sprintf("SELECT * FROM `%s` WHERE id = ? AND is_deleted = ? LIMIT 1", tableName)
params := []interface{}{id, 0}
return m.getByQuery(query, params)
}
// Touch will update model's timestamp(s)
func (m *Model) Touch(created bool) {
var d types.DBDate
d.Time = time.Now()
if created {
m.CreatedOn = d
}
m.ModifiedOn = d
}
// Save will save this model to the DB
func (m *Model) Save() error {
var err error
if m.UpstreamID == 0 {
return fmt.Errorf("Upstream ID must be specified")
}
if m.ID == 0 {
m.ID, err = create(m)
} else {
err = update(m)
}
return err
}
// Delete will mark a upstream as deleted
func (m *Model) Delete() bool {
m.Touch(false)
m.IsDeleted = true
if err := m.Save(); err != nil {
return false
}
return true
}

15
backend/internal/entity/upstreamserver/structs.go Normal file
View File

@ -0,0 +1,15 @@
package upstreamserver
import (
"npm/internal/model"
)
// ListResponse is the JSON response for this list
type ListResponse struct {
Total int `json:"total"`
Offset int `json:"offset"`
Limit int `json:"limit"`
Sort []model.Sort `json:"sort"`
Filter []model.Filter `json:"filter,omitempty"`
Items []Model `json:"items,omitempty"`
}

8
backend/internal/entity/user/capabilities.go
View File

@ -25,10 +25,10 @@ const (
CapabilityHostsView = "hosts.view"
// CapabilityHostsManage hosts manage
CapabilityHostsManage = "hosts.manage"
// CapabilityHostTemplatesView host-templates view
CapabilityHostTemplatesView = "host-templates.view"
// CapabilityHostTemplatesManage host-templates manage
CapabilityHostTemplatesManage = "host-templates.manage"
// CapabilityNginxTemplatesView nginx-templates view
CapabilityNginxTemplatesView = "nginx-templates.view"
// CapabilityNginxTemplatesManage nginx-templates manage
CapabilityNginxTemplatesManage = "nginx-templates.manage"
// CapabilitySettingsManage settings manage
CapabilitySettingsManage = "settings.manage"
// CapabilityStreamsView streams view

2
backend/internal/entity/user/methods.go
View File

@ -154,7 +154,7 @@ func List(pageInfo model.PageInfo, filters []model.Filter, expand []string) (Lis
}
// Get rows
var items []Model
items := make([]Model, 0)
query, params = entity.ListQueryBuilder(exampleModel, tableName, &pageInfo, defaultSort, filters, getFilterMapFunctions(), false)
err := db.Select(&items, query, params...)
if err != nil {

66
backend/internal/nginx/control.go
View File

@ -4,47 +4,97 @@ import (
"fmt"
"npm/internal/config"
"npm/internal/entity/certificate"
"npm/internal/entity/host"
"npm/internal/entity/upstream"
"npm/internal/logger"
"npm/internal/status"
)
// ConfigureHost will attempt to write nginx conf and reload nginx
func ConfigureHost(h host.Model) error {
// nolint: errcheck, gosec
h.Expand([]string{"certificate", "hosttemplate"})
h.Expand([]string{"certificate", "nginxtemplate"})
var certificateTemplate certificate.Template
if h.Certificate != nil {
certificateTemplate = h.Certificate.GetTemplate()
}
data := TemplateData{
ConfDir: fmt.Sprintf("%s/nginx/hosts", config.Configuration.DataFolder),
DataDir: config.Configuration.DataFolder,
Host: h.GetTemplate(),
Certificate: h.Certificate.GetTemplate(),
Certificate: certificateTemplate,
}
filename := fmt.Sprintf("%s/host_%d.conf", data.ConfDir, h.ID)
// Write the config to disk
err := writeTemplate(filename, h.HostTemplate.Template, data)
err := writeTemplate(filename, h.NginxTemplate.Template, data)
if err != nil {
// this configuration failed somehow
h.Status = host.StatusError
h.Status = status.StatusError
h.ErrorMessage = fmt.Sprintf("Template generation failed: %s", err.Error())
logger.Debug(h.ErrorMessage)
return h.Save(true)
}
// nolint: errcheck, gosec
if err := reloadNginx(); err != nil {
if output, err := reloadNginx(); err != nil {
// reloading nginx failed, likely due to this host having a problem
h.Status = host.StatusError
h.ErrorMessage = fmt.Sprintf("Nginx configuation error: %s", err.Error())
h.Status = status.StatusError
h.ErrorMessage = fmt.Sprintf("Nginx configuation error: %s - %s", err.Error(), output)
writeConfigFile(filename, fmt.Sprintf("# %s", h.ErrorMessage))
logger.Debug(h.ErrorMessage)
} else {
// All good
h.Status = host.StatusOK
h.Status = status.StatusOK
h.ErrorMessage = ""
logger.Debug("ConfigureHost OK: %+v", h)
}
return h.Save(true)
}
// ConfigureUpstream will attempt to write nginx conf and reload nginx
func ConfigureUpstream(u upstream.Model) error {
logger.Debug("ConfigureUpstream: %+v)", u)
// nolint: errcheck, gosec
u.Expand([]string{"nginxtemplate"})
data := TemplateData{
ConfDir: fmt.Sprintf("%s/nginx/upstreams", config.Configuration.DataFolder),
DataDir: config.Configuration.DataFolder,
Upstream: u,
}
filename := fmt.Sprintf("%s/upstream_%d.conf", data.ConfDir, u.ID)
// Write the config to disk
err := writeTemplate(filename, u.NginxTemplate.Template, data)
if err != nil {
// this configuration failed somehow
u.Status = status.StatusError
u.ErrorMessage = fmt.Sprintf("Template generation failed: %s", err.Error())
logger.Debug(u.ErrorMessage)
return u.Save(true)
}
// nolint: errcheck, gosec
if output, err := reloadNginx(); err != nil {
// reloading nginx failed, likely due to this host having a problem
u.Status = status.StatusError
u.ErrorMessage = fmt.Sprintf("Nginx configuation error: %s - %s", err.Error(), output)
writeConfigFile(filename, fmt.Sprintf("# %s", u.ErrorMessage))
logger.Debug(u.ErrorMessage)
} else {
// All good
u.Status = status.StatusOK
u.ErrorMessage = ""
logger.Debug("ConfigureUpstream OK: %+v", u)
}
return u.Save(true)
}

7
backend/internal/nginx/exec.go
View File

@ -7,9 +7,8 @@ import (
"npm/internal/logger"
)
func reloadNginx() error {
_, err := shExec([]string{"-s", "reload"})
return err
func reloadNginx() (string, error) {
return shExec([]string{"-s", "reload"})
}
func getNginxFilePath() (string, error) {
@ -32,7 +31,7 @@ func shExec(args []string) (string, error) {
// nolint: gosec
c := exec.Command(ng, args...)
b, e := c.Output()
b, e := c.CombinedOutput()
if e != nil {
logger.Error("NginxError", fmt.Errorf("Command error: %s -- %v\n%+v", ng, args, e))

9
backend/internal/nginx/templates.go
View File

@ -6,7 +6,9 @@ import (
"npm/internal/entity/certificate"
"npm/internal/entity/host"
"npm/internal/entity/upstream"
"npm/internal/logger"
"npm/internal/util"
"github.com/aymerick/raymond"
)
@ -17,10 +19,15 @@ type TemplateData struct {
DataDir string
Host host.Template
Certificate certificate.Template
Upstream upstream.Model
}
func generateHostConfig(template string, data TemplateData) (string, error) {
logger.Debug("Rendering Template - Template: %s", template)
logger.Debug("Rendering Template - Data: %+v", data)
return raymond.Render(template, data)
// todo: apply some post processing to this config, stripe trailing whitespace from lines and then remove groups of 2+ \n's so the config looks nicer
}
func writeTemplate(filename, template string, data TemplateData) error {
@ -31,7 +38,7 @@ func writeTemplate(filename, template string, data TemplateData) error {
// Write it. This will also write an error comment if generation failed
// nolint: gosec
writeErr := writeConfigFile(filename, output)
writeErr := writeConfigFile(filename, util.CleanupWhitespace(output))
if err != nil {
return err
}

10
backend/internal/status/status.go Normal file
View File

@ -0,0 +1,10 @@
package status
const (
// StatusReady means a host is ready to configure
StatusReady = "ready"
// StatusOK means a host is configured within Nginx
StatusOK = "ok"
// StatusError is self explanatory
StatusError = "error"
)

24
backend/internal/util/strings.go Normal file
View File

@ -0,0 +1,24 @@
package util
import (
"regexp"
"strings"
"unicode"
)
// CleanupWhitespace will trim up and remove extra lines and stuff
func CleanupWhitespace(s string) string {
// Remove trailing whitespace from all lines
slices := strings.Split(s, "\n")
for idx := range slices {
slices[idx] = strings.TrimRightFunc(slices[idx], unicode.IsSpace)
}
// Output: [a b c]
result := strings.Join(slices, "\n")
// Remove empty lines
r1 := regexp.MustCompile("\n+")
result = r1.ReplaceAllString(result, "\n")
return result
}

51
backend/internal/util/strings_test.go Normal file
View File

@ -0,0 +1,51 @@
package util
import (
"testing"
"github.com/stretchr/testify/assert"
)
func TestCleanupWhitespace(t *testing.T) {
tests := []struct {
name string
input string
want string
}{
{
name: "test a",
input: `# ------------------------------------------------------------
# Upstream 5: API servers 2
# ------------------------------------------------------------
upstream npm_upstream_5 {` + ` ` + /* this adds whitespace to the end without the ide trimming it */ `
server 192.168.0.10:80 weight=100 ;
server 192.168.0.11:80 weight=50 ;
}`,
want: `# ------------------------------------------------------------
# Upstream 5: API servers 2
# ------------------------------------------------------------
upstream npm_upstream_5 {
server 192.168.0.10:80 weight=100 ;
server 192.168.0.11:80 weight=50 ;
}`,
},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
output := CleanupWhitespace(tt.input)
assert.Equal(t, tt.want, output)
})
}
}

12
backend/internal/validator/hosts.go
View File

@ -5,7 +5,7 @@ import (
"npm/internal/entity/certificate"
"npm/internal/entity/host"
"npm/internal/entity/hosttemplate"
"npm/internal/entity/nginxtemplate"
)
// ValidateHost will check if associated objects exist and other checks
@ -20,13 +20,13 @@ func ValidateHost(h host.Model) error {
}
}
// Check the host template exists and has the same type.
hostTemplate, tErr := hosttemplate.GetByID(h.HostTemplateID)
// Check the nginx template exists and has the same type.
nginxTemplate, tErr := nginxtemplate.GetByID(h.NginxTemplateID)
if tErr != nil {
return fmt.Errorf("Host Template #%d does not exist", h.HostTemplateID)
return fmt.Errorf("Host Template #%d does not exist", h.NginxTemplateID)
}
if hostTemplate.Type != h.Type {
return fmt.Errorf("Host Template #%d is not valid for this host type", h.HostTemplateID)
if nginxTemplate.Type != h.Type {
return fmt.Errorf("Host Template #%d is not valid for this host type", h.NginxTemplateID)
}
return nil

39
backend/internal/validator/upstreams.go Normal file
View File

@ -0,0 +1,39 @@
package validator
import (
"errors"
"fmt"
"npm/internal/entity/nginxtemplate"
"npm/internal/entity/upstream"
)
// ValidateUpstream will check if associated objects exist and other checks
// will return a nil error if things are OK
func ValidateUpstream(u upstream.Model) error {
// Needs to have more than 1 server
if len(u.Servers) < 2 {
return errors.New("Upstreams require at least 2 servers")
}
// Backup servers aren't permitted with hash balancing
if u.IPHash {
// check all servers for a backup param
for _, server := range u.Servers {
if server.Backup {
return errors.New("Backup servers cannot be used with hash balancing")
}
}
}
// Check the nginx template exists and has the same type.
nginxTemplate, err := nginxtemplate.GetByID(u.NginxTemplateID)
if err != nil {
return fmt.Errorf("Nginx Template #%d does not exist", u.NginxTemplateID)
}
if nginxTemplate.Type != "upstream" {
return fmt.Errorf("Host Template #%d is not valid for this upstream", u.NginxTemplateID)
}
return nil
}