Gather uname information from DUT

Some OSs behave slightly differently, but still within the RFC. It can be useful
to have access to uname information from the testbench.

PiperOrigin-RevId: 361193766

3 files changed, 46 insertions, 29 deletions

diff --git a/test/packetimpact/testbench/BUILD b/test/packetimpact/testbench/BUILD
index 983c2c030..43b4c7ca1 100644
--- a/test/packetimpact/testbench/BUILD
+++ b/test/packetimpact/testbench/BUILD
@@ -1,7 +1,6 @@
 load("//tools:defs.bzl", "go_library", "go_test")
 
 package(
-    default_visibility = ["//test/packetimpact:__subpackages__"],
     licenses = ["notice"],
 )
 
@@ -15,6 +14,7 @@ go_library(
         "rawsockets.go",
         "testbench.go",
     ],
+    visibility = ["//test/packetimpact:__subpackages__"],
     deps = [
         "//pkg/tcpip",
         "//pkg/tcpip/buffer",
diff --git a/test/packetimpact/testbench/dut.go b/test/packetimpact/testbench/dut.go
index be5121d98..aeae5e5d3 100644
--- a/test/packetimpact/testbench/dut.go
+++ b/test/packetimpact/testbench/dut.go
@@ -35,24 +35,26 @@ type DUT struct {
 	conn        *grpc.ClientConn
 	posixServer POSIXClient
 	Net         *DUTTestNet
+	Uname       *DUTUname
 }
 
 // NewDUT creates a new connection with the DUT over gRPC.
 func NewDUT(t *testing.T) DUT {
 	t.Helper()
-	n := GetDUTTestNet()
-	dut := n.ConnectToDUT(t)
+	info := getDUTInfo()
+	dut := info.ConnectToDUT(t)
 	t.Cleanup(func() {
 		dut.TearDownConnection()
-		dut.Net.Release()
+		info.release()
 	})
 	return dut
 }
 
 // ConnectToDUT connects to DUT through gRPC.
-func (n *DUTTestNet) ConnectToDUT(t *testing.T) DUT {
+func (info *DUTInfo) ConnectToDUT(t *testing.T) DUT {
 	t.Helper()
 
+	n := info.Net
 	posixServerAddress := net.JoinHostPort(n.POSIXServerIP.String(), fmt.Sprintf("%d", n.POSIXServerPort))
 	conn, err := grpc.Dial(posixServerAddress, grpc.WithInsecure(), grpc.WithKeepaliveParams(keepalive.ClientParameters{Timeout: RPCKeepalive}))
 	if err != nil {
@@ -63,6 +65,7 @@ func (n *DUTTestNet) ConnectToDUT(t *testing.T) DUT {
 		conn:        conn,
 		posixServer: posixServer,
 		Net:         n,
+		Uname:       info.Uname,
 	}
 }
 
diff --git a/test/packetimpact/testbench/testbench.go b/test/packetimpact/testbench/testbench.go
index 891897d55..a73c07e64 100644
--- a/test/packetimpact/testbench/testbench.go
+++ b/test/packetimpact/testbench/testbench.go
@@ -34,14 +34,29 @@ var (
 	// RPCTimeout is the gRPC timeout.
 	RPCTimeout = 100 * time.Millisecond
 
-	// dutTestNetsJSON is the json string that describes all the test networks to
+	// dutInfosJSON is the json string that describes information about all the
 	// duts available to use.
-	dutTestNetsJSON string
-	// dutTestNets is the pool among which the testbench can choose a DUT to work
+	dutInfosJSON string
+	// dutInfo is the pool among which the testbench can choose a DUT to work
 	// with.
-	dutTestNets chan *DUTTestNet
+	dutInfo chan *DUTInfo
 )
 
+// DUTInfo has both network and uname information about the DUT.
+type DUTInfo struct {
+	Uname *DUTUname
+	Net   *DUTTestNet
+}
+
+// DUTUname contains information about the DUT from uname.
+type DUTUname struct {
+	Machine         string
+	KernelName      string
+	KernelRelease   string
+	KernelVersion   string
+	OperatingSystem string
+}
+
 // DUTTestNet describes the test network setup on dut and how the testbench
 // should connect with an existing DUT.
 type DUTTestNet struct {
@@ -86,7 +101,7 @@ func registerFlags(fs *flag.FlagSet) {
 	fs.BoolVar(&Native, "native", Native, "whether the test is running natively")
 	fs.DurationVar(&RPCTimeout, "rpc_timeout", RPCTimeout, "gRPC timeout")
 	fs.DurationVar(&RPCKeepalive, "rpc_keepalive", RPCKeepalive, "gRPC keepalive")
-	fs.StringVar(&dutTestNetsJSON, "dut_test_nets_json", dutTestNetsJSON, "path to the dut test nets json file")
+	fs.StringVar(&dutInfosJSON, "dut_infos_json", dutInfosJSON, "json that describes the DUTs")
 }
 
 // Initialize initializes the testbench, it parse the flags and sets up the
@@ -94,27 +109,27 @@ func registerFlags(fs *flag.FlagSet) {
 func Initialize(fs *flag.FlagSet) {
 	registerFlags(fs)
 	flag.Parse()
-	if err := loadDUTTestNets(); err != nil {
+	if err := loadDUTInfos(); err != nil {
 		panic(err)
 	}
 }
 
-// loadDUTTestNets loads available DUT test networks from the json file, it
+// loadDUTInfos loads available DUT test infos from the json file, it
 // must be called after flag.Parse().
-func loadDUTTestNets() error {
-	var parsedTestNets []DUTTestNet
-	if err := json.Unmarshal([]byte(dutTestNetsJSON), &parsedTestNets); err != nil {
+func loadDUTInfos() error {
+	var dutInfos []DUTInfo
+	if err := json.Unmarshal([]byte(dutInfosJSON), &dutInfos); err != nil {
 		return fmt.Errorf("failed to unmarshal JSON: %w", err)
 	}
-	if got, want := len(parsedTestNets), 1; got < want {
+	if got, want := len(dutInfos), 1; got < want {
 		return fmt.Errorf("got %d DUTs, the test requires at least %d DUTs", got, want)
 	}
 	// Using a buffered channel as semaphore
-	dutTestNets = make(chan *DUTTestNet, len(parsedTestNets))
-	for i := range parsedTestNets {
-		parsedTestNets[i].LocalIPv4 = parsedTestNets[i].LocalIPv4.To4()
-		parsedTestNets[i].RemoteIPv4 = parsedTestNets[i].RemoteIPv4.To4()
-		dutTestNets <- &parsedTestNets[i]
+	dutInfo = make(chan *DUTInfo, len(dutInfos))
+	for i := range dutInfos {
+		dutInfos[i].Net.LocalIPv4 = dutInfos[i].Net.LocalIPv4.To4()
+		dutInfos[i].Net.RemoteIPv4 = dutInfos[i].Net.RemoteIPv4.To4()
+		dutInfo <- &dutInfos[i]
 	}
 	return nil
 }
@@ -130,14 +145,13 @@ func GenerateRandomPayload(t *testing.T, n int) []byte {
 	return buf
 }
 
-// GetDUTTestNet gets a usable DUTTestNet, the function will block until any
-// becomes available.
-func GetDUTTestNet() *DUTTestNet {
-	return <-dutTestNets
+// getDUTInfo returns information about an available DUT from the pool. If no
+// DUT is readily available, getDUTInfo blocks until one becomes available.
+func getDUTInfo() *DUTInfo {
+	return <-dutInfo
 }
 
-// Release releases the DUTTestNet back to the pool so that some other test
-// can use.
-func (n *DUTTestNet) Release() {
-	dutTestNets <- n
+// release returns the DUTInfo back to the pool.
+func (info *DUTInfo) release() {
+	dutInfo <- info
 }