Extend peer http endpoint (#94)

* feature: add peer GET and DELETE API methods

* refactor: extract peer business logic to a separate file

* refactor: extract peer business logic to a separate file

* feature: add peer update HTTP endpoint

* chore: fill peer new fields

* merge with main

* refactor: HTTP methods according to standards

* chore: setup keys POST endpoint without ID

management/server/http/handler/peers.go

@@ -2,24 +2,30 @@ package handler
 
 import (
 	"encoding/json"
+	"github.com/gorilla/mux"
 	log "github.com/sirupsen/logrus"
 	"github.com/wiretrustee/wiretrustee/management/server"
 	"net/http"
 	"time"
 )
 
-// Peers is a handler that returns peers of the account
+//Peers is a handler that returns peers of the account
 type Peers struct {
 	accountManager *server.AccountManager
 }
 
-// PeerResponse is a response sent to the client
+//PeerResponse is a response sent to the client
 type PeerResponse struct {
 	Name      string
 	IP        string
 	Connected bool
 	LastSeen  time.Time
-	Os        string
+	OS        string
+}
+
+//PeerRequest is a request sent by the client
+type PeerRequest struct {
+	Name string
 }
 
 func NewPeers(accountManager *server.AccountManager) *Peers {
@@ -28,6 +34,63 @@ func NewPeers(accountManager *server.AccountManager) *Peers {
 	}
 }
 
+func (h *Peers) updatePeer(accountId string, peer *server.Peer, w http.ResponseWriter, r *http.Request) {
+	req := &PeerRequest{}
+	peerIp := peer.IP
+	err := json.NewDecoder(r.Body).Decode(&req)
+	if err != nil {
+		http.Error(w, err.Error(), http.StatusBadRequest)
+		return
+	}
+	peer, err = h.accountManager.RenamePeer(accountId, peer.Key, req.Name)
+	if err != nil {
+		log.Errorf("failed updating peer %s under account %s %v", peerIp, accountId, err)
+		http.Redirect(w, r, "/", http.StatusInternalServerError)
+		return
+	}
+	writeJSONObject(w, toPeerResponse(peer))
+}
+func (h *Peers) deletePeer(accountId string, peer *server.Peer, w http.ResponseWriter, r *http.Request) {
+	_, err := h.accountManager.DeletePeer(accountId, peer.Key)
+	if err != nil {
+		log.Errorf("failed deleteing peer %s, %v", peer.IP, err)
+		http.Redirect(w, r, "/", http.StatusInternalServerError)
+		return
+	}
+}
+
+func (h *Peers) HandlePeer(w http.ResponseWriter, r *http.Request) {
+	accountId := extractAccountIdFromRequestContext(r)
+	vars := mux.Vars(r)
+	peerId := vars["id"] //effectively peer IP address
+	if len(peerId) == 0 {
+		http.Error(w, "invalid peer Id", http.StatusBadRequest)
+		return
+	}
+
+	peer, err := h.accountManager.GetPeerByIP(accountId, peerId)
+	if err != nil {
+		http.Error(w, "peer not found", http.StatusNotFound)
+		return
+	}
+
+	switch r.Method {
+	case http.MethodDelete:
+		h.deletePeer(accountId, peer, w, r)
+		return
+	case http.MethodPut:
+		h.updatePeer(accountId, peer, w, r)
+		return
+	case http.MethodGet:
+		writeJSONObject(w, toPeerResponse(peer))
+		return
+
+	default:
+		http.Error(w, "", http.StatusNotFound)
+	}
+
+}
+
 func (h *Peers) GetPeers(w http.ResponseWriter, r *http.Request) {
 	switch r.Method {
 	case http.MethodGet:
@@ -39,27 +102,24 @@ func (h *Peers) GetPeers(w http.ResponseWriter, r *http.Request) {
 			http.Redirect(w, r, "/", http.StatusInternalServerError)
 			return
 		}
-		w.WriteHeader(200)
-		w.Header().Set("Content-Type", "application/json")
 
 		respBody := []*PeerResponse{}
 		for _, peer := range account.Peers {
-			respBody = append(respBody, &PeerResponse{
-				Name:      peer.Key,
-				IP:        peer.IP.String(),
-				LastSeen:  time.Now(),
-				Connected: false,
-				Os:        "Ubuntu 21.04 (Hirsute Hippo)",
-			})
-		}
-
-		err = json.NewEncoder(w).Encode(respBody)
-		if err != nil {
-			log.Errorf("failed encoding account peers %s: %v", accountId, err)
-			http.Redirect(w, r, "/", http.StatusInternalServerError)
-			return
+			respBody = append(respBody, toPeerResponse(peer))
 		}
+		writeJSONObject(w, respBody)
+		return
 	default:
 		http.Error(w, "", http.StatusNotFound)
 	}
 }
+
+func toPeerResponse(peer *server.Peer) *PeerResponse {
+	return &PeerResponse{
+		Name:      peer.Name,
+		IP:        peer.IP.String(),
+		Connected: peer.Connected,
+		LastSeen:  peer.LastSeen,
+		OS:        peer.OS,
+	}
+}

management/server/http/handler/setupkeys.go

@@ -43,8 +43,52 @@ func NewSetupKeysHandler(accountManager *server.AccountManager) *SetupKeys {
 	}
 }
 
