Add cli command visor ping and test

cmd/skywire-cli/commands/visor/ping.go

@@ -0,0 +1,69 @@
+// Package clivisor cmd/skywire-cli/commands/visor/ping.go
+package clivisor
+
+import (
+	"fmt"
+	"os"
+
+	"github.com/spf13/cobra"
+
+	clirpc "github.com/skycoin/skywire/cmd/skywire-cli/commands/rpc"
+	"github.com/skycoin/skywire/cmd/skywire-cli/internal"
+	"github.com/skycoin/skywire/pkg/visor"
+)
+
+var tries int
+var pcktSize int
+
+func init() {
+	RootCmd.AddCommand(pingCmd)
+	pingCmd.Flags().IntVarP(&tries, "tries", "t", 1, "Number of pings")
+	pingCmd.Flags().IntVarP(&pcktSize, "size", "s", 32, "Size of packet, in KB, default is 32KB")
+	RootCmd.AddCommand(testCmd)
+	testCmd.Flags().IntVarP(&tries, "tries", "t", 1, "Number of tests per public visors")
+	testCmd.Flags().IntVarP(&pcktSize, "size", "s", 32, "Size of packet, in KB, default is 32KB")
+}
+
+var pingCmd = &cobra.Command{
+	Use:   "ping <pk>",
+	Short: "Ping the visor with given pk",
+	Long:  "\n	Creates a route with the provided pk as a hop and returns latency on the conn",
+	Args:  cobra.MinimumNArgs(1),
+	Run: func(cmd *cobra.Command, args []string) {
+		pk := internal.ParsePK(cmd.Flags(), "pk", args[0])
+		pingConfig := visor.PingConfig{PK: pk, Tries: tries, PcktSize: pcktSize}
+		rpcClient, err := clirpc.Client(cmd.Flags())
+		if err != nil {
+			os.Exit(1)
+		}
+		err = rpcClient.DialPing(pingConfig)
+		internal.Catch(cmd.Flags(), err)
+
+		latencies, err := rpcClient.Ping(pingConfig)
+		internal.Catch(cmd.Flags(), err)
+
+		for _, latency := range latencies {
+			internal.PrintOutput(cmd.Flags(), fmt.Sprint(latency), fmt.Sprintf(fmt.Sprint(latency)+"\n"))
+		}
+		err = rpcClient.StopPing(pk)
+		internal.Catch(cmd.Flags(), err)
+	},
+}
+
+var testCmd = &cobra.Command{
+	Use:   "test",
+	Short: "Test the visor with public visors on network",
+	Long:  "\n	Creates a route with public visors as a hop and returns latency on the conn",
+	Run: func(cmd *cobra.Command, args []string) {
+		pingConfig := visor.PingConfig{Tries: tries, PcktSize: pcktSize}
+		rpcClient, err := clirpc.Client(cmd.Flags())
+		if err != nil {
+			os.Exit(1)
+		}
+		results, err := rpcClient.TestVisor(pingConfig)
+		internal.Catch(cmd.Flags(), err)
+		for i, result := range results {
+			internal.PrintOutput(cmd.Flags(), result, fmt.Sprintf("Test No. %d\nPK: %s\nMax: %s\nMin: %s\nMean: %s\n\n", i+1, result.PK, result.Max, result.Min, result.Mean))
+		}
+	},
+}

pkg/app/appnet/dmsg_networker.go

@@ -3,9 +3,12 @@ package appnet
 
 import (
 	"context"
+	"fmt"
 	"net"
 
 	"github.com/skycoin/dmsg/pkg/dmsg"
+
+	"github.com/skycoin/skywire-utilities/pkg/cipher"
 )
 
 // DmsgNetworker implements `Networker` for dmsg network.
@@ -25,6 +28,11 @@ func (n *DmsgNetworker) Dial(addr Addr) (net.Conn, error) {
 	return n.DialContext(context.Background(), addr)
 }
 
