service.pb.netconn.go

// Code generated by kraftkit.sh/tools/protoc-gen-go-netconn. DO NOT EDIT.
// source: machine/qemu/qmp/v7alpha2/service.proto

package qmpv7alpha2

import (
	"bufio"
	"encoding/json"
	"fmt"
	"io"
	"reflect"
	"sync"
)

type QEMUMachineProtocolClient struct {
	conn io.ReadWriteCloser
	lock sync.RWMutex
	recv *bufio.Reader
	send *bufio.Writer
}

func NewQEMUMachineProtocolClient(conn io.ReadWriteCloser) *QEMUMachineProtocolClient {
	return &QEMUMachineProtocolClient{
		conn: conn,
		recv: bufio.NewReader(conn),
		send: bufio.NewWriter(conn),
	}
}

func (c *QEMUMachineProtocolClient) Close() error {
	return c.conn.Close()
}

func (c *QEMUMachineProtocolClient) setRpcRequestSetDefaults(face any) error {
	v := reflect.ValueOf(face)

	// If it's an interface or a pointer, unwrap it.
	if v.Kind() == reflect.Ptr && v.Elem().Kind() == reflect.Struct {
		v = v.Elem()
	} else {
		return nil
	}

	t := reflect.TypeOf(v.Interface())

	for i := 0; i < v.NumField(); i++ {
		def := t.Field(i).Tag.Get("default")
		if def == "" {
			continue
		}

		f := v.FieldByName(t.Field(i).Name)
		if !f.IsValid() || !f.CanSet() {
			continue
		}

		switch f.Kind() {
		case reflect.String:
			f.SetString(def)
		default:
			return fmt.Errorf("unsupported default kind: %s", f.Kind().String())
		}
	}

	return nil
}

func (c *QEMUMachineProtocolClient) Greeting() (*GreetingResponse, error) {
	var b []byte
	var err error

	c.lock.Lock()
	defer c.lock.Unlock()

	var res GreetingResponse
	b, err = c.recv.ReadBytes('\n')
	if err != nil {
		return nil, err
	}
	if err := json.Unmarshal(b, &res); err != nil {
		return nil, err
	}

	return &res, nil
}

func (c *QEMUMachineProtocolClient) Quit(req QuitRequest) (*QuitResponse, error) {
	var b []byte
	var err error

	c.lock.Lock()
	defer c.lock.Unlock()

	if err := c.setRpcRequestSetDefaults(&req); err != nil {
		return nil, err
	}

	b, err = json.Marshal(req)
	if err != nil {
		return nil, err
	}
	if _, err := c.send.Write(append(b, '\x0a')); err != nil {
		return nil, err
	}
	if err := c.send.Flush(); err != nil {
		return nil, err
	}

	var res QuitResponse
	b, err = c.recv.ReadBytes('\n')
	if err != nil {
		return nil, err
	}
	if err := json.Unmarshal(b, &res); err != nil {
		return nil, err
	}

	return &res, nil
}

func (c *QEMUMachineProtocolClient) Stop(req StopRequest) (*any, error) {
	var b []byte
	var err error

	c.lock.Lock()
	defer c.lock.Unlock()

	if err := c.setRpcRequestSetDefaults(&req); err != nil {
		return nil, err
	}

	b, err = json.Marshal(req)
	if err != nil {
		return nil, err
	}
	if _, err := c.send.Write(append(b, '\x0a')); err != nil {
		return nil, err
	}
	if err := c.send.Flush(); err != nil {
		return nil, err
	}

	var res any
	b, err = c.recv.ReadBytes('\n')
	if err != nil {
		return nil, err
	}
	if err := json.Unmarshal(b, &res); err != nil {
		return nil, err
	}

	return &res, nil
}

