controllers/minio.go

@@ -1,7 +1,6 @@
 package controllers
 
 import (
-	"encoding/json"
 	"oc-datacenter/infrastructure"
 
 	oclib "cloud.o-forge.io/core/oc-lib"
@@ -15,36 +14,60 @@ type MinioController struct {
 
 
 // @Title CreateServiceAccounnt
-// @Description Add a new ServiceAccount to a Minio server using its ID and an execution ID and store the secret holding the login in the appropriate namespace
+// @Description Add a new ServiceAccount to a Minio server using its ID and an execution ID
-// @Success 201
+// @Success 200
-// @Param	executions	path	string				true	"The executionsID of the execution"
+// @Param	executions	path	string	true	"The executionsID of the execution"
-// @Param	minioId		path	string				true	"The ID of the Minio you want to reach"
+// @Param	minioId		path	string	true	"The ID of the Minio you want to reach"
-// @Param 	retrieve	body	map[string]string	false	"Should be empty or contain "'retrieve': true"
 // @router	/serviceaccount/:minioId/:executions [post]
 func (m *MinioController) CreateServiceAccount() {
 	_, peerID, _ := oclib.ExtractTokenInfo(*m.Ctx.Request)
 	// This part is solely for dev purposes and should be removed once test on 
 
- 
+
 	executionsId := m.Ctx.Input.Param(":executions")
 	minioId := m.Ctx.Input.Param(":minioId")
 
-	var b map[string]interface{}
-	retrieve := false
-	json.Unmarshal(m.Ctx.Input.CopyBody(10000), &b)
-	if r, ok :=  b["retrieve"]; ok {
-		retrieve = r.(bool)
-	}
-
 	// retrieve the live storage with the minioId 
-	access, secret, ok := m.createServiceAccount(minioId, peerID, executionsId)
+	s := oclib.NewRequest(oclib.LibDataEnum(oclib.STORAGE_RESOURCE), "", "", []string{}, nil).LoadOne(minioId)
-	if !ok {
+	if s.Err != "" {
+		m.Ctx.Output.SetStatus(400)
+		m.Data["json"] = map[string]interface{}{"error": " Could not load the storage resource with id " + minioId + ": " + s.Err}
+		m.ServeJSON()
 		return
 	}
 
-	if retrieve {
+	live := findLiveStorage(minioId, peerID)
-		m.Ctx.Output.SetStatus(201)
+	if live == nil {
-		m.Data["json"] = map[string]string{"access": access, "secret": secret}
+		m.Ctx.Output.SetStatus(404)
+		m.Data["json"] = map[string]interface{}{"error":"could not find the Minio instance " + s.Err}
+		m.ServeJSON()
+		return
+	}	
+	
+	url := live.Source
+	service := infrastructure.NewMinioService(url)
+		
+	// call the method ctrating the svcacc
+	err := service.CreateClient()
+	if err != nil {
+		m.Ctx.Output.SetStatus(500)
+		m.Data["json"] = map[string]interface{}{"error":"could not create the client for " +  minioId + " : " + err.Error()}
+		m.ServeJSON()
+		return	
+	}
+
+	access, secret, err := service.CreateCredentials(executionsId)
+	if err != nil {
+		m.Ctx.Output.SetStatus(500)
+		m.Data["json"] = map[string]interface{}{"error":"could not create the service account for " +  minioId + " : " + err.Error()}
+		m.ServeJSON()
+		return
+	}
+
+	err = service.CreateBucket(executionsId)
+	if err != nil {
+		m.Ctx.Output.SetStatus(500)
+		m.Data["json"] = map[string]interface{}{"error":"could not create the service account for " +  minioId + " : " + err.Error()}
 		m.ServeJSON()
 		return
 	}
@@ -85,55 +108,6 @@ func (m *MinioController) CreateServiceAccount() {
 	m.ServeJSON()
 }
 
-
-
-func (m *MinioController) createServiceAccount(minioId string, peerID string, executionsId string) (string, string, bool) {
-	s := oclib.NewRequest(oclib.LibDataEnum(oclib.STORAGE_RESOURCE), "", "", []string{}, nil).LoadOne(minioId)
-	if s.Err != "" {
-		m.Ctx.Output.SetStatus(400)
-		m.Data["json"] = map[string]interface{}{"error": " Could not load the storage resource with id " + minioId + ": " + s.Err}
-		m.ServeJSON()
-		return "","", false
-	}
-
-	live := findLiveStorage(minioId, peerID)
-	if live == nil {
-		m.Ctx.Output.SetStatus(404)
-		m.Data["json"] = map[string]interface{}{"error": "could not find the Minio instance for " + minioId}
-		m.ServeJSON()
-		return "", "", false
-	}
-
-	url := live.Source
-	service := infrastructure.NewMinioService(url)
-
-	// call the method ctrating the svcacc
-	err := service.CreateClient()
-	if err != nil {
-		m.Ctx.Output.SetStatus(500)
-		m.Data["json"] = map[string]interface{}{"error": "could not create the client for " + minioId + " : " + err.Error()}
-		m.ServeJSON()
-		return "", "", false
-	}
-
-	access, secret, err := service.CreateCredentials(executionsId)
-	if err != nil {
-		m.Ctx.Output.SetStatus(500)
-		m.Data["json"] = map[string]interface{}{"error": "could not create the service account for " + minioId + " : " + err.Error()}
-		m.ServeJSON()
-		return "", "", false
-	}
-
-	err = service.CreateBucket(executionsId)
-	if err != nil {
-		m.Ctx.Output.SetStatus(500)
-		m.Data["json"] = map[string]interface{}{"error": "error while creating the service account for " + minioId + " : " + err.Error()}
-		m.ServeJSON()
-		return "", "", false
-	}
-	return access, secret, true
-}
-
 func findLiveStorage(storageId string, peerId string) *live.LiveStorage {
 	res := oclib.NewRequest(oclib.LibDataEnum(oclib.LIVE_STORAGE),"",peerId,[]string{},nil).LoadAll(false)
 	if res.Err != "" {
@@ -153,65 +127,4 @@ func findLiveStorage(storageId string, peerId string) *live.LiveStorage {
 	}
 
 	return nil
-}
+}
-
-// @Title CreateCredentialsSecret
-// @Description Create a Kubernetes secret holding the access and secret keys to a given S3 server and bucket
-// @Success 201
-// @Param	executions	path	string				true	"The executionsID of the execution"
-// @Param	minioId		path	string				true	"The ID of the Minio youto which the credentials give access to"
-// @Param 	creds		body	map[string]string	true	"The credentials to store in the secret"
-// @router	/secret/:minioId/:executions [post]
-func (m *MinioController) CreateCredentialHoldingSecret(){
-	executionsId := m.Ctx.Input.Param(":executions")
-	minioId := m.Ctx.Input.Param(":minioId")
-
-	
-	var creds map[string]string
-	json.Unmarshal(m.Ctx.Input.CopyBody(10000), &creds)
-	
-	access, aOk := creds["access"]
-	secret, sOk := creds["secret"]  
-	
-	if !aOk || !sOk || len(access) == 0 || len(secret) == 0 {
-		m.Ctx.Output.SetStatus(403)
-		m.Data["json"] = map[string]interface{}{"error": "Missing credentials"}
-		m.ServeJSON()
-	}
-
-		// test if the namespace exists
-	k, err := infrastructure.NewService()
-	if err != nil {
-		m.Ctx.Output.SetStatus(500)
-		m.Data["json"] = map[string]string{"error": err.Error()}
-		m.ServeJSON()
-		return
-	}
-
-	ns, err := k.GetNamespace(m.Ctx.Request.Context(), executionsId)
-	if ns == nil {
-		m.Ctx.Output.SetStatus(403)
-		m.Data["json"] = map[string]string{"error":"Could not find the namespace corresponding to executionsID " + executionsId}
-		m.ServeJSON()
-		return
-	}
-	if err != nil {
-		m.Ctx.Output.SetStatus(500)
-		m.Data["json"] = map[string]string{"error": "Error when trying to check if namespace " + executionsId + " exists : " + err.Error()}
-		m.ServeJSON()
-		return
-	}
-
-	// store the credentials in the namespace
-	err = k.CreateSecret(m.Ctx.Request.Context(), minioId, executionsId, creds["access"], creds["secret"])
-	if err != nil {
-		m.Ctx.Output.SetStatus(500)
-		m.Data["json"] = map[string]string{"error": "Error when storing Minio serviceAccount credentials in namespace " + executionsId + " exists : " + err.Error()}
-		m.ServeJSON()
-		return
-	}
-
-	m.Ctx.Output.SetStatus(201)
-	m.ServeJSON()
-
-}

infrastructure/minio.go

@@ -115,8 +115,8 @@ func (m *MinioService) CreateBucket(executionId string) error {
 		return err
 	}
 
-	err = client.MakeBucket(context.Background(), executionId, minio.MakeBucketOptions{ForceCreate: false})
+	err = client.MakeBucket(context.Background(), executionId, minio.MakeBucketOptions{})
-	if err != nil && err.(minio.ErrorResponse).Code != "BucketAlreadyOwnedByYou" {
+	if err != nil {
 		l.Error().Msg("Error when creating the bucket for namespace " + executionId)
 		return err
 	}

routers/commentsRouter.go

@@ -196,15 +196,6 @@ func init() {
             Filters: nil,
             Params: nil})
 
-    beego.GlobalControllerRouter["oc-datacenter/controllers:MinioController"] = append(beego.GlobalControllerRouter["oc-datacenter/controllers:MinioController"],
-        beego.ControllerComments{
-            Method: "CreateCredentialHoldingSecret",
-            Router: `/secret/:minioId/:executions`,
-            AllowHTTPMethods: []string{"post"},
-            MethodParams: param.Make(),
-            Filters: nil,
-            Params: nil})
-
     beego.GlobalControllerRouter["oc-datacenter/controllers:MinioController"] = append(beego.GlobalControllerRouter["oc-datacenter/controllers:MinioController"],
         beego.ControllerComments{
             Method: "CreateServiceAccount",