+// Ping dials remote `addr` via dmsg network.
+func (n *DmsgNetworker) Ping(pk cipher.PubKey, addr Addr) (net.Conn, error) {
+	return nil, fmt.Errorf("Ping not available on dmsg network")
+}
+
 // DialContext dials remote `addr` via dmsg network with context.
 func (n *DmsgNetworker) DialContext(ctx context.Context, addr Addr) (net.Conn, error) {
 	remote := dmsg.Addr{

pkg/app/appnet/networker.go

@@ -6,9 +6,11 @@ import (
 	"errors"
 	"net"
 	"sync"
+
+	"github.com/skycoin/skywire-utilities/pkg/cipher"
 )
 
-//go:generate mockery -name Networker -case underscore -inpkg
+//go:generate mockery --name Networker --case underscore --inpackage
 
 var (
 	// ErrNoSuchNetworker is being returned when there's no suitable networker.
@@ -63,6 +65,7 @@ func ClearNetworkers() {
 // Networker defines basic network operations, such as Dial/Listen.
 type Networker interface {
 	Dial(addr Addr) (net.Conn, error)
+	Ping(pk cipher.PubKey, addr Addr) (net.Conn, error)
 	DialContext(ctx context.Context, addr Addr) (net.Conn, error)
 	Listen(addr Addr) (net.Listener, error)
 	ListenContext(ctx context.Context, addr Addr) (net.Listener, error)
@@ -73,6 +76,15 @@ func Dial(addr Addr) (net.Conn, error) {
 	return DialContext(context.Background(), addr)
 }
 
+// Ping dials the remote `addr`.
+func Ping(pk cipher.PubKey, addr Addr) (net.Conn, error) {
+	n, err := ResolveNetworker(addr.Net)
+	if err != nil {
+		return nil, err
+	}
+	return n.Ping(pk, addr)
+}
+
 // DialContext dials the remote `addr` with the context.
 func DialContext(ctx context.Context, addr Addr) (net.Conn, error) {
 	n, err := ResolveNetworker(addr.Net)

pkg/app/appnet/skywire_networker.go

@@ -12,6 +12,7 @@ import (
 
 	"github.com/sirupsen/logrus"
 
+	"github.com/skycoin/skywire-utilities/pkg/cipher"
 	"github.com/skycoin/skywire-utilities/pkg/netutil"
 	"github.com/skycoin/skywire/pkg/router"
 	"github.com/skycoin/skywire/pkg/routing"
@@ -20,6 +21,8 @@ import (
 var (
 	// ErrPortAlreadyBound is being returned when the desired port is already bound to.
 	ErrPortAlreadyBound = errors.New("port already bound")
+	// ErrConnClosed is being returned when we listen on a closed conn.
+	ErrConnClosed = errors.New("listening on closed connection")
 )
 
 // SkywireNetworker implements `Networker` for skynet.
@@ -70,6 +73,32 @@ func (r *SkywireNetworker) DialContext(ctx context.Context, addr Addr) (conn net
 	}, nil
 }
 
+// Ping dials remote `addr` via `skynet` with context.
+func (r *SkywireNetworker) Ping(pk cipher.PubKey, addr Addr) (net.Conn, error) {
+	ctx := context.Background()
+	localPort, freePort, err := r.porter.ReserveEphemeral(ctx, nil)
+	if err != nil {
+		return nil, err
+	}
+
+	// ensure ports are freed on error.
+	defer func() {
+		if err != nil {
+			freePort()
+		}
+	}()
+	conn, err := r.r.PingRoute(ctx, pk, routing.Port(localPort), addr.Port, router.DefaultDialOptions())
+	if err != nil {
+		return nil, err
+	}
+
+	return &SkywireConn{
+		Conn:     conn,
+		nrg:      conn.(*router.NoiseRouteGroup),
+		freePort: freePort,
+	}, nil
+}
+
 // Listen starts listening on local `addr` in the skynet.
 func (r *SkywireNetworker) Listen(addr Addr) (net.Listener, error) {
 	return r.ListenContext(context.Background(), addr)
@@ -181,7 +210,7 @@ type skywireListener struct {
 func (l *skywireListener) Accept() (net.Conn, error) {
 	conn, ok := <-l.connsCh
 	if !ok {
-		return nil, errors.New("listening on closed connection")
+		return nil, ErrConnClosed
 	}
 
 	return &SkywireConn{

pkg/app/appserver/proc.go

@@ -445,10 +445,10 @@ func (p *Proc) ConnectionsSummary() []ConnectionSummary {
 			})
 			return true
 		}
-
 		summaries = append(summaries, ConnectionSummary{
-			IsAlive:            skywireConn.IsAlive(),
-			Latency:            skywireConn.Latency(),
+			IsAlive: skywireConn.IsAlive(),
+			// Latency in summary is expected to be in ms and not ns so we change the base to ms
+			Latency:            time.Duration(skywireConn.Latency().Milliseconds()),
 			UploadSpeed:        skywireConn.UploadSpeed(),
 			DownloadSpeed:      skywireConn.DownloadSpeed(),
 			BandwidthSent:      skywireConn.BandwidthSent(),

pkg/router/network_stats.go

@@ -31,8 +31,8 @@ func (s *networkStats) SetLatency(latency uint32) {
 
 func (s *networkStats) Latency() time.Duration {
 	latencyMs := atomic.LoadUint32(&s.latency)
-
-	return time.Duration(latencyMs)
+	// the latency is store in uint32 of millisecond but time.Duration takes nanosecond
+	return time.Duration(latencyMs * uint32(time.Millisecond.Nanoseconds()))
 }
 
 func (s *networkStats) SetUploadSpeed(speed uint32) {