func (c *QEMUMachineProtocolClient) Cont(req ContRequest) (*any, error) {
	var b []byte
	var err error

	c.lock.Lock()
	defer c.lock.Unlock()

	if err := c.setRpcRequestSetDefaults(&req); err != nil {
		return nil, err
	}

	b, err = json.Marshal(req)
	if err != nil {
		return nil, err
	}
	if _, err := c.send.Write(append(b, '\x0a')); err != nil {
		return nil, err
	}
	if err := c.send.Flush(); err != nil {
		return nil, err
	}

	var res any
	b, err = c.recv.ReadBytes('\n')
	if err != nil {
		return nil, err
	}
	if err := json.Unmarshal(b, &res); err != nil {
		return nil, err
	}

	return &res, nil
}

func (c *QEMUMachineProtocolClient) SystemReset(req SystemResetRequest) (*any, error) {
	var b []byte
	var err error

	c.lock.Lock()
	defer c.lock.Unlock()

	if err := c.setRpcRequestSetDefaults(&req); err != nil {
		return nil, err
	}

	b, err = json.Marshal(req)
	if err != nil {
		return nil, err
	}
	if _, err := c.send.Write(append(b, '\x0a')); err != nil {
		return nil, err
	}
	if err := c.send.Flush(); err != nil {
		return nil, err
	}

	var res any
	b, err = c.recv.ReadBytes('\n')
	if err != nil {
		return nil, err
	}
	if err := json.Unmarshal(b, &res); err != nil {
		return nil, err
	}

	return &res, nil
}

func (c *QEMUMachineProtocolClient) SystemPowerdown(req SystemPowerdownRequest) (*any, error) {
	var b []byte
	var err error

	c.lock.Lock()
	defer c.lock.Unlock()

	if err := c.setRpcRequestSetDefaults(&req); err != nil {
		return nil, err
	}

	b, err = json.Marshal(req)
	if err != nil {
		return nil, err
	}
	if _, err := c.send.Write(append(b, '\x0a')); err != nil {
		return nil, err
	}
	if err := c.send.Flush(); err != nil {
		return nil, err
	}

	var res any
	b, err = c.recv.ReadBytes('\n')
	if err != nil {
		return nil, err
	}
	if err := json.Unmarshal(b, &res); err != nil {
		return nil, err
	}

	return &res, nil
}

func (c *QEMUMachineProtocolClient) SystemWakeup(req SystemWakeupRequest) (*any, error) {
	var b []byte
	var err error

	c.lock.Lock()
	defer c.lock.Unlock()

	if err := c.setRpcRequestSetDefaults(&req); err != nil {
		return nil, err
	}

	b, err = json.Marshal(req)
	if err != nil {
		return nil, err
	}
	if _, err := c.send.Write(append(b, '\x0a')); err != nil {
		return nil, err
	}
	if err := c.send.Flush(); err != nil {
		return nil, err
	}

	var res any
	b, err = c.recv.ReadBytes('\n')
	if err != nil {
		return nil, err
	}
	if err := json.Unmarshal(b, &res); err != nil {
		return nil, err
	}

	return &res, nil
}

func (c *QEMUMachineProtocolClient) Capabilities(req CapabilitiesRequest) (*any, error) {
	var b []byte
	var err error

	c.lock.Lock()
	defer c.lock.Unlock()

	if err := c.setRpcRequestSetDefaults(&req); err != nil {
		return nil, err
	}

	b, err = json.Marshal(req)
	if err != nil {
		return nil, err
	}
	if _, err := c.send.Write(append(b, '\x0a')); err != nil {
		return nil, err
	}
	if err := c.send.Flush(); err != nil {
		return nil, err
	}

	var res any
	b, err = c.recv.ReadBytes('\n')
	if err != nil {
		return nil, err
	}
	if err := json.Unmarshal(b, &res); err != nil {
		return nil, err
	}

	return &res, nil
}

func (c *QEMUMachineProtocolClient) QueryKvm(req QueryKvmRequest) (*QueryKvmResponse, error) {
	var b []byte
	var err error

	c.lock.Lock()
	defer c.lock.Unlock()

	if err := c.setRpcRequestSetDefaults(&req); err != nil {
		return nil, err
	}

	b, err = json.Marshal(req)
	if err != nil {
		return nil, err
	}
	if _, err := c.send.Write(append(b, '\x0a')); err != nil {
		return nil, err
	}
	if err := c.send.Flush(); err != nil {
		return nil, err
	}

	var res QueryKvmResponse
	b, err = c.recv.ReadBytes('\n')
	if err != nil {
		return nil, err
	}
	if err := json.Unmarshal(b, &res); err != nil {
		return nil, err
	}

	return &res, nil
}