-func (h *SetupKeys) CreateKey(w http.ResponseWriter, r *http.Request) {
-	accountId := extractAccountIdFromRequestContext(r)
+func (h *SetupKeys) updateKey(accountId string, keyId string, w http.ResponseWriter, r *http.Request) {
+	req := &SetupKeyRequest{}
+	err := json.NewDecoder(r.Body).Decode(&req)
+	if err != nil {
+		http.Error(w, err.Error(), http.StatusBadRequest)
+		return
+	}
+
+	var key *server.SetupKey
+	if req.Revoked {
+		//handle only if being revoked, don't allow to enable key again for now
+		key, err = h.accountManager.RevokeSetupKey(accountId, keyId)
+		if err != nil {
+			http.Error(w, "failed revoking key", http.StatusInternalServerError)
+			return
+		}
+	}
+	if len(req.Name) != 0 {
+		key, err = h.accountManager.RenameSetupKey(accountId, keyId, req.Name)
+		if err != nil {
+			http.Error(w, "failed renaming key", http.StatusInternalServerError)
+			return
+		}
+	}
+
+	if key != nil {
+		writeSuccess(w, key)
+	}
+}
+
+func (h *SetupKeys) getKey(accountId string, keyId string, w http.ResponseWriter, r *http.Request) {
+	account, err := h.accountManager.GetAccount(accountId)
+	if err != nil {
+		http.Error(w, "account doesn't exist", http.StatusInternalServerError)
+		return
+	}
+	for _, key := range account.SetupKeys {
+		if key.Id == keyId {
+			writeSuccess(w, key)
+			return
+		}
+	}
+	http.Error(w, "setup key not found", http.StatusNotFound)
+}
+
+func (h *SetupKeys) createKey(accountId string, w http.ResponseWriter, r *http.Request) {
 	req := &SetupKeyRequest{}
 	err := json.NewDecoder(r.Body).Decode(&req)
 	if err != nil {
@@ -81,50 +125,11 @@ func (h *SetupKeys) HandleKey(w http.ResponseWriter, r *http.Request) {
 	}
 
 	switch r.Method {
-	case http.MethodPost:
-		req := &SetupKeyRequest{}
-		err := json.NewDecoder(r.Body).Decode(&req)
-		if err != nil {
-			http.Error(w, err.Error(), http.StatusBadRequest)
-			return
-		}
-
-		var key *server.SetupKey
-		if req.Revoked {
-			//handle only if being revoked, don't allow to enable key again for now
-			key, err = h.accountManager.RevokeSetupKey(accountId, keyId)
-			if err != nil {
-				http.Error(w, "failed revoking key", http.StatusInternalServerError)
-				return
-			}
-		}
-		if len(req.Name) != 0 {
-			key, err = h.accountManager.RenameSetupKey(accountId, keyId, req.Name)
-			if err != nil {
-				http.Error(w, "failed renaming key", http.StatusInternalServerError)
-				return
-			}
-		}
-
-		if key != nil {
-			writeSuccess(w, key)
-		}
-
+	case http.MethodPut:
+		h.updateKey(accountId, keyId, w, r)
 		return
-
 	case http.MethodGet:
-		account, err := h.accountManager.GetAccount(accountId)
-		if err != nil {
-			http.Error(w, "account doesn't exist", http.StatusInternalServerError)
-			return
-		}
-		for _, key := range account.SetupKeys {
-			if key.Id == keyId {
-				writeSuccess(w, key)
-				return
-			}
-		}
-		http.Error(w, "setup key not found", http.StatusNotFound)
+		h.getKey(accountId, keyId, w, r)
 		return
 	default:
 		http.Error(w, "", http.StatusNotFound)
@@ -132,9 +137,15 @@ func (h *SetupKeys) HandleKey(w http.ResponseWriter, r *http.Request) {
 }
 
 func (h *SetupKeys) GetKeys(w http.ResponseWriter, r *http.Request) {
+
+	accountId := extractAccountIdFromRequestContext(r)
+
 	switch r.Method {
+	case http.MethodPost:
+		h.createKey(accountId, w, r)
+		return
 	case http.MethodGet:
-		accountId := extractAccountIdFromRequestContext(r)
+
 		//new user -> create a new account
 		account, err := h.accountManager.GetOrCreateAccount(accountId)
 		if err != nil {

management/server/http/handler/util.go

@@ -17,6 +17,17 @@ func extractAccountIdFromRequestContext(r *http.Request) string {
 	return claims["sub"].(string)
 }
 
+//writeJSONObject simply writes object to the HTTP reponse in JSON format
+func writeJSONObject(w http.ResponseWriter, obj interface{}) {
+	w.WriteHeader(200)
+	w.Header().Set("Content-Type", "application/json; charset=UTF-8")
+	err := json.NewEncoder(w).Encode(obj)
+	if err != nil {
+		http.Error(w, "failed handling request", http.StatusInternalServerError)
+		return
+	}
+}
+
 //Duration is used strictly for JSON requests/responses due to duration marshalling issues
 type Duration struct {
 	time.Duration