changed how url is consructed in LaunchPeerExecution by placing meth after peer url + dt

models/peer/peer_cache.go

@@ -4,6 +4,7 @@ import (
 	"encoding/json"
 	"errors"
 	"fmt"
+	"regexp"
 	"strings"
 
 	"cloud.o-forge.io/core/oc-lib/tools"
@@ -31,7 +32,7 @@ type PeerCache struct {
 func (p *PeerCache) urlFormat(hostUrl string, dt tools.DataType) string {
 	// localhost is replaced by the local peer URL
 	// because localhost must collide on a web request security protocol
-	/*localhost := ""
+	localhost := ""
 	if strings.Contains(hostUrl, "localhost") {
 		localhost = "localhost"
 	}
@@ -46,10 +47,10 @@ func (p *PeerCache) urlFormat(hostUrl string, dt tools.DataType) string {
 		} else {
 			hostUrl = strings.ReplaceAll(hostUrl, localhost, dt.API()+":8080/oc")
 		}
-	} else {*/
+	} else {
-	hostUrl = hostUrl + "/" + strings.ReplaceAll(dt.API(), "oc-", "")
+		hostUrl = hostUrl + "/" + strings.ReplaceAll(dt.API(), "oc-", "")
-	//}
+	}
-	fmt.Println("Contacting", hostUrl)
+	fmt.Println("Host URL : ", hostUrl)
 	return hostUrl
 }
 
@@ -69,16 +70,15 @@ func (p *PeerCache) checkPeerStatus(peerID string, appName string) (*Peer, bool)
 }
 
 // LaunchPeerExecution launches an execution on a peer
