pve-go/server.go

// Copyright (C) 2020 Marius Schellenberger

package pve

import (
	"context"
	"errors"
	"fmt"
	"strconv"
	"strings"
)

var ErrServerNotFound = errors.New("server not found")

type ServerList []*Server

type Server struct {
	ID              string `json:"vmid"`
	Name            string `json:"name"`
	Node            string
	Pool            string
	Status          ServerStatus `json:"status"`
	Resources       Resources
	NetDevices      NetworkDevices
	IPConfig        IPConfigs
	Nameserver      Nameserver
	SearchDomain    string
	UserData        *UserData
	UserDataStorage string
	cicustom        bool
}

func (s *Server) UserDataSnippetName() string {
	return fmt.Sprintf("%s_userdata", s.ID)
}

func (s *Server) UserDataSnippet(storage string) string {
	return fmt.Sprintf("user=%s", SnippetVolume(storage, s.UserDataSnippetName()))
}

func (s *Server) body() (b httpbody) {
	b = httpbody{
		"memory":       s.Resources.Memory.String(),
		"cores":        s.Resources.Cores.String(),
		"name":         s.Name,
		"nameserver":   s.Nameserver.String(),
		"searchdomain": s.SearchDomain,
	}
	if s.UserData != nil || s.cicustom {
		b["cicustom"] = s.UserDataSnippet(s.UserDataStorage)
	}
	// TODO userdata, err := s.UserData.String()
	for i, n := range s.NetDevices {
		if n == nil {
			b["net"+strconv.Itoa(i)] = ""
			continue
		}
		b["net"+strconv.Itoa(i)] = n.String()
	}
	for i, ip := range s.IPConfig {
		if ip == nil {
			b["ipconfig"+strconv.Itoa(i)] = ""
			continue
		}
		b["ipconfig"+strconv.Itoa(i)] = ip.String()
	}
	return
}

func (s *Server) InstanceID() string {
	return NewURL("", s.Node, s.ID)
}

func (s *Server) K8sID() string {
	return NewURL(s.Pool, "", s.ID)
}

type Resources struct {
	Cores  Cores  `json:"cores"`
	Memory Memory `json:"memory"`
	Disk   Disk   `json:"disk"`
}

type Cores uint64

func (c Cores) String() string {
	return strconv.FormatUint(uint64(c), 10)
}

type Memory uint64

func (m Memory) String() string {
	return strconv.FormatUint(uint64(m)*1024, 10)
}

type Disk struct {
	Storage string `json:"storage"`
	Name    string `json:"name,omitempty"`
	Size    uint64 `json:"size"`
}

func (d Disk) String() string {
	return strconv.FormatUint(d.Size, 10) + "G"
}

type Nameserver []string

func parseNameserver(s string) Nameserver {
	return strings.Split(s, " ")
}

func (n Nameserver) String() string {
	return strings.Join(n, " ")
}

type serverConfig map[string]interface{}

func (sc serverConfig) Server(node, id string) (s *Server, err error) {
	if len(sc) == 0 {
		return
	}
	s = &Server{ID: id, Node: node}

	for k := range sc {
		switch k {
		case "name":
			if v, ok := sc[k].(string); ok {
				s.Name = v
			}
		case "cicustom":
			if _, ok := sc[k].(string); ok {
				s.cicustom = true
			}
		// TODO
		// case "ciuserdata":
		// 	if v, ok := sc[k].(string); ok {
		// 		s.UserData, err = parseUserData(v)
		// 	}
		case "memory":
			if v, ok := sc[k].(float64); ok {
				s.Resources.Memory = Memory(uint64(v) / 1024)
			}
		case "cores":
			if v, ok := sc[k].(float64); ok {
				s.Resources.Cores = Cores(uint64(v))
			}
		case "bootdisk":
			if v, ok := sc[k].(string); ok {
				s.Resources.Disk.Name = v
				if val, ok := sc[v].(string); ok {
					vals := strings.Split(val, ",")
					if len(vals) > 0 {
						storage := strings.Split(vals[0], ":")
						if len(storage) > 0 {
							s.Resources.Disk.Storage = storage[0]
						}
					}
					for _, o := range vals {
						if strings.HasPrefix(o, "size=") {
							size, _ := strconv.ParseUint(o[5:], 10, 64)
							s.Resources.Disk.Size = size
							break
						}
					}
				}
			}
		case "nameserver":
			if v, ok := sc[k].(string); ok {
				s.Nameserver = parseNameserver(v)
			}
		case "searchdomain":
			if v, ok := sc[k].(string); ok {
				s.SearchDomain = v
			}
		default:
			switch {
			case strings.HasPrefix(k, "net"):
				if v, ok := sc[k].(string); ok {
					n := parseNetworkDevice(v)
					if n != nil {
						s.NetDevices = append(s.NetDevices, n)
					}
				}
			case strings.HasPrefix(k, "ipconfig"):
				if v, ok := sc[k].(string); ok {
					ip := parseIPConfig(v)
					if ip != nil {
						s.IPConfig = append(s.IPConfig, ip)
					}
				}

			}
		}
	}
	if s.Resources.Cores == 0 {
		s.Resources.Cores = 1
	}
	return
}

