admin.go

package main

import (
	"encoding/json"
	"fmt"
	"net/http"
	"strings"
)

// Method to Explicitly Admin removes a server
func (sp *ServerPool) removeServer(rawURL string) bool {
	sp.mux.Lock()
	defer sp.mux.Unlock()
	if _, ok := sp.backends[rawURL]; ok {
		delete(sp.backends, rawURL)
		return true
	}
	return false
}

// Method to explicitly return all the server (thread safe)
func (sp *ServerPool) getServers() []*Server {
	sp.mux.RLock()
	defer sp.mux.RUnlock()
	servers := make([]*Server, 0, len(sp.backends))
	for _, server := range sp.backends {
		servers = append(servers, server)
	}
	return servers
}

// Admin Route handlers and Methods to authenticate admin token

func (h *adminRoutesHandler) AuthenticateAdmin(w http.ResponseWriter, r *http.Request) bool {
	authHeader := r.Header.Get("Authorization")
	parts := strings.SplitN(authHeader, " ", 2)
	
	if len(parts) == 2 && parts[0] == "Bearer" {
        token := parts[1]
		// Take the token

		if strings.Compare(h.adminToken, token) == 0 {
			return true
		} else {
			w.WriteHeader(http.StatusBadRequest)
			fmt.Printf("Inavlid Admin token %s", token)
    		http.Error(w, "Invalid Authorization header", http.StatusUnauthorized)
			return false			
		}
    } else {
        http.Error(w, "Missing or invalid Authorization header", http.StatusUnauthorized)
        return false
    }

}

type serverData struct {
	URL string
	Weight int64
}

// Encoder to send any json, decoder to recieve any json from the body or whatever 

func (h *adminRoutesHandler) CreateAServer(w http.ResponseWriter, r *http.Request) {
	if r.URL.Path != "/admin/servers" {
		http.NotFound(w, r)
		return
	}

	var backend BackendConfig
	err := json.NewDecoder(r.Body).Decode(&backend);
	// Decoded and stored into the var backend (a new server)

	if err != nil {
		http.Error(w, "invalid body", http.StatusBadRequest)
		return
	}

	if backend.URL == "" {
		http.Error(w, "url is required", http.StatusBadRequest)
		return
	}

	h.serverPool.addServer(backend.URL, int64(backend.Weight))
	w.WriteHeader(http.StatusCreated)
	fmt.Fprintf(w, "server %s added\n", backend.URL)
}

func (h *adminRoutesHandler) DeleteAServer(w http.ResponseWriter, r *http.Request) {
	if !strings.HasPrefix(r.URL.Path, "/admin/servers/") {
		http.NotFound(w, r)
		return
	}
	serverURL := r.PathValue("url")
	// want to delete this one h.serverPool[serverURL]

	if !h.serverPool.removeServer(serverURL) {
		http.Error(w, "Server is invalid", http.StatusBadRequest)
		return
	}

	w.WriteHeader(http.StatusCreated)
	fmt.Printf("The Server %s has been deleted", serverURL)
}


func (h *adminRoutesHandler) GetAllServerAdmin(w http.ResponseWriter, r *http.Request) {
	if r.URL.Path != "/admin/servers" {
		http.NotFound(w, r)
		return
	}

	var backends []*Server
	backends = h.serverPool.getServers()
	
	servers := make([]serverData, 0)
	for _, backend := range backends {
		servers = append(servers, serverData{URL: backend.URL, Weight: backend.Weight})
	}

	if err := json.NewEncoder(w).Encode(servers); err != nil {
		http.Error(w, "Internal Server Error", http.StatusBadRequest)
		fmt.Printf("The error: %s", err)
		return
	}
}