WIP: stateless client

libclient/template.go

+package nexusclient
+
+import (
+	"errors"
+
+	"gitedu.hesge.ch/flg_projects/nexus_vdi/nexus/libclient/response"
+
+	"encoding/json"
+
+	t "gitedu.hesge.ch/flg_projects/nexus_vdi/nexus/common/template"
+
+	u "gitedu.hesge.ch/flg_projects/nexus_vdi/nexus/libclient/utils"
+
+	"gitedu.hesge.ch/flg_projects/nexus_vdi/nexus/common/params"
+	"gitedu.hesge.ch/flg_projects/nexus_vdi/nexus/common/template"
+
+	"github.com/google/uuid"
+
+	"github.com/go-resty/resty/v2"
+)
+
+func (nc *NexusClient) TemplateDel(tplID string) error {
+	resp, err := nc.client.R().Delete("/templates/" + tplID)
+	if err != nil {
+		return err
+	}
+	if resp.IsSuccess() {
+		return nil
+	} else {
+		return response.ErrorToMsg(resp)
+	}
+}
+
+func (nc *NexusClient) TemplateCreate(vmID uuid.UUID, name, access string) (*template.TemplateSerialized, error) {
+	p := &params.TplCreate{vmID, name, access}
+	resp, err := nc.client.R().SetBody(p).Post("/templates/vm")
+	if err != nil {
+		return nil, err
+	}
+	if resp.IsSuccess() {
+		var tpl template.TemplateSerialized
+		if err := json.Unmarshal(resp.Body(), &tpl); err != nil {
+			return nil, err
+		}
+		return &tpl, nil
+	} else {
+		return nil, response.ErrorToMsg(resp)
+	}
+}
+
+func (nc *NexusClient) GetTemplates() ([]t.TemplateSerialized, error) {
+	resp, err := nc.client.R().Get("/templates")
+	if err != nil {
+		return nil, err
+	}
+
+	if resp.IsSuccess() {
+		templates, err := deserializeTemplates(resp)
+		if err != nil {
+			return nil, err
+		}
+		return templates, nil
+	} else {
+		return nil, response.ErrorToMsg(resp)
+	}
+}
+
+func (nc *NexusClient) GetTemplate(uuid string) (*t.TemplateSerialized, error) {
+	resp, err := nc.client.R().Get("/templates/" + uuid)
+	if err != nil {
+		return nil, err
+	}
+
+	if resp.IsSuccess() {
+		template, err := deserializeTemplate(resp)
+		if err != nil {
+			return nil, err
+		}
+		return template, nil
+	} else {
+		return nil, response.ErrorToMsg(resp)
+	}
+}
+
+func (nc *NexusClient) TemplateEdit(tplID string, p params.TplEdit) (*template.TemplateSerialized, error) {
+	resp, err := nc.client.R().SetBody(p).Put("/templates/" + tplID)
+	if err != nil {
+		return nil, err
+	}
+	if resp.IsSuccess() {
+		var tpl template.TemplateSerialized
+		if err := json.Unmarshal(resp.Body(), &tpl); err != nil {
+			return nil, err
+		}
+		return &tpl, nil
+	} else {
+		return nil, response.ErrorToMsg(resp)
+	}
+}
+
+func (nc *NexusClient) TemplateExportDisk(tplID, outputFile string) error {
+	resp, err := nc.client.R().SetOutput(outputFile).Get("/templates/" + tplID + "/disk")
+	if err != nil {
+		return err
+	} else {
+		if resp.IsSuccess() {
+			return nil
+		} else {
+			errorMsg, _ := u.FileToString(outputFile)
+			return errors.New(response.ErrorToMsg(resp).Error() + ": " + errorMsg)
+		}
+	}
+}
+
+// Deserialize a list of templates from an http response (no filtering).
+func deserializeTemplates(resp *resty.Response) ([]t.TemplateSerialized, error) {
+	templates := []t.TemplateSerialized{}
+	if err := json.Unmarshal(resp.Body(), &templates); err != nil {
+		return nil, err
+	}
+	return templates, nil
+}
+
+// Deserialize a single template from an http response.
+func deserializeTemplate(resp *resty.Response) (*t.TemplateSerialized, error) {
+	tpl := t.TemplateSerialized{}
+	if err := json.Unmarshal(resp.Body(), &tpl); err != nil {
+		return nil, err
+	}
+	return &tpl, nil
+}

libclient/templateCreate.go

