fedilogue/fedilogue/ctl.go

package main

import (
	"encoding/json"
	"fmt"
	"io/ioutil"
	"log"
	"net/http"

	"gitlab.com/khanzf/fedilogue/shared"
)

func cmdFollow(w http.ResponseWriter, r *http.Request) {
	body, err := ioutil.ReadAll(r.Body)
	if err != nil {
		fmt.Println(err)
		return
	}
	defer r.Body.Close()

	var commandmap shared.CommandMap
	err = json.Unmarshal(body, &commandmap)
	if err != nil {
		logWarn("Unable to unmarshal here, exiting...")
		return
	}
	go followInbox(commandmap.Endpoint)

	fmt.Fprintf(w, "{}")
}

func startctl() {
	http.HandleFunc("/follow", cmdFollow)
	log.Print("Starting HTTP inbox on port 127.0.0.1:5555")
	log.Fatal(http.ListenAndServe("127.0.0.1:5555", nil))

}

/*
func handleClient(commandClient net.Conn) {
	defer commandClient.Close()
	sizebyte := make([]byte, 4)
	var commandmap shared.CommandMap
	var responseback shared.ResponseBack
	n, err := io.ReadFull(commandClient, sizebyte)
	if err != nil {
		logFatal.Fatal("Read error: ", err)
		return
	}
	if n != 4 {
		logFatal.Fatal("Did not read 4 bytes, failure.")
		return
	}
	jsonsize := int(binary.LittleEndian.Uint32(sizebyte))
	jsonbyte := make([]byte, jsonsize)
	n, err = io.ReadFull(commandClient, jsonbyte)
	if err != nil {
		logFatal.Fatal("Unable to unmarshal")
	}
	if n != jsonsize {
		logFatal.Fatal("Failed to read json size of ", n)
	}

	err = json.Unmarshal(jsonbyte, &commandmap)
	if err != nil {
		logFatal.Fatal("Unable to unmarshal")
	}

	switch commandmap.Type {
	case "status":
		responseback.Message = "Ok"
	case "add":
		logConn("Manually added instance: " + commandmap.Endpoint)
		//ri_mutex.Lock()
		_, exists := GetRunner(commandmap.Endpoint)
		if exists == true {
			logConn("Already exists: " + commandmap.Endpoint)
			responseback.Message = "Exists: " + commandmap.Endpoint
		} else {
			responseback.Message = "Adding: " + commandmap.Endpoint
			ri_mutex.Lock()
			go StartInstance(commandmap.Endpoint)
			ri_mutex.Unlock()
		}
		//ri_mutex.Unlock()
	case "follow":
		logInfo("Follow handling...")
		responseback.Message = "Trying to follow " + commandmap.Endpoint
		go followInbox(commandmap.Endpoint)
	case "suspend":
		logFatal.Fatal("Suspend")
	case "resume":
		logFatal.Fatal("Resume")
	default:
		logFatal.Fatal("Something else")
	}

	responseback.Type = "status"
	responseback.RunningInstances = runninginstances

	ri_mutex.Lock()
	responsebytes, err := json.Marshal(responseback)
	ri_mutex.Unlock()
	if err != nil {
		logFatal.Fatal(err)
	}

	n = len(responsebytes)
	binary.LittleEndian.PutUint32(sizebyte, uint32(n))

	_, err = commandClient.Write(sizebyte)
	if err != nil {
		logFatal.Fatal("Error on write:", err)
	}

	ri_mutex.Lock()
	responsebyte, err := json.Marshal(responseback)
	ri_mutex.Unlock()
	if err != nil {
		logFatal.Fatal("Error response back: ", err)
	}

	_, err = commandClient.Write(responsebyte)
	if err != nil {
		logFatal.Fatal("Error on write:", err)
	}
}
*/