type ServerClient struct {
	client *Client
}

func (c *ServerClient) NextID(ctx context.Context) (id string, err error) {
	req, err := c.client.NewRequest(ctx, "GET", "/cluster/nextid", nil)
	if err != nil {
		return
	}
	_, err = c.client.Do(req, &id)
	return
}

func (c *ServerClient) getConfig(ctx context.Context, node, id string) (cfg serverConfig, err error) {
	cfg = make(serverConfig)
	req, err := c.client.NewRequest(ctx, "GET", fmt.Sprintf("/nodes/%s/qemu/%s/config?current=1", node, id), nil)
	if err != nil {
		return
	}
	_, err = c.client.Do(req, &cfg)
	return
}

func (c *ServerClient) getServer(ctx context.Context, node, id string) (s *Server, cfg serverConfig, err error) {
	cfg, err = c.getConfig(ctx, node, id)
	if err != nil {
		return
	}
	s, err = cfg.Server(node, id)
	return
}

func (c *ServerClient) GetByURL(ctx context.Context, url string) (s *Server, err error) {
	pool, node, id, err := ParseURL(url)
	if err != nil {
		return
	}
	var srv *Server
	if node == "" && pool != "" {
		srv, err = c.client.Pool.FindServerByID(ctx, pool, id)
		if err != nil {
			return
		}
		node = srv.Node
	} else if node == "" && pool == "" {
		srv, err = c.client.Node.FindServerByID(ctx, id)
		if err != nil {
			return
		}
		node = srv.Node
	}
	s, cfg, err := c.getServer(ctx, node, id)
	if err != nil {
		return
	}
	if s != nil {
		var lock string
		if v, ok := cfg["lock"].(string); ok {
			lock = v
		}
		err = c.GetStatus(ctx, s, &lock)
	}
	return
}

type ServerTemplateOpts struct {
	Name          string
	TemplateID    string
	TemplateNode  string
	Pool          string
	TargetStorage string
	TargetNode    string
}

func (o ServerTemplateOpts) Validate() error {
	if o.Name == "" {
		return errors.New("missing name")
	}
	if o.TemplateID == "" {
		return errors.New("missing template id")
	}
	if o.TemplateNode == "" {
		return errors.New("missing template node")
	}
	return nil
}

func (o ServerTemplateOpts) body() httpbody {
	body := httpbody{"name": o.Name}
	if o.TargetStorage != "" {
		body["storage"] = o.TargetStorage
		body["full"] = "1"
	}
	if o.Pool != "" {
		body["pool"] = o.Pool
	}
	return body
}

func (c *ServerClient) CreateFromTemplate(ctx context.Context, opts ServerTemplateOpts) (t *Task, url string, err error) {
	err = opts.Validate()
	if err != nil {
		return
	}
	nextid, err := c.NextID(ctx)
	if err != nil {
		return
	}
	body := opts.body()
	body["newid"] = nextid
	node := opts.TemplateNode
	if opts.TargetNode != "" && opts.TemplateNode != opts.TargetNode {
		node = opts.TargetNode
		body["target"] = opts.TargetNode
	}
	url = NewURL(opts.Pool, node, nextid)
	req, err := c.client.NewRequest(ctx, "POST", fmt.Sprintf("/nodes/%s/qemu/%s/clone", opts.TemplateNode, opts.TemplateID), body.Reader())
	if err != nil {
		return
	}
	var taskid string
	_, err = c.client.Do(req, &taskid)
	t = c.client.Task.MustGet(ctx, taskid)
	return
}

func (c *ServerClient) Start(ctx context.Context, s *Server) (t *Task, err error) {
	return c.setStatus(ctx, s, "start")
}

func (c *ServerClient) Reboot(ctx context.Context, s *Server) (t *Task, err error) {
	return c.setStatus(ctx, s, "reboot")
}

func (c *ServerClient) Shutdown(ctx context.Context, s *Server) (t *Task, err error) {
	return c.setStatus(ctx, s, "shutdown")
}

func (c *ServerClient) Reset(ctx context.Context, s *Server) (t *Task, err error) {
	return c.setStatus(ctx, s, "reset")
}

func (c *ServerClient) Suspend(ctx context.Context, s *Server) (t *Task, err error) {
	return c.setStatus(ctx, s, "suspent")
}

func (c *ServerClient) Resume(ctx context.Context, s *Server) (t *Task, err error) {
	return c.setStatus(ctx, s, "resume")
}

