feat(ping): implement fallback for *nix and windows

feat(ping): implement fallback for *nix and windows

Author: ycd

.github/workflows/test.yml

@@ -26,4 +26,4 @@ jobs:
         timeout-minutes: 2
         run: |
           go build cmd/dstp/main.go
-          go test -v ./...
+          go test -v -tags=integration ./...

config/config.go

@@ -24,7 +24,7 @@ Options:
 	-o, --out    <string>  The type of the output, either json or plaintext    [Default: plaintext] 
 	-c           <bool>    Run all the tests concurrently.                     [Default: false]
 	-p           <int>     Number of ping packets                              [Default: 3]
-	-t           <int>     Give up on ping after this many seconds             [Default: 10s per ping packet]
+	-t           <int>     Give up on ping after this many seconds             [Default: 2s per ping packet]
 	-h, --help             Show this message and exit.
 `
 

pkg/dstp/dstp_test.go

@@ -1,4 +1,4 @@
-//go:build integration || darwin
+//go:build integration
 
 package dstp
 
@@ -16,7 +16,7 @@ func TestRunAllTests(t *testing.T) {
 		Output:     "plaintext",
 		ShowHelp:   false,
 		Concurrent: false,
-		Timeout:    10,
+		Timeout:    3,
 		PingCount:  3,
 	}
 
@@ -25,7 +25,7 @@ func TestRunAllTests(t *testing.T) {
 		Output:     "plaintext",
 		ShowHelp:   false,
 		Concurrent: false,
-		Timeout:    10,
+		Timeout:    3,
 		PingCount:  3,
 	}
 
@@ -34,7 +34,7 @@ func TestRunAllTests(t *testing.T) {
 		Output:     "plaintext",
 		ShowHelp:   false,
 		Concurrent: false,
-		Timeout:    10,
+		Timeout:    3,
 		PingCount:  3,
 	}
 
@@ -43,7 +43,7 @@ func TestRunAllTests(t *testing.T) {
 		Output:     "plaintext",
 		ShowHelp:   false,
 		Concurrent: false,
-		Timeout:    10,
+		Timeout:    3,
 		PingCount:  3,
 	}
 
@@ -52,7 +52,7 @@ func TestRunAllTests(t *testing.T) {
 		Output:     "plaintext",
 		ShowHelp:   false,
 		Concurrent: false,
-		Timeout:    10,
+		Timeout:    3,
 		PingCount:  3,
 	}
 

pkg/ping/dns.go

@@ -0,0 +1,31 @@
+package ping
+
+import (
+	"context"
+	"fmt"
+	"github.com/ycd/dstp/pkg/common"
+	"time"
+)
+
+func RunDNSTest(ctx context.Context, addr common.Address, count int, timeout int) (common.Output, error) {
+	var output string
+
+	pinger, err := createPinger(addr.String())
+	if err != nil {
+		return "", err
+	}
+
+	pinger.Count = count
+	if timeout == -1 {
+		pinger.Timeout = time.Duration(2*count) * time.Second
+	} else {
+		pinger.Timeout = time.Duration(timeout) * time.Second
+	}
+	err = pinger.Run()
+	if err != nil {
+		return "", fmt.Errorf("failed to run ping: %v", err.Error())
+	}
+
+	output += joinS("resolving", pinger.IPAddr().String())
+	return common.Output(output), nil
+}

pkg/ping/ping.go

@@ -1,15 +1,24 @@
 package ping
 
 import (
+	"bufio"
+	"bytes"
 	"context"
 	"fmt"
+	"log"
+	"os/exec"
+	"runtime"
 	"strings"
 	"time"
 
 	"github.com/ycd/dstp/pkg/common"
 )
 
 func RunTest(ctx context.Context, addr common.Address, count int, timeout int) (common.Output, error) {
+	return runPing(ctx, addr, count, timeout)
+}
+
+func runPing(ctx context.Context, addr common.Address, count int, timeout int) (common.Output, error) {
 	var output string
 
 	pinger, err := createPinger(addr.String())
@@ -19,52 +28,158 @@ func RunTest(ctx context.Context, addr common.Address, count int, timeout int) (
 
 	pinger.Count = count
 	if timeout == -1 {
-		pinger.Timeout = time.Duration(10*count) * time.Second
+		pinger.Timeout = time.Duration(2*count) * time.Second
 	} else {
 		pinger.Timeout = time.Duration(timeout) * time.Second
 	}
 	err = pinger.Run()
 	if err != nil {
-		return "", fmt.Errorf("failed to run ping: %v", err.Error())
-	}
-
-	stats := pinger.Statistics()
-	if stats.PacketsRecv == 0 {
-		output += "no response"
+		if out, err := runPingFallback(ctx, addr, count, timeout); err == nil {
+			output += out.String()
+		} else {
+			return "", fmt.Errorf("failed to run ping: %v", err.Error())
+		}
 	} else {
-		output += joinS(joinC(stats.AvgRtt.String()))
+		stats := pinger.Statistics()
+		if stats.PacketsRecv == 0 {
+			if out, err := runPingFallback(ctx, addr, count, timeout); err == nil {
+				output += out.String()
+			} else {
+				output += "no response"
+			}
+		} else {
+			output += joinS(joinC(stats.AvgRtt.String()))
+		}
 	}
 
 	return common.Output(output), nil
 }
 
-func joinC(args ...string) string {
-	return strings.Join(args, ",")
-}
+// runPingFallback executes the ping command from cli
+// Currently fallback is not implemented for windows.
+func runPingFallback(ctx context.Context, addr common.Address, count int, timeout int) (common.Output, error) {
+	args := fmt.Sprintf("-c %v -t %v", count, timeout)
+	command := fmt.Sprintf("ping %s %s", args, addr.String())
 
-func joinS(args ...string) string {
-	return strings.Join(args, " ")
+	out, err := executeCommand("bash", command)
+	if err != nil {
+		return common.Output(""), err
+	}
+
+	po, err := parsePingOutput(out)
+	if err != nil {
+		return common.Output(""), err
+	}
+
+	return common.Output(po.AvgRTT + "ms"), nil
 }
 
-func RunDNSTest(ctx context.Context, addr common.Address, count int, timeout int) (common.Output, error) {
-	var output string
+func executeCommand(shell, command string) (string, error) {
+	var errb bytes.Buffer
+	var out string
 
-	pinger, err := createPinger(addr.String())
+	var cmd *exec.Cmd
+	if runtime.GOOS == "windows" {
+		cmd = exec.Command("cmd", "/C", command)
+	} else {
+		cmd = exec.Command(shell, "-c", command)
+	}
+	cmd.Stderr = &errb
+	stdout, err := cmd.StdoutPipe()
+	if err != nil {
+		log.Printf("got error while tracing pipe: %v", err)
+	}
+	err = cmd.Start()
 	if err != nil {
 		return "", err
 	}
 
-	pinger.Count = count
-	if timeout == -1 {
-		pinger.Timeout = time.Duration(10*count) * time.Second
-	} else {
-		pinger.Timeout = time.Duration(timeout) * time.Second
+	scanner := bufio.NewScanner(stdout)
+	for scanner.Scan() {
+		out += scanner.Text() + "\n"
 	}
-	err = pinger.Run()
-	if err != nil {
-		return "", fmt.Errorf("failed to run ping: %v", err.Error())
+
+	if err := cmd.Wait(); err != nil {
+		return "", fmt.Errorf("got error: %v, stderr: %v", err, errb.String())
 	}
 
-	output += joinS("resolving", pinger.IPAddr().String())
-	return common.Output(output), nil
+	return out, nil
+}
+
+type pingOutput struct {
+	PacketLoss        string
+	PacketReceived    string
+	PacketTransmitted string
+	MinRTT            string
+	AvgRTT            string
+	MaxRTT            string
+}
+
+var (
+	RequestTimeoutError = fmt.Errorf("requests timed out")
+	PacketLossError     = fmt.Errorf("timeout error: 100.0%% packet loss")
+)
+
+// parsePingOutput parses the output of ping by parsing the stdout
+// example output:
+//
+// ping -c 3 jvns.ca
+// PING jvns.ca (104.21.91.206): 56 data bytes
+// 64 bytes from 104.21.91.206: icmp_seq=0 ttl=58 time=14.468 ms
+// 64 bytes from 104.21.91.206: icmp_seq=1 ttl=58 time=14.450 ms
+// 64 bytes from 104.21.91.206: icmp_seq=2 ttl=58 time=14.683 ms
+//
+// --- jvns.ca ping statistics ---
+// 3 packets transmitted, 3 packets received, 0.0% packet loss
+// round-trip min/avg/max/stddev = 14.450/14.534/14.683/0.106 ms
+func parsePingOutput(out string) (pingOutput, error) {
+	var po pingOutput
+
+	lines := strings.Split(out, "\n")
+
+	for _, line := range lines {
+		switch {
+		case strings.Contains(line, "packets transmitted"):
+			arr := strings.Split(line, ",")
+			fmt.Println(arr)
+			if len(arr) != 3 {
+				continue
+			}
+
+			po.PacketTransmitted, po.PacketReceived, po.PacketLoss = arr[0], arr[1], arr[2]
+
+		case strings.Contains(line, "round-trip min/avg/max"):
+			l := strings.ReplaceAll(line, " = ", " ")
+			arr := strings.Split(l, " ")
+
+			if len(arr) != 4 {
+				continue
+			}
+
+			rttArr := strings.Split(arr[2], "/")
+			if len(rttArr) != 4 {
+				continue
+			}
+
+			po.MinRTT, po.AvgRTT, po.MaxRTT = rttArr[0], rttArr[1], rttArr[2]
+		}
+	}
+
+	if po.MinRTT == "" && po.AvgRTT == "" && po.MaxRTT == "" {
+		return po, RequestTimeoutError
+	}
+
+	if po.PacketLoss == "100.0% packet loss" {
+		return po, PacketLossError
+	}
+
+	return po, nil
+}
+
+func joinC(args ...string) string {
+	return strings.Join(args, ",")
+}
+
+func joinS(args ...string) string {
+	return strings.Join(args, " ")
 }

pkg/ping/ping_test.go

@@ -0,0 +1,19 @@
+//go:build integration
+
+package ping
+
+import (
+	"context"
+	"fmt"
+	"github.com/ycd/dstp/pkg/common"
+	"testing"
+)
+
+func TestPingFallback(t *testing.T) {
+	out, err := runPingFallback(context.Background(), common.Address("8.8.8.8"), 3, 10)
+	if err != nil {
+		t.Fatal(err.Error())
+	}
+
+	fmt.Println(out.String())
+}