-package nexusclient
-
-import (
-	"encoding/json"
-
-	g "gitedu.hesge.ch/flg_projects/nexus_vdi/nexus/libclient/globals"
-	"gitedu.hesge.ch/flg_projects/nexus_vdi/nexus/libclient/response"
-
-	"gitedu.hesge.ch/flg_projects/nexus_vdi/nexus/common/params"
-	"gitedu.hesge.ch/flg_projects/nexus_vdi/nexus/common/template"
-
-	"github.com/google/uuid"
-)
-
-func (nc *NexusClient) TemplateCreate(vmID uuid.UUID, name, access string) (*template.TemplateSerialized, error) {
-	p := &params.TplCreate{vmID, name, access}
-	resp, err := nc.client.R().SetBody(p).Post("/templates/vm")
-	if err != nil {
-		return nil, err
-	}
-	if resp.IsSuccess() {
-		var tpl template.TemplateSerialized
-		if err := json.Unmarshal(resp.Body(), &tpl); err != nil {
-			return nil, err
-		}
-		return &tpl, nil
-	} else {
-		return nil, response.ErrorToMsg(resp)
-	}
-}

libclient/templateDel.go

-package nexusclient
-
-import (
-	"gitedu.hesge.ch/flg_projects/nexus_vdi/nexus/libclient/response"
-)
-
-func (nc *NexusClient) TemplateDel(tplID string) error {
-	resp, err := nc.client.R().Delete("/templates/" + tplID)
-	if err != nil {
-		return err
-	}
-	if resp.IsSuccess() {
-		return nil
-	} else {
-		return response.ErrorToMsg(resp)
-	}
-}

libclient/templateDeserializer.go

-package nexusclient
-
-import (
-	"encoding/json"
-
-	t "gitedu.hesge.ch/flg_projects/nexus_vdi/nexus/common/template"
-
-	"github.com/go-resty/resty/v2"
-)
-
-// Deserialize a list of templates from an http response (no filtering).
-func deserializeTemplates(resp *resty.Response) ([]t.TemplateSerialized, error) {
-	templates := []t.TemplateSerialized{}
-	if err := json.Unmarshal(resp.Body(), &templates); err != nil {
-		return nil, err
-	}
-	return templates, nil
-}
-
-// Deserialize a single template from an http response.
-func deserializeTemplate(resp *resty.Response) (*t.TemplateSerialized, error) {
-	tpl := t.TemplateSerialized{}
-	if err := json.Unmarshal(resp.Body(), &tpl); err != nil {
-		return nil, err
-	}
-	return &tpl, nil
-}

libclient/templateEdit.go

-package nexusclient
-
-import (
-	"encoding/json"
-
-	"gitedu.hesge.ch/flg_projects/nexus_vdi/nexus/libclient/response"
-
-	"gitedu.hesge.ch/flg_projects/nexus_vdi/nexus/common/params"
-	"gitedu.hesge.ch/flg_projects/nexus_vdi/nexus/common/template"
-)
-
-func (nc *NexusClient) TemplateEdit(tplID string, p params.TplEdit) (*template.TemplateSerialized, error) {
-	resp, err := nc.client.R().SetBody(p).Put("/templates/" + tplID)
-	if err != nil {
-		return nil, err
-	}
-	if resp.IsSuccess() {
-		var tpl template.TemplateSerialized
-		if err := json.Unmarshal(resp.Body(), &tpl); err != nil {
-			return nil, err
-		}
-		return &tpl, nil
-	} else {
-		return nil, response.ErrorToMsg(resp)
-	}
-}

libclient/templateExportDisk.go

-package nexusclient
-
-import (
-	"errors"
-
-	"gitedu.hesge.ch/flg_projects/nexus_vdi/nexus/libclient/response"
-	u "gitedu.hesge.ch/flg_projects/nexus_vdi/nexus/libclient/utils"
-)
-
-func (nc *NexusClient) TemplateExportDisk(tplID, outputFile string) error {
-	resp, err := nc.client.R().SetOutput(outputFile).Get("/templates/" + tplID + "/disk")
-	if err != nil {
-		return err
-	} else {
-		if resp.IsSuccess() {
-			return nil
-		} else {
-			errorMsg, _ := u.FileToString(outputFile)
-			return errors.New(response.ErrorToMsg(resp).Error() + ": " + errorMsg)
-		}
-	}
-}

libclient/templateList.go