func (c *ServerClient) Stop(ctx context.Context, s *Server) (t *Task, err error) {
	return c.setStatus(ctx, s, "stop")
}

func (c *ServerClient) setStatus(ctx context.Context, s *Server, status string) (t *Task, err error) {
	req, err := c.client.NewRequest(ctx, "POST", fmt.Sprintf("/nodes/%s/qemu/%s/status/%s", s.Node, s.ID, status), nil)
	if err != nil {
		return
	}
	var taskid string
	_, err = c.client.Do(req, &taskid)
	t = c.client.Task.MustGet(ctx, taskid)
	return
}

type statusObj struct {
	Status string `json:"status"`
}

func (c *ServerClient) GetStatus(ctx context.Context, s *Server, lock *string) (err error) {
	var lockval string
	if lock == nil {
		cfg, err := c.getConfig(ctx, s.Node, s.ID)
		if err != nil {
			return err
		}
		if v, ok := cfg["lock"].(string); ok {
			lockval = v
		}
	} else {
		lockval = *lock
	}
	var status statusObj
	req, err := c.client.NewRequest(ctx, "GET", fmt.Sprintf("/nodes/%s/qemu/%s/status/current", s.Node, s.ID), nil)
	if err != nil {
		s.Status = ServerStatusUnknown
		return
	}
	_, err = c.client.Do(req, &status)
	if err != nil {
		s.Status = ServerStatusUnknown
		return
	}
	s.Status = ServerStatusFromLock(status.Status, lockval)
	return
}

func diffBody(cur, n *Server) (b httpbody) {
	b = n.body()
	curbody := cur.body()
	for k, v := range b {
		if curbody[k] == v {
			delete(b, k)
		}
	}
	return
}

func (c *ServerClient) updateConfig(ctx context.Context, s *Server, body httpbody) (err error) {
	req, err := c.client.NewRequest(ctx, "PUT", fmt.Sprintf("/nodes/%s/qemu/%s/config", s.Node, s.ID), body.Reader())
	if err != nil {
		return err
	}
	_, err = c.client.Do(req, nil)
	return
}

func (c *ServerClient) resizeDisk(ctx context.Context, s *Server) (err error) {
	body := httpbody{
		"disk": s.Resources.Disk.Name,
		"size": s.Resources.Disk.String(),
	}
	req, err := c.client.NewRequest(ctx, "PUT", fmt.Sprintf("/nodes/%s/qemu/%s/resize", s.Node, s.ID), body.Reader())
	if err != nil {
		return err
	}
	_, err = c.client.Do(req, nil)
	return
}

func (c *ServerClient) Update(ctx context.Context, s *Server) (t *Task, err error) {
	cur, _, err := c.getServer(ctx, s.Node, s.ID)
	if err != nil {
		return
	}
	body := diffBody(cur, s)
	var e []string
	if s.UserData != nil {
		b, userdata := s.UserData.Bytes()
		if userdata == nil {
			t, userdata = c.client.Snippet.Create(ctx, s.Node, s.UserDataStorage, s.UserDataSnippetName(), b)
		}
		if userdata != nil {
			e = append(e, fmt.Sprintf("userdata: %s", userdata))
		}
	}
	if len(body) > 0 {
		cfg := c.updateConfig(ctx, s, body)
		if cfg != nil {
			e = append(e, fmt.Sprintf("config: %s", cfg))
		}
	}
	if cur.Resources.Disk.Size != s.Resources.Disk.Size {
		resize := c.resizeDisk(ctx, s)
		if resize != nil {
			e = append(e, fmt.Sprintf("resize: %s", resize))
		}
	}
	if len(e) > 0 {
		err = fmt.Errorf("%s", strings.Join(e, ""))
	}
	if t == nil {
		dummy := DummyTask
		t = &dummy
	}
	return
}

func (c *ServerClient) Delete(ctx context.Context, s *Server, f OnTaskChange) (t *Task, err error) {
	if s.Status == ServerStatusRunning || s.Status == ServerStatusUnknown {
		task, err := c.Stop(ctx, s)
		if err != nil {
			return nil, err
		}
		err = c.client.Task.Wait(ctx, task, f)
		if err != nil {
			return nil, err
		}
	}
	req, err := c.client.NewRequest(ctx, "DELETE", fmt.Sprintf("/nodes/%s/qemu/%s", s.Node, s.ID), nil)
	if err != nil {
		return
	}
	var taskid string
	_, err = c.client.Do(req, &taskid)
	t = c.client.Task.MustGet(ctx, taskid)
	return
}

/* TODO

// ServerCreateOpts specifies options for creating a new server.
type ServerCreateOpts struct {
	Server
	TemplateID string
	UserData   string
}

// Validate checks if options are valid.
func (o ServerCreateOpts) Validate() error {
	if o.Name == "" {
		return errors.New("missing name")
	}
	return nil
}
*/