implement a jsonrpc api for all zos endpoint followin net/rpc pkg

protocol.

Author: Omarabdul3ziz

cmds/modules/api_gateway/main.go

@@ -12,6 +12,7 @@ import (
 	"github.com/threefoldtech/tfgrid-sdk-go/rmb-sdk-go/peer"
 	"github.com/threefoldtech/zbus"
 	"github.com/threefoldtech/zos/pkg/environment"
+	"github.com/threefoldtech/zos/pkg/rpc"
 	"github.com/threefoldtech/zos/pkg/stubs"
 	substrategw "github.com/threefoldtech/zos/pkg/substrate_gateway"
 	"github.com/threefoldtech/zos/pkg/utils"
@@ -36,6 +37,11 @@ var Module cli.Command = cli.Command{
 			Usage: "number of workers `N`",
 			Value: 1,
 		},
+		&cli.UintFlag{
+			Name:  "port",
+			Usage: "rpc server port",
+			Value: 3000,
+		},
 	},
 	Action: action,
 }
@@ -44,6 +50,7 @@ func action(cli *cli.Context) error {
 	var (
 		msgBrokerCon string = cli.String("broker")
 		workerNr     uint   = cli.Uint("workers")
+		port         uint   = cli.Uint("port")
 	)
 
 	server, err := zbus.NewRedisServer(module, msgBrokerCon, workerNr)
@@ -98,6 +105,13 @@ func action(cli *cli.Context) error {
 	}
 	api.SetupRoutes(router)
 
+	go func() {
+		if err := rpc.Run(ctx, port, manager, redis, msgBrokerCon); err != nil {
+			log.Error().Err(err).Msg("failed to run rpc server")
+			return
+		}
+	}()
+
 	pair, err := id.KeyPair()
 	if err != nil {
 		return err

openrpc.json

@@ -297,7 +297,7 @@
       }
     },
     {
-      "name": "zos.DeploymentCreate",
+      "name": "zos.DeploymentDeploy",
       "params": [
         {
           "name": "deployment",

pkg/rpc/admin.go

@@ -0,0 +1,40 @@
+package rpc
+
+func (s *Service) AdminPublicNICSet(arg string, reply *any) error {
+	return s.networkerStub.SetPublicExitDevice(s.ctx, arg)
+}
+
+func (s *Service) AdminPublicNICGet(arg any, reply *ExitDevice) error {
+	ed, err := s.networkerStub.GetPublicExitDevice(s.ctx)
+	if err != nil {
+		return err
+	}
+
+	reply.AsDualInterface = ed.AsDualInterface
+	reply.IsDual = ed.IsDual
+	reply.IsSingle = ed.IsSingle
+	return nil
+}
+
+func (s *Service) AdminInterfaces(arg any, reply *Interfaces) error {
+	interfaces, err := s.networkerStub.Interfaces(s.ctx, "", "")
+	if err != nil {
+		return err
+	}
+
+	for name, inf := range interfaces.Interfaces {
+		reply.Interfaces = append(reply.Interfaces, Interface{
+			Name: name,
+			Mac:  inf.Mac,
+			Ips: func() []string {
+				var ips []string
+				for _, ip := range inf.IPs {
+					ips = append(ips, ip.String())
+				}
+				return ips
+			}(),
+		})
+	}
+
+	return nil
+}

pkg/rpc/converter.go

@@ -0,0 +1,66 @@
+package rpc
+
+import (
+	"encoding/json"
+
+	"github.com/threefoldtech/zos/pkg/capacity/dmi"
+)
+
+// This function heavily used and it depends on matching json tags on both types
+func convert(input any, output any) error {
+	data, err := json.Marshal(input)
+	if err != nil {
+		return err
+	}
+
+	if err := json.Unmarshal(data, &output); err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func convertDmi(input *dmi.DMI, output *DMI) {
+	dmi := *input
+
+	*output = DMI{
+		Tooling: Tooling{
+			Aggregator: dmi.Tooling.Aggregator,
+			Decoder:    dmi.Tooling.Decoder,
+		},
+		Sections: func() []Section {
+			var sections []Section
+			for _, sec := range dmi.Sections {
+				section := Section{
+					HandleLine: sec.HandleLine,
+					TypeStr:    sec.TypeStr,
+					Type:       uint64(sec.Type),
+					SubSections: func() []SubSection {
+						var subsections []SubSection
+						for _, subsec := range sec.SubSections {
+							subsection := SubSection{
+								Title: subsec.Title,
+								Properties: func() []PropertyData {
+									var properties []PropertyData
+									for key, prop := range subsec.Properties {
+										property := PropertyData{
+											Name:  key,
+											Val:   prop.Val,
+											Items: prop.Items,
+										}
+										properties = append(properties, property)
+									}
+									return properties
+								}(),
+							}
+							subsections = append(subsections, subsection)
+						}
+						return subsections
+					}(),
+				}
+				sections = append(sections, section)
+			}
+			return sections
+		}(),
+	}
+}

pkg/rpc/deployment.go

@@ -0,0 +1,66 @@
+package rpc
+
+import (
+	"context"
+
+	"github.com/threefoldtech/zos/pkg/gridtypes"
+)
+
+func (s *Service) DeploymentChanges(arg uint64, reply *Workloads) error {
+	wls, err := s.provisionStub.Changes(context.Background(), GetTwinID(s.ctx), arg)
+	if err != nil {
+		return err
+	}
+
+	for _, wl := range wls {
+		var workload Workload
+		if err := convert(wl, &workload); err != nil {
+			return err
+		}
+		reply.Workloads = append(reply.Workloads, workload)
+	}
+
+	return nil
+}
+
+func (s *Service) DeploymentList(arg any, reply *Deployments) error {
+	deps, err := s.provisionStub.List(s.ctx, GetTwinID(s.ctx))
+	if err != nil {
+		return err
+	}
+
+	for _, dep := range deps {
+		var deployment Deployment
+		if err := convert(dep, &deployment); err != nil {
+			return err
+		}
+		reply.Deployments = append(reply.Deployments, deployment)
+	}
+
+	return nil
+}
+
+func (s *Service) DeploymentGet(arg uint64, reply *Deployment) error {
+	dep, err := s.provisionStub.Get(s.ctx, GetTwinID(s.ctx), arg)
+	if err != nil {
+		return err
+	}
+
+	return convert(dep, reply)
+}
+
+func (s *Service) DeploymentUpdate(arg Deployment, reply *any) error {
+	var deployment gridtypes.Deployment
+	if err := convert(arg, &deployment); err != nil {
+		return err
+	}
+	return s.provisionStub.CreateOrUpdate(s.ctx, GetTwinID(s.ctx), deployment, true)
+}
+
+func (s *Service) DeploymentDeploy(arg Deployment, reply *any) error {
+	var deployment gridtypes.Deployment
+	if err := convert(arg, &deployment); err != nil {
+		return err
+	}
+	return s.provisionStub.CreateOrUpdate(s.ctx, GetTwinID(s.ctx), deployment, false)
+}

pkg/rpc/gpu.go

@@ -0,0 +1,19 @@
+package rpc
+
+func (s *Service) GpuList(arg any, reply *GPUs) error {
+	gpus, err := s.statisticsStub.ListGPUs(s.ctx)
+	if err != nil {
+		return err
+	}
+
+	for _, gpu := range gpus {
+		reply.GPUs = append(reply.GPUs, GPU{
+			ID:       gpu.ID,
+			Vendor:   gpu.Vendor,
+			Device:   gpu.Device,
+			Contract: gpu.Contract,
+		})
+	}
+
+	return nil
+}

pkg/rpc/network.go

@@ -0,0 +1,96 @@
+package rpc
+
+import (
+	"fmt"
+	"net"
+
+	"github.com/threefoldtech/zos/pkg/gridtypes"
+)
+
+func (s *Service) NetworkPublicIps(arg any, reply *Ips) error {
+	ips, err := s.provisionStub.ListPublicIPs(s.ctx)
+	if err != nil {
+		return err
+	}
+
+	reply.Ips = append(reply.Ips, ips...)
+	return nil
+}
+
+func (s *Service) NetworkHasIpv6(arg any, reply *bool) error {
+	ipData, err := s.networkerStub.GetPublicIPv6Subnet(s.ctx)
+	hasIP := ipData.IP != nil && err == nil
+	*reply = hasIP
+	return nil
+}
+
+func (s *Service) NetworkInterfaces(arg any, reply *Interfaces) error {
+	type q struct {
+		inf    string
+		ns     string
+		rename string
+	}
+
+	for _, i := range []q{
+		{"zos", "", "zos"},
+		{"nygg6", "ndmz", "ygg"},
+	} {
+		ips, _, err := s.networkerStub.Addrs(s.ctx, i.inf, i.ns)
+		if err != nil {
+			return fmt.Errorf("failed to get ips for '%s' interface: %w", i, err)
+		}
+
+		reply.Interfaces = append(reply.Interfaces, Interface{
+			Name: i.rename,
+			Ips: func() []string {
+				var list []string
+				for _, item := range ips {
+					ip := net.IP(item)
+					list = append(list, ip.String())
+				}
+
+				return list
+			}(),
+		})
+	}
+
+	return nil
+}
+
+func (s *Service) NetworkPublicConfig(arg any, reply *PublicConfig) error {
+	config, err := s.networkerStub.GetPublicConfig(s.ctx)
+	if err != nil {
+		return err
+	}
+
+	reply.Domain = config.Domain
+	reply.IPv4 = config.IPv4.String()
+	reply.IPv6 = config.IPv6.String()
+	reply.GW4 = config.GW4.String()
+	reply.GW6 = config.GW6.String()
+	reply.Type = string(config.Type)
+	return nil
+}
+
+func (s *Service) NetworkWGPorts(arg any, reply *WGPorts) error {
+	ports, err := s.networkerStub.WireguardPorts(s.ctx)
+	if err != nil {
+		return err
+	}
+
+	for _, port := range ports {
+		reply.Ports = append(reply.Ports, uint64(port))
+	}
+
+	return nil
+}
+
+func (s *Service) NetworkPrivateIps(arg string, reply *Ips) error {
+	ips, err := s.provisionStub.ListPrivateIPs(s.ctx, GetTwinID(s.ctx), gridtypes.Name(arg))
+	if err != nil {
+		return err
+	}
+
+	reply.Ips = append(reply.Ips, ips...)
+	return nil
+}

pkg/rpc/perf.go

@@ -0,0 +1,46 @@
+package rpc
+
+func (s *Service) PerfGetCpuBench(arg any, reply *CpuBenchTaskResult) error {
+	r, err := s.performanceMonitorStub.GetCpuBenchTaskResult(s.ctx)
+	if err != nil {
+		return err
+	}
+
+	return convert(r, reply)
+}
+
+func (s *Service) PerfGetHealth(arg any, reply *HealthTaskResult) error {
+	r, err := s.performanceMonitorStub.GetHealthTaskResult(s.ctx)
+	if err != nil {
+		return err
+	}
+
+	return convert(r, reply)
+}
+
+func (s *Service) PerfGetIperf(arg any, reply *IperfTaskResult) error {
+	r, err := s.performanceMonitorStub.GetIperfTaskResult(s.ctx)
+	if err != nil {
+		return err
+	}
+
+	return convert(r, reply)
+}
+
+func (s *Service) PerfGetPublicIP(arg any, reply *PublicIpTaskResult) error {
+	r, err := s.performanceMonitorStub.GetPublicIpTaskResult(s.ctx)
+	if err != nil {
+		return err
+	}
+
+	return convert(r, reply)
+}
+
+func (s *Service) PerfGetAll(arg any, reply *AllTaskResult) error {
+	r, err := s.performanceMonitorStub.GetAllTaskResult(s.ctx)
+	if err != nil {
+		return err
+	}
+
+	return convert(r, reply)
+}