-package nexusclient
-
-import (
-	"gitedu.hesge.ch/flg_projects/nexus_vdi/nexus/libclient/response"
-
-	t "gitedu.hesge.ch/flg_projects/nexus_vdi/nexus/common/template"
-)
-
-func (nc *NexusClient) GetTemplates() ([]t.TemplateSerialized, error) {
-	resp, err := nc.client.R().Get("/templates")
-	if err != nil {
-		return nil, err
-	}
-
-	if resp.IsSuccess() {
-		templates, err := deserializeTemplates(resp)
-		if err != nil {
-			return nil, err
-		}
-		return templates, nil
-	} else {
-		return nil, response.ErrorToMsg(resp)
-	}
-}
-
-func (nc *NexusClient) GetTemplate(uuid string) (*t.TemplateSerialized, error) {
-	resp, err := nc.client.R().Get("/templates/" + uuid)
-	if err != nil {
-		return nil, err
-	}
-
-	if resp.IsSuccess() {
-		template, err := deserializeTemplate(resp)
-		if err != nil {
-			return nil, err
-		}
-		return template, nil
-	} else {
-		return nil, response.ErrorToMsg(resp)
-	}
-}

libclient/user.go

+package nexusclient
+
+import (
+	"gitedu.hesge.ch/flg_projects/nexus_vdi/nexus/libclient/response"
+
+	"gitedu.hesge.ch/flg_projects/nexus_vdi/nexus/common/params"
+
+	"encoding/json"
+
+	"github.com/go-resty/resty/v2"
+)
+
+func (nc *NexusClient) UserCreate(p params.UserWithPwd) error {
+	resp, err := nc.client.R().SetBody(p).Post("/users")
+	if err != nil {
+		return err
+	}
+	if resp.IsSuccess() {
+		return nil
+	} else {
+		return response.ErrorToMsg(resp)
+	}
+}
+
+func (nc *NexusClient) UserDelete(email string) error {
+	resp, err := nc.client.R().Delete("/users/" + email)
+	if err != nil {
+		return err
+	}
+	if resp.IsSuccess() {
+		return nil
+	} else {
+		return response.ErrorToMsg(resp)
+	}
+}
+
+func (nc *NexusClient) UserResetPwd(email string) (string, error) {
+	resp, err := nc.client.R().Put("/users/" + email + "/resetpwd")
+	if err != nil {
+		return "", err
+	}
+
+	if resp.IsSuccess() {
+		pwd, err := deserializePwd(resp)
+		if err != nil {
+			return "", err
+		}
+		return pwd, nil
+	} else {
+		return "", response.ErrorToMsg(resp)
+	}
+}
+
+func (nc *NexusClient) UserSetCaps(email string, userCaps *params.UserSetCaps) error {
+	resp, err := nc.client.R().SetBody(userCaps).Put("/users/" + email + "/caps")
+	if err != nil {
+		return err
+	}
+	if resp.IsSuccess() {
+		return nil
+	} else {
+		return response.ErrorToMsg(resp)
+	}
+}
+
+func (nc *NexusClient) UserUnlock(email string) error {
+	resp, err := nc.client.R().Put("/users/" + email + "/unlock")
+	if err != nil {
+		return err
+	}
+	if resp.IsSuccess() {
+		return nil
+	} else {
+		return response.ErrorToMsg(resp)
+	}
+}
+
+func (nc *NexusClient) UserUpdatePwd(newPwd string) error {
+	p := &params.UserSetPwd{newPwd}
+	resp, err := nc.client.R().SetBody(p).Put("/users/pwd")
+	if err != nil {
+		return err
+	}
+
+	if resp.IsSuccess() {
+		return nil
+	} else {
+		return response.ErrorToMsg(resp)
+	}
+}
+
+// NOTE: this route is not implemented in the backend yet.
+func (nc *NexusClient) UserWhoAmI() (*params.UserWithoutPwd, error) {
+	resp, err := nc.client.R().Get("/users/whoami")
+	if err != nil {
+		return nil, err
+	}
+
+	if resp.IsSuccess() {
+		user, err := deserializeUser(resp)
+		if err != nil {
+			return nil, err
+		}
+		return user, nil
+	} else {
+		return nil, response.ErrorToMsg(resp)
+	}
+}
+
+// NOTE: this route is not implemented in the backend yet.
+func (nc *NexusClient) GetUser(email string) (*params.UserWithoutPwd, error) {
+	resp, err := nc.client.R().Get("/users/" + email)
+	if err != nil {
+		return nil, err
+	}
+
+	if resp.IsSuccess() {
+		user, err := deserializeUser(resp)
+		if err != nil {
+			return nil, err
+		}
+		return user, nil
+	} else {
+		return nil, response.ErrorToMsg(resp)
+	}
+}
+
+func (nc *NexusClient) GetUsers() ([]params.UserWithoutPwd, error) {
+	resp, err := nc.client.R().Get("/users")
+	if err != nil {
+		return nil, err
+	}
+
+	if resp.IsSuccess() {
+		users, err := deserializeUsers(resp)
+		if err != nil {
+			return nil, err
+		}
+		return users, nil
+	} else {
+		return nil, response.ErrorToMsg(resp)
+	}
+}
+
+// Deserialize a list of users from an http response (no filtering).
+func deserializeUsers(resp *resty.Response) ([]params.UserWithoutPwd, error) {
+	users := []params.UserWithoutPwd{}
+	if err := json.Unmarshal(resp.Body(), &users); err != nil {
+		return nil, err
+	}
+	return users, nil
+}
+
+// Deserialize a single user from an http response.
+func deserializeUser(resp *resty.Response) (*params.UserWithoutPwd, error) {
+	user := params.UserWithoutPwd{}
+	if err := json.Unmarshal(resp.Body(), &user); err != nil {
+		return nil, err
+	}
+	return &user, nil
+}
+
+// Deserialize user password from http response.
+func deserializePwd(resp *resty.Response) (string, error) {
+	var pwd *params.UserSetPwd = &params.UserSetPwd{}
+	if err := json.Unmarshal(resp.Body(), &pwd); err != nil {
+		return "", err
+	}
+	return pwd.Pwd, nil
+}

