kirby/infra-dashboard
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Working docker containerization

Browse Source
This commit is contained in:
kirby
2024-12-24 16:13:33 +01:00
parent 08e11786c0
commit 06e7b4e9c0
24 changed files with 383 additions and 85 deletions
Download Patch File Download Diff File Expand all files Collapse all files

151
Http/os.go
View File

@@ -1,151 +0,0 @@
package http
import (
"encoding/json"
db "infra-dashboard/Database"
"io"
"io/ioutil"
"log"
"net/http"
"strconv"
"time"
"github.com/gorilla/mux"
"gopkg.in/guregu/null.v4"
)
func GetOS(w http.ResponseWriter, r *http.Request) {
var list []db.OS
var err error
t := time.Now()
status := 200
dbConn := db.GetDatabaseConnection()
defer dbConn.Close()
list, err = db.GetOS(dbConn)
if err != nil {
log.Println("Error getting OS list")
status = 500
}
logRequest(t, r, status)
w.Header().Set("Content-Type", "application/json")
json.NewEncoder(w).Encode(list)
}
func GetOSbyID(w http.ResponseWriter, r *http.Request) {
var os db.OS
var err error
t := time.Now()
status := 200
params := mux.Vars(r)
dbConn := db.GetDatabaseConnection()
defer dbConn.Close()
id, err := strconv.ParseInt(params["id"], 10, 64)
if err != nil {
log.Println("Error converting ID", err)
status = 500
}
os, err = db.GetOSbyID(dbConn, int64(id))
if err != nil {
log.Println("Error getting OS")
status = 500
}
logRequest(t, r, status)
w.Header().Set("Content-Type", "application/json")
json.NewEncoder(w).Encode(os)
}
func GetDistributionList(w http.ResponseWriter, r *http.Request) {
var list []null.String
var err error
t := time.Now()
status := 200
dbConn := db.GetDatabaseConnection()
defer dbConn.Close()
list, err = db.GetDistributionList(dbConn)
if err != nil {
log.Println("Error getting distribution list")
status = 500
}
logRequest(t, r, status)
w.Header().Set("Content-Type", "application/json")
json.NewEncoder(w).Encode(list)
}
func GetVersionsByDistributionList(w http.ResponseWriter, r *http.Request) {
var list []null.String
var err error
t := time.Now()
status := 200
params := mux.Vars(r)
dbConn := db.GetDatabaseConnection()
defer dbConn.Close()
list, err = db.GetVersionsByDistributionList(dbConn, params["distribution"])
if err != nil {
log.Println("Error getting distribution list")
status = 500
}
logRequest(t, r, status)
w.Header().Set("Content-Type", "application/json")
json.NewEncoder(w).Encode(list)
}
func CreateOS(w http.ResponseWriter, r *http.Request) {
var os db.OS
var err error
t := time.Now()
status := 204
body, err := io.ReadAll(r.Body)
if err != nil {
log.Println("Error reading request body", err)
}
params := make(map[string]null.String)
json.Unmarshal(body, &params)
os.Distribution = params["distribution"]
os.Version = params["version"]
os.EndOfSupport = params["end_of_support"]
dbConn := db.GetDatabaseConnection()
defer dbConn.Close()
err = db.CreateOS(os, dbConn)
if err != nil {
log.Println("Error creating new OS", err)
status = 500
}
logRequest(t, r, status)
w.WriteHeader(status)
}
func DeleteOS(w http.ResponseWriter, r *http.Request) {
var os db.OS
var err error
var status int
t := time.Now()
body, err := ioutil.ReadAll(r.Body)
if err != nil {
log.Println(err.Error(), "Error reading request body")
}
params := make(map[string]null.String)
json.Unmarshal(body, &params)
os.Distribution = params["distribution"]
os.Version = params["version"]
dbConn := db.GetDatabaseConnection()
defer dbConn.Close()
status, err = db.DeleteOS(os, dbConn)
if err != nil {
log.Println(err.Error(), "Error deleting OS")
}
logRequest(t, r, status)
w.WriteHeader(status)
}

155
Http/package.go
View File

