123 lines
2.5 KiB
Go
123 lines
2.5 KiB
Go
package main
|
|
|
|
import (
|
|
"bytes"
|
|
"encoding/json"
|
|
"fmt"
|
|
"io/ioutil"
|
|
"net/http"
|
|
"sync"
|
|
"time"
|
|
)
|
|
|
|
var (
|
|
connCode string
|
|
peers []string
|
|
connCodeMutex sync.Mutex
|
|
)
|
|
|
|
type Message struct {
|
|
ID string `json:"id"`
|
|
Type string `json:"type"`
|
|
Content string `json:"content"`
|
|
}
|
|
|
|
func loadNodeConfig() {
|
|
config := loadConfig()
|
|
connCode = config.ConnectionCode
|
|
peers = config.Peers
|
|
}
|
|
|
|
func handleNodeRequest(w http.ResponseWriter, r *http.Request) {
|
|
if r.Method != http.MethodPost {
|
|
http.Error(w, "Invalid request method", http.StatusMethodNotAllowed)
|
|
return
|
|
}
|
|
|
|
connCodeMutex.Lock()
|
|
defer connCodeMutex.Unlock()
|
|
|
|
body, err := ioutil.ReadAll(r.Body)
|
|
if err != nil {
|
|
http.Error(w, "Error reading request body", http.StatusInternalServerError)
|
|
return
|
|
}
|
|
defer r.Body.Close()
|
|
|
|
var msg Message
|
|
if err := json.Unmarshal(body, &msg); err != nil {
|
|
http.Error(w, "Error parsing JSON", http.StatusBadRequest)
|
|
return
|
|
}
|
|
|
|
if msg.ID != connCode {
|
|
http.Error(w, "Authentication failed", http.StatusUnauthorized)
|
|
return
|
|
}
|
|
|
|
interpretMessage(msg)
|
|
fmt.Fprintln(w, "Message received")
|
|
}
|
|
|
|
func interpretMessage(msg Message) {
|
|
switch msg.Type {
|
|
case "test":
|
|
fmt.Println("Received test message:", msg.Content)
|
|
case "get-version":
|
|
fmt.Println("Received get-version message")
|
|
// Handle get-version logic here
|
|
case "update":
|
|
fmt.Println("Received update message:", msg.Content)
|
|
// Handle update logic here
|
|
go update()
|
|
default:
|
|
fmt.Println("Received unknown message type:", msg.Type)
|
|
}
|
|
}
|
|
|
|
func sendMessage(address, id, msgType, content string) error {
|
|
msg := Message{
|
|
ID: id,
|
|
Type: msgType,
|
|
Content: content,
|
|
}
|
|
msgBytes, err := json.Marshal(msg)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
req, err := http.NewRequest(http.MethodPost, fmt.Sprintf("%s/node", address), bytes.NewBuffer(msgBytes))
|
|
if err != nil {
|
|
return err
|
|
}
|
|
req.Header.Set("Content-Type", "application/json")
|
|
|
|
client := &http.Client{}
|
|
resp, err := client.Do(req)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
defer resp.Body.Close()
|
|
|
|
if resp.StatusCode != http.StatusOK {
|
|
body, _ := ioutil.ReadAll(resp.Body)
|
|
return fmt.Errorf("failed to send message: %s", body)
|
|
}
|
|
|
|
return nil
|
|
}
|
|
|
|
func startNodeClient(addresses []string) {
|
|
for _, address := range addresses {
|
|
go func(addr string) {
|
|
for {
|
|
err := sendMessage(addr, connCode, "test", "This is a test message")
|
|
if err != nil {
|
|
fmt.Println("Error sending test message to", addr, ":", err)
|
|
continue
|
|
}
|
|
time.Sleep(10 * time.Second)
|
|
}
|
|
}(address)
|
|
}
|
|
}
|