107 lines
2.9 KiB
Go
107 lines
2.9 KiB
Go
package rainyun
|
|
|
|
import (
|
|
"context"
|
|
"fmt"
|
|
"time"
|
|
|
|
"git.yoresee.cc/nightstar/ry/internal/model"
|
|
)
|
|
|
|
// ServerService implements provider.ServerService for 雨云.
|
|
type ServerService struct {
|
|
client *client
|
|
}
|
|
|
|
// rainyunServer mirrors the Rainyun RCS API JSON fields (PascalCase).
|
|
type rainyunServer struct {
|
|
ID int `json:"ID"`
|
|
HostName string `json:"HostName"`
|
|
Status string `json:"status"`
|
|
MainIPv4 string `json:"MainIPv4"`
|
|
CPU int `json:"CPU"`
|
|
Memory int `json:"memory"`
|
|
Disk int `json:"disk"`
|
|
OsName string `json:"OsName"`
|
|
Zone string `json:"Zone"`
|
|
ExpireDate int64 `json:"ExpDate"`
|
|
}
|
|
|
|
func (s *ServerService) List(ctx context.Context) ([]model.Server, error) {
|
|
var raw []rainyunServer
|
|
if err := s.client.getList(ctx, "/product/rcs/", &raw); err != nil {
|
|
return nil, err
|
|
}
|
|
servers := make([]model.Server, len(raw))
|
|
for i, r := range raw {
|
|
servers[i] = toServer(r)
|
|
}
|
|
return servers, nil
|
|
}
|
|
|
|
func (s *ServerService) Get(ctx context.Context, id string) (*model.Server, error) {
|
|
var resp struct {
|
|
Data rainyunServer `json:"Data"`
|
|
}
|
|
path := fmt.Sprintf("/product/rcs/%s/", id)
|
|
if err := s.client.get(ctx, path, &resp); err != nil {
|
|
return nil, err
|
|
}
|
|
sv := toServer(resp.Data)
|
|
return &sv, nil
|
|
}
|
|
|
|
func (s *ServerService) Start(ctx context.Context, id string) error {
|
|
return s.client.post(ctx, fmt.Sprintf("/product/rcs/%s/start", id), nil, nil)
|
|
}
|
|
|
|
func (s *ServerService) Stop(ctx context.Context, id string) error {
|
|
return s.client.post(ctx, fmt.Sprintf("/product/rcs/%s/stop", id), nil, nil)
|
|
}
|
|
|
|
func (s *ServerService) Reboot(ctx context.Context, id string) error {
|
|
return s.client.post(ctx, fmt.Sprintf("/product/rcs/%s/reboot", id), nil, nil)
|
|
}
|
|
|
|
func (s *ServerService) Reinstall(ctx context.Context, id, osTemplate string) error {
|
|
body := map[string]string{"os": osTemplate}
|
|
return s.client.post(ctx, fmt.Sprintf("/product/rcs/%s/changeos", id), body, nil)
|
|
}
|
|
|
|
func (s *ServerService) ResetPassword(ctx context.Context, id string) error {
|
|
return s.client.post(ctx, fmt.Sprintf("/product/rcs/%s/reset-password", id), nil, nil)
|
|
}
|
|
|
|
func (s *ServerService) GetVNC(ctx context.Context, id string) (string, error) {
|
|
var resp struct {
|
|
VNCURL string `json:"vnc_url"`
|
|
}
|
|
if err := s.client.get(ctx, fmt.Sprintf("/product/rcs/%s/vnc", id), &resp); err != nil {
|
|
return "", err
|
|
}
|
|
return resp.VNCURL, nil
|
|
}
|
|
|
|
func (s *ServerService) Upgrade(ctx context.Context, id, plan string) error {
|
|
body := map[string]string{"plan": plan}
|
|
return s.client.post(ctx, fmt.Sprintf("/product/rcs/%s/upgrade", id), body, nil)
|
|
}
|
|
|
|
// toServer maps a rainyunServer to the model.Server model.
|
|
func toServer(r rainyunServer) model.Server {
|
|
expire := time.Unix(r.ExpireDate, 0)
|
|
return model.Server{
|
|
ID: fmt.Sprintf("%d", r.ID),
|
|
Name: r.HostName,
|
|
Status: r.Status,
|
|
IP: r.MainIPv4,
|
|
CPU: r.CPU,
|
|
Memory: r.Memory,
|
|
Disk: r.Disk,
|
|
OS: r.OsName,
|
|
Region: r.Zone,
|
|
ExpireAt: expire,
|
|
Raw: r,
|
|
}
|
|
}
|