mycelium messaging integration

- generated openrpc file with all methods/types for api
- new `api` pkg handling both modes normal/light handlers with defined
  param/return type, decoupled from the messaging part
- new `reciever` pkg handling the messaging over mycelium binary with
  handlers mapped to api pkg
- update monitor pkg/stub for better defined-typed results

Author: Omarabdul3ziz

mycelium-openrpc.json

@@ -0,0 +1,71 @@
+package api
+
+import (
+	"errors"
+	"time"
+
+	"github.com/patrickmn/go-cache"
+	"github.com/threefoldtech/zbus"
+	"github.com/threefoldtech/zosbase/pkg/capacity"
+	"github.com/threefoldtech/zosbase/pkg/diagnostics"
+	"github.com/threefoldtech/zosbase/pkg/stubs"
+)
+
+const (
+	cacheDefaultExpiration = 24 * time.Hour
+	cacheDefaultCleanup    = 24 * time.Hour
+	lightMode              = "light"
+)
+
+var (
+	ErrNotSupportedInLightMode = errors.New("method is not supported in light mode")
+)
+
+type API struct {
+	mode                   string
+	oracle                 *capacity.ResourceOracle
+	versionMonitorStub     *stubs.VersionMonitorStub
+	systemMonitorStub      *stubs.SystemMonitorStub
+	provisionStub          *stubs.ProvisionStub
+	networkerStub          *stubs.NetworkerStub
+	networkerLightStub     *stubs.NetworkerLightStub
+	statisticsStub         *stubs.StatisticsStub
+	storageStub            *stubs.StorageModuleStub
+	performanceMonitorStub *stubs.PerformanceMonitorStub
+	diagnosticsManager     *diagnostics.DiagnosticsManager
+	inMemCache             *cache.Cache
+}
+
+func NewAPI(client zbus.Client, msgBrokerCon string, mode string) (*API, error) {
+	diagnosticsManager, err := diagnostics.NewDiagnosticsManager(msgBrokerCon, client)
+	if err != nil {
+		return nil, err
+	}
+
+	storageModuleStub := stubs.NewStorageModuleStub(client)
+
+	api := &API{
+		mode:                   mode,
+		storageStub:            storageModuleStub,
+		diagnosticsManager:     diagnosticsManager,
+		oracle:                 capacity.NewResourceOracle(storageModuleStub),
+		versionMonitorStub:     stubs.NewVersionMonitorStub(client),
+		systemMonitorStub:      stubs.NewSystemMonitorStub(client),
+		provisionStub:          stubs.NewProvisionStub(client),
+		statisticsStub:         stubs.NewStatisticsStub(client),
+		performanceMonitorStub: stubs.NewPerformanceMonitorStub(client),
+	}
+
+	if mode == lightMode {
+		api.networkerLightStub = stubs.NewNetworkerLightStub(client)
+	} else {
+		api.networkerStub = stubs.NewNetworkerStub(client)
+	}
+
+	api.inMemCache = cache.New(cacheDefaultExpiration, cacheDefaultCleanup)
+	return api, nil
+}
+
+func (a *API) isLightMode() bool {
+	return a.mode == lightMode
+}

pkg/api/api.go

@@ -0,0 +1,52 @@
+package api
+
+import (
+	"context"
+	"errors"
+
+	"github.com/threefoldtech/zosbase/pkg/gridtypes"
+)
+
+func (a *API) DeploymentDeployHandler(ctx context.Context, deployment gridtypes.Deployment) error {
+	twinID, ok := ctx.Value("twin_id").(uint32)
+	if !ok {
+		return errors.New("could not get twin_id from context")
+	}
+	return a.provisionStub.CreateOrUpdate(ctx, twinID, deployment, false)
+}
+
+func (a *API) DeploymentUpdateHandler(ctx context.Context, deployment gridtypes.Deployment) error {
+	twinID, ok := ctx.Value("twin_id").(uint32)
+	if !ok {
+		return errors.New("could not get twin_id from context")
+	}
+	return a.provisionStub.CreateOrUpdate(ctx, twinID, deployment, true)
+}
+
+func (a *API) DeploymentDeleteHandler(ctx context.Context, contractID uint64) error {
+	return errors.New("deletion over the api is disabled, please cancel your contract instead")
+}
+
+func (a *API) DeploymentGetHandler(ctx context.Context, contractID uint64) (gridtypes.Deployment, error) {
+	twinID, ok := ctx.Value("twin_id").(uint32)
+	if !ok {
+		return gridtypes.Deployment{}, errors.New("could not get twin_id from context")
+	}
+	return a.provisionStub.Get(ctx, twinID, contractID)
+}
+
+func (a *API) DeploymentListHandler(ctx context.Context) ([]gridtypes.Deployment, error) {
+	twinID, ok := ctx.Value("twin_id").(uint32)
+	if !ok {
+		return nil, errors.New("could not get twin_id from context")
+	}
+	return a.provisionStub.List(ctx, twinID)
+}
+
+func (a *API) DeploymentChangesHandler(ctx context.Context, contractID uint64) ([]gridtypes.Workload, error) {
+	twinID, ok := ctx.Value("twin_id").(uint32)
+	if !ok {
+		return nil, errors.New("could not get twin_id from context")
+	}
+	return a.provisionStub.Changes(ctx, twinID, contractID)
+}

