Infinite ping

cmd/ping.go

@@ -2,6 +2,9 @@ package cmd
 
 import (
 	"fmt"
+	"os"
+	"os/signal"
+	"syscall"
 
 	"github.com/jsdelivr/globalping-cli/client"
 	"github.com/jsdelivr/globalping-cli/model"
@@ -49,20 +52,41 @@ Examples:
 			return err
 		}
 		if ctx.Infinite {
-			ctx.Limit = min(ctx.Limit, 5) // Limit to 5 probes
-			ctx.Packets = 16              // Default to 16 packets
-			for {
-				ctx.From, err = ping(cmd)
-				if err != nil {
-					return err
-				}
-			}
+			return infinitePing(cmd)
 		}
 		_, err = ping(cmd)
 		return err
 	},
 }
 
+func infinitePing(cmd *cobra.Command) error {
+	var err error
+	if ctx.Limit > 5 {
+		return fmt.Errorf("continous mode is currently limited to 5 probes")
+	}
+	ctx.Packets = 16 // Default to 16 packets
+
+	// Trap sigterm or interupt to display info on exit
+	sig := make(chan os.Signal, 1)
+	signal.Notify(sig, syscall.SIGINT, syscall.SIGTERM)
+
+	go func() {
+		for {
+			ctx.From, err = ping(cmd)
+			if err != nil {
+				sig <- syscall.SIGINT
+				return
+			}
+		}
+	}()
+
+	<-sig
+	if err == nil {
+		view.OutputSummary(&ctx)
+	}
+	return err
+}
+
 func ping(cmd *cobra.Command) (string, error) {
 	opts = model.PostMeasurement{
 		Type:              "ping",
@@ -88,6 +112,8 @@ func ping(cmd *cobra.Command) (string, error) {
 		return "", err
 	}
 
+	ctx.CallCount++
+
 	// Save measurement ID to history
 	if !isPreviousMeasurementId {
 		err := saveMeasurementID(res.ID)

cmd/root.go

@@ -26,6 +26,7 @@ var (
 	opts = model.PostMeasurement{}
 	ctx  = model.Context{
 		APIMinInterval: 500 * time.Millisecond,
+		MaxHistory:     10,
 	}
 )
 

model/get.go

@@ -43,6 +43,7 @@ type PingStats struct {
 	Rcv   int     `json:"rcv"`   // The number of received packets.
 	Drop  int     `json:"drop"`  // The number of dropped packets (total - rcv).
 	Loss  float64 `json:"loss"`  // The percentage of dropped packets.
+	Mdev  float64 `json:"mdev"`  // The mean deviation of the rtt values.
 }
 
 type PingTiming struct {

model/root.go

@@ -1,6 +1,7 @@
 package model
 
 import (
+	"math"
 	"time"
 
 	"github.com/pterm/pterm"
@@ -24,16 +25,67 @@ type Context struct {
 	Infinite   bool // Infinite flag
 
 	APIMinInterval time.Duration // Minimum interval between API calls
-	Area           *pterm.AreaPrinter
-	Stats          []MeasurementStats
+
+	Area            *pterm.AreaPrinter
+	Hostname        string
+	CompletedStats  []MeasurementStats
+	InProgressStats []MeasurementStats
+	CallCount       int      // Number of measurements created
+	MaxHistory      int      // Maximum number of measurements to keep in history
+	History         *Rbuffer // History of measurements
 }
 
 type MeasurementStats struct {
 	Sent int     // Number of packets sent
+	Rcv  int     // Number of packets received
 	Lost int     // Number of packets lost
 	Loss float64 // Percentage of packets lost
 	Last float64 // Last RTT
 	Min  float64 // Minimum RTT
 	Avg  float64 // Average RTT
 	Max  float64 // Maximum RTT
+	Mdev float64 // Mean deviation of RTT
+	Time float64 // Total time
+}
+
+func NewMeasurementStats() MeasurementStats {
+	return MeasurementStats{Last: -1, Min: math.MaxFloat64, Avg: -1, Max: -1}
+}
+
+type Rbuffer struct {
+	Index int
+	Slice []string
+}
+
+func (q *Rbuffer) Push(id string) {
+	q.Slice[q.Index] = id
+	q.Index = (q.Index + 1) % len(q.Slice)
+}
+
+func (q *Rbuffer) ToString(sep string) string {
+	s := ""
+	i := q.Index
+	isFirst := true
+	for {
+		if q.Slice[i] != "" {
+			if isFirst {
+				isFirst = false
+				s += q.Slice[i]
+			} else {
+				s += sep + q.Slice[i]
+			}
+		}
+		i = (i + 1) % len(q.Slice)
+		if i == q.Index {
+			break
+		}
+	}
+	return s
+}
+
+func NewRbuffer(size int) *Rbuffer {
+	return &Rbuffer{
+		Index: 0,
+		Slice: make([]string, size),
+	}
 }

model/root_test.go

@@ -0,0 +1,40 @@
+package model
+
+import (
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+)
+
+func TestRBuffer(t *testing.T) {
+	t.Run("Push", func(t *testing.T) {
+		b := NewRbuffer(3)
+		assert.Equal(t, 0, b.Index)
+		assert.Equal(t, []string{"", "", ""}, b.Slice)
+		b.Push("a")
+		assert.Equal(t, 1, b.Index)
+		assert.Equal(t, []string{"a", "", ""}, b.Slice)
+		b.Push("b")
+		assert.Equal(t, 2, b.Index)
+		assert.Equal(t, []string{"a", "b", ""}, b.Slice)
+		b.Push("c")
+		assert.Equal(t, 0, b.Index)
+		assert.Equal(t, []string{"a", "b", "c"}, b.Slice)
+		b.Push("d")
+		assert.Equal(t, 1, b.Index)
+		assert.Equal(t, []string{"d", "b", "c"}, b.Slice)
+	})
+
+	t.Run("ToString", func(t *testing.T) {
+		b := NewRbuffer(3)
+		assert.Equal(t, "", b.ToString("+"))
+		b.Push("a")
+		assert.Equal(t, "a", b.ToString("+"))
+		b.Push("b")
+		assert.Equal(t, "a+b", b.ToString("+"))
+		b.Push("c")
+		assert.Equal(t, "a+b+c", b.ToString("+"))
+		b.Push("d")
+		assert.Equal(t, "b+c+d", b.ToString("+"))
+	})
+}