libclient/userCreate.go

-package nexusclient
-
-import (
-	"gitedu.hesge.ch/flg_projects/nexus_vdi/nexus/libclient/response"
-
-	"gitedu.hesge.ch/flg_projects/nexus_vdi/nexus/common/params"
-)
-
-func (nc *NexusClient) UserCreate(p params.UserWithPwd) error {
-	resp, err := nc.client.R().SetBody(p).Post("/users")
-	if err != nil {
-		return err
-	}
-	if resp.IsSuccess() {
-		return nil
-	} else {
-		return response.ErrorToMsg(resp)
-	}
-}

libclient/userDel.go

-package nexusclient
-
-import (
-	"gitedu.hesge.ch/flg_projects/nexus_vdi/nexus/libclient/response"
-)
-
-func (nc *NexusClient) UserDelete(email string) error {
-	resp, err := nc.client.R().Delete("/users/" + email)
-	if err != nil {
-		return err
-	}
-	if resp.IsSuccess() {
-		return nil
-	} else {
-		return response.ErrorToMsg(resp)
-	}
-}

libclient/userDeserializer.go

-package nexusclient
-
-import (
-	"encoding/json"
-
-	"gitedu.hesge.ch/flg_projects/nexus_vdi/nexus/common/params"
-
-	"github.com/go-resty/resty/v2"
-)
-
-// Deserialize a list of users from an http response (no filtering).
-func deserializeUsers(resp *resty.Response) ([]params.UserWithoutPwd, error) {
-	users := []params.UserWithoutPwd{}
-	if err := json.Unmarshal(resp.Body(), &users); err != nil {
-		return nil, err
-	}
-	return users, nil
-}
-
-// Deserialize a single user from an http response.
-func deserializeUser(resp *resty.Response) (*params.UserWithoutPwd, error) {
-	user := params.UserWithoutPwd{}
-	if err := json.Unmarshal(resp.Body(), &user); err != nil {
-		return nil, err
-	}
-	return &user, nil
-}
-
-// Deserialize user password from http response.
-func deserializePwd(resp *resty.Response) (string, error) {
-	var pwd *params.UserSetPwd = &params.UserSetPwd{}
-	if err := json.Unmarshal(resp.Body(), &pwd); err != nil {
-		return "", err
-	}
-	return pwd.Pwd, nil
-}

libclient/userList.go

-package nexusclient
-
-import (
-	"gitedu.hesge.ch/flg_projects/nexus_vdi/nexus/libclient/response"
-
-	"gitedu.hesge.ch/flg_projects/nexus_vdi/nexus/common/params"
-)
-
-func (nc *NexusClient) GetUsers() ([]params.UserWithoutPwd, error) {
-	resp, err := nc.client.R().Get("/users")
-	if err != nil {
-		return nil, err
-	}
-
-	if resp.IsSuccess() {
-		users, err := deserializeUsers(resp)
-		if err != nil {
-			return nil, err
-		}
-		return users, nil
-	} else {
-		return nil, response.ErrorToMsg(resp)
-	}
-}
-
-// NOTE: this route is not implemented in the backend yet.
-func (nc *NexusClient) GetUser(email string) (*params.UserWithoutPwd, error) {
-	resp, err := nc.client.R().Get("/users/" + email)
-	if err != nil {
-		return nil, err
-	}
-
-	if resp.IsSuccess() {
-		user, err := deserializeUser(resp)
-		if err != nil {
-			return nil, err
-		}
-		return user, nil
-	} else {
-		return nil, response.ErrorToMsg(resp)
-	}
-}