pkg/api/deployment.go

@@ -0,0 +1,31 @@
+package api
+
+import (
+	"context"
+	"fmt"
+
+	"github.com/patrickmn/go-cache"
+	"github.com/threefoldtech/zosbase/pkg/geoip"
+)
+
+const (
+	locationCacheKey = "location"
+)
+
+func (a *API) LocationGet(ctx context.Context) (geoip.Location, error) {
+	if loc, found := a.inMemCache.Get(locationCacheKey); found {
+		if loc, ok := loc.(geoip.Location); ok {
+			return loc, nil
+		}
+
+		return geoip.Location{}, fmt.Errorf("failed to convert cached location")
+	}
+
+	loc, err := geoip.Fetch()
+	if err != nil {
+		return geoip.Location{}, err
+	}
+	a.inMemCache.Set(locationCacheKey, loc, cache.DefaultExpiration)
+
+	return loc, nil
+}

pkg/api/location.go

@@ -0,0 +1,20 @@
+package api
+
+import (
+	"context"
+	"fmt"
+	"os"
+	"path/filepath"
+)
+
+// GetVmLogsHandler returns VM logs
+func (a *API) GetVmLogsHandler(ctx context.Context, fileName string) (string, error) {
+	rootPath := "/var/cache/modules/vmd/logs/"
+	fullPath := filepath.Join(rootPath, fileName)
+	content, err := os.ReadFile(fullPath)
+	if err != nil {
+		return "", fmt.Errorf("failed to read file, path: %s, %w", fullPath, err)
+	}
+
+	return string(content), nil
+}

pkg/api/logs.go

@@ -0,0 +1,27 @@
+package api
+
+import (
+	"context"
+
+	"github.com/threefoldtech/zosbase/pkg"
+)
+
+func (a *API) PerfSpeed(ctx context.Context) (pkg.IperfTaskResult, error) {
+	return a.performanceMonitorStub.GetIperfTaskResult(ctx)
+}
+
+func (a *API) PerfHealth(ctx context.Context) (pkg.HealthTaskResult, error) {
+	return a.performanceMonitorStub.GetHealthTaskResult(ctx)
+}
+
+func (a *API) PerfPublicIp(ctx context.Context) (pkg.PublicIpTaskResult, error) {
+	return a.performanceMonitorStub.GetPublicIpTaskResult(ctx)
+}
+
+func (a *API) PerfBenchmark(ctx context.Context) (pkg.CpuBenchTaskResult, error) {
+	return a.performanceMonitorStub.GetCpuBenchTaskResult(ctx)
+}
+
+func (a *API) PerfAll(ctx context.Context) (pkg.AllTaskResult, error) {
+	return a.performanceMonitorStub.GetAllTaskResult(ctx)
+}

pkg/api/monitor.go