@@ -1,155 +0,0 @@
package http
import (
"encoding/json"
"gopkg.in/guregu/null.v4"
db "infra-dashboard/Database"
"io/ioutil"
"log"
"net/http"
"strconv"
"time"
"github.com/gorilla/mux"
)
func GetAllPackages(w http.ResponseWriter, r *http.Request) {
var list []db.Package
var err error
t := time.Now()
status := 200
db_conn := db.GetDatabaseConnection()
defer db_conn.Close()
list, err = db.GetPackage(db_conn)
if err != nil {
log.Println("Error getting Package list")
status = 500
}
logRequest(t, r, status)
w.Header().Set("Content-Type", "application/json")
json.NewEncoder(w).Encode(list)
}
func GetPackagebyID(w http.ResponseWriter, r *http.Request) {
var pkg db.Package
var err error
t := time.Now()
status := 200
params := mux.Vars(r)
dbConn := db.GetDatabaseConnection()
defer dbConn.Close()
id, err := strconv.ParseInt(params["id"], 10, 64)
if err != nil {
log.Println("Error converting ID", err)
status = 500
}
pkg, err = db.GetPackagebyID(dbConn, int64(id))
if err != nil {
log.Println("Error getting Package")
status = 500
}
logRequest(t, r, status)
w.Header().Set("Content-Type", "application/json")
json.NewEncoder(w).Encode(pkg)
}
func CreatePackage(w http.ResponseWriter, r *http.Request) {
var pkg db.Package
var err error
t := time.Now()
status := 200
body, err := ioutil.ReadAll(r.Body)
if err != nil {
log.Println(err.Error(), "Error reading request body")
}
params := make(map[string]null.String)
json.Unmarshal(body, &params)
pkg.Name = params["name"]
dbConn := db.GetDatabaseConnection()
defer dbConn.Close()
err = db.CreatePackage(pkg, dbConn)
if err != nil {
log.Println("Error creating package", pkg.Name)
status = 500
}
logRequest(t, r, status)
w.WriteHeader(status)
}
func DisablePackage(w http.ResponseWriter, r *http.Request) {
var pkg db.Package
var err error
var status int
t := time.Now()
body, err := ioutil.ReadAll(r.Body)
if err != nil {
log.Println(err.Error(), "Error reading request body")
}
params := make(map[string]null.String)
json.Unmarshal(body, &params)
pkg.Name = params["name"]
dbConn := db.GetDatabaseConnection()
defer dbConn.Close()
status, err = db.DisablePackage(pkg, dbConn)
if err != nil {
log.Println(err.Error(), "Error disabling package", pkg.Name)
}
logRequest(t, r, status)
w.WriteHeader(status)
}
func EnablePackage(w http.ResponseWriter, r *http.Request) {
var pkg db.Package
var err error
var status int
t := time.Now()
body, err := ioutil.ReadAll(r.Body)
if err != nil {
log.Println(err.Error(), "Error reading request body")
}
params := make(map[string]null.String)
json.Unmarshal(body, &params)
pkg.Name = params["name"]
dbConn := db.GetDatabaseConnection()
defer dbConn.Close()
status, err = db.EnablePackage(pkg, dbConn)
if err != nil {
log.Println(err.Error(), "Error enabling package", pkg.Name)
}
logRequest(t, r, status)
w.WriteHeader(status)
}
func DeletePackage(w http.ResponseWriter, r *http.Request) {
var pkg db.Package
var err error
var status int
t := time.Now()
body, err := ioutil.ReadAll(r.Body)
if err != nil {
log.Println(err.Error(), "Error reading request body")
}
params := make(map[string]null.String)
json.Unmarshal(body, &params)
pkg.Name = params["name"]
dbConn := db.GetDatabaseConnection()
defer dbConn.Close()
status, err = db.DeletePackage(pkg, dbConn)
if err != nil {
log.Println(err.Error(), "Error deleting package", pkg.Name)
}
logRequest(t, r, status)
w.WriteHeader(status)
}

131
Http/server.go
View File