libclient/userResetPwd.go

-package nexusclient
-
-import (
-	"gitedu.hesge.ch/flg_projects/nexus_vdi/nexus/libclient/response"
-)
-
-func (nc *NexusClient) UserResetPwd(email string) (string, error) {
-	resp, err := nc.client.R().Put("/users/" + email + "/resetpwd")
-	if err != nil {
-		return "", err
-	}
-
-	if resp.IsSuccess() {
-		pwd, err := deserializePwd(resp)
-		if err != nil {
-			return "", err
-		}
-		return pwd, nil
-	} else {
-		return "", response.ErrorToMsg(resp)
-	}
-}

libclient/userSetCaps.go

-package nexusclient
-
-import (
-	"gitedu.hesge.ch/flg_projects/nexus_vdi/nexus/libclient/response"
-
-	"gitedu.hesge.ch/flg_projects/nexus_vdi/nexus/common/params"
-)
-
-func (nc *NexusClient) UserSetCaps(email string, userCaps *params.UserSetCaps) error {
-	resp, err := nc.client.R().SetBody(userCaps).Put("/users/" + email + "/caps")
-	if err != nil {
-		return err
-	}
-	if resp.IsSuccess() {
-		return nil
-	} else {
-		return response.ErrorToMsg(resp)
-	}
-}

libclient/userUnlock.go

-package nexusclient
-
-import (
-	"gitedu.hesge.ch/flg_projects/nexus_vdi/nexus/libclient/response"
-)
-
-func (nc *NexusClient) UserUnlock(email string) error {
-	resp, err := nc.client.R().Put("/users/" + email + "/unlock")
-	if err != nil {
-		return err
-	}
-	if resp.IsSuccess() {
-		return nil
-	} else {
-		return response.ErrorToMsg(resp)
-	}
-}

libclient/userUpdatePwd.go

-package nexusclient
-
-import (
-	"gitedu.hesge.ch/flg_projects/nexus_vdi/nexus/libclient/response"
-
-	"gitedu.hesge.ch/flg_projects/nexus_vdi/nexus/common/params"
-)
-
-func (nc *NexusClient) UserUpdatePwd(newPwd string) error {
-	p := &params.UserSetPwd{newPwd}
-	resp, err := nc.client.R().SetBody(p).Put("/users/pwd")
-	if err != nil {
-		return err
-	}
-
-	if resp.IsSuccess() {
-		return nil
-	} else {
-		return response.ErrorToMsg(resp)
-	}
-}

libclient/userWhoAmI.go

-package nexusclient
-
-import (
-	"gitedu.hesge.ch/flg_projects/nexus_vdi/nexus/libclient/response"
-
-	"gitedu.hesge.ch/flg_projects/nexus_vdi/nexus/common/params"
-)
-
-// NOTE: this route is not implemented in the backend yet.
-func (nc *NexusClient) UserWhoAmI() (*params.UserWithoutPwd, error) {
-	resp, err := nc.client.R().Get("/users/whoami")
-	if err != nil {
-		return nil, err
-	}
-
-	if resp.IsSuccess() {
-		user, err := deserializeUser(resp)
-		if err != nil {
-			return nil, err
-		}
-		return user, nil
-	} else {
-		return nil, response.ErrorToMsg(resp)
-	}
-}

libclient/vm.go