-// The method contacts the path described by : peer.Url + datatype path (from enums) + replacement of id by dataID
 func (p *PeerCache) LaunchPeerExecution(peerID string, dataID string,
 	dt tools.DataType, method tools.METHOD, body interface{}, caller *tools.HTTPCaller) (*PeerExecution, error) {
 	fmt.Println("Launching peer execution on", caller.URLS, dt, method)
 	methods := caller.URLS[dt] // Get the methods url of the data type
 	if m, ok := methods[method]; !ok || m == "" {
-		return nil, errors.New("Requested method " + method.String() + " not declared in HTTPCaller")
+		return nil, errors.New("no path found")
 	}
-	path := methods[method]                        // Get the path corresponding to the action we want to execute
+	meth := methods[method]                        // Get the method url to execute
-	path = strings.ReplaceAll(path, ":id", dataID) // Replace the id in the path in case of a DELETE / UPDATE method (it's a standard naming in OC)
+	meth = strings.ReplaceAll(meth, ":id", dataID) // Replace the id in the url in case of a DELETE / UPDATE method (it's a standard naming in OC)
 	url := ""
 
 	// Check the status of the peer
@@ -86,7 +86,7 @@ func (p *PeerCache) LaunchPeerExecution(peerID string, dataID string,
 		// If the peer is not reachable, add the execution to the failed executions list
 		pexec := &PeerExecution{
 			Method:   method.String(),
-			Url:      p.urlFormat((mypeer.Url), dt) + path,  // the url is constitued of : host URL + resource path + action path (ex : mypeer.com/datacenter/resourcetype/path/to/action)
+			Url:      p.urlFormat((mypeer.Url), dt) + meth,
 			Body:     body,
 			DataType: dt.EnumIndex(),
 			DataID:   dataID,
@@ -99,7 +99,7 @@ func (p *PeerCache) LaunchPeerExecution(peerID string, dataID string,
 			return nil, errors.New("peer not found")
 		}
 		// If the peer is reachable, launch the execution
-		url = p.urlFormat((mypeer.Url), dt) + path       // Format the URL
+		url = p.urlFormat((mypeer.Url), dt) + meth       // Format the URL
 		tmp := mypeer.FailedExecution                  // Get the failed executions list
 		mypeer.FailedExecution = []PeerExecution{}     // Reset the failed executions list
 		NewShallowAccessor().UpdateOne(mypeer, peerID) // Update the peer in the db

tools/enums.go

@@ -39,7 +39,7 @@ var ADMIRALTY_SOURCEAPI = DATACENTERAPI+"/admiralty/source"
 var ADMIRALTY_TARGETAPI = DATACENTERAPI+"/admiralty/target"
 var ADMIRALTY_SECRETAPI = DATACENTERAPI+"/admiralty/secret"
 var ADMIRALTY_KUBECONFIGAPI = DATACENTERAPI+"/admiralty/kubeconfig"
-var ADMIRALTY_NODESAPI = DATACENTERAPI+"/admiralty/node"
+var ADMIRALTY_NODESAPI = DATACENTERAPI+"/admiralty/nodes"
 
 // Bind the standard API name to the data type
 var DefaultAPI = [...]string{

tools/remote_caller.go

@@ -3,7 +3,6 @@ package tools
 import (
 	"bytes"
 	"encoding/json"
-	"fmt"
 	"io"
 	"net/http"
 	"net/url"
@@ -50,9 +49,8 @@ func ToMethod(str string) METHOD {
 var HTTPCallerInstance = &HTTPCaller{} // Singleton instance of the HTTPCaller
 
 type HTTPCaller struct {
-	URLS     	map[DataType]map[METHOD]string 	// Map of the different methods and their urls
+	URLS     map[DataType]map[METHOD]string // Map of the different methods and their urls
-	Disabled 	bool                           	// Disabled flag
+	Disabled bool                           // Disabled flag
-	LastResults map[string]interface{}			// Used to store information regarding the last execution of a given method on a given data type
 }
 
 // NewHTTPCaller creates a new instance of the HTTP Caller
@@ -78,33 +76,17 @@ func (caller *HTTPCaller) CallGet(url string, subpath string, types ...string) (
 		return nil, err
 	}
 	defer resp.Body.Close()
-	err = caller.StoreResp(resp)
+	return io.ReadAll(resp.Body)
-	if err != nil {
-		return nil, err
-	}
-
-	return caller.LastResults["body"].([]byte), nil
 }
 
 // CallPut calls the DELETE method on the HTTP server
 func (caller *HTTPCaller) CallDelete(url string, subpath string) ([]byte, error) {
-	req, err := http.NewRequest("DELETE", url+subpath, nil)
+	resp, err := http.NewRequest("DELETE", url+subpath, nil)
-	if err != nil {
+	if err != nil || resp == nil || resp.Body == nil {
-		return nil, err
-	}
-	client := &http.Client{}
-	resp, err := client.Do(req)
-	if err != nil || req == nil || req.Body == nil {
 		return nil, err
 	}
 	defer resp.Body.Close()
-
+	return io.ReadAll(resp.Body)
-	err = caller.StoreResp(resp)
-	if err != nil {
-		return nil, err
-	}
-
-	return caller.LastResults["body"].([]byte), nil
 }
 
 // CallPost calls the POST method on the HTTP server
@@ -123,12 +105,7 @@ func (caller *HTTPCaller) CallPost(url string, subpath string, body interface{},
 		return nil, err
 	}
 	defer resp.Body.Close()
-	err = caller.StoreResp(resp)
+	return io.ReadAll(resp.Body)
-	if err != nil {
-		return nil, err
-	}
-
-	return caller.LastResults["body"].([]byte), nil
 }
 
 // CallPost calls the POST method on the HTTP server
@@ -146,12 +123,7 @@ func (caller *HTTPCaller) CallPut(url string, subpath string, body map[string]in
 		return nil, err
 	}
 	defer resp.Body.Close()
-	err = caller.StoreResp(resp)
+	return io.ReadAll(resp.Body)
-	if err != nil {
-		return nil, err
-	}
-
-	return caller.LastResults["body"].([]byte), nil
 }
 
 // CallRaw calls the Raw method on the HTTP server
@@ -171,12 +143,7 @@ func (caller *HTTPCaller) CallRaw(method string, url string, subpath string,
 		req.AddCookie(c)
 	}
 	client := &http.Client{}
-	resp, err := client.Do(req)
+	return client.Do(req)
-	if err != nil {
-		return nil, err
-	}
-
-	return resp, nil
 }
 
 // CallRaw calls the Raw method on the HTTP server
@@ -196,17 +163,3 @@ func (caller *HTTPCaller) CallForm(method string, url string, subpath string,
 	client := &http.Client{}
 	return client.Do(req)
 }
-
-func (caller *HTTPCaller) StoreResp(resp *http.Response) error {
-	caller.LastResults = make(map[string]interface{})
-	caller.LastResults["header"] = resp.Header
-	caller.LastResults["code"] = resp.StatusCode
-	data, err := io.ReadAll(resp.Body)
-	if err != nil {
-		fmt.Println("Error reading the body of the last request")
-		return err
-	}
-
-	caller.LastResults["body"] = data
-	return nil
-}