Working docker containerization

2024-12-24 16:13:33 +01:00
parent 08e11786c0
commit 06e7b4e9c0
24 changed files with 383 additions and 85 deletions
--- a/app/Database/os.go
+++ b/app/Database/os.go
@@ -0,0 +1,131 @@
+package database
+
+import (
+	"database/sql"
+	"errors"
+	"log"
+
+	"gopkg.in/guregu/null.v4"
+)
+
+type OS struct {
+	ID           int         `json:"id"`
+	Distribution null.String `json:"distribution"`
+	Version      null.String `json:"version"`
+	EndOfSupport null.String `json:"EndOfSupport"`
+}
+
+func GetOS(db *sql.DB) ([]OS, error) {
+	var oses []OS
+	rows, err := db.Query("SELECT * FROM dashboard_os")
+	if err != nil {
+		log.Println("Error querying list of OS", err)
+	}
+	defer func(rows *sql.Rows) {
+		err := rows.Close()
+		if err != nil {
+
+		}
+	}(rows)
+
+	for rows.Next() {
+		var os OS
+		err := rows.Scan(&os.ID, &os.Distribution, &os.Version, &os.EndOfSupport)
+		if err != nil {
+			log.Println("Error building list", err)
+		}
+		oses = append(oses, os)
+	}
+	return oses, err
+}
+
+func GetOSbyID(db *sql.DB, id int64) (OS, error) {
+	var os OS
+	if err := db.QueryRow("SELECT * FROM dashboard_os where id = ?", id).Scan(&os.ID, &os.Distribution, &os.Version, &os.EndOfSupport); err != nil {
+		if errors.Is(err, sql.ErrNoRows) {
+			return os, nil
+		}
+		log.Println("Error getting OS by ID", err)
+	}
+	return os, nil
+}
+
+func GetDistributionList(db *sql.DB) ([]null.String, error) {
+	var list []null.String
+	rows, err := db.Query("SELECT DISTINCT distribution FROM dashboard_os")
+	if err != nil {
+		log.Println("Error getting distribution list", err)
+	}
+	for rows.Next() {
+		var os OS
+		err := rows.Scan(&os.Distribution)
+		if err != nil {
+			log.Println("Error building distribution list", err)
+		}
+		list = append(list, os.Distribution)
+	}
+	return list, nil
+}
+
+func GetVersionsByDistributionList(db *sql.DB, d string) ([]null.String, error) {
+	var list []null.String
+	rows, err := db.Query("SELECT DISTINCT version FROM dashboard_os where distribution = ?", d)
+	if err != nil {
+		log.Println("Error getting distribution list", err)
+	}
+	for rows.Next() {
+		var os OS
+		err := rows.Scan(&os.Distribution)
+		if err != nil {
+			log.Println("Error building distribution list", err)
+		}
+		list = append(list, os.Distribution)
+	}
+	return list, nil
+}
+
+func checkIfOsExists(os OS, db *sql.DB) bool {
+	row := db.QueryRow("Select distribution, version from dashboard_os where distribution = ? and version = ?", os.Distribution, os.Version)
+	err := row.Scan(&os.Distribution, &os.Version)
+	if !errors.Is(err, sql.ErrNoRows) {
+		return true
+	}
+	return false
+}
+
+func CreateOS(os OS, db *sql.DB) error {
+	if checkIfOsExists(os, db) {
+		log.Println("OS already exists")
+		return nil
+	}
+	q, err := db.Prepare("INSERT INTO `dashboard_os` (`distribution`,`version`,`end_of_support`) VALUES (?,?,?)")
+	if err != nil {
+		log.Println("Error creating query", err)
+		return err
+	}
+	_, err = q.Exec(&os.Distribution, &os.Version, &os.EndOfSupport)
+	if err != nil {
+		log.Println("Error inserting OS", err)
+		return err
+	}
+	return nil
+}
+
+func DeleteOS(os OS, db *sql.DB) (int, error) {
+	if !checkIfOsExists(os, db) {
+		log.Println("OS does not exist, nothing to delete")
+		return 404, nil
+	}
+	q, err := db.Prepare("DELETE FROM dashboard_os WHERE distribution = ? AND version = ?")
+	if err != nil {
+		log.Println("Error deleting OS", err)
+		return 500, err
+	}
+	_, err = q.Exec(&os.Distribution, &os.Version)
+	if err != nil {
+		log.Println("Error deleting OS", err)
+		return 500, err
+	}
+	log.Println("OS deleted")
+	return 200, nil
+}
--- a/app/Database/package.go
+++ b/app/Database/package.go
@@ -0,0 +1,151 @@
+package database
+
+import (
+	"database/sql"
+	"errors"
+	"log"
+
+	"gopkg.in/guregu/null.v4"
+)
+
+type Package struct {
+	ID     int         `json:"id"`
+	Name   null.String `json:"name"`
+	Active int         `json:"active"`
+}
+
+func GetPackage(db *sql.DB) ([]Package, error) {
+	var packages []Package
+	rows, err := db.Query("SELECT * FROM dashboard_package")
+	if err != nil {
+		log.Println("Error querying list of OS", err)
+	}
+	defer rows.Close()
+
+	for rows.Next() {
+		var pkg Package
+		err := rows.Scan(&pkg.ID, &pkg.Name, &pkg.Active)
+		if err != nil {
+			log.Println("Error building list", err)
+		}
+		packages = append(packages, pkg)
+	}
+	return packages, err
+}
+
+func GetPackagebyID(db *sql.DB, id int64) (Package, error) {
+	var pkg Package
+	if err := db.QueryRow("SELECT * FROM dashboard_package where id = ?", id).Scan(&pkg.ID, &pkg.Name, &pkg.Active); err != nil {
+		if errors.Is(err, sql.ErrNoRows) {
+			return pkg, nil
+		}
+		log.Println("Error getting OS by ID", err)
+	}
+	return pkg, nil
+}
+
+func GetPackagebyName(db *sql.DB, id int64) (Package, error) {
+	var pkg Package
+	if err := db.QueryRow("SELECT * FROM dashboard_package where name = ?", id).Scan(&pkg.ID, &pkg.Name, &pkg.Active); err != nil {
+		if errors.Is(err, sql.ErrNoRows) {
+			return pkg, nil
+		}
+		log.Println("Error getting OS by ID", err)
+	}
+	return pkg, nil
+}
+
+func checkIfPackageExists(pkg Package, db *sql.DB) bool {
+	if err := db.QueryRow("Select name from dashboard_package where name = ?", pkg.Name).Scan(&pkg.Name); err != nil {
+		if errors.Is(err, sql.ErrNoRows) {
+			return false
+		}
+	}
+	return true
+}
+
+func CreatePackage(pkg Package, db *sql.DB) error {
+	if checkIfPackageExists(pkg, db) {
+		/* If package exists but is not active we activate it */
+		row := db.QueryRow("Select name, active from dashboard_package where name = ? and active = 1", pkg.Name)
+		err := row.Scan(&pkg.Name, &pkg.Active)
+		if errors.Is(err, sql.ErrNoRows) {
+			q, err := db.Prepare("UPDATE dashboard_package set active = 1 where name = ?")
+			if err != nil {
+				log.Println("Error creating query", err)
+			}
+			_, err = q.Exec(pkg.Name)
+			if err != nil {
+				log.Println("Error activating Package", err)
+			}
+			log.Println("Activating new package", pkg.Name)
+			return nil
+		}
+		return nil
+	}
+	q, err := db.Prepare("INSERT INTO dashboard_package (name, active) values (?, 1)")
+	if err != nil {
+		log.Println("Error creating query", err)
+		return err
+	}
+	_, err = q.Exec(pkg.Name)
+	if err != nil {
+		log.Println("Error creating Package", err)
+		return err
+	}
+	return nil
+}
+
+func DisablePackage(pkg Package, db *sql.DB) (int, error) {
+	if !checkIfPackageExists(pkg, db) {
+		log.Println("Package does not exist", pkg.Name)
+		return 404, nil
+	}
+	q, err := db.Prepare("UPDATE dashboard_package set active = 0 where name = ?")
+	if err != nil {
+		log.Println("Error creating query", err)
+		return 500, err
+	}
+	_, err = q.Exec(pkg.Name)
+	if err != nil {
+		log.Println("Error disabling Package", err)
+		return 500, err
+	}
+	return 200, nil
+}
+
+func EnablePackage(pkg Package, db *sql.DB) (int, error) {
+	if !checkIfPackageExists(pkg, db) {
+		log.Println("Package does not exist", pkg.Name)
+		return 404, nil
+	}
+	q, err := db.Prepare("UPDATE dashboard_package set active = 1 where name = ?")
+	if err != nil {
+		log.Println("Error creating query", err)
+		return 500, err
+	}
+	_, err = q.Exec(pkg.Name)
+	if err != nil {
+		log.Println("Error disabling Package", err)
+		return 500, err
+	}
+	return 200, nil
+}
+
+func DeletePackage(pkg Package, db *sql.DB) (int, error) {
+	if !checkIfPackageExists(pkg, db) {
+		log.Println("Package does not exist", pkg.Name)
+		return 404, nil
+	}
+	q, err := db.Prepare("DELETE FROM dashboard_package where name = ?")
+	if err != nil {
+		log.Println("Error creating query", err)
+		return 500, err
+	}
+	_, err = q.Exec(pkg.Name)
+	if err != nil {
+		log.Println("Error deleting Package", err)
+		return 500, err
+	}
+	return 200, nil
+}
--- a/app/Database/server.go
+++ b/app/Database/server.go
@@ -0,0 +1,118 @@
+package database
+
+import (
+	"database/sql"
+	"errors"
+	"gopkg.in/guregu/null.v4"
+	"log"
+)
+
+type Server struct {
+	ID       int         `json:"id"`
+	Hostname null.String `json:"hostname"`
+	OsId     null.String `json:"OsId"`
+}
+
+func GetServersList(db *sql.DB) ([]Server, error) {
+	var servers []Server
+	rows, err := db.Query("SELECT * FROM dashboard_server")
+	if err != nil {
+		log.Println("Error querying servers list", err)
+	}
+	defer func(rows *sql.Rows) {
+		err := rows.Close()
+		if err != nil {
+
+		}
+	}(rows)
+
+	for rows.Next() {
+		var s Server
+		err := rows.Scan(&s.ID, &s.Hostname, &s.OsId)
+		if err != nil {
+			log.Println("Error building servers list", err)
+		}
+		servers = append(servers, s)
+	}
+	return servers, err
+}
+
+func GetServersbyID(db *sql.DB, id int64) Server {
+	var s Server
+	rows := db.QueryRow("SELECT * FROM dashboard_server WHERE id = ?", id)
+	err := rows.Scan(&s.ID, &s.Hostname, &s.OsId)
+	if err != nil {
+		return Server{}
+	}
+	return s
+}
+
+func GetServersbyOS(db *sql.DB, id int64) ([]Server, error) {
+	var servers []Server
+	rows, err := db.Query("SELECT * FROM dashboard_server WHERE os_id = ?", id)
+	if err != nil {
+		log.Println("Error querying servers list by os_id", err)
+	}
+	defer func(rows *sql.Rows) {
+		err := rows.Close()
+		if err != nil {
+
+		}
+	}(rows)
+
+	for rows.Next() {
+		var s Server
+		err := rows.Scan(&s.ID, &s.Hostname, &s.OsId)
+		if err != nil {
+			log.Println("Error building servers list", err)
+		}
+		servers = append(servers, s)
+	}
+	return servers, err
+}
+
+func checkIfServerExists(server Server, db *sql.DB) bool {
+	row := db.QueryRow("Select hostname, os_id from dashboard_server where hostname = ? and os_id = ?", server.Hostname, server.OsId)
+	err := row.Scan(&server.Hostname, &server.OsId)
+	if !errors.Is(err, sql.ErrNoRows) {
+		return true
+	}
+	return false
+}
+
+func CreateServer(server Server, db *sql.DB) error {
+	if checkIfServerExists(server, db) {
+		log.Println("Server already exists")
+		return nil
+	}
+	q, err := db.Prepare("INSERT INTO `dashboard_server` (hostname, os_id) VALUES (?,?)")
+	if err != nil {
+		log.Println("Error creating query", err)
+		return err
+	}
+	_, err = q.Exec(server.Hostname, server.OsId)
+	if err != nil {
+		log.Println("Error inserting Server", err)
+		return err
+	}
+	return nil
+}
+
+func DeleteServer(server Server, db *sql.DB) (int, error) {
+	if !checkIfServerExists(server, db) {
+		log.Println("Server does not exist, nothing to delete")
+		return 404, nil
+	}
+	q, err := db.Prepare("DELETE FROM dashboard_server WHERE hostname = ? AND os_id = ?")
+	if err != nil {
+		log.Println("Error deleting Server", err)
+		return 500, err
+	}
+	_, err = q.Exec(server.Hostname, server.OsId)
+	if err != nil {
+		log.Println("Error deleting Server", err)
+		return 500, err
+	}
+	log.Println("Server deleted")
+	return 200, nil
+}
--- a/app/Database/utils.go
+++ b/app/Database/utils.go
@@ -0,0 +1,25 @@
+package database
+
+import (
+	"database/sql"
+	"log"
+	"os"
+
+	"github.com/go-sql-driver/mysql"
+	_ "github.com/go-sql-driver/mysql"
+)
+
+func GetDatabaseConnection() *sql.DB {
+	cfg := mysql.Config{
+		User:   os.Getenv("DATABASE_USER"),
+		Passwd: os.Getenv("DATABASE_PASSWORD"),
+		Net:    "tcp",
+		Addr:   os.Getenv("DATABASE_HOST"),
+		DBName: os.Getenv("DATABASE_NAME"),
+	}
+	DbConn, err := sql.Open("mysql", cfg.FormatDSN())
+	if err != nil {
+		log.Println("Database connection error : ", err)
+	}
+	return DbConn
+}
--- a/app/Http/os.go
+++ b/app/Http/os.go
@@ -0,0 +1,151 @@
+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)
+}
--- a/app/Http/package.go
+++ b/app/Http/package.go
@@ -0,0 +1,155 @@
+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)
+}
--- a/app/Http/server.go
+++ b/app/Http/server.go
@@ -0,0 +1,131 @@
+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)
+}
--- a/app/Http/utils.go
+++ b/app/Http/utils.go
@@ -0,0 +1,40 @@
+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 %d \"-\" \"%s\" %d\n",
+		r.Host,
+		t.Format("[02/Jan/2006:15:04:05 -0700]"),
+		r.Method,
+		r.URL.Path,
+		r.Proto,
+		s,
+		r.ContentLength,
+		r.UserAgent(),
+		time.Since(t).Milliseconds(),
+	)
+}
--- a/app/Tools/utils.go
+++ b/app/Tools/utils.go
@@ -0,0 +1,12 @@
+package Tools
+
+import (
+	"log"
+	"os"
+)
+
+// InitLog ensure log file exists and set appropriate flags (remove timestamp at start of line).
+func InitLog() {
+	log.SetOutput(os.Stdout)
+	log.SetFlags(log.Flags() &^ (log.Ldate | log.Ltime))
+}
--- a/app/go.mod
+++ b/app/go.mod
@@ -0,0 +1,32 @@
+module infra-dashboard
+
+go 1.23.1
+
+toolchain go1.23.3
+
+require (
+	github.com/alexflint/go-arg v1.5.1
+	github.com/go-sql-driver/mysql v1.8.1
+	github.com/gorilla/mux v1.8.1
+	github.com/joho/godotenv v1.5.1
+	gopkg.in/guregu/null.v4 v4.0.0
+)
+
+require (
+	filippo.io/edwards25519 v1.1.0 // indirect
+	github.com/BurntSushi/toml v1.4.1-0.20240526193622-a339e1f7089c // indirect
+	github.com/alexflint/go-scalar v1.2.0 // indirect
+	github.com/google/go-cmp v0.6.0 // indirect
+	golang.org/x/exp/typeparams v0.0.0-20231108232855-2478ac86f678 // indirect
+	golang.org/x/mod v0.22.0 // indirect
+	golang.org/x/sync v0.9.0 // indirect
+	golang.org/x/sys v0.27.0 // indirect
+	golang.org/x/telemetry v0.0.0-20241106142447-58a1122356f5 // indirect
+	golang.org/x/text v0.20.0 // indirect
+	golang.org/x/tools v0.27.1-0.20241219162658-575221bfbda3 // indirect
+	golang.org/x/tools/gopls v0.17.1 // indirect
+	golang.org/x/vuln v1.0.4 // indirect
+	honnef.co/go/tools v0.5.1 // indirect
+	mvdan.cc/gofumpt v0.7.0 // indirect
+	mvdan.cc/xurls/v2 v2.5.0 // indirect
+)
--- a/app/go.sum
+++ b/app/go.sum
@@ -0,0 +1,51 @@
+filippo.io/edwards25519 v1.1.0 h1:FNf4tywRC1HmFuKW5xopWpigGjJKiJSV0Cqo0cJWDaA=
+filippo.io/edwards25519 v1.1.0/go.mod h1:BxyFTGdWcka3PhytdK4V28tE5sGfRvvvRV7EaN4VDT4=
+github.com/BurntSushi/toml v1.4.1-0.20240526193622-a339e1f7089c h1:pxW6RcqyfI9/kWtOwnv/G+AzdKuy2ZrqINhenH4HyNs=
+github.com/BurntSushi/toml v1.4.1-0.20240526193622-a339e1f7089c/go.mod h1:ukJfTF/6rtPPRCnwkur4qwRxa8vTRFBF0uk2lLoLwho=
+github.com/alexflint/go-arg v1.5.1 h1:nBuWUCpuRy0snAG+uIJ6N0UvYxpxA0/ghA/AaHxlT8Y=
+github.com/alexflint/go-arg v1.5.1/go.mod h1:A7vTJzvjoaSTypg4biM5uYNTkJ27SkNTArtYXnlqVO8=
+github.com/alexflint/go-scalar v1.2.0 h1:WR7JPKkeNpnYIOfHRa7ivM21aWAdHD0gEWHCx+WQBRw=
+github.com/alexflint/go-scalar v1.2.0/go.mod h1:LoFvNMqS1CPrMVltza4LvnGKhaSpc3oyLEBUZVhhS2o=
+github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c=
+github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
+github.com/go-sql-driver/mysql v1.8.1 h1:LedoTUt/eveggdHS9qUFC1EFSa8bU2+1pZjSRpvNJ1Y=
+github.com/go-sql-driver/mysql v1.8.1/go.mod h1:wEBSXgmK//2ZFJyE+qWnIsVGmvmEKlqwuVSjsCm7DZg=
+github.com/google/go-cmp v0.6.0 h1:ofyhxvXcZhMsU5ulbFiLKl/XBFqE1GSq7atu8tAmTRI=
+github.com/google/go-cmp v0.6.0/go.mod h1:17dUlkBOakJ0+DkrSSNjCkIjxS6bF9zb3elmeNGIjoY=
+github.com/gorilla/mux v1.8.1 h1:TuBL49tXwgrFYWhqrNgrUNEY92u81SPhu7sTdzQEiWY=
+github.com/gorilla/mux v1.8.1/go.mod h1:AKf9I4AEqPTmMytcMc0KkNouC66V3BtZ4qD5fmWSiMQ=
+github.com/joho/godotenv v1.5.1 h1:7eLL/+HRGLY0ldzfGMeQkb7vMd0as4CfYvUVzLqw0N0=
+github.com/joho/godotenv v1.5.1/go.mod h1:f4LDr5Voq0i2e/R5DDNOoa2zzDfwtkZa6DnEwAbqwq4=
+github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM=
+github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=
+github.com/stretchr/testify v1.2.2/go.mod h1:a8OnRcib4nhh0OaRAV+Yts87kKdq0PP7pXfy6kDkUVs=
+github.com/stretchr/testify v1.7.0 h1:nwc3DEeHmmLAfoZucVR881uASk0Mfjw8xYJ99tb5CcY=
+github.com/stretchr/testify v1.7.0/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg=
+golang.org/x/exp/typeparams v0.0.0-20231108232855-2478ac86f678 h1:1P7xPZEwZMoBoz0Yze5Nx2/4pxj6nw9ZqHWXqP0iRgQ=
+golang.org/x/exp/typeparams v0.0.0-20231108232855-2478ac86f678/go.mod h1:AbB0pIl9nAr9wVwH+Z2ZpaocVmF5I4GyWCDIsVjR0bk=
+golang.org/x/mod v0.22.0 h1:D4nJWe9zXqHOmWqj4VMOJhvzj7bEZg4wEYa759z1pH4=
+golang.org/x/mod v0.22.0/go.mod h1:6SkKJ3Xj0I0BrPOZoBy3bdMptDDU9oJrpohJ3eWZ1fY=
+golang.org/x/sync v0.9.0 h1:fEo0HyrW1GIgZdpbhCRO0PkJajUS5H9IFUztCgEo2jQ=
+golang.org/x/sync v0.9.0/go.mod h1:Czt+wKu1gCyEFDUtn0jG5QVvpJ6rzVqr5aXyt9drQfk=
+golang.org/x/sys v0.27.0 h1:wBqf8DvsY9Y/2P8gAfPDEYNuS30J4lPHJxXSb/nJZ+s=
+golang.org/x/sys v0.27.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA=
+golang.org/x/telemetry v0.0.0-20241106142447-58a1122356f5 h1:TCDqnvbBsFapViksHcHySl/sW4+rTGNIAoJJesHRuMM=
+golang.org/x/telemetry v0.0.0-20241106142447-58a1122356f5/go.mod h1:8nZWdGp9pq73ZI//QJyckMQab3yq7hoWi7SI0UIusVI=
+golang.org/x/text v0.20.0 h1:gK/Kv2otX8gz+wn7Rmb3vT96ZwuoxnQlY+HlJVj7Qug=
+golang.org/x/text v0.20.0/go.mod h1:D4IsuqiFMhST5bX19pQ9ikHC2GsaKyk/oF+pn3ducp4=
+golang.org/x/tools v0.27.1-0.20241219162658-575221bfbda3 h1:kgwdasJRsdDWYgWcEgMF424DiXwwXHSb3V8xVTi//i8=
+golang.org/x/tools v0.27.1-0.20241219162658-575221bfbda3/go.mod h1:sUi0ZgbwW9ZPAq26Ekut+weQPR5eIM6GQLQ1Yjm1H0Q=
+golang.org/x/tools/gopls v0.17.1 h1:Mt/DSfnnSe3dyf6MH/dZZ0iww+viHNhAFc4rEYDiOAw=
+golang.org/x/tools/gopls v0.17.1/go.mod h1:niea3AFBDJrqLpvDQ8vjmtzjGcT44nAoYm/vd34SaH4=
+golang.org/x/vuln v1.0.4 h1:SP0mPeg2PmGCu03V+61EcQiOjmpri2XijexKdzv8Z1I=
+golang.org/x/vuln v1.0.4/go.mod h1:NbJdUQhX8jY++FtuhrXs2Eyx0yePo9pF7nPlIjo9aaQ=
+gopkg.in/guregu/null.v4 v4.0.0 h1:1Wm3S1WEA2I26Kq+6vcW+w0gcDo44YKYD7YIEJNHDjg=
+gopkg.in/guregu/null.v4 v4.0.0/go.mod h1:YoQhUrADuG3i9WqesrCmpNRwm1ypAgSHYqoOcTu/JrI=
+gopkg.in/yaml.v3 v3.0.0 h1:hjy8E9ON/egN1tAYqKb61G10WtihqetD4sz2H+8nIeA=
+gopkg.in/yaml.v3 v3.0.0/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=
+honnef.co/go/tools v0.5.1 h1:4bH5o3b5ZULQ4UrBmP+63W9r7qIkqJClEA9ko5YKx+I=
+honnef.co/go/tools v0.5.1/go.mod h1:e9irvo83WDG9/irijV44wr3tbhcFeRnfpVlRqVwpzMs=
+mvdan.cc/gofumpt v0.7.0 h1:bg91ttqXmi9y2xawvkuMXyvAA/1ZGJqYAEGjXuP0JXU=
+mvdan.cc/gofumpt v0.7.0/go.mod h1:txVFJy/Sc/mvaycET54pV8SW8gWxTlUuGHVEcncmNUo=
+mvdan.cc/xurls/v2 v2.5.0 h1:lyBNOm8Wo71UknhUs4QTFUNNMyxy2JEIaKKo0RWOh+8=
+mvdan.cc/xurls/v2 v2.5.0/go.mod h1:yQgaGQ1rFtJUzkmKiHYSSfuQxqfYmd//X6PxvholpeE=
--- a/app/main.go
+++ b/app/main.go
@@ -0,0 +1,43 @@
+// Receive and send information about servers
+package main
+
+import (
+	h "infra-dashboard/Http"
+	tools "infra-dashboard/Tools"
+	"log"
+	"net/http"
+
+	"github.com/gorilla/mux"
+)
+
+func main() {
+	tools.InitLog()
+
+	router := mux.NewRouter()
+
+	router.NotFoundHandler = http.HandlerFunc(h.NotFound)
+
+	router.HandleFunc("/", h.RequestHandler).Methods("GET")
+	router.HandleFunc("/healthcheck", h.HealthHandler)
+	router.HandleFunc("/os", h.GetOS).Methods("GET")
+	router.HandleFunc("/os/{id:[0-9]+}", h.GetOSbyID).Methods("GET")
+	router.HandleFunc("/os/create", h.CreateOS).Methods("POST")
+	router.HandleFunc("/os/distribution", h.GetDistributionList).Methods("GET")
+	router.HandleFunc("/os/distribution/{distribution:[a-zA-Z]+}/versions", h.GetVersionsByDistributionList).Methods("GET")
+	router.HandleFunc("/os/delete", h.DeleteOS).Methods("DELETE")
+
+	router.HandleFunc("/servers", h.GetServersList).Methods("GET")
+	router.HandleFunc("/server/{id:[0-9]+}", h.GetServersbyID).Methods("GET")
+	router.HandleFunc("/server/os/{os_id:[0-9]+}", h.GetServersbyOS).Methods("GET")
+	router.HandleFunc("/server/create", h.CreateServer).Methods("POST")
+	router.HandleFunc("/server/delete", h.DeleteServer).Methods("DELETE")
+
+	router.HandleFunc("/packages", h.GetAllPackages).Methods("GET")
+	router.HandleFunc("/packages/create", h.CreatePackage).Methods("POST")
+	router.HandleFunc("/packages/disable", h.DisablePackage).Methods("POST")
+	router.HandleFunc("/packages/enable", h.EnablePackage).Methods("POST")
+	router.HandleFunc("/packages/delete", h.DeletePackage).Methods("DELETE")
+	router.HandleFunc("/packages/{id:[0-9]+}", h.GetPackagebyID).Methods("GET")
+
+	log.Fatal(http.ListenAndServe(":8080", router))
+}