+package nexusclient
+
+import (
+	"encoding/json"
+	"errors"
+
+	"gitedu.hesge.ch/flg_projects/nexus_vdi/nexus/common/params"
+	"gitedu.hesge.ch/flg_projects/nexus_vdi/nexus/common/vm"
+	"gitedu.hesge.ch/flg_projects/nexus_vdi/nexus/libclient/response"
+	u "gitedu.hesge.ch/flg_projects/nexus_vdi/nexus/libclient/utils"
+	"github.com/go-playground/validator/v10"
+	"github.com/go-resty/resty/v2"
+)
+
+const (
+	attachVMs     = "/vms/attach"
+	delVMs        = "/vms/del"
+	editVMs       = "/vms/edit"
+	editaccessVMs = "/vms/editaccess"
+	exportdirVMs  = "/vms/exportdir"
+	importfileVMs = "/vms/importfiles"
+	listVMs       = "/vms"
+	rebootVMs     = "/vms/reboot"
+	startVMs      = "/vms/start"
+	stopVMs       = "/vms/stop"
+)
+
+func (nc *NexusClient) VMCreate(p params.VMCreate) (*vm.VMNetworkSerialized, error) {
+	resp, err := nc.client.R().SetBody(p).Post("/vms")
+	if err != nil {
+		return nil, err
+	}
+	if resp.IsSuccess() {
+		var vm vm.VMNetworkSerialized
+		if err := json.Unmarshal(resp.Body(), &vm); err != nil {
+			return nil, err
+		}
+		return &vm, nil
+	} else {
+		return nil, response.ErrorToMsg(resp)
+	}
+}
+
+func (nc *NexusClient) VMEdit(vmID string, p params.VMEdit) (*vm.VMNetworkSerialized, error) {
+	resp, err := nc.client.R().SetBody(p).Put("/vms/" + vmID)
+	if err != nil {
+		return nil, err
+	}
+	if resp.IsSuccess() {
+		var vm vm.VMNetworkSerialized
+		if err := json.Unmarshal(resp.Body(), &vm); err != nil {
+			return nil, err
+		}
+		return &vm, nil
+	} else {
+		return nil, response.ErrorToMsg(resp)
+	}
+}
+
+func (nc *NexusClient) VMDel(vmID string) error {
+	resp, err := nc.client.R().Delete("/vms/" + vmID)
+	if err != nil {
+		return err
+	}
+	if resp.IsSuccess() {
+		return nil
+	} else {
+		return response.ErrorToMsg(resp)
+	}
+}
+
+func (nc *NexusClient) VMExportDir(vmName, vmID, dirToExport string) (string, error) {
+	p := &params.VMExportDir{Dir: dirToExport}
+
+	nc.client.SetAllowGetMethodPayload(true)
+
+	outputFile := vmName + "_" + vmID + ".tar.gz"
+	resp, err := nc.client.R().SetOutput(outputFile).SetBody(p).Get("/vms/" + vmID + "/exportdir")
+	if err != nil {
+		// u.PrintlnErr("Failed exporting " + dir + " from VM \"" + vm.Name + "\": " + err.Error())
+		return "", err
+	}
+	if resp.IsSuccess() {
+		return outputFile, nil
+	} else {
+		errorMsg, _ := u.FileToString(outputFile)
+		return "", errors.New("Failed exporting " + dirToExport + " from VM \"" + vmName + "\": " + resp.Status() + ": " + errorMsg)
+	}
+}
+
+func (nc *NexusClient) VMGetSpiceCreds(vmID string, p params.VMAttachCreds) (*vm.VMSpiceCredentialsSerialized, error) {
+	resp, err := nc.client.R().SetBody(p).Post("/vms/" + vmID + "/spicecreds")
+	if err != nil {
+		return nil, err
+	}
+
+	return handleResponse(resp)
+}
+
+func (nc *NexusClient) VMGetAnySpiceCreds(p params.VMAttachCreds) (*vm.VMSpiceCredentialsSerialized, error) {
+	resp, err := nc.client.R().SetBody(p).Post("/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)
+	}
+}
+
+func (nc *NexusClient) VMDelAccess(vmID, vmName, email string) error {
+	resp, err := nc.client.R().Delete("/vms/" + vmID + "/access/" + email)
+	if err != nil {
+		return err
+	}
+
+	if resp.IsSuccess() {
+		return nil
+	} else {
+		return response.ErrorToMsg(resp)
+	}
+}
+
+func (nc *NexusClient) VMImportArchive(vmID, vmDir, archiveFile string) error {
+	resp, err := nc.client.R().SetFile("file", archiveFile).
+		SetFormData(map[string]string{
+			"vmDir": vmDir,
+		}).Post("/vms/" + vmID + "/importfiles")
+
+	if err != nil {
+		return err
+	}
+	if resp.IsSuccess() {
+		return nil
+	} else {
+		return response.ErrorToMsg(resp)
+	}
+}
+
+func (nc *NexusClient) VMReboot(vmID string) error {
+	resp, err := nc.client.R().Put("/vms/" + vmID + "/reboot")
+	if err != nil {
+		return err
+	}
+	if resp.IsSuccess() {
+		return nil
+	} else {
+		return response.ErrorToMsg(resp)
+	}
+}
+
+func (nc *NexusClient) VMShutdown(vmID string) error {
+	resp, err := nc.client.R().Put("/vms/" + vmID + "/shutdown")
+	if err != nil {
+		return err
+	}
+	if resp.IsSuccess() {
+		return nil
+	} else {
+		return response.ErrorToMsg(resp)
+	}
+}
+
+func (nc *NexusClient) VMStart(vmID string) error {
+	resp, err := nc.client.R().Put("/vms/" + vmID + "/start")
+	if err != nil {
+		return err
+	}
+	if resp.IsSuccess() {
+		return nil
+	} else {
+		return response.ErrorToMsg(resp)
+	}
+}
+
+func (nc *NexusClient) VMStartWithCreds(vmID string, p params.VMStartWithCreds) error {
+	resp, err := nc.client.R().SetBody(p).Put("/vms/" + vmID + "/startwithcreds")
+	if err != nil {
+		return err
+	}
+	if resp.IsSuccess() {
+		return nil
+	} else {
+		return response.ErrorToMsg(resp)
+	}
+}
+
+func (nc *NexusClient) VMStop(vmID string) error {
+	resp, err := nc.client.R().Put("/vms/" + vmID + "/stop")
+	if err != nil {
+		return err
+	}
+	if resp.IsSuccess() {
+		return nil
+	} else {
+		return response.ErrorToMsg(resp)
+	}
+}
+
+func (nc *NexusClient) VMAttach(vmID string) (*vm.VMAttachCredentialsSerialized, error) {
+	resp, err := nc.client.R().Get("/vms/" + vmID + "/attach")
+	if err != nil {
+		return nil, err
+	}
+
+	if resp.IsSuccess() {
+		vmCreds, err := deserializeVMCredentials(resp)
+		if err != nil {
+			return nil, err
+		}
+		return vmCreds, nil
+	} else {
+		return nil, response.ErrorToMsg(resp)
+	}
+}
+
+func (nc *NexusClient) VMAddAccess(vmID, vmName, email string, vmAccessCaps *params.VMAddAccess) error {
+	resp, err := nc.client.R().SetBody(vmAccessCaps).Put("/vms/" + vmID + "/access/" + email)
+	if err != nil {
+		return err
+	}
+
+	if resp.IsSuccess() {
+		return nil
+	} else {
+		return response.ErrorToMsg(resp)
+	}
+}
+
+func (nc *NexusClient) GetVMAttachCredentials() ([]vm.VMAttachCredentialsSerialized, error) {
+	resp, err := nc.client.R().Get("/vms/attach")
+	if err != nil {
+		return nil, err
+	}
+
+	if resp.IsSuccess() {
+		vmCreds, err := deserializeVMsCredentials(resp)
+		if err != nil {
+			return nil, err
+		}
+		return vmCreds, nil
+	} else {
+		return nil, response.ErrorToMsg(resp)
+	}
+}
+
+func (nc *NexusClient) GetAttachVMs() ([]vm.VMNetworkSerialized, error) {
+	return nc.getFilteredVMs(attachVMs)
+}
+
+func (nc *NexusClient) GetDelVMs() ([]vm.VMNetworkSerialized, error) {
+	return nc.getFilteredVMs(delVMs)
+}
+
+func (nc *NexusClient) GetEditAccessVMs() ([]vm.VMNetworkSerialized, error) {
+	return nc.getFilteredVMs(editaccessVMs)
+}
+
+func (nc *NexusClient) GetEditVMs() ([]vm.VMNetworkSerialized, error) {
+	return nc.getFilteredVMs(editVMs)
+}
+
+func (nc *NexusClient) GetExportDirVMs() ([]vm.VMNetworkSerialized, error) {
+	return nc.getFilteredVMs(exportdirVMs)
+}
+
+func (nc *NexusClient) GetImportFileVMs() ([]vm.VMNetworkSerialized, error) {
+	return nc.getFilteredVMs(importfileVMs)
+}
+
+func (nc *NexusClient) GetListVMs() ([]vm.VMNetworkSerialized, error) {
+	return nc.getFilteredVMs(listVMs)
+}
+
+func (nc *NexusClient) GetRebootVMs() ([]vm.VMNetworkSerialized, error) {
+	return nc.getFilteredVMs(rebootVMs)
+}
+
+func (nc *NexusClient) GetStartVMs() ([]vm.VMNetworkSerialized, error) {
+	return nc.getFilteredVMs(startVMs)
+}
+
+func (nc *NexusClient) GetStopVMs() ([]vm.VMNetworkSerialized, error) {
+	return nc.getFilteredVMs(stopVMs)
+}
+
+func (nc *NexusClient) getFilteredVMs(route string) ([]vm.VMNetworkSerialized, error) {
+	resp, err := nc.client.R().Get(route)
+	if err != nil {
+		return nil, err
+	}
+
+	if resp.IsSuccess() {
+		vms, err := deserializeVMs(resp)
+		if err != nil {
+			return nil, err
+		}
+		return vms, nil
+	} else {
+		return nil, response.ErrorToMsg(resp)
+	}
+}
+
+func (nc *NexusClient) GetListVM(vmID string) (*vm.VMNetworkSerialized, error) {
+	resp, err := nc.client.R().Get("/vms/" + vmID)
+	if err != nil {
+		return nil, err
+	}
+
+	if resp.IsSuccess() {
+		vm, err := deserializeVM(resp)
+		if err != nil {
+			return nil, err
+		}
+		return vm, nil
+	} else {
+		return nil, response.ErrorToMsg(resp)
+	}
+}
+
+// Deserialize a list of VMs from an http response.
+func deserializeVMs(resp *resty.Response) ([]vm.VMNetworkSerialized, error) {
+	vms := []vm.VMNetworkSerialized{}
+	if err := json.Unmarshal(resp.Body(), &vms); err != nil {
+		return nil, err
+	}
+	return vms, nil
+}
+
+// Deserialize a single VM from an http response.
+func deserializeVM(resp *resty.Response) (*vm.VMNetworkSerialized, error) {
+	vm := vm.VMNetworkSerialized{}
+	if err := json.Unmarshal(resp.Body(), &vm); err != nil {
+		return nil, err
+	}
+	if err := validator.New(validator.WithRequiredStructEnabled()).Struct(vm); err != nil {
+		return nil, err
+	}
+	return &vm, nil
+}
+
+// Deserialize a list of VM credentials from an http response.
+func deserializeVMsCredentials(resp *resty.Response) ([]vm.VMAttachCredentialsSerialized, error) {
+	vmsCreds := []vm.VMAttachCredentialsSerialized{}
+	if err := json.Unmarshal(resp.Body(), &vmsCreds); err != nil {
+		return nil, err
+	}
+	return vmsCreds, nil
+}
+
+// Deserialize a VM credentials from an http response.
+func deserializeVMCredentials(resp *resty.Response) (*vm.VMAttachCredentialsSerialized, error) {
+	var vmCreds vm.VMAttachCredentialsSerialized
+	if err := json.Unmarshal(resp.Body(), &vmCreds); err != nil {
+		return nil, err
+	}
+	if err := validator.New(validator.WithRequiredStructEnabled()).Struct(vmCreds); err != nil {
+		return nil, err
+	}
+	return &vmCreds, nil
+}