func (c *QEMUMachineProtocolClient) QueryStatus(req QueryStatusRequest) (*QueryStatusResponse, error) {
	var b []byte
	var err error

	c.lock.Lock()
	defer c.lock.Unlock()

	if err := c.setRpcRequestSetDefaults(&req); err != nil {
		return nil, err
	}

	b, err = json.Marshal(req)
	if err != nil {
		return nil, err
	}
	if _, err := c.send.Write(append(b, '\x0a')); err != nil {
		return nil, err
	}
	if err := c.send.Flush(); err != nil {
		return nil, err
	}

	var res QueryStatusResponse
	b, err = c.recv.ReadBytes('\n')
	if err != nil {
		return nil, err
	}
	if err := json.Unmarshal(b, &res); err != nil {
		return nil, err
	}

	return &res, nil
}

func (c *QEMUMachineProtocolClient) SetLink(req SetLinkRequest) (*any, error) {
	var b []byte
	var err error

	c.lock.Lock()
	defer c.lock.Unlock()

	if err := c.setRpcRequestSetDefaults(&req); err != nil {
		return nil, err
	}

	b, err = json.Marshal(req)
	if err != nil {
		return nil, err
	}
	if _, err := c.send.Write(append(b, '\x0a')); err != nil {
		return nil, err
	}
	if err := c.send.Flush(); err != nil {
		return nil, err
	}

	var res any
	b, err = c.recv.ReadBytes('\n')
	if err != nil {
		return nil, err
	}
	if err := json.Unmarshal(b, &res); err != nil {
		return nil, err
	}

	return &res, nil
}

func (c *QEMUMachineProtocolClient) NetdevAddLegacyNic(req NetdevAddLegacyNicRequest) (*any, error) {
	var b []byte
	var err error

	c.lock.Lock()
	defer c.lock.Unlock()

	if err := c.setRpcRequestSetDefaults(&req); err != nil {
		return nil, err
	}

	b, err = json.Marshal(req)
	if err != nil {
		return nil, err
	}
	if _, err := c.send.Write(append(b, '\x0a')); err != nil {
		return nil, err
	}
	if err := c.send.Flush(); err != nil {
		return nil, err
	}

	var res any
	b, err = c.recv.ReadBytes('\n')
	if err != nil {
		return nil, err
	}
	if err := json.Unmarshal(b, &res); err != nil {
		return nil, err
	}

	return &res, nil
}

func (c *QEMUMachineProtocolClient) NetdevAddDevUser(req NetdevAddDevUserRequest) (*any, error) {
	var b []byte
	var err error

	c.lock.Lock()
	defer c.lock.Unlock()

	if err := c.setRpcRequestSetDefaults(&req); err != nil {
		return nil, err
	}

	b, err = json.Marshal(req)
	if err != nil {
		return nil, err
	}
	if _, err := c.send.Write(append(b, '\x0a')); err != nil {
		return nil, err
	}
	if err := c.send.Flush(); err != nil {
		return nil, err
	}

	var res any
	b, err = c.recv.ReadBytes('\n')
	if err != nil {
		return nil, err
	}
	if err := json.Unmarshal(b, &res); err != nil {
		return nil, err
	}

	return &res, nil
}

func (c *QEMUMachineProtocolClient) NetdevAddDevTap(req NetdevAddDevTapRequest) (*any, error) {
	var b []byte
	var err error

	c.lock.Lock()
	defer c.lock.Unlock()

	if err := c.setRpcRequestSetDefaults(&req); err != nil {
		return nil, err
	}

	b, err = json.Marshal(req)
	if err != nil {
		return nil, err
	}
	if _, err := c.send.Write(append(b, '\x0a')); err != nil {
		return nil, err
	}
	if err := c.send.Flush(); err != nil {
		return nil, err
	}

	var res any
	b, err = c.recv.ReadBytes('\n')
	if err != nil {
		return nil, err
	}
	if err := json.Unmarshal(b, &res); err != nil {
		return nil, err
	}

	return &res, nil
}

