Live Structure

models/peer/peer.go

@@ -77,7 +77,7 @@ func (p *Peer) IsMySelf() (bool, string) {
 }
 
 // LaunchPeerExecution launches an execution on a peer
-func (p *Peer) LaunchPeerExecution(peerID string, dataID string, dt tools.DataType, method tools.METHOD, body interface{}, caller *tools.HTTPCaller) (*PeerExecution, error) {
+func (p *Peer) LaunchPeerExecution(peerID string, dataID string, dt tools.DataType, method tools.METHOD, body interface{}, caller *tools.HTTPCaller) (map[string]interface{}, error) {
 	p.UUID = peerID
 	return cache.LaunchPeerExecution(peerID, dataID, dt, method, body, caller) // Launch the execution on the peer through the cache
 }

models/peer/peer_cache.go

@@ -50,11 +50,11 @@ 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.HTTPCallerITF) (*PeerExecution, error) {
+	dt tools.DataType, method tools.METHOD, body interface{}, caller tools.HTTPCallerITF) (map[string]interface{}, error) {
 	fmt.Println("Launching peer execution on", caller.GetUrls(), dt, method)
 	methods := caller.GetUrls()[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 map[string]interface{}{}, errors.New("Requested method " + method.String() + " not declared in HTTPCaller")
 	}
 	path := methods[method]                        // Get the path corresponding to the action we want 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)
@@ -72,10 +72,10 @@ func (p *PeerCache) LaunchPeerExecution(peerID string, dataID string,
 		}
 		mypeer.AddExecution(*pexec)
 		NewShallowAccessor().UpdateOne(mypeer, peerID) // Update the peer in the db
-		return nil, errors.New("peer is " + peerID + " not reachable")
+		return map[string]interface{}{}, errors.New("peer is " + peerID + " not reachable")
 	} else {
 		if mypeer == nil {
-			return nil, errors.New("peer " + peerID + " not found")
+			return map[string]interface{}{}, errors.New("peer " + peerID + " not found")
 		}
 		// If the peer is reachable, launch the execution
 		url = p.urlFormat((mypeer.Url), dt) + path     // Format the URL
@@ -86,11 +86,11 @@ func (p *PeerCache) LaunchPeerExecution(peerID string, dataID string,
 			go p.Exec(v.Url, tools.ToMethod(v.Method), v.Body, caller)
 		}
 	}
-	return nil, p.Exec(url, method, body, caller) // Execute the method
+	return p.Exec(url, method, body, caller) // Execute the method
 }
 
 // exec executes the method on the peer
-func (p *PeerCache) Exec(url string, method tools.METHOD, body interface{}, caller tools.HTTPCallerITF) error {
+func (p *PeerCache) Exec(url string, method tools.METHOD, body interface{}, caller tools.HTTPCallerITF) (map[string]interface{}, error) {
 	var b []byte
 	var err error
 	if method == tools.POST { // Execute the POST method if it's a POST method
@@ -102,16 +102,16 @@ func (p *PeerCache) Exec(url string, method tools.METHOD, body interface{}, call
 	if method == tools.DELETE { // Execute the DELETE method if it's a DELETE method
 		b, err = caller.CallDelete(url, "")
 	}
-	if err != nil {
-		return err
-	}
 	var m map[string]interface{}
+	if err != nil {
+		return m, err
+	}
 	err = json.Unmarshal(b, &m)
 	if err != nil {
-		return err
+		return m, err
 	}
 	if e, ok := m["error"]; ok && e != "<nil>" && e != "" { // Check if there is an error in the response
-		return errors.New(fmt.Sprintf("%v", m["error"]))
+		return m, errors.New(fmt.Sprintf("%v", m["error"]))
 	}
-	return nil
+	return m, nil
 }

models/peer/tests/peer_cache_test.go

@@ -58,7 +58,7 @@ func TestExecSuccess(t *testing.T) {
 	data, _ := json.Marshal(response)
 
 	caller.On("CallPost", url, "", mock.Anything).Return(data, nil)
-	err := cache.Exec(url, tools.POST, map[string]string{"key": "value"}, caller)
+	_, err := cache.Exec(url, tools.POST, map[string]string{"key": "value"}, caller)
 	assert.NoError(t, err)
 	caller.AssertExpectations(t)
 }
@@ -71,7 +71,7 @@ func TestExecReturnsErrorField(t *testing.T) {
 	data, _ := json.Marshal(response)
 
 	caller.On("CallPost", url, "", mock.Anything).Return(data, nil)
-	err := cache.Exec(url, tools.POST, map[string]string{"key": "value"}, caller)
+	_, err := cache.Exec(url, tools.POST, map[string]string{"key": "value"}, caller)
 	assert.Error(t, err)
 	assert.Equal(t, "something failed", err.Error())
 }
@@ -81,7 +81,7 @@ func TestExecInvalidJSON(t *testing.T) {
 	caller := &MockHTTPCaller{}
 	url := "http://mockpeer/resource"
 	caller.On("CallPost", url, "", mock.Anything).Return([]byte("{invalid json}"), nil)
-	err := cache.Exec(url, tools.POST, map[string]string{"key": "value"}, caller)
+	_, err := cache.Exec(url, tools.POST, map[string]string{"key": "value"}, caller)
 	assert.Error(t, err)
 	assert.Contains(t, err.Error(), "invalid character")
 }