added new speed test functions

p2p/iptable.go

@@ -21,6 +21,7 @@ type IpAddress struct {
 	Upload float64 `json:"upload"`
 }
 
+// Read data from Ip tables from json file
 func ReadIpTable()(*IpAddresses ,error){
 
 	jsonFile, err := os.Open("/etc/p2p-rendering/ip_table.json")
@@ -45,6 +46,7 @@ func ReadIpTable()(*IpAddresses ,error){
     return &ipAddresses, nil
 }
 
+// Write to IP table json file
 func (i *IpAddresses) WriteIpTable() error {
 	file, err := json.MarshalIndent(i, "", " ")
 	if err != nil {
@@ -59,6 +61,7 @@ func (i *IpAddresses) WriteIpTable() error {
 	return nil
 }
 
+// Print Ip table data for Cli
 func PrintIpTable() error {
 	table, err := ReadIpTable()
 

p2p/speedtest.go

@@ -2,36 +2,34 @@ package p2p
 
 import "fmt"
 
-func SpeedTest() error{
+// Runs a speed test and does updates IP tables accordingly
+func (ip *IpAddresses)SpeedTest() error{
 
-	targets, err := ReadIpTable()
-
-	if err != nil {
-		return err
-	}
-
-	for i, _ := range targets.IpAddress {
+	for i, _ := range ip.IpAddress {
 
 		// Ping Test
-		err = targets.IpAddress[i].PingTest()
+		err := ip.IpAddress[i].PingTest()
 		if err != nil {
-			return err
+			// Remove IP address of element not pingable 
+			ip.IpAddress = append(ip.IpAddress[:i], ip.IpAddress[i+1:]...)
+			// Proceed to next element in the array  
+			continue
 		}
 
 		//Upload Speed Test
-		err = targets.IpAddress[i].UploadSpeed()
+		err = ip.IpAddress[i].UploadSpeed()
 		if err != nil {
 			return err
 		}
 
-		err = targets.IpAddress[i].DownloadSpeed()
+		err = ip.IpAddress[i].DownloadSpeed()
 		if err != nil {
 			return err
 		}
-		fmt.Println(targets.IpAddress[i].Latency)
+		fmt.Println(ip.IpAddress[i].Latency)
 	}
 
-	err = targets.WriteIpTable()
+	err := ip.WriteIpTable()
 	if err != nil {
 		return err
 	}
@@ -39,4 +37,39 @@ func SpeedTest() error{
 	return nil
 }
 
+// Called when ip tables from client/server is also passed on
+func (ip *IpAddresses)SpeedTestUpdatedIPTable() error{
+	targets, err := ReadIpTable()
 
+	if err != nil {
+		return err
+	}
+
+    // Appends all IP addresses
+	for i, _ := range targets.IpAddress {
+		ip.IpAddress = append(ip.IpAddress, targets.IpAddress[i])
+	}
+
+	err = ip.SpeedTest()
+
+	if err != nil {
+		return err
+	}
+
+	return nil
+}
+
+// Runs speed test in iptables locally only
+func LocalSpeedTestIpTable() error {
+	targets, err := ReadIpTable()
+	if err != nil {
+		return err
+	}
+
+	err = targets.SpeedTest()
+	if err != nil {
+		return err
+	}
+
+	return nil
+}

p2p/speedtest_test.go

@@ -6,7 +6,7 @@ import (
 
 // To run this test ip_table.json must be populated
 func TestServer_SpeedTest(t *testing.T) {
-	err := SpeedTest()
+	err := LocalSpeedTestIpTable()
 	if err != nil {
 		t.Fatal(err)
 	}

server/gpu.go

@@ -33,6 +33,8 @@ type GpuClock struct {
 	GpuMemClock string `xml:"mem_clock"`
 }
 
+// Gets GPU information by calling nvidia-smi
+// in XML output
 func GPUInfo()(*Query,error) {
 	out, err := exec.Command("nvidia-smi", "-q", "-x").Output()
 

server/server.go

@@ -2,6 +2,7 @@ package server
 
 import (
 	"fmt"
+	"git.sr.ht/~akilan1999/p2p-rendering-computation/p2p"
 	"git.sr.ht/~akilan1999/p2p-rendering-computation/server/docker"
 	"github.com/gin-gonic/gin"
 	"net/http"
@@ -31,7 +32,24 @@ func Server() {
 		c.String(http.StatusOK, fmt.Sprintf("'%s' uploaded!", file.Filename))
 	})
 
+	//Gets Ip Table from server node
+	r.GET("/IpTable", func(c *gin.Context) {
+		// Runs speed test to return only servers in the IP table pingable
+		err := p2p.SpeedTest()
+		if err != nil {
+			c.String(http.StatusOK, fmt.Sprint(err))
+		}
 
+		// Reads IP addresses from ip table
+		IpAddresses,err := p2p.ReadIpTable()
+		if err != nil {
+			c.String(http.StatusOK, fmt.Sprint(err))
+		}
+
+		c.JSON(http.StatusOK, IpAddresses)
+	})
+
+    // Starts docker container in server
 	r.GET("/startcontainer", func(c *gin.Context) {
 
 		resp, err := docker.BuildRunContainer()

server/test/test.go

@@ -1,60 +0,0 @@
-package main
-
-import (
-	"fmt"
-	"log"
-	"os"
-	"text/template"
-
-	"github.com/NVIDIA/gpu-monitoring-tools/bindings/go/nvml"
-)
-
-const (
-	DEVICEINFO = `UUID           : {{.UUID}}
-Model          : {{or .Model "N/A"}}
-Path           : {{.Path}}
-Power          : {{if .Power}}{{.Power}} W{{else}}N/A{{end}}
-Memory         : {{if .Memory}}{{.Memory}} MiB{{else}}N/A{{end}}
-CudaComputeCap : {{if .CudaComputeCapability.Major}}{{.CudaComputeCapability.Major}}.{{.CudaComputeCapability.Minor}}{{else}}N/A{{end}}
-CPU Affinity   : {{if .CPUAffinity}}NUMA node{{.CPUAffinity}}{{else}}N/A{{end}}
-Bus ID         : {{.PCI.BusID}}
-BAR1           : {{if .PCI.BAR1}}{{.PCI.BAR1}} MiB{{else}}N/A{{end}}
-Bandwidth      : {{if .PCI.Bandwidth}}{{.PCI.Bandwidth}} MB/s{{else}}N/A{{end}}
-Cores          : {{if .Clocks.Cores}}{{.Clocks.Cores}} MHz{{else}}N/A{{end}}
-Memory         : {{if .Clocks.Memory}}{{.Clocks.Memory}} MHz{{else}}N/A{{end}}
-P2P Available  : {{if not .Topology}}None{{else}}{{range .Topology}}
-                      {{.BusID}} - {{(.Link.String)}}{{end}}{{end}}
----------------------------------------------------------------------
-`
-)
-
-func main() {
-	nvml.Init()
-	defer nvml.Shutdown()
-
-	count, err := nvml.GetDeviceCount()
-	if err != nil {
-		log.Panicln("Error getting device count:", err)
-	}
-
-	driverVersion, err := nvml.GetDriverVersion()
-	if err != nil {
-		log.Panicln("Error getting driver version:", err)
-	}
-
-	t := template.Must(template.New("Device").Parse(DEVICEINFO))
-
-	fmt.Printf("Driver Version : %5v\n", driverVersion)
-	for i := uint(0); i < count; i++ {
-		device, err := nvml.NewDevice(i)
-		if err != nil {
-			log.Panicf("Error getting device %d: %v\n", i, err)
-		}
-
-		fmt.Printf("GPU %12s %d\n", ":", i)
-		err = t.Execute(os.Stdout, device)
-		if err != nil {
-			log.Panicln("Template error:", err)
-		}
-	}
-}