func (c *QEMUMachineProtocolClient) NetdevAddDevL2TPv3(req NetdevAddDevL2TPv3Request) (*any, error) {
	var b []byte
	var err error

	c.lock.Lock()
	defer c.lock.Unlock()

	if err := c.setRpcRequestSetDefaults(&req); err != nil {
		return nil, err
	}

	b, err = json.Marshal(req)
	if err != nil {
		return nil, err
	}
	if _, err := c.send.Write(append(b, '\x0a')); err != nil {
		return nil, err
	}
	if err := c.send.Flush(); err != nil {
		return nil, err
	}

	var res any
	b, err = c.recv.ReadBytes('\n')
	if err != nil {
		return nil, err
	}
	if err := json.Unmarshal(b, &res); err != nil {
		return nil, err
	}

	return &res, nil
}

func (c *QEMUMachineProtocolClient) NetdevAddDevSocket(req NetdevAddDevSocketRequest) (*any, error) {
	var b []byte
	var err error

	c.lock.Lock()
	defer c.lock.Unlock()

	if err := c.setRpcRequestSetDefaults(&req); err != nil {
		return nil, err
	}

	b, err = json.Marshal(req)
	if err != nil {
		return nil, err
	}
	if _, err := c.send.Write(append(b, '\x0a')); err != nil {
		return nil, err
	}
	if err := c.send.Flush(); err != nil {
		return nil, err
	}

	var res any
	b, err = c.recv.ReadBytes('\n')
	if err != nil {
		return nil, err
	}
	if err := json.Unmarshal(b, &res); err != nil {
		return nil, err
	}

	return &res, nil
}

func (c *QEMUMachineProtocolClient) NetdevAddDevStream(req NetdevAddDevStreamRequest) (*any, error) {
	var b []byte
	var err error

	c.lock.Lock()
	defer c.lock.Unlock()

	if err := c.setRpcRequestSetDefaults(&req); err != nil {
		return nil, err
	}

	b, err = json.Marshal(req)
	if err != nil {
		return nil, err
	}
	if _, err := c.send.Write(append(b, '\x0a')); err != nil {
		return nil, err
	}
	if err := c.send.Flush(); err != nil {
		return nil, err
	}

	var res any
	b, err = c.recv.ReadBytes('\n')
	if err != nil {
		return nil, err
	}
	if err := json.Unmarshal(b, &res); err != nil {
		return nil, err
	}

	return &res, nil
}

func (c *QEMUMachineProtocolClient) NetdevAddDevDgram(req NetdevAddDevDgramRequest) (*any, error) {
	var b []byte
	var err error

	c.lock.Lock()
	defer c.lock.Unlock()

	if err := c.setRpcRequestSetDefaults(&req); err != nil {
		return nil, err
	}

	b, err = json.Marshal(req)
	if err != nil {
		return nil, err
	}
	if _, err := c.send.Write(append(b, '\x0a')); err != nil {
		return nil, err
	}
	if err := c.send.Flush(); err != nil {
		return nil, err
	}

	var res any
	b, err = c.recv.ReadBytes('\n')
	if err != nil {
		return nil, err
	}
	if err := json.Unmarshal(b, &res); err != nil {
		return nil, err
	}

	return &res, nil
}

func (c *QEMUMachineProtocolClient) NetdevAddDevVde(req NetdevAddDevVdeRequest) (*any, error) {
	var b []byte
	var err error

	c.lock.Lock()
	defer c.lock.Unlock()

	if err := c.setRpcRequestSetDefaults(&req); err != nil {
		return nil, err
	}

	b, err = json.Marshal(req)
	if err != nil {
		return nil, err
	}
	if _, err := c.send.Write(append(b, '\x0a')); err != nil {
		return nil, err
	}
	if err := c.send.Flush(); err != nil {
		return nil, err
	}

	var res any
	b, err = c.recv.ReadBytes('\n')
	if err != nil {
		return nil, err
	}
	if err := json.Unmarshal(b, &res); err != nil {
		return nil, err
	}

	return &res, nil
}

