config/conf_loader.go

@@ -26,12 +26,12 @@ import (
 func GetConfLoader() *onion.Onion {
 	logger := zerolog.New(os.Stdout).With().Timestamp().Logger()
 	AppName := GetAppName()
-	EnvPrefix := "OC_"
+	EnvPrefix := strings.ToUpper(AppName[0:2]+AppName[3:]) + "_"
 	defaultConfigFile := "/etc/oc/" + AppName[3:] + ".json"
 	localConfigFile := "./" + AppName[3:] + ".json"
 	var configFile string
 	var o *onion.Onion
-	l3 := GetEnvVarLayer(EnvPrefix)
+	l3 := onion.NewEnvLayerPrefix("_", EnvPrefix)
 	l2, err := onion.NewFileLayer(localConfigFile, nil)
 	if err == nil {
 		logger.Info().Msg("Local config file found " + localConfigFile + ", overriding default file")
@@ -54,17 +54,3 @@ func GetConfLoader() *onion.Onion {
 	}
 	return o
 }
-
-func GetEnvVarLayer(prefix string) onion.Layer {
-	envVars := make(map[string]interface{})
-
-	for _, e := range os.Environ() {
-		pair := strings.SplitN(e, "=", 2)
-		key := pair[0]
-		if strings.HasPrefix(key, prefix) {
-			envVars[strings.TrimPrefix(key, prefix)] = pair[1]
-		}
-	}
-
-	return onion.NewMapLayer(envVars)
-}

models/booking/booking.go

@@ -15,7 +15,7 @@ import (
  */
 type Booking struct {
 	utils.AbstractObject                    // AbstractObject contains the basic fields of an object (id, name)
-	ExecutionsID         string             `json:"executions_id,omitempty" bson:"executions_id,omitempty" validate:"required"` // ExecutionsID is the ID of the executions
+	ExecutionsID         string             `json:"executions_id,omitempty" bson:"executions_id,omitempty"` // ExecutionsID is the ID of the executions
 	DestPeerID           string             `json:"dest_peer_id,omitempty"`                                 // DestPeerID is the ID of the destination peer
 	WorkflowID           string             `json:"workflow_id,omitempty" bson:"workflow_id,omitempty"`     // WorkflowID is the ID of the workflow
 	ExecutionID          string             `json:"execution_id,omitempty" bson:"execution_id,omitempty" validate:"required"`

models/booking/booking_mongo_accessor.go

@@ -51,15 +51,13 @@ func (a *bookingMongoAccessor) CopyOne(data utils.DBObject) (utils.DBObject, int
 
 func (a *bookingMongoAccessor) LoadOne(id string) (utils.DBObject, int, error) {
 	return utils.GenericLoadOne[*Booking](id, func(d utils.DBObject) (utils.DBObject, int, error) {
-		now := time.Now()
+		if d.(*Booking).State == enum.DRAFT && time.Now().UTC().After(d.(*Booking).ExpectedStartDate) {
-		now = now.Add(time.Second * -60)
-		if d.(*Booking).State == enum.DRAFT && now.UTC().After(d.(*Booking).ExpectedStartDate) {
 			return utils.GenericDeleteOne(d.GetID(), a)
 		}
 		if (d.(*Booking).ExpectedEndDate) == nil {
 			d.(*Booking).State = enum.FORGOTTEN
 			utils.GenericRawUpdateOne(d, id, a)
-		} else if d.(*Booking).State == enum.SCHEDULED && now.UTC().After(d.(*Booking).ExpectedStartDate) {
+		} else if d.(*Booking).State == enum.SCHEDULED && time.Now().UTC().After(*&d.(*Booking).ExpectedStartDate) {
 			d.(*Booking).State = enum.DELAYED
 			utils.GenericRawUpdateOne(d, id, a)
 		}
@@ -77,13 +75,11 @@ func (a *bookingMongoAccessor) Search(filters *dbs.Filters, search string, isDra
 
 func (a *bookingMongoAccessor) getExec() func(utils.DBObject) utils.ShallowDBObject {
 	return func(d utils.DBObject) utils.ShallowDBObject {
-		now := time.Now()
+		if d.(*Booking).State == enum.DRAFT && time.Now().UTC().After(d.(*Booking).ExpectedStartDate) {
-		now = now.Add(time.Second * -60)
-		if d.(*Booking).State == enum.DRAFT && now.UTC().After(d.(*Booking).ExpectedStartDate) {
 			utils.GenericDeleteOne(d.GetID(), a)
 			return nil
 		}
-		if d.(*Booking).State == enum.SCHEDULED && now.UTC().After(d.(*Booking).ExpectedStartDate) {
+		if d.(*Booking).State == enum.SCHEDULED && time.Now().UTC().After(*&d.(*Booking).ExpectedStartDate) {
 			d.(*Booking).State = enum.DELAYED
 			utils.GenericRawUpdateOne(d, d.GetID(), a)
 		}

models/peer/peer_cache.go

@@ -4,6 +4,7 @@ import (
 	"encoding/json"
 	"errors"
 	"fmt"
+	"regexp"
 	"strings"
 
 	"cloud.o-forge.io/core/oc-lib/tools"
@@ -28,40 +29,47 @@ type PeerCache struct {
 }
 
 // urlFormat formats the URL of the peer with the data type API function
-func (p *PeerCache) urlFormat(hostUrl string, dt tools.DataType) string {
+func (p *PeerCache) urlFormat(url 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") {
+	if strings.Contains(url, "localhost") {
 		localhost = "localhost"
 	}
-	if strings.Contains(hostUrl, "127.0.0.1") {
+	if strings.Contains(url, "127.0.0.1") {
 		localhost = "127.0.0.1"
 	}
 	if localhost != "" {
 		r := regexp.MustCompile("(" + localhost + ":[0-9]+)")
-		t := r.FindString(hostUrl)
+		t := r.FindString(url)
 		if t != "" {
-			hostUrl = strings.Replace(hostUrl, t, dt.API()+":8080/oc", -1)
+			url = strings.Replace(url, t, dt.API()+":8080/oc", -1)
 		} else {
-			hostUrl = strings.ReplaceAll(hostUrl, localhost, dt.API()+":8080/oc")
+			url = strings.ReplaceAll(url, localhost, dt.API()+":8080/oc")
 		}
-	} else {*/
+	} else {
-	hostUrl = hostUrl + "/" + strings.ReplaceAll(dt.API(), "oc-", "")
+		url = url + "/" + dt.API()
-	//}
+	}
-	fmt.Println("Contacting", hostUrl)
+	return url
-	return hostUrl
 }
 
 // checkPeerStatus checks the status of a peer
-func (p *PeerCache) checkPeerStatus(peerID string, appName string) (*Peer, bool) {
+func (p *PeerCache) checkPeerStatus(peerID string, appName string, caller *tools.HTTPCaller) (*Peer, bool) {
 	api := tools.API{}
 	access := NewShallowAccessor()
 	res, code, _ := access.LoadOne(peerID) // Load the peer from db
 	if code != 200 {                       // no peer no party
 		return nil, false
 	}
-	url := p.urlFormat(res.(*Peer).Url, tools.PEER) + "/status" // Format the URL
+	methods := caller.URLS[tools.PEER] // Get the methods url of the peer
+	if methods == nil {
+		return res.(*Peer), false
+	}
+	meth := methods[tools.POST] // Get the POST method to check status
+	if meth == "" {
+		return res.(*Peer), false
+	}
+	url := p.urlFormat(res.(*Peer).Url, tools.PEER) + meth // Format the URL
 	state, services := api.CheckRemotePeer(url)
 	res.(*Peer).ServicesState = services                              // Update the services states of the peer
 	access.UpdateOne(res, peerID)                                     // Update the peer in the db
@@ -69,24 +77,23 @@ 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
-	if mypeer, ok := p.checkPeerStatus(peerID, dt.API()); !ok && mypeer != nil {
+	if mypeer, ok := p.checkPeerStatus(peerID, dt.API(), caller); !ok && mypeer != nil {
 		// 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)+meth, dt),
 			Body:     body,
 			DataType: dt.EnumIndex(),
 			DataID:   dataID,
@@ -99,7 +106,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)+meth, dt)       // 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

models/resources/resource.go

@@ -89,9 +89,6 @@ func (r *AbstractInstanciatedResource[T]) GetSelectedInstance() utils.DBObject {
 }
 
 func (abs *AbstractInstanciatedResource[T]) SetAllowedInstances(request *tools.APIRequest) {
-	if request != nil && request.PeerID == abs.CreatorID && request.PeerID != "" {
-		return
-	}
 	abs.Instances = verifyAuthAction[T](abs.Instances, request)
 }
 

models/resources/resource_accessor.go

@@ -65,12 +65,6 @@ func (wfa *resourceMongoAccessor[T]) LoadAll(isDraft bool) ([]utils.ShallowDBObj
 }
 
 func (wfa *resourceMongoAccessor[T]) Search(filters *dbs.Filters, search string, isDraft bool) ([]utils.ShallowDBObject, int, error) {
-	if filters == nil && search == "*" {
-		return utils.GenericLoadAll[T](func(d utils.DBObject) utils.ShallowDBObject {
-			d.(T).SetAllowedInstances(wfa.Request)
-			return d
-		}, isDraft, wfa)
-	}
 	return utils.GenericSearch[T](filters, search, wfa.getResourceFilter(search),
 		func(d utils.DBObject) utils.ShallowDBObject {
 			d.(T).SetAllowedInstances(wfa.Request)
@@ -79,6 +73,9 @@ func (wfa *resourceMongoAccessor[T]) Search(filters *dbs.Filters, search string,
 }
 
 func (abs *resourceMongoAccessor[T]) getResourceFilter(search string) *dbs.Filters {
+	if search == "*" {
+		search = ""
+	}
 	return &dbs.Filters{
 		Or: map[string][]dbs.Filter{ // filter by like name, short_description, description, owner, url if no filters are provided
 			"abstractintanciatedresource.abstractresource.abstractobject.name":       {{Operator: dbs.LIKE.String(), Value: search}},

models/utils/abstracts.go

@@ -91,7 +91,7 @@ func (ao *AbstractObject) UpToDate(user string, peer string, create bool) {
 }
 
 func (ao *AbstractObject) VerifyAuth(request *tools.APIRequest) bool {
-	return ao.AccessMode == Public || (request != nil && ao.CreatorID == request.PeerID && request.PeerID != "")
+	return ao.AccessMode == Public || (request != nil && ao.CreatorID == request.PeerID)
 }
 
 func (ao *AbstractObject) GetObjectFilters(search string) *dbs.Filters {

models/workflow/workflow_mongo_accessor.go

@@ -95,7 +95,7 @@ func (a *workflowMongoAccessor) UpdateOne(set utils.DBObject, id string) (utils.
 	if set.(*Workflow).Graph != nil && set.(*Workflow).Graph.Partial {
 		return nil, 403, errors.New("you are not allowed to update a partial workflow")
 	}
-	res, code, err := utils.GenericUpdateOne(set, id, a, &Workflow{})
+	res, code, err := utils.GenericUpdateOne(a.verifyResource(set), id, a, &Workflow{})
 	if code != 200 {
 		return nil, code, err
 	}

models/workflow_execution/workflow_execution_mongo_accessor.go

@@ -60,13 +60,11 @@ func (wfa *workflowExecutionMongoAccessor) CopyOne(data utils.DBObject) (utils.D
 
 func (a *workflowExecutionMongoAccessor) LoadOne(id string) (utils.DBObject, int, error) {
 	return utils.GenericLoadOne[*WorkflowExecution](id, func(d utils.DBObject) (utils.DBObject, int, error) {
-		now := time.Now()
+		if d.(*WorkflowExecution).State == enum.DRAFT && !a.shallow && time.Now().UTC().After(d.(*WorkflowExecution).ExecDate) {
-		now = now.Add(time.Second * -60)
-		if d.(*WorkflowExecution).State == enum.DRAFT && !a.shallow && now.UTC().After(d.(*WorkflowExecution).ExecDate) {
 			utils.GenericDeleteOne(d.GetID(), newShallowAccessor(a.Request))
 			return nil, 404, errors.New("not found")
 		}
-		if d.(*WorkflowExecution).State == enum.SCHEDULED && !a.shallow && now.UTC().After(d.(*WorkflowExecution).ExecDate) {
+		if d.(*WorkflowExecution).State == enum.SCHEDULED && !a.shallow && time.Now().UTC().After(d.(*WorkflowExecution).ExecDate) {
 			d.(*WorkflowExecution).State = enum.FORGOTTEN
 			utils.GenericRawUpdateOne(d, id, newShallowAccessor(a.Request))
 		}
@@ -84,13 +82,11 @@ func (a *workflowExecutionMongoAccessor) Search(filters *dbs.Filters, search str
 
 func (a *workflowExecutionMongoAccessor) getExec() func(utils.DBObject) utils.ShallowDBObject {
 	return func(d utils.DBObject) utils.ShallowDBObject {
-		now := time.Now()
+		if d.(*WorkflowExecution).State == enum.DRAFT && time.Now().UTC().After(d.(*WorkflowExecution).ExecDate) {
-		now = now.Add(time.Second * -60)
-		if d.(*WorkflowExecution).State == enum.DRAFT && now.UTC().After(d.(*WorkflowExecution).ExecDate) {
 			utils.GenericDeleteOne(d.GetID(), newShallowAccessor(a.Request))
 			return nil
 		}
-		if d.(*WorkflowExecution).State == enum.SCHEDULED && now.UTC().After(d.(*WorkflowExecution).ExecDate) {
+		if d.(*WorkflowExecution).State == enum.SCHEDULED && time.Now().UTC().After(d.(*WorkflowExecution).ExecDate) {
 			d.(*WorkflowExecution).State = enum.FORGOTTEN
 			utils.GenericRawUpdateOne(d, d.GetID(), newShallowAccessor(a.Request))
 			return d

models/workflow_execution/workflow_scheduler.go

@@ -118,16 +118,15 @@ func (ws *WorkflowSchedule) Schedules(wfID string, request *tools.APIRequest) (*
 			return ws, wf, executions, errors.New("could not launch the peer execution : " + fmt.Sprintf("%v", err))
 		}
 	}
-	fmt.Println("Schedules")
 	for _, exec := range executions {
 		err := exec.PurgeDraft(request)
 		if err != nil {
 			return ws, nil, []*WorkflowExecution{}, errors.New("purge draft" + fmt.Sprintf("%v", err))
 		}
 		exec.StoreDraftDefault()
-		utils.GenericStoreOne(exec, NewAccessor(request))
+		// Should DELETE the previous execution2
+		fmt.Println(utils.GenericStoreOne(exec, NewAccessor(request)))
 	}
-	fmt.Println("Schedules")
 	return ws, wf, executions, nil
 }
 

models/workspace/workspace_mongo_accessor.go

@@ -72,11 +72,9 @@ func (a *workspaceMongoAccessor) UpdateOne(set utils.DBObject, id string) (utils
 func (a *workspaceMongoAccessor) StoreOne(data utils.DBObject) (utils.DBObject, int, error) {
 	filters := &dbs.Filters{
 		Or: map[string][]dbs.Filter{
-			"abstractobject.name":       {{Operator: dbs.LIKE.String(), Value: data.GetName() + "_workspace"}},
+			"abstractobject.name": {{Operator: dbs.LIKE.String(), Value: data.GetName() + "_workspace"}},
-			"abstractobject.creator_id": {{Operator: dbs.EQUAL.String(), Value: a.GetPeerID()}},
 		},
 	}
-	// filters *dbs.Filters, word string, isDraft bool
 	res, _, err := a.Search(filters, "", true) // Search for the workspace
 	if err == nil && len(res) > 0 {            // If the workspace already exists, return an error
 		return nil, 409, errors.New("a workspace with the same name already exists")

tools/api.go

@@ -115,8 +115,8 @@ func (a *API) SubscribeRouter(infos []*beego.ControllerInfo) {
 // CheckRemotePeer checks the state of a remote peer
 func (a *API) CheckRemotePeer(url string) (State, map[string]int) {
 	// Check if the database is up
-	var resp APIStatusResponse
 	caller := NewHTTPCaller(map[DataType]map[METHOD]string{}) // Create a new http caller
+	var resp APIStatusResponse
 	b, err := caller.CallPost(url, "", map[string]interface{}{}) // Call the status endpoint of the peer
 	if err != nil {
 		return DEAD, map[string]int{} // If the peer is not reachable, return dead

tools/enums.go

@@ -21,11 +21,6 @@ const (
 	WORKSPACE_HISTORY
 	ORDER
 	PURCHASE_RESOURCE
-	ADMIRALTY_SOURCE
-	ADMIRALTY_TARGET
-	ADMIRALTY_SECRET
-	ADMIRALTY_KUBECONFIG
-	ADMIRALTY_NODES
 )
 
 var NOAPI = ""
@@ -35,11 +30,6 @@ var WORKFLOWAPI = "oc-workflow"
 var WORKSPACEAPI = "oc-workspace"
 var PEERSAPI = "oc-peer"
 var DATACENTERAPI = "oc-datacenter"
-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"
 
 // Bind the standard API name to the data type
 var DefaultAPI = [...]string{
@@ -60,11 +50,6 @@ var DefaultAPI = [...]string{
 	NOAPI,
 	NOAPI,
 	NOAPI,
-	ADMIRALTY_SOURCEAPI,
-	ADMIRALTY_TARGETAPI,
-	ADMIRALTY_SECRETAPI,
-	ADMIRALTY_KUBECONFIGAPI,
-	ADMIRALTY_NODESAPI,
 }
 
 // Bind the standard data name to the data type
@@ -86,11 +71,6 @@ var Str = [...]string{
 	"workspace_history",
 	"order",
 	"purchase_resource",
-	"admiralty_source",
-	"admiralty_target",
-	"admiralty_secret",
-	"admiralty_kubeconfig",
-	"admiralty_node",
 }
 
 func FromInt(i int) string {
@@ -111,5 +91,5 @@ func (d DataType) EnumIndex() int {
 }
 
 func DataTypeList() []DataType {
-	return []DataType{DATA_RESOURCE, PROCESSING_RESOURCE, STORAGE_RESOURCE, COMPUTE_RESOURCE, WORKFLOW_RESOURCE, WORKFLOW, WORKFLOW_EXECUTION, WORKSPACE, PEER, COLLABORATIVE_AREA, RULE, BOOKING, WORKFLOW_HISTORY, WORKSPACE_HISTORY, ORDER, PURCHASE_RESOURCE,ADMIRALTY_SOURCE,ADMIRALTY_TARGET,ADMIRALTY_SECRET,ADMIRALTY_KUBECONFIG,ADMIRALTY_NODES}
+	return []DataType{DATA_RESOURCE, PROCESSING_RESOURCE, STORAGE_RESOURCE, COMPUTE_RESOURCE, WORKFLOW_RESOURCE, WORKFLOW, WORKFLOW_EXECUTION, WORKSPACE, PEER, COLLABORATIVE_AREA, RULE, BOOKING, WORKFLOW_HISTORY, WORKSPACE_HISTORY, ORDER, PURCHASE_RESOURCE}
 }

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
-}