implement perf method and required changes in the perf package

Author: Omarabdul3ziz

pkg/api/perf.go

@@ -2,255 +2,26 @@ package api
 
 import (
 	"context"
-	"fmt"
 
-	"github.com/rs/zerolog/log"
-	"github.com/threefoldtech/zos/pkg/perf/cpubench"
-	"github.com/threefoldtech/zos/pkg/perf/iperf"
+	"github.com/threefoldtech/zos/pkg"
 )
 
-type CpuBenchTaskResult struct {
-	Name        string                      `json:"name"`
-	Description string                      `json:"description"`
-	Timestamp   uint64                      `json:"timestamp"`
-	Result      cpubench.CPUBenchmarkResult `json:"result"`
+func (g *Api) PerfGetIperf(ctx context.Context) (pkg.IperfTaskResult, error) {
+	return g.performanceMonitorStub.GetIperfTaskResult(ctx)
 }
 
-func (g *Api) PerfGetCpuBench(ctx context.Context) (CpuBenchTaskResult, error) {
-	res, err := g.performanceMonitorStub.Get(ctx, "cpu-benchmark")
-	if err != nil {
-		return CpuBenchTaskResult{}, err
-	}
-
-	innerResult, ok := res.Result.(cpubench.CPUBenchmarkResult)
-	if !ok {
-		return CpuBenchTaskResult{}, err
-	}
-
-	return CpuBenchTaskResult{
-		Name:        res.Name,
-		Description: res.Description,
-		Timestamp:   res.Timestamp,
-		Result:      innerResult,
-	}, nil
+func (g *Api) PerfGetPublicIp(ctx context.Context) (pkg.PublicIpTaskResult, error) {
+	return g.performanceMonitorStub.GetPublicIpTaskResult(ctx)
 }
 
-type AllTaskResult struct {
-	CpuBenchmark CpuBenchTaskResult `json:"cpu_benchmark"`
-	HealthCheck  HealthTaskResult   `json:"health_check"`
-	Iperf        IperfTaskResult    `json:"iperf"`
-	PublicIp     PublicIpTaskResult `json:"public_ip"`
+func (g *Api) PerfGetCpuBench(ctx context.Context) (pkg.CpuBenchTaskResult, error) {
+	return g.performanceMonitorStub.GetCpuBenchTaskResult(ctx)
 }
 
-func (g *Api) PerfGetAllHandler(ctx context.Context) (AllTaskResult, error) {
-	res, err := g.performanceMonitorStub.GetAll(ctx)
-	if err != nil {
-		return AllTaskResult{}, nil
-	}
-
-	results := AllTaskResult{}
-	for _, result := range res {
-		switch result.Name {
-		case "cpu-benchmark":
-			innerResult, ok := result.Result.(cpubench.CPUBenchmarkResult)
-			if !ok {
-				return AllTaskResult{}, err
-			}
-
-			results.CpuBenchmark = CpuBenchTaskResult{
-				Name:        result.Name,
-				Description: result.Description,
-				Timestamp:   result.Timestamp,
-				Result:      innerResult,
-			}
-		case "healthcheck":
-			innerResult, ok := result.Result.(map[string][]string)
-			if !ok {
-				return AllTaskResult{}, err
-			}
-
-			healthResult := HealthTaskResult{
-				Name:        result.Name,
-				Description: result.Description,
-				Timestamp:   result.Timestamp,
-			}
-
-			for key, val := range innerResult {
-				healthResult.Result = append(healthResult.Result, HealthReport{
-					TestName: key,
-					Errors:   val,
-				})
-			}
-
-			results.HealthCheck = healthResult
-		case "iperf":
-			innerResult, ok := result.Result.(iperf.IperfResult)
-			if !ok {
-				return AllTaskResult{}, err
-			}
-
-			results.Iperf = IperfTaskResult{
-				Name:        result.Name,
-				Description: result.Description,
-				Timestamp:   result.Timestamp,
-				Result:      innerResult,
-			}
-		case "public-ip-validation":
-			// innerResult, ok := result.Result.(map[string]publicip.IPReport)
-			// if !ok {
-			// 	return AllTaskResult{}, err
-			// }
-
-			// ipResults := PublicIpTaskResult{
-			// 	Name:        result.Name,
-			// 	Description: result.Description,
-			// 	Timestamp:   result.Timestamp,
-			// }
-
-			// for key, report := range innerResult {
-			// 	report.Ip = key
-			// 	ipResults.Result = append(ipResults.Result, report)
-			// }
-			// results.PublicIp = ipResults
-		}
-	}
-
-	return results, nil
+func (g *Api) PerfGetHealth(ctx context.Context) (pkg.HealthTaskResult, error) {
+	return g.performanceMonitorStub.GetHealthTaskResult(ctx)
 }
 
-// ==========================================================
-type HealthReport struct {
-	TestName string   `json:"test_name"`
-	Errors   []string `json:"errors"`
-}
-
-type HealthTaskResult struct {
-	Name        string         `json:"name"`
-	Description string         `json:"description"`
-	Timestamp   uint64         `json:"timestamp"`
-	Result      []HealthReport `json:"result"`
-}
-
-func (g *Api) PerfGetHealth(ctx context.Context) (HealthTaskResult, error) {
-	taskResult, err := g.performanceMonitorStub.Get(ctx, "healthcheck")
-	if err != nil {
-		return HealthTaskResult{}, err
-	}
-
-	healthTaskResult := HealthTaskResult{
-		Name:        taskResult.Name,
-		Description: taskResult.Description,
-		Timestamp:   taskResult.Timestamp,
-	}
-
-	// convert inner result from map[string][]string to []HealthReport
-	innerResult, ok := taskResult.Result.(map[string]interface{})
-	if !ok {
-		return HealthTaskResult{}, fmt.Errorf("failed to assert type: %w", err)
-	}
-
-	for testName, errors := range innerResult {
-		errorStrings := []string{}
-		errorList, ok := errors.([]interface{})
-		if !ok {
-			return HealthTaskResult{}, fmt.Errorf("failed to assert type: %w", err)
-		}
-
-		for _, errorItem := range errorList {
-			errorString, ok := errorItem.(string)
-			if !ok {
-				return HealthTaskResult{}, fmt.Errorf("failed to assert type: %w", err)
-			}
-			errorStrings = append(errorStrings, errorString)
-		}
-
-		healthReport := HealthReport{
-			TestName: testName,
-			Errors:   errorStrings,
-		}
-
-		healthTaskResult.Result = append(healthTaskResult.Result, healthReport)
-	}
-
-	return healthTaskResult, nil
-}
-
-type Report struct {
-	Ip     string `json:"ip"`
-	State  string `json:"state"`
-	Reason string `json:"reason"`
-}
-
-type PublicIpTaskResult struct {
-	Name        string   `json:"name"`
-	Description string   `json:"description"`
-	Timestamp   uint64   `json:"timestamp"`
-	Result      []Report `json:"result"`
-}
-
-func (g *Api) PerfGetPublicIP(ctx context.Context) (PublicIpTaskResult, error) {
-	taskResult, err := g.performanceMonitorStub.Get(ctx, "public-ip-validation")
-	if err != nil {
-		return PublicIpTaskResult{}, err
-	}
-
-	response := PublicIpTaskResult{
-		Name:        taskResult.Name,
-		Description: taskResult.Description,
-		Timestamp:   taskResult.Timestamp,
-	}
-
-	// convert inner result from map[string]IpReport into []IpReport
-	innerResult, ok := taskResult.Result.(map[string]interface{})
-	if !ok {
-		return PublicIpTaskResult{}, fmt.Errorf("failed to assert type: %w", err)
-	}
-
-	reports := []Report{}
-	for ip, report := range innerResult {
-
-		r, ok := report.(map[string]interface{})
-		if !ok {
-			return PublicIpTaskResult{}, fmt.Errorf("failed to assert report type: %w", err)
-		}
-
-		rep := Report{
-			Ip:     ip,
-			State:  r["state"].(string),
-			Reason: r["reason"].(string),
-		}
-
-		reports = append(reports, rep)
-	}
-
-	response.Result = reports
-	return response, nil
-}
-
-type IperfTaskResult struct {
-	Name        string            `json:"name"`
-	Description string            `json:"description"`
-	Timestamp   uint64            `json:"timestamp"`
-	Result      iperf.IperfResult `json:"result"`
-}
-
-func (g *Api) PerfGetIperf(ctx context.Context) (IperfTaskResult, error) {
-	res, err := g.performanceMonitorStub.GetIperfTaskResult(ctx, "iperf")
-	if err != nil {
-		return IperfTaskResult{}, err
-	}
-
-	innerResult, ok := res.Result.(iperf.IperfResult)
-	if !ok {
-		return IperfTaskResult{}, err
-	}
-	log.Info().Msgf("inner %v", innerResult)
-	log.Info().Msgf("inner type %T", innerResult)
-
-	return IperfTaskResult{
-		Name:        res.Name,
-		Description: res.Description,
-		Timestamp:   res.Timestamp,
-		Result:      innerResult,
-	}, nil
+func (g *Api) PerfGetAll(ctx context.Context) (pkg.AllTaskResult, error) {
+	return g.performanceMonitorStub.GetAllTaskResult(ctx)
 }