func (c *QEMUMachineProtocolClient) NetdevAddDevBridge(req NetdevAddDevBridgeRequest) (*any, error) {
	var b []byte
	var err error

	c.lock.Lock()
	defer c.lock.Unlock()

	if err := c.setRpcRequestSetDefaults(&req); err != nil {
		return nil, err
	}

	b, err = json.Marshal(req)
	if err != nil {
		return nil, err
	}
	if _, err := c.send.Write(append(b, '\x0a')); err != nil {
		return nil, err
	}
	if err := c.send.Flush(); err != nil {
		return nil, err
	}

	var res any
	b, err = c.recv.ReadBytes('\n')
	if err != nil {
		return nil, err
	}
	if err := json.Unmarshal(b, &res); err != nil {
		return nil, err
	}

	return &res, nil
}

func (c *QEMUMachineProtocolClient) NetdevAddDevHubPort(req NetdevAddDevHubPortRequest) (*any, error) {
	var b []byte
	var err error

	c.lock.Lock()
	defer c.lock.Unlock()

	if err := c.setRpcRequestSetDefaults(&req); err != nil {
		return nil, err
	}

	b, err = json.Marshal(req)
	if err != nil {
		return nil, err
	}
	if _, err := c.send.Write(append(b, '\x0a')); err != nil {
		return nil, err
	}
	if err := c.send.Flush(); err != nil {
		return nil, err
	}

	var res any
	b, err = c.recv.ReadBytes('\n')
	if err != nil {
		return nil, err
	}
	if err := json.Unmarshal(b, &res); err != nil {
		return nil, err
	}

	return &res, nil
}

func (c *QEMUMachineProtocolClient) NetdevAddDevNetmap(req NetdevAddDevNetmapRequest) (*any, error) {
	var b []byte
	var err error

	c.lock.Lock()
	defer c.lock.Unlock()

	if err := c.setRpcRequestSetDefaults(&req); err != nil {
		return nil, err
	}

	b, err = json.Marshal(req)
	if err != nil {
		return nil, err
	}
	if _, err := c.send.Write(append(b, '\x0a')); err != nil {
		return nil, err
	}
	if err := c.send.Flush(); err != nil {
		return nil, err
	}

	var res any
	b, err = c.recv.ReadBytes('\n')
	if err != nil {
		return nil, err
	}
	if err := json.Unmarshal(b, &res); err != nil {
		return nil, err
	}

	return &res, nil
}

func (c *QEMUMachineProtocolClient) NetdevAddDevVhostUser(req NetdevAddDevVhostUserRequest) (*any, error) {
	var b []byte
	var err error

	c.lock.Lock()
	defer c.lock.Unlock()

	if err := c.setRpcRequestSetDefaults(&req); err != nil {
		return nil, err
	}

	b, err = json.Marshal(req)
	if err != nil {
		return nil, err
	}
	if _, err := c.send.Write(append(b, '\x0a')); err != nil {
		return nil, err
	}
	if err := c.send.Flush(); err != nil {
		return nil, err
	}

	var res any
	b, err = c.recv.ReadBytes('\n')
	if err != nil {
		return nil, err
	}
	if err := json.Unmarshal(b, &res); err != nil {
		return nil, err
	}

	return &res, nil
}

func (c *QEMUMachineProtocolClient) NetdevAddDevVhostVDPA(req NetdevAddDevVhostVDPARequest) (*any, error) {
	var b []byte
	var err error

	c.lock.Lock()
	defer c.lock.Unlock()

	if err := c.setRpcRequestSetDefaults(&req); err != nil {
		return nil, err
	}

	b, err = json.Marshal(req)
	if err != nil {
		return nil, err
	}
	if _, err := c.send.Write(append(b, '\x0a')); err != nil {
		return nil, err
	}
	if err := c.send.Flush(); err != nil {
		return nil, err
	}

	var res any
	b, err = c.recv.ReadBytes('\n')
	if err != nil {
		return nil, err
	}
	if err := json.Unmarshal(b, &res); err != nil {
		return nil, err
	}

	return &res, nil
}

