libclient: WIP, but almost completed

src/client/cmdVM/attachHelper.go

 package cmdVM
 
 import (
-	"encoding/json"
-	"errors"
 	"fmt"
 	"nexus-client/exec"
 	u "nexus-client/utils"
 	"nexus-common/params"
 	"nexus-common/vm"
 	g "nexus-libclient/globals"
-	"sync"
-
-	"github.com/go-playground/validator/v10"
+	libclient "nexus-libclient/vm"
 )
 
-// The boolean indicates whether attaching is blocking (synchronous) or non-blocking (asynchronous).
-func AttachToVMs(vms []vm.VMAttachCredentialsSerialized, synchronous bool) (int, error) {
+func AttachToVMs(vms []vm.VMAttachCredentialsSerialized) (int, error) {
 	statusCode := 0
 
 	hostname := g.GetInstance().Hostname
 	cert := g.GetInstance().PubCert
 
-	client := g.GetInstance().Client
-	host := g.GetInstance().Host
-
-	var wg sync.WaitGroup
-
-	if synchronous {
-		// Use wait groups to wait until all viewers threads have completed.
-		wg.Add(len(vms))
-	}
-
 	for _, v := range vms {
-		uuid := v.ID.String()
-		p := &params.VMAttachCreds{Pwd: v.Pwd}
-		resp, err := client.R().SetBody(p).Post(host + "/vms/" + uuid + "/spicecreds")
-		if err != nil {
-			return 1, err
-		}
+		p := params.VMAttachCreds{Pwd: v.Pwd}
 
-		if resp.IsSuccess() {
-			var creds vm.VMSpiceCredentialsSerialized
-			if err := json.Unmarshal(resp.Body(), &creds); err != nil {
-				return 1, err
-			}
-			if err := validator.New(validator.WithRequiredStructEnabled()).Struct(creds); err != nil {
+		creds, err := libclient.VMGetSpiceCreds(v.ID.String(), p)
+		if err != nil {
+			u.PrintlnErr(err)
 			return 1, err
 		}
 
@@ -54,18 +31,7 @@ func AttachToVMs(vms []vm.VMAttachCredentialsSerialized, synchronous bool) (int,
 				u.PrintlnErr("Failed attaching to VM ", v.ID, ": ", fmt.Sprintf("%s", stdoutStderr))
 				statusCode |= 1
 			}
-				if synchronous {
-					wg.Done()
-				}
-			}(v, creds)
-
-		} else {
-			return 1, errors.New(resp.Status() + ": " + resp.String())
-		}
-	}
-
-	if synchronous {
-		wg.Wait()
+		}(v, *creds)
 	}
 
 	return statusCode, nil

src/client/cmdVM/helper.go

@@ -108,7 +108,7 @@ func getFilteredVMs(filteredVMsFunc GetVMs, patterns []string) ([]vm.VMNetworkSe
 //
 //	"."   -> matches everything
 //	"bla" -> matches any VM name containing "bla"
-func getFilteredVMCredentials(route string, patterns []string) ([]vm.VMAttachCredentialsSerialized, error) {
+func getFilteredVMCredentials(patterns []string) ([]vm.VMAttachCredentialsSerialized, error) {
 	if len(patterns) < 1 {
 		return nil, errors.New("At least one ID or regex must be specified")
 	}

src/client/cmdVM/vmAttachAsync.go

@@ -36,7 +36,7 @@ func (cmd *AttachAsync) Run(args []string) int {
 		return 1
 	}
 
-	creds, err := getFilteredVMCredentials("/vms/attach", args)
+	creds, err := getFilteredVMCredentials(args)
 	if err != nil {
 		u.PrintlnErr(err)
 		return 1
@@ -47,7 +47,7 @@ func (cmd *AttachAsync) Run(args []string) int {
 		return 1
 	}
 
-	statusCode, err := AttachToVMs(creds, false)
+	statusCode, err := AttachToVMs(creds)
 	if err != nil {
 		u.PrintlnErr(err)
 	}

src/client/cmdVM/vmAttachAsyncSingle.go

@@ -50,7 +50,7 @@ func (cmd *AttachAsyncSingle) Run(args []string) int {
 		return 1
 	}
 
-	statusCode, err := AttachToVMs([]vm.VMAttachCredentialsSerialized{*creds}, false)
+	statusCode, err := AttachToVMs([]vm.VMAttachCredentialsSerialized{*creds})
 	if err != nil {
 		u.PrintlnErr(err)
 		return 1

src/client/cmdVM/vmAttachFromPwd.go

 package cmdVM
 
 import (
-	"encoding/json"
 	"nexus-client/exec"
 	e "nexus-client/exec"
 	u "nexus-client/utils"
 	"nexus-common/params"
 	"nexus-common/vm"
 	g "nexus-libclient/globals"
-
-	"github.com/go-playground/validator/v10"
+	libclient "nexus-libclient/vm"
 )
 
 type AttachFromPwd struct {
@@ -23,7 +21,7 @@ func (cmd *AttachFromPwd) GetName() string {
 func (cmd *AttachFromPwd) GetDesc() []string {
 	return []string{
 		"Attaches to the VM that matches the specified password.",
-		"Requires the VM_ATTACH_ANY user capability."}
+		"Requires either EXAM_ATTACH or VM_ATTACH_ANY user capability."}
 }
 
 func (cmd *AttachFromPwd) PrintUsage() {
@@ -47,47 +45,23 @@ func (cmd *AttachFromPwd) Run(args []string) int {
 		return 1
 	}
 
-	client := g.GetInstance().Client
-	host := g.GetInstance().Host
-
 	hostname := g.GetInstance().Hostname
 	cert := g.GetInstance().PubCert
 
 	pwd := args[0]
-	p := &params.VMAttachCreds{Pwd: pwd}
-	resp, err := client.R().SetBody(p).Post(host + "/vms/spicecreds")
-	if err != nil {
-		u.PrintlnErr("Failed retrieving VM credentials: " + err.Error())
-		return 1
-	}
+	p := params.VMAttachCreds{Pwd: pwd}
 
-	if resp.IsSuccess() {
-		var creds vm.VMSpiceCredentialsSerialized
-		if err := json.Unmarshal(resp.Body(), &creds); err != nil {
-			u.PrintlnErr("Failed deserializing VM spice credentials: " + err.Error())
-			return 1
-		}
-		if err := validator.New(validator.WithRequiredStructEnabled()).Struct(creds); err != nil {
-			u.PrintlnErr("Failed validating VM spice credentials: " + err.Error())
+	creds, err := libclient.VMGetAnySpiceCreds(p)
+	if err != nil {
+		u.PrintlnErr(err)
 		return 1
-		}
+	} else {
 		go func(creds vm.VMSpiceCredentialsSerialized) {
 			_, err := e.RunRemoteViewer(hostname, cert, creds.Name, creds.SpicePort, creds.SpicePwd, true)
 			if err != nil {
 				u.PrintlnErr("Failed executing remote-viewer: " + err.Error())
 			}
-		}(creds)
-	} else {
-		type msg struct {
-			Message string `json:"message"`
-		}
-		var m msg
-		if err := json.Unmarshal(resp.Body(), &m); err != nil {
-			u.PrintlnErr("Failed retrieving VM credentials: " + err.Error())
-			return 1
-		}
-		u.PrintlnErr("Failed retrieving VM credentials: " + m.Message)
-		return 1
+		}(*creds)
 	}
 
 	return 0

src/client/cmdVM/vmCreds2csv.go

@@ -41,7 +41,7 @@ func (cmd *Creds2csv) Run(args []string) int {
 
 	csvFile := args[argc-1]
 
-	credsList, err := getFilteredVMCredentials("/vms/attach", args[:argc-1])
+	credsList, err := getFilteredVMCredentials(args[:argc-1])
 	if err != nil {
 		u.PrintlnErr("Error: " + err.Error())
 		return 1

src/client/cmdVM/vmCreds2pdf.go

@@ -44,7 +44,7 @@ func (cmd *Creds2pdf) Run(args []string) int {
 
 	pdfFile := args[argc-1]
 
-	credsList, err := getFilteredVMCredentials("/vms/attach", args[:argc-1])
+	credsList, err := getFilteredVMCredentials(args[:argc-1])
 	if err != nil {
 		u.PrintlnErr("Error: " + err.Error())
 		return 1

src/client/cmdVM/vmListSingle.go

@@ -36,7 +36,7 @@ func (cmd *ListSingle) Run(args []string) int {
 	}
 
 	vmID := args[0]
-	vm, err := libclient.GetListableVM(vmID)
+	vm, err := libclient.GetListVM(vmID)
 	if err != nil {
 		u.PrintlnErr(err)
 		return 1

src/client/cmdVM/vmStartAttach.go

@@ -73,7 +73,7 @@ func (cmd *StartAttach) Run(args []string) int {
 	}
 
 	// at this point, the returned filtered credentials only works for VMs that started successfully
-	creds, err := getFilteredVMCredentials("/vms/attach", args)
+	creds, err := getFilteredVMCredentials(args)
 	if err != nil {
 		u.PrintlnErr(err)
 		return 1
@@ -84,7 +84,7 @@ func (cmd *StartAttach) Run(args []string) int {
 		return 1
 	}
 
-	attachStatusCode, err := AttachToVMs(creds, false)
+	attachStatusCode, err := AttachToVMs(creds)
 	if err != nil {
 		u.PrintlnErr(err)
 	}

src/client/nexush/nexush.go

@@ -60,7 +60,7 @@ var cmdList = []cmd.Command{
 	&cmdVM.AddAccess{"vmaddaccess"},
 	&cmdVM.AttachAsync{"vmattach"},
 	// &cmdVM.AttachAsyncSingle{"vmattachsingle"},   // for testing the route only
-	// &cmdVM.AttachFromPwd{"vmattachfrompwd"},    // for testing the route only
+	&cmdVM.AttachFromPwd{"vmattachfrompwd"}, // for testing the route only
 	&cmdVM.Create{"vmcreate"},
 	&cmdVM.Creds2pdf{"vmcreds2pdf"},
 	&cmdVM.Creds2csv{"vmcreds2csv"},

src/libclient/vm/vmGet.go

@@ -69,31 +69,31 @@ func getFilteredVMs(route string) ([]vm.VMNetworkSerialized, error) {
 	}
 
 	if resp.IsSuccess() {
-		templates, err := deserializeVMs(resp)
+		vms, err := deserializeVMs(resp)
 		if err != nil {
 			return nil, err
 		}
-		return templates, nil
+		return vms, nil
 	} else {
 		return nil, response.ErrorToMsg(resp)
 	}
 }
 
-func GetListableVM(uuid string) (*vm.VMNetworkSerialized, error) {
+func GetListVM(vmID string) (*vm.VMNetworkSerialized, error) {
 	client := g.GetInstance().Client
 	host := g.GetInstance().Host
 
-	resp, err := client.R().Get(host + "/vms/" + uuid)
+	resp, err := client.R().Get(host + "/vms/" + vmID)
 	if err != nil {
 		return nil, err
 	}
 
 	if resp.IsSuccess() {
-		template, err := deserializeVM(resp)
+		vm, err := deserializeVM(resp)
 		if err != nil {
 			return nil, err
 		}
-		return template, nil
+		return vm, nil
 	} else {
 		return nil, response.ErrorToMsg(resp)
 	}

src/libclient/vm/vmGetSpiceCreds.go

+package vm
+
+import (
+	"encoding/json"
+	"errors"
+	"nexus-common/params"
+	"nexus-common/vm"
+	g "nexus-libclient/globals"
+	"nexus-libclient/response"
+
+	"github.com/go-playground/validator/v10"
+	"github.com/go-resty/resty/v2"
+)
+
+func VMGetSpiceCreds(vmID string, p params.VMAttachCreds) (*vm.VMSpiceCredentialsSerialized, error) {
+	client := g.GetInstance().Client
+	host := g.GetInstance().Host
+
+	resp, err := client.R().SetBody(p).Post(host + "/vms/" + vmID + "/spicecreds")
+	if err != nil {
+		return nil, err
+	}
+
+	return handleResponse(resp)
+}
+
+func VMGetAnySpiceCreds(p params.VMAttachCreds) (*vm.VMSpiceCredentialsSerialized, error) {
+	client := g.GetInstance().Client
+	host := g.GetInstance().Host
+
+	resp, err := client.R().SetBody(p).Post(host + "/vms/spicecreds")
+	if err != nil {
+		return nil, err
+	}
+
+	return handleResponse(resp)
+}
+
+func handleResponse(resp *resty.Response) (*vm.VMSpiceCredentialsSerialized, error) {
+	if resp.IsSuccess() {
+		var creds vm.VMSpiceCredentialsSerialized
+		if err := json.Unmarshal(resp.Body(), &creds); err != nil {
+			return nil, errors.New("Failed deserializing VM spice credentials: " + err.Error())
+		}
+		if err := validator.New(validator.WithRequiredStructEnabled()).Struct(creds); err != nil {
+			return nil, errors.New("Failed validating VM spice credentials: " + err.Error())
+		}
+		return &creds, nil
+	} else {
+		return nil, response.ErrorToMsg(resp)
+	}
+}

src/server/router/routerVMs.go

@@ -205,7 +205,8 @@ func (r *RouterVMs) VMSpiceCreds(c echo.Context) error {
 
 // Returns the Spice credentials for the VM matching the specific VM attach password.
 // Output: nexus-common/vm.VMSpiceCredentialsSerialized
-// Requires either CAP_EXAM_ATTACH or CAP_VM_ATTACH_ANY user capability:
+// Requires either to be the VM's owner, or either capability:
+// CAP_EXAM_ATTACH or CAP_VM_ATTACH_ANY user capability:
 // curl --cacert ca.pem -X POST https://localhost:1077/vms/spicecreds -H 'Content-Type: application/json' -d '{"pwd":"46L8drgZ5Dx"}' -H "Authorization: Bearer <AccessToken>"
 func (r *RouterVMs) VMSpiceCredsAny(c echo.Context) error {
 	// Retrieves logged user from context.