Files

174 lines
4.4 KiB
Go

package taskflow
import (
"context"
"fmt"
"net/url"
"github.com/coder/websocket"
"github.com/chaitin/MonkeyCode/backend/pkg/request"
)
type virtualMachineClient struct {
client *request.Client
}
func newVirtualMachineClient(client *request.Client) VirtualMachiner {
return &virtualMachineClient{client: client}
}
// Create implements VirtualMachiner.
func (v *virtualMachineClient) Create(ctx context.Context, req *CreateVirtualMachineReq) (*VirtualMachine, error) {
resp, err := request.Post[Resp[*VirtualMachine]](v.client, ctx, "/internal/vm", req)
if err != nil {
return nil, err
}
return resp.Data, nil
}
// Delete implements VirtualMachiner.
func (v *virtualMachineClient) Delete(ctx context.Context, req *DeleteVirtualMachineReq) error {
q := request.Query{
"id": req.ID,
"host_id": req.HostID,
"user_id": req.UserID,
}
_, err := request.Delete[any](v.client, ctx, "/internal/vm", request.WithQuery(q))
return err
}
// List implements VirtualMachiner.
func (v *virtualMachineClient) List(ctx context.Context, id string) ([]*VirtualMachine, error) {
q := request.Query{
"id": id,
}
resp, err := request.Get[Resp[[]*VirtualMachine]](v.client, ctx, "/internal/vm/list", request.WithQuery(q))
if err != nil {
return []*VirtualMachine{}, err
}
return resp.Data, nil
}
// Info implements VirtualMachiner.
func (v *virtualMachineClient) Info(ctx context.Context, req VirtualMachineInfoReq) (*VirtualMachine, error) {
q := request.Query{
"id": req.ID,
"user_id": req.UserID,
}
resp, err := request.Get[Resp[*VirtualMachine]](v.client, ctx, "/internal/vm/info", request.WithQuery(q))
if err != nil {
return &VirtualMachine{}, err
}
return resp.Data, nil
}
// IsOnline implements VirtualMachiner.
func (v *virtualMachineClient) IsOnline(ctx context.Context, req *IsOnlineReq[string]) (*IsOnlineResp, error) {
resp, err := request.Post[Resp[*IsOnlineResp]](v.client, ctx, "/internal/vm/is-online", req)
if err != nil {
return nil, err
}
return resp.Data, nil
}
// Terminal implements VirtualMachiner.
func (v *virtualMachineClient) Terminal(ctx context.Context, req *TerminalReq) (Sheller, error) {
wsScheme := "ws"
if v.client.GetScheme() == "https" {
wsScheme = "wss"
}
dial := func(ctx context.Context) (*websocket.Conn, error) {
u := &url.URL{
Scheme: wsScheme,
Host: v.client.GetHost(),
Path: "/internal/ws/terminal",
}
values := url.Values{}
values.Add("id", req.ID)
values.Add("col", fmt.Sprintf("%d", req.Col))
values.Add("row", fmt.Sprintf("%d", req.Row))
values.Add("terminal_id", req.TerminalID)
values.Add("exec", req.Exec)
values.Add("mode", fmt.Sprintf("%d", req.Mode))
u.RawQuery = values.Encode()
conn, _, err := websocket.Dial(ctx, u.String(), &websocket.DialOptions{})
if err != nil {
return nil, err
}
return conn, nil
}
conn, err := dial(ctx)
if err != nil {
return nil, err
}
ctx, cancel := context.WithCancelCause(ctx)
shell := &Shell{
ctx: ctx,
cancel: cancel,
conn: conn,
dial: dial,
}
shell.startPing()
return shell, nil
}
// Reports implements VirtualMachiner.
func (v *virtualMachineClient) Reports(ctx context.Context, req ReportSubscribeReq) (Reporter, error) {
wsScheme := "ws"
if v.client.GetScheme() == "https" {
wsScheme = "wss"
}
u := &url.URL{
Scheme: wsScheme,
Host: v.client.GetHost(),
Path: "/internal/ws/reports",
}
values := url.Values{}
values.Add("id", req.ID)
if req.FromID != "" {
values.Add("from_id", req.FromID)
}
if req.History > 0 {
values.Add("history", fmt.Sprintf("%d", req.History))
}
u.RawQuery = values.Encode()
conn, _, err := websocket.Dial(ctx, u.String(), &websocket.DialOptions{})
if err != nil {
return nil, err
}
ctx, cancel := context.WithCancelCause(ctx)
return &ReportsStream{
ctx: ctx,
cancel: cancel,
conn: conn,
}, nil
}
// TerminalList implements VirtualMachiner.
func (v *virtualMachineClient) TerminalList(ctx context.Context, id string) ([]*Terminal, error) {
resp, err := request.Get[Resp[[]*Terminal]](v.client, ctx, "/internal/terminal", request.WithQuery(
request.Query{"id": id},
))
if err != nil {
return nil, err
}
return resp.Data, nil
}
// CloseTerminal implements VirtualMachiner.
func (v *virtualMachineClient) CloseTerminal(ctx context.Context, req *CloseTerminalReq) error {
_, err := request.Delete[any](v.client, ctx, "/internal/terminal", request.WithBody(req))
return err
}