func (c *QEMUMachineProtocolClient) NetdevAddDevVmnetHost(req NetdevAddDevVmnetHostRequest) (*any, error) {
	var b []byte
	var err error

	c.lock.Lock()
	defer c.lock.Unlock()

	if err := c.setRpcRequestSetDefaults(&req); err != nil {
		return nil, err
	}

	b, err = json.Marshal(req)
	if err != nil {
		return nil, err
	}
	if _, err := c.send.Write(append(b, '\x0a')); err != nil {
		return nil, err
	}
	if err := c.send.Flush(); err != nil {
		return nil, err
	}

	var res any
	b, err = c.recv.ReadBytes('\n')
	if err != nil {
		return nil, err
	}
	if err := json.Unmarshal(b, &res); err != nil {
		return nil, err
	}

	return &res, nil
}

func (c *QEMUMachineProtocolClient) NetdevAddDevVmnetShared(req NetdevAddDevVmnetSharedRequest) (*any, error) {
	var b []byte
	var err error

	c.lock.Lock()
	defer c.lock.Unlock()

	if err := c.setRpcRequestSetDefaults(&req); err != nil {
		return nil, err
	}

	b, err = json.Marshal(req)
	if err != nil {
		return nil, err
	}
	if _, err := c.send.Write(append(b, '\x0a')); err != nil {
		return nil, err
	}
	if err := c.send.Flush(); err != nil {
		return nil, err
	}

	var res any
	b, err = c.recv.ReadBytes('\n')
	if err != nil {
		return nil, err
	}
	if err := json.Unmarshal(b, &res); err != nil {
		return nil, err
	}

	return &res, nil
}

func (c *QEMUMachineProtocolClient) NetdevAddDevVmnetBridged(req NetdevAddDevVmnetBridgedRequest) (*any, error) {
	var b []byte
	var err error

	c.lock.Lock()
	defer c.lock.Unlock()

	if err := c.setRpcRequestSetDefaults(&req); err != nil {
		return nil, err
	}

	b, err = json.Marshal(req)
	if err != nil {
		return nil, err
	}
	if _, err := c.send.Write(append(b, '\x0a')); err != nil {
		return nil, err
	}
	if err := c.send.Flush(); err != nil {
		return nil, err
	}

	var res any
	b, err = c.recv.ReadBytes('\n')
	if err != nil {
		return nil, err
	}
	if err := json.Unmarshal(b, &res); err != nil {
		return nil, err
	}

	return &res, nil
}

func (c *QEMUMachineProtocolClient) NetdevDel(req NetdevDelRequest) (*any, error) {
	var b []byte
	var err error

	c.lock.Lock()
	defer c.lock.Unlock()

	if err := c.setRpcRequestSetDefaults(&req); err != nil {
		return nil, err
	}

	b, err = json.Marshal(req)
	if err != nil {
		return nil, err
	}
	if _, err := c.send.Write(append(b, '\x0a')); err != nil {
		return nil, err
	}
	if err := c.send.Flush(); err != nil {
		return nil, err
	}

	var res any
	b, err = c.recv.ReadBytes('\n')
	if err != nil {
		return nil, err
	}
	if err := json.Unmarshal(b, &res); err != nil {
		return nil, err
	}

	return &res, nil
}

func (c *QEMUMachineProtocolClient) QueryRxFilter(req QueryRxFilterRequest) (*QueryRxFilterResponse, error) {
	var b []byte
	var err error

	c.lock.Lock()
	defer c.lock.Unlock()

	if err := c.setRpcRequestSetDefaults(&req); err != nil {
		return nil, err
	}

	b, err = json.Marshal(req)
	if err != nil {
		return nil, err
	}
	if _, err := c.send.Write(append(b, '\x0a')); err != nil {
		return nil, err
	}
	if err := c.send.Flush(); err != nil {
		return nil, err
	}

	var res QueryRxFilterResponse
	b, err = c.recv.ReadBytes('\n')
	if err != nil {
		return nil, err
	}
	if err := json.Unmarshal(b, &res); err != nil {
		return nil, err
	}

	return &res, nil
}