http.go

package gosdn

import (
	"context"
	"fmt"
	"io"
	"net/http"
	"net/url"
	"time"

	"code.fbi.h-da.de/cocsn/gosdn/forks/goarista/gnmi"
	"code.fbi.h-da.de/cocsn/gosdn/nucleus"
	"code.fbi.h-da.de/cocsn/gosdn/nucleus/errors"
	"code.fbi.h-da.de/cocsn/gosdn/nucleus/types"

	"github.com/google/uuid"

	gpb "github.com/openconfig/gnmi/proto/gnmi"
	log "github.com/sirupsen/logrus"
)

var apiOpmap = map[string]types.Operation{
	"update":  types.TransportUpdate,
	"replace": types.TransportReplace,
	"delete":  types.TransportDelete,
}

func stopHttpServer() error {
	ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
	defer cancel()
	log.Info("shutting down http server")
	return c.httpServer.Shutdown(ctx)
}

func registerHttpHandler() {
	defer func() {
		if r := recover(); r != nil {
			fmt.Println("Recovered in f", r)
		}
	}()
	http.HandleFunc("/api", httpApi)
	http.HandleFunc("/livez", healthCheck)
	http.HandleFunc("/readyz", readynessCheck)
}

func startHttpServer() {
	registerHttpHandler()
	c.httpServer = &http.Server{Addr: ":8080"}
	go func() {
		log.Info(c.httpServer.ListenAndServe())
	}()
}

func healthCheck(writer http.ResponseWriter, request *http.Request) {
	writer.WriteHeader(http.StatusOK)
}

func readynessCheck(writer http.ResponseWriter, request *http.Request) {
	writer.WriteHeader(http.StatusOK)
}

