jesusprubio · jesusprubio · Apr 6, 2025 · Apr 6, 2025
diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
@@ -2,8 +2,8 @@ name: CI
 
 on:
   push:
-    branches: main
-    tags: v*
+    branches: [main]
+    tags: [v*]
   pull_request:
 
 jobs:
@@ -16,7 +16,7 @@ jobs:
       - name: Install Go
         uses: actions/setup-go@v5
         with:
-          go-version: "1.23.2"
+          go-version: "1.24.2"
       - name: Install Task
         uses: arduino/setup-task@v2
       - name: Install dependencies

diff --git a/.github/workflows/release.yml b/.github/workflows/release.yml
@@ -19,7 +19,7 @@ jobs:
       - name: Install Go
         uses: actions/setup-go@v5
         with:
-          go-version: "1.23.2"
+          go-version: "1.24.2"
       - name: Release
         uses: goreleaser/goreleaser-action@v6
         env:

diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md
@@ -31,4 +31,8 @@ task build
 
 ## Release
 
-TODO(#32)
+We use [GoReleaser](https://goreleaser.com/) and GitHub workflows to automate
+the binary publishing process. Setup files:
+
+- [GoReleaser](./.goreleaser.yml)
+- [GitHub Workflows](./.github/workflows/release.yml)
diff --git a/README.md b/README.md
@@ -31,6 +31,10 @@ against a randomly selected [public server](internal/servers.go) for each one.
 
 ```sh
 up
+up -p http
+up -p http -c 3
+up -p http -tg example.com
+cat testdata/stdin-urls.txt | go run . -p http
 ```
 
 [doc-img]: https://pkg.go.dev/badge/github.com/jesusprubio/up

diff --git a/Taskfile.yml b/Taskfile.yml
@@ -39,4 +39,4 @@ tasks:
 
   test:
     summary: "Run tests"
-    cmd: go test -v ./...
+    cmd: go test ./...
diff --git a/examples/tcp.go b/examples/tcp.go
diff --git a/go.mod b/go.mod
@@ -1,6 +1,6 @@
 module github.com/jesusprubio/up
 
-go 1.22.4
+go 1.23.5
 
 require github.com/fatih/color v1.18.0
 

diff --git a/internal/options.go b/internal/options.go
@@ -2,15 +2,20 @@
 package internal
 
 import (
+	"errors"
 	"flag"
 	"time"
 )
 
+const targetDesc = "Protocol is required because the format is dependent: URL for HTTP, host:port for TCP, domain for DNS"
+
 // Options are the flags supported by the command line application.
 type Options struct {
-	// Input flags.
 	// Protocol to use. Example: 'http'.
 	Protocol string
+	// Where to point the probe.
+	// URL (HTTP), host/port string (TCP) or domain (DNS).
+	Target string
 	// Number of iterations. Zero means infinite.
 	Count uint
 	// Time to wait for a response.
@@ -32,11 +37,14 @@ type Options struct {
 	Debug bool
 	// Show app documentation.
 	Help bool
+	// Disable stardard input target reading.
+	NoStdin bool
 }
 
 // Parse fulfills the command line flags provided by the user.
-func (opts *Options) Parse() {
+func (opts *Options) Parse() error {
 	flag.StringVar(&opts.Protocol, "p", "", "Test only one protocol")
+	flag.StringVar(&opts.Target, "tg", "", targetDesc)
 	flag.UintVar(&opts.Count, "c", 0, "Number of iterations")
 	flag.DurationVar(
 		&opts.Timeout, "t", 5*time.Second, "Time to wait for a response",
@@ -51,7 +59,22 @@ func (opts *Options) Parse() {
 	flag.BoolVar(&opts.JSONOutput, "j", false, "Output in JSON format")
 	flag.BoolVar(&opts.GrepOutput, "g", false, "Output in grepable format")
 	flag.BoolVar(&opts.NoColor, "nc", false, "Disable color output")
-	flag.BoolVar(&opts.Debug, "dbg", false, "Verbose output")
+	flag.BoolVar(&opts.Debug, "vv", false, "Verbose output")
 	flag.BoolVar(&opts.Help, "h", false, "Show app documentation")
+	flag.BoolVar(
+		&opts.NoStdin,
+		"nstd",
+		false,
+		"Disable standard input target reading",
+	)
 	flag.Parse()
+	return opts.validate()
+}
+
+// Ensures the setup is correct.
+func (opts *Options) validate() error {
+	if opts.Target != "" && opts.Protocol == "" {
+		return errors.New("protocol is required if target is set")
+	}
+	return nil
 }
diff --git a/internal/probe.go b/internal/probe.go
@@ -7,11 +7,10 @@ import (
 	"time"
 )
 
-// Probe is an experiment to measure the connectivity of a network using
-// different protocols and public servers.
+// Probe is an experiment to measure the connectivity of a network.
 type Probe struct {
-	// Protocols to use.
-	Protocols []Protocol
+	// Protocol to use.
+	Proto Protocol
 	// Number of iterations. Zero means infinite.
 	Count uint
 	// Delay between requests.
@@ -20,14 +19,15 @@ type Probe struct {
 	Logger *slog.Logger
 	// Channel to send back partial results.
 	ReportCh chan *Report
-	// URLs (HTTP), host/port strings (TCP) or domains (DNS).
-	Input []string
+	// Optional. Where to point the probe.
+	// URL (HTTP), host/port string (TCP) or domain (DNS).
+	Target string
 }
 
 // Ensures the probe setup is correct.
 func (p Probe) validate() error {
-	if p.Protocols == nil {
-		return newErrorReqProp("Protocols")
+	if p.Proto == nil {
+		return newErrorReqProp("Proto")
 	}
 	// 'Delay' could be zero.
 	if p.Logger == nil {
@@ -58,71 +58,39 @@ func (p Probe) Do(ctx context.Context) error {
 	for {
 		select {
 		case <-ctx.Done():
-			p.Logger.Debug(
-				"Context cancelled between iterations",
-				"count", count,
-			)
+			p.Logger.Debug("Context cancelled", "count", count)
 			return nil
 		default:
-			p.Logger.Debug("New iteration", "count", count)
-			for _, proto := range p.Protocols {
-				select {
-				case <-ctx.Done():
-					p.Logger.Debug(
-						"Context cancelled between protocols",
-						"count", count, "protocol", proto,
-					)
-					return nil
-				default:
-					start := time.Now()
-					p.Logger.Debug(
-						"New protocol", "count", count, "protocol", proto,
-					)
-					if len(p.Input) == 0 {
-						// Probe default list of urls
-						rhost, extra, err := proto.Probe("")
-						report := Report{
-							ProtocolID: proto.String(),
-							Time:       time.Since(start),
-							Error:      err,
-							RHost:      rhost,
-							Extra:      extra,
-						}
-						p.Logger.Debug(
-							"Sending report back",
-							"count", count, "report", report,
-						)
-						p.ReportCh <- &report
-						time.Sleep(p.Delay)
-						continue
-					}
-
-					// iterate over User provided inputs
-					for _, addr := range p.Input {
-						rhost, extra, err := proto.Probe(addr)
-						report := Report{
-							ProtocolID: proto.String(),
-							Time:       time.Since(start),
-							Error:      err,
-							RHost:      rhost,
-							Extra:      extra,
-						}
-						p.Logger.Debug(
-							"Sending report back for address",
-							"count", count, "address", addr, "report", report,
-						)
-						p.ReportCh <- &report
-						time.Sleep(p.Delay)
-					}
-				}
-				time.Sleep(p.Delay)
+			p.Logger.Debug(
+				"New iteration",
+				"count",
+				count,
+				"protocol",
+				p.Proto,
+				"target",
+				p.Target,
+			)
+			start := time.Now()
+			target, extra, err := p.Proto.Probe(p.Target)
+			var errMsg string
+			if err != nil {
+				errMsg = err.Error()
+			}
+			report := Report{
+				ProtocolID: p.Proto.String(),
+				Time:       time.Since(start),
+				Error:      errMsg,
+				Target:     target,
+				Extra:      extra,
+			}
+			p.Logger.Debug("Sending report back", "report", report)
+			p.ReportCh <- &report
+			time.Sleep(p.Delay)
+			count++
+			if p.Count > 0 && count >= p.Count {
+				p.Logger.Debug("Count limit reached", "count", count)
+				return nil
 			}
-		}
-		p.Logger.Debug("Iteration finished", "count", count, "p.Count", p.Count)
-		count++
-		if count == p.Count {
-			p.Logger.Debug("Count limit reached", "count", count)
-			return nil
 		}
 	}
 }
diff --git a/internal/probe_test.go b/internal/probe_test.go
@@ -18,36 +18,35 @@ func (p *testProtocol) Probe(target string) (string, string, error) {
 }
 
 func TestProbeValidate(t *testing.T) {
-	protocols := []Protocol{&testProtocol{}}
+	proto := &testProtocol{}
+	logger := slog.Default()
+	reportCh := make(chan *Report)
+	defer close(reportCh)
 	t.Run("returns nil with valid setup", func(t *testing.T) {
-		reportCh := make(chan *Report)
-		defer close(reportCh)
-		p := Probe{
-			Protocols: protocols, Logger: slog.Default(), ReportCh: reportCh,
-		}
+		p := Probe{Proto: proto, Logger: logger, ReportCh: reportCh}
 		err := p.validate()
 		if err != nil {
 			t.Fatalf("got %q, want nil", err)
 		}
 	})
-	t.Run("returns an error if 'Protocols' is nil", func(t *testing.T) {
+	t.Run("returns an error if 'Proto' is nil", func(t *testing.T) {
 		p := Probe{}
 		err := p.validate()
-		want := "required property: Protocols"
+		want := "required property: Proto"
 		if err.Error() != want {
 			t.Fatalf("got %q, want %q", err, want)
 		}
 	})
 	t.Run("returns an error if 'Logger' is nil", func(t *testing.T) {
-		p := Probe{Protocols: protocols}
+		p := Probe{Proto: proto}
 		err := p.validate()
 		want := "required property: Logger"
 		if err.Error() != want {
 			t.Fatalf("got %q, want %q", err, want)
 		}
 	})
 	t.Run("returns an error if 'ReportCh' is nil", func(t *testing.T) {
-		p := Probe{Protocols: protocols, Logger: slog.Default()}
+		p := Probe{Proto: proto, Logger: logger}
 		err := p.validate()
 		want := "required property: ReportCh"
 		if err.Error() != want {
@@ -60,29 +59,29 @@ func TestProbeDo(t *testing.T) {
 	t.Run("returns an error if the setup is invalid", func(t *testing.T) {
 		p := Probe{}
 		err := p.Do(context.Background())
-		want := "invalid setup: required property: Protocols"
+		want := "invalid setup: required property: Proto"
 		if err.Error() != want {
 			t.Fatalf("got %q, want %q", err, want)
 		}
 	})
-	protocols := []Protocol{&testProtocol{}}
+	protocol := &testProtocol{}
 	t.Run("sends back the report in the channel", func(t *testing.T) {
 		reportCh := make(chan *Report)
 		defer close(reportCh)
 		p := Probe{
-			Protocols: protocols,
-			Count:     2,
-			Logger:    slog.Default(),
-			ReportCh:  reportCh,
+			Proto:    &testProtocol{},
+			Count:    2,
+			Logger:   slog.Default(),
+			ReportCh: reportCh,
 		}
-		protoID := protocols[0].String()
+		protoID := protocol.String()
 		go func(t *testing.T) {
 			for report := range p.ReportCh {
 				if report.ProtocolID != protoID {
 					t.Errorf("got %q, want %q", report.ProtocolID, protoID)
 				}
-				if report.RHost != testHostPort {
-					t.Errorf("got %q, want %q", report.RHost, testHostPort)
+				if report.Target != testHostPort {
+					t.Errorf("got %q, want %q", report.Target, testHostPort)
 				}
 				if report.Time == 0 {
 					t.Errorf("got %q, want > 0", report.Time)
@@ -101,7 +100,7 @@ func TestProbeDo(t *testing.T) {
 		reportCh := make(chan *Report)
 		defer close(reportCh)
 		p := Probe{
-			Protocols: protocols, Logger: slog.Default(), ReportCh: reportCh,
+			Proto: protocol, Logger: slog.Default(), ReportCh: reportCh,
 		}
 		ctx, cancel := context.WithCancel(context.Background())
 		cancel()