libclient/vmAddAccess.go

-package nexusclient
-
-import (
-	"gitedu.hesge.ch/flg_projects/nexus_vdi/nexus/libclient/response"
-
-	"gitedu.hesge.ch/flg_projects/nexus_vdi/nexus/common/params"
-)
-
-func (nc *NexusClient) VMAddAccess(vmID, vmName, email string, vmAccessCaps *params.VMAddAccess) error {
-	resp, err := nc.client.R().SetBody(vmAccessCaps).Put("/vms/" + vmID + "/access/" + email)
-	if err != nil {
-		return err
-	}
-
-	if resp.IsSuccess() {
-		return nil
-	} else {
-		return response.ErrorToMsg(resp)
-	}
-}

libclient/vmAttach.go

-package nexusclient
-
-import (
-	"gitedu.hesge.ch/flg_projects/nexus_vdi/nexus/libclient/response"
-
-	"gitedu.hesge.ch/flg_projects/nexus_vdi/nexus/common/vm"
-)
-
-func (nc *NexusClient) VMAttach(vmID string) (*vm.VMAttachCredentialsSerialized, error) {
-	resp, err := nc.client.R().Get("/vms/" + vmID + "/attach")
-	if err != nil {
-		return nil, err
-	}
-
-	if resp.IsSuccess() {
-		vmCreds, err := deserializeVMCredentials(resp)
-		if err != nil {
-			return nil, err
-		}
-		return vmCreds, nil
-	} else {
-		return nil, response.ErrorToMsg(resp)
-	}
-}