@@ -0,0 +1,117 @@
+package api
+
+import (
+	"context"
+	"errors"
+	"fmt"
+	"net"
+
+	"github.com/threefoldtech/zosbase/pkg"
+	"github.com/threefoldtech/zosbase/pkg/gridtypes"
+)
+
+func (a *API) NetworkWGPorts(ctx context.Context) ([]uint, error) {
+	if a.isLightMode() {
+		return nil, ErrNotSupportedInLightMode
+	}
+	return a.networkerStub.WireguardPorts(ctx)
+}
+
+func (a *API) NetworkPublicConfigGet(ctx context.Context, _ any) (pkg.PublicConfig, error) {
+	if a.isLightMode() {
+		return pkg.PublicConfig{}, ErrNotSupportedInLightMode
+	}
+
+	return a.networkerStub.GetPublicConfig(ctx)
+}
+
+func (a *API) NetworkHasIPv6(ctx context.Context) (bool, error) {
+	if a.isLightMode() {
+		return false, nil
+	}
+
+	ipData, err := a.networkerStub.GetPublicIPv6Subnet(ctx)
+	hasIP := ipData.IP != nil && err == nil
+	return hasIP, nil
+
+}
+
+func (a *API) NetworkListPublicIPs(ctx context.Context) ([]string, error) {
+	if a.isLightMode() {
+		return nil, ErrNotSupportedInLightMode
+	}
+
+	return a.provisionStub.ListPublicIPs(ctx)
+}
+
+func (a *API) NetworkListPrivateIPs(ctx context.Context, networkName string) ([]string, error) {
+	name := gridtypes.Name(networkName)
+	twinID, ok := ctx.Value("twin_id").(uint32)
+	if !ok {
+		return nil, errors.New("could not get twin_id from context")
+	}
+	return a.provisionStub.ListPrivateIPs(ctx, twinID, name)
+}
+
+func (a *API) NetworkInterfaces(ctx context.Context) (pkg.Interfaces, error) {
+	if a.isLightMode() {
+		return a.networkerLightStub.Interfaces(ctx, "zos", "")
+	}
+
+	type q struct {
+		inf    string
+		ns     string
+		rename string
+	}
+	result := pkg.Interfaces{
+		Interfaces: make(map[string]pkg.Interface),
+	}
+	for _, i := range []q{{"zos", "", "zos"}, {"nygg6", "ndmz", "ygg"}} {
+		ips, mac, err := a.networkerStub.Addrs(ctx, i.inf, i.ns)
+		if err != nil {
+			return pkg.Interfaces{Interfaces: make(map[string]pkg.Interface)}, fmt.Errorf("failed to get ips for '%s' interface: %w", i.inf, err)
+		}
+
+		iface := pkg.Interface{
+			Name: i.rename,
+			Mac:  mac,
+			IPs:  []net.IPNet{},
+		}
+
+		for _, item := range ips {
+			ipNet := net.IPNet{
+				IP:   item,
+				Mask: nil,
+			}
+			iface.IPs = append(iface.IPs, ipNet)
+		}
+
+		result.Interfaces[i.rename] = iface
+	}
+
+	return result, nil
+}
+
+// all interfaces on the node
+func (a *API) AdminInterfaces(ctx context.Context) (pkg.Interfaces, error) {
+	if a.isLightMode() {
+		return a.networkerLightStub.Interfaces(ctx, "", "")
+	}
+
+	return a.networkerStub.Interfaces(ctx, "", "")
+}
+
+func (a *API) AdminSetPublicNIC(ctx context.Context, device string) error {
+	if a.isLightMode() {
+		return ErrNotSupportedInLightMode
+	}
+	return a.networkerStub.SetPublicExitDevice(ctx, device)
+}
+
+func (a *API) AdminGetPublicNIC(ctx context.Context) (pkg.ExitDevice, error) {
+	if a.isLightMode() {
+		return pkg.ExitDevice{}, ErrNotSupportedInLightMode
+	}
+
+	return a.networkerStub.GetPublicExitDevice(ctx)
+}

pkg/api/network.go

@@ -0,0 +1,15 @@
+package api
+
+import (
+	"context"
+
+	"github.com/threefoldtech/zosbase/pkg"
+)
+
+func (a *API) Statistics(ctx context.Context) (pkg.Counters, error) {
+	return a.statisticsStub.GetCounters(ctx)
+}
+
+func (a *API) GpuList(ctx context.Context) ([]pkg.GPUInfo, error) {
+	return a.statisticsStub.ListGPUs(ctx)
+}

pkg/api/statistics.go

@@ -0,0 +1,11 @@
+package api
+
+import (
+	"context"
+
+	"github.com/threefoldtech/zosbase/pkg"
+)
+
+func (a *API) StoragePoolsHandler(ctx context.Context) ([]pkg.PoolMetrics, error) {
+	return a.storageStub.Metrics(ctx)
+}

pkg/api/storage.go

@@ -0,0 +1,45 @@
+package api
+
+import (
+	"context"
+	"os/exec"
+	"strings"
+
+	"github.com/threefoldtech/zosbase/pkg"
+	"github.com/threefoldtech/zosbase/pkg/capacity/dmi"
+	"github.com/threefoldtech/zosbase/pkg/diagnostics"
+)
+
+func (a *API) SystemVersion(ctx context.Context) (Version, error) {
+	output, err := exec.CommandContext(ctx, "zinit", "-V").CombinedOutput()
+	var zInitVer string
+	if err != nil {
+		zInitVer = err.Error()
+	} else {
+		zInitVer = strings.TrimSpace(strings.TrimPrefix(string(output), "zinit"))
+	}
+
+	version := Version{
+		Zos:   a.versionMonitorStub.GetVersion(ctx).String(),
+		Zinit: zInitVer,
+	}
+
+	return version, nil
+}
+
+func (a *API) SystemDMI(ctx context.Context) (dmi.DMI, error) {
+	dmi, err := a.oracle.DMI()
+	return *dmi, err
+}
+
+func (a *API) SystemHypervisor(ctx context.Context) (string, error) {
+	return a.oracle.GetHypervisor()
+}
+
+func (a *API) SystemDiagnostics(ctx context.Context) (diagnostics.Diagnostics, error) {
+	return a.diagnosticsManager.GetSystemDiagnostics(ctx)
+}
+
+func (a *API) SystemNodeFeatures(ctx context.Context) []pkg.NodeFeature {
+	return a.systemMonitorStub.GetNodeFeatures(ctx)
+}