virtigod/http.go

package main

import (
	"errors"
	"fmt"
	"io/ioutil"
	"net/http"
	"os"
	"strings"

	"go.wit.com/lib/gui/shell"
	"go.wit.com/lib/virtigolib"
	pb "go.wit.com/lib/protobuf/virtbuf"
	"go.wit.com/log"
	"libvirt.org/go/libvirtxml"
)

// remove '?' part and trailing '/'
func cleanURL(url string) string {
	url = "/" + strings.Trim(url, "/")
	return url
}

func okHandler(w http.ResponseWriter, r *http.Request) {
	var tmp string

	log.Info("Got URL Path: ", r.URL.Path)
	log.Info("Got URL Query:", r.URL.Query().Get("start"))

	tmp = cleanURL(r.URL.Path)

	msg, err := ioutil.ReadAll(r.Body) // Read the body as []byte
	if err != nil {
		fmt.Fprintln(w, "ReadAll() error =", err)
		return
	}

	log.Info("Got URL msg:", string(msg))
	log.Info("Got URL jcarr2 tmp:", tmp)
	if tmp == "/" {
		fmt.Fprintln(w, "OK")
		return
	}

	// exit the virtigo daemon & have systemd restart it
	// this can happen & when it does, access to
	// to libvirtd will hang (aka: virsh list will hang)
	// One way to trigger this is to not properly close
	// domain sockets opened from go-qemu/hypervisor
	// it's a good idea in any case so leave it here
	if tmp == "/kill" {
		log.Warn("KILLED")
		fmt.Fprintln(w, "KILLED")
		os.Exit(-1)
		return
	}

	if tmp == "/vms" {
		s := pollHypervisor(me.hv)
		fmt.Fprint(w, s)
		return
	}

	if tmp == "/import" {
		domname := r.URL.Query().Get("import")
		fmt.Fprint(w, "import domain:", domname)

		xmldoc, err := virshDumpXML(w, r, domname)

		domcfg := &libvirtxml.Domain{}
		err = domcfg.Unmarshal(xmldoc)
		if err != nil {
			fmt.Fprintln(w, "domain.Unmarshal XML failed")
			fmt.Fprintln(w, "error =", err)
			return
		}
		// importDomain(w, r, domcfg)
		// importDomain(w http.ResponseWriter, r *http.Request, dom *libvirtxml.Domain) {
		d, _, err := virtigolib.ImportXML(domcfg)
		if err != nil {
			fmt.Fprintln(w, "ImportXML failed for", domname, err)
			return
		}
		fmt.Fprintln(w, "ImportXML worked for", domname)
		fmt.Fprintln(w, "should send the protobuf to virtigo here", domname)
		d.Current.FullXml = xmldoc
		return
	}

	if tmp == "/cluster" {
		log.Info("/cluster jcarr actually doing START")
		fmt.Fprintln(w, "/cluster jcarr actually doing START")
		var c *pb.Cluster
		c = new(pb.Cluster)

		fmt.Fprintln(w, "cluster len(msg) =", len(msg))
		err = c.UnmarshalJSON(msg)
		if err != nil {
			fmt.Fprintln(w, "cluster dirs failed")
			fmt.Fprintln(w, "error =", err)
		}
		for _, dir := range c.Dirs {
			var found bool = false
			for _, d := range me.dirs {
				if d == dir {
					found = true
				}
			}
			if found {
				log.Info("dir already here", dir)
				fmt.Fprintln(w, "dir already here", dir)
			} else {
				log.Info("append new dir", dir)
				fmt.Fprintln(w, "append new dir", dir)
				me.dirs = append(me.dirs, dir)
			}
		}
		return
	}

	if tmp == "/start" {
		log.Info("/start jcarr actually doing START", me.Hostname)
		fmt.Fprintln(w, "/start jcarr actually doing START", me.Hostname)
		start := r.URL.Query().Get("start")
		xml := "/tmp/" + start + ".xml"
		if shell.Unlink(xml) {
			fmt.Fprintln(w, "START FAILED", me.Hostname)
			fmt.Fprintln(w, "error =", "could not remove existing xml file", xml)
			fmt.Fprintln(w, "error =", "file still exists after unlink")
			return
		}
		// fmt.Fprintln(w, "HTTP:", r.Body)
		var d *pb.Droplet
		d = new(pb.Droplet)
		// msg, err := ioutil.ReadAll(r.Body) // Read the body as []byte
		fmt.Fprintln(w, "/start ReadAll() START")
		fmt.Fprintln(w, "msg =", string(msg))
		fmt.Fprintln(w, "/start ReadAll() END")
		if err != nil {
			fmt.Fprintln(w, "START FAILED", me.Hostname)
			fmt.Fprintln(w, "error =", err)
			return
		}
		fmt.Fprintln(w, "START len(msg) =", len(msg))
		err = d.UnmarshalJSON(msg)
		if d.Hostname == "" {
			fmt.Fprintln(w, "START hostname is blank", me.Hostname)
			log.Info("START hostname is blank")
			return
		}

		if err != nil {
			fmt.Fprintln(w, "START FAILED", me.Hostname)
			fmt.Fprintln(w, "error =", err)
		}

		if err := newStart(start, d); err != nil {
			fmt.Fprintln(w, "START FAILED", me.Hostname)
			fmt.Fprintln(w, "error =", err)
			return
		}
		cmd := []string{"virsh", "create", xml}

		fmt.Fprintln(w, "Handling URL:", tmp, "start droplet")
		log.Warn("cmd :", cmd)

		fmt.Fprintln(w, "Handling URL:", tmp, "start droplet")
		fmt.Fprintln(w, "cmd: ", cmd)
		err, ok, output := shell.RunCmd("/home/", cmd)
		shell.Run(cmd)
		if ok {
			fmt.Fprintln(w, "START OK", me.Hostname)
			fmt.Fprintln(w, output)
		} else {
			fmt.Fprintln(w, "START FAILED", me.Hostname)
			fmt.Fprintln(w, "error =", err)
			fmt.Fprintln(w, "output =", output)
		}
		return
	}

	if tmp == "/favicon.ico" {
		writeFile(w, "ipv6.png")
		return
	}
	if tmp == "/uptime" {
		writeFile(w, "uptime.html")
		return
	}

	// used for uptime monitor checking (like Kuma)
	if tmp == "/uptime" {
		writeFile(w, "uptime.html")
		return
	}
	log.Warn("BAD URL =", tmp)
	fmt.Fprintln(w, "BAD ZOOT")
	// badurl(w, r.URL.String())
	// fmt.Fprintln(w, "BAD", tmp)
}