// deprecated
// nolint
func httpApi(writer http.ResponseWriter, request *http.Request) {
	log.WithFields(log.Fields{
		"request": request,
	}).Debug("incoming request")

	query, err := url.ParseQuery(request.URL.RawQuery)
	if err != nil {
		log.Error(err)
		writer.WriteHeader(http.StatusBadRequest)
		return
	}

	id, err := uuid.Parse(query.Get("uuid"))
	if err != nil {
		if err.Error() != "invalid UUID length: 0" {
			log.Error(err)
		}
	}

	pid, err := uuid.Parse(query.Get("pnd"))
	if err != nil {
		if err.Error() != "invalid UUID length: 0" {
			log.Error(err)
		}
	}

	sid, err := uuid.Parse(query.Get("sbi"))
	if err != nil {
		if err.Error() != "invalid UUID length: 0" {
			log.Error(err)
		}
	}

	var httpPnd nucleus.PrincipalNetworkDomain
	var httpSbi nucleus.SouthboundInterface
	if query.Get("q") != "init" && query.Get("q") != "getIDs" {
		httpPnd, err = c.pndc.Get(pid)
		if err != nil {
			handleServerError(writer, err)
			return
		}
		sbic := httpPnd.GetSBIs()
		httpSbi, err = sbic.(*nucleus.SbiStore).Get(sid)
		if err != nil {
			handleServerError(writer, err)
			return
		}
	}

	switch q := query.Get("q"); q {
	case "addDevice":
		d, err := nucleus.NewDevice(httpSbi, &nucleus.GnmiTransportOptions{
			Config: gnmi.Config{
				Addr:     query.Get("address"),
				Password: query.Get("password"),
				Username: query.Get("username"),
				Encoding: gpb.Encoding_JSON_IETF,
			},
			SetNode:   httpSbi.SetNode(),
			Unmarshal: httpSbi.(*nucleus.OpenConfig).Unmarshal(),
			RespChan:  make(chan *gpb.SubscribeResponse),
		},
			query.Get("name"),
		)
		if err != nil {
			writer.WriteHeader(http.StatusInternalServerError)
			log.Error(err)

			return
		}

		err = httpPnd.AddDevice(d)
		if err != nil {
			writer.WriteHeader(http.StatusInternalServerError)
			log.Error(err)

			return
		}
		writer.WriteHeader(http.StatusCreated)
		fmt.Fprintf(writer, "device added\n")
		fmt.Fprintf(writer, "Name: %s\n", d.Name)
		fmt.Fprintf(writer, "UUID: %v\n", d.UUID)
	case "request":
		err = httpPnd.Request(id, query.Get("path"))
		if err != nil {
			switch err.(type) {
			case *errors.ErrNotFound:
				writer.WriteHeader(http.StatusNotFound)
			default:
				writer.WriteHeader(http.StatusInternalServerError)
			}
			log.Error(err)
			return
		}
		writer.WriteHeader(http.StatusOK)
	case "requestAll":
		err = httpPnd.RequestAll(query.Get("path"))
		if err != nil {
			switch err.(type) {
			case *errors.ErrNotFound:
				writer.WriteHeader(http.StatusNotFound)
			default:
				writer.WriteHeader(http.StatusInternalServerError)
			}
			log.Error(err)
			return
		}
		writer.WriteHeader(http.StatusOK)
	case "getDevice":
		deviceIdentifier := query.Get("identifier")

		device, err := httpPnd.MarshalDevice(deviceIdentifier)
		if err != nil {
			switch err.(type) {
			case *errors.ErrNotFound:
				writer.WriteHeader(http.StatusNotFound)
			default:
				writer.WriteHeader(http.StatusInternalServerError)
			}
			log.Error(err)

			return
		}

		writer.Header().Set("Content-Type", "application/json")
		fmt.Fprintf(writer, "%v", device)

	case "getIDs":

		pnds := c.pndc.UUIDs()
		writeIDs(writer, "PNDs", pnds)
		writeIDs(writer, "SBIs", c.sbic.UUIDs())
		for _, id := range pnds {
			p, err := c.pndc.Get(id)
			if err != nil {
				handleServerError(writer, err)
				return
			}
			writeIDs(writer, "Devices", p.Devices())
		}
	case "init":
		writeIDs(writer, "PNDs", c.pndc.UUIDs())
		writeIDs(writer, "SBIs", c.sbic.UUIDs())
	case "update", "replace":
		if err := httpPnd.ChangeOND(id, apiOpmap[q], query.Get("path"), query.Get("value")); err != nil {
			handleServerError(writer, err)
			return
		}
		writer.WriteHeader(http.StatusOK)
	case "delete":
		if err := httpPnd.ChangeOND(id, types.TransportDelete, query.Get("path")); err != nil {
			handleServerError(writer, err)
			return
		}
		writer.WriteHeader(http.StatusOK)
	case "change-list":
		changes := httpPnd.Committed()
		writeIDs(writer, "Tentative changes", changes)
	case "change-list-pending":
		changes := httpPnd.Pending()
		writeIDs(writer, "Pending changes", changes)
	case "change-commit":
		cuid, err := uuid.Parse(query.Get("cuid"))
		if err != nil {
			handleServerError(writer, err)
			return
		}
		if err := httpPnd.Commit(cuid); err != nil {
			handleServerError(writer, err)
			return
		}
		writer.WriteHeader(http.StatusAccepted)
	case "change-confirm":
		cuid, err := uuid.Parse(query.Get("cuid"))
		if err != nil {
			handleServerError(writer, err)
			return
		}
		if err := httpPnd.Confirm(cuid); err != nil {
			handleServerError(writer, err)
			return
		}
		writer.WriteHeader(http.StatusAccepted)
	default:
		writer.WriteHeader(http.StatusBadRequest)
	}
}

func writeIDs(w io.Writer, typ string, ids []uuid.UUID) {
	fmt.Fprintf(w, "%v:\n", typ)
	for i, id := range ids {
		fmt.Fprintf(w, "%v: %v\n", i+1, id)
	}
}

func handleServerError(w http.ResponseWriter, err error) {
	w.WriteHeader(http.StatusInternalServerError)
	fmt.Fprintf(w, "error: %v", err)
	log.Error(err)
}