@@ -1,131 +0,0 @@
package http
import (
"encoding/json"
"gopkg.in/guregu/null.v4"
db "infra-dashboard/Database"
"io/ioutil"
"log"
"net/http"
"strconv"
"time"
"github.com/gorilla/mux"
)
func GetServersList(w http.ResponseWriter, r *http.Request) {
var list []db.Server
var err error
t := time.Now()
status := 200
dbConn := db.GetDatabaseConnection()
defer dbConn.Close()
list, err = db.GetServersList(dbConn)
if err != nil {
log.Println("Error getting OS list")
status = 500
}
logRequest(t, r, status)
w.Header().Set("Content-Type", "application/json")
json.NewEncoder(w).Encode(list)
}
func GetServersbyID(w http.ResponseWriter, r *http.Request) {
var server db.Server
var err error
t := time.Now()
status := 200
params := mux.Vars(r)
id, err := strconv.ParseInt(params["id"], 10, 32)
if err != nil {
log.Println("Error converting ID", err)
status = 500
}
dbConn := db.GetDatabaseConnection()
defer dbConn.Close()
server = db.GetServersbyID(dbConn, int64(id))
logRequest(t, r, status)
w.Header().Set("Content-Type", "application/json")
json.NewEncoder(w).Encode(server)
}
func GetServersbyOS(w http.ResponseWriter, r *http.Request) {
var servers []db.Server
var err error
t := time.Now()
status := 200
params := mux.Vars(r)
osId, err := strconv.ParseInt(params["os_id"], 10, 32)
if err != nil {
log.Println("Error converting ID", err)
status = 500
}
dbConn := db.GetDatabaseConnection()
defer dbConn.Close()
servers, err = db.GetServersbyOS(dbConn, int64(osId))
if err != nil {
log.Println("Error getting servers by OS", err)
status = 500
}
logRequest(t, r, status)
w.Header().Set("Content-Type", "application/json")
json.NewEncoder(w).Encode(servers)
}
func CreateServer(w http.ResponseWriter, r *http.Request) {
var server db.Server
var err error
t := time.Now()
status := 204
body, err := ioutil.ReadAll(r.Body)
if err != nil {
log.Println(err.Error(), "Error reading request body")
}
params := make(map[string]null.String)
json.Unmarshal(body, &params)
server.Hostname = params["hostname"]
server.OsId = params["os_id"]
dbConn := db.GetDatabaseConnection()
defer dbConn.Close()
err = db.CreateServer(server, dbConn)
if err != nil {
log.Println(err.Error(), "Error creating server")
status = 500
}
logRequest(t, r, status)
w.WriteHeader(status)
}
func DeleteServer(w http.ResponseWriter, r *http.Request) {
var server db.Server
var err error
var status int
t := time.Now()
body, err := ioutil.ReadAll(r.Body)
if err != nil {
log.Println(err.Error(), "Error reading request body")
}
params := make(map[string]null.String)
json.Unmarshal(body, &params)
server.Hostname = params["hostname"]
server.OsId = params["os_id"]
dbConn := db.GetDatabaseConnection()
defer dbConn.Close()
status, err = db.DeleteServer(server, dbConn)
if err != nil {
log.Println(err.Error(), "Error deleting server")
}
logRequest(t, r, status)
w.WriteHeader(status)
}

39
Http/utils.go
View File

@@ -1,39 +0,0 @@
package http
import (
"fmt"
"io"
"log"
"net/http"
"time"
)
func RequestHandler(w http.ResponseWriter, r *http.Request) {
t := time.Now()
logRequest(t, r, 418)
w.WriteHeader(http.StatusTeapot)
fmt.Fprint(w, "Bip Boop I'm a teapot")
}
func HealthHandler(w http.ResponseWriter, _ *http.Request) {
_, _ = io.WriteString(w, "OK")
}
func NotFound(w http.ResponseWriter, r *http.Request) {
t := time.Now()
logRequest(t, r, 404)
w.WriteHeader(http.StatusNotFound)
}
func logRequest(t time.Time, r *http.Request, s int) {
log.Printf("%s - - %s \"%s %s %s\" %d 0 \"-\" \"%s\" %d\n",
r.Host,
t.Format("[02/Jan/2006:15:04:05 -0700]"),
r.Method,
r.URL.Path,
r.Proto,
s,
r.UserAgent(),
time.Since(t).Milliseconds(),
)
}