func writeFile(w http.ResponseWriter, filename string) {
	// fmt.Fprintln(w, "GOT TEST?")
	fullname := "resources/" + filename
	pfile, err := resources.ReadFile(fullname)
	if err != nil {
		log.Println("ERROR:", err)
		// w.Write(pfile)
		return
	}

	var repohtml string
	repohtml = string(pfile)
	if filename == "goReference.svg" {
		w.Header().Set("Content-Type", "image/svg+xml")
	}
	fmt.Fprintln(w, repohtml)
	log.Println("writeFile() found internal file:", filename)
}

// starts and sits waiting for HTTP requests
func startHTTP() {
	http.HandleFunc("/", okHandler)

	p := fmt.Sprintf(":%d", argv.Port)
	log.Println("Running on port", p)

	err := http.ListenAndServe(p, nil)
	if err != nil {
		log.Println("Error starting server:", err)
	}
}

func virshDumpXML(w http.ResponseWriter, r *http.Request, name string) (string, error) {
	cmd := []string{"virsh", "dumpxml", "--security-info", name}

	fmt.Fprintln(w, "virsh dumpxml", name)
	log.Warn("cmd :", cmd)
	fmt.Fprintln(w, "cmd: ", cmd)
	err, ok, output := shell.RunCmd("/home/", cmd)
	shell.Run(cmd)
	if !ok {
		fmt.Fprintln(w, "START FAILED", me.Hostname)
		fmt.Fprintln(w, "error =", err)
		result := fmt.Sprintln("virsh dumpxml failed:", err)
		return output, errors.New(result)
	}
	fmt.Fprintln(w, "START OK", me.Hostname)
	fmt.Fprintln(w, output)
	return output, nil
}