Move uds_test_app to common test_app

This was done so it's easier to add more functionality
to this file for other tests.

PiperOrigin-RevId: 214782043
Change-Id: I1f38b9ee1219b3ce7b789044ada8e52bdc1e6279
This commit is contained in:
Fabricio Voznika 2018-09-27 08:57:32 -07:00 committed by Shentubot
parent fca9a390db
commit 6910ff3643
4 changed files with 126 additions and 94 deletions

View File

@ -2,13 +2,6 @@ package(licenses = ["notice"]) # Apache 2.0
load("@io_bazel_rules_go//go:def.bzl", "go_binary", "go_library", "go_test")
go_binary(
name = "uds_test_app",
srcs = [
"uds_test_app.go",
],
)
go_library(
name = "container",
srcs = [
@ -42,7 +35,7 @@ go_test(
"multi_container_test.go",
],
data = [
":uds_test_app",
":test_app",
"//runsc",
],
embed = [":container"],
@ -64,3 +57,9 @@ go_test(
"@org_golang_x_sys//unix:go_default_library",
],
)
go_binary(
name = "test_app",
srcs = ["test_app.go"],
deps = ["@com_github_google_subcommands//:go_default_library"],
)

View File

@ -722,15 +722,15 @@ func TestUnixDomainSockets(t *testing.T) {
}
defer outputFile.Close()
app, err := testutil.FindFile("runsc/container/uds_test_app")
app, err := testutil.FindFile("runsc/container/test_app")
if err != nil {
t.Fatal("error finding uds_test_app:", err)
t.Fatal("error finding test_app:", err)
}
socketPath := filepath.Join(dir, "uds_socket")
defer os.Remove(socketPath)
spec := testutil.NewSpecWithArgs(app, "--file", outputPath, "--socket", socketPath)
spec := testutil.NewSpecWithArgs(app, "uds", "--file", outputPath, "--socket", socketPath)
spec.Process.User = specs.User{
UID: uint32(os.Getuid()),
GID: uint32(os.Getgid()),

116
runsc/container/test_app.go Normal file
View File

@ -0,0 +1,116 @@
// Copyright 2018 Google Inc.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
// Binary test_app is like a swiss knife for tests that need to run anything
// inside the sandbox. New functionality can be added with new commands.
package main
import (
"context"
"fmt"
"log"
"net"
"os"
"strconv"
"time"
"flag"
"github.com/google/subcommands"
)
func main() {
subcommands.Register(subcommands.HelpCommand(), "")
subcommands.Register(subcommands.FlagsCommand(), "")
subcommands.Register(new(uds), "")
flag.Parse()
exitCode := subcommands.Execute(context.Background())
os.Exit(int(exitCode))
}
type uds struct {
fileName string
socketPath string
}
// Name implements subcommands.Command.Name.
func (*uds) Name() string {
return "uds"
}
// Synopsis implements subcommands.Command.Synopsys.
func (*uds) Synopsis() string {
return "creates unix domain socket client and server. Client sends a contant flow of sequential numbers. Server prints them to --file"
}
// Usage implements subcommands.Command.Usage.
func (*uds) Usage() string {
return "uds <flags>"
}
// SetFlags implements subcommands.Command.SetFlags.
func (c *uds) SetFlags(f *flag.FlagSet) {
f.StringVar(&c.fileName, "file", "", "name of output file")
f.StringVar(&c.socketPath, "socket", "", "path to socket")
}
// Execute implements subcommands.Command.Execute.
func (c *uds) Execute(ctx context.Context, f *flag.FlagSet, args ...interface{}) subcommands.ExitStatus {
if c.fileName == "" || c.socketPath == "" {
log.Fatal("Flags cannot be empty, given: fileName: %q, socketPath: %q", c.fileName, c.socketPath)
return subcommands.ExitFailure
}
outputFile, err := os.OpenFile(c.fileName, os.O_WRONLY|os.O_CREATE, 0666)
if err != nil {
log.Fatal("error opening output file:", err)
}
defer os.Remove(c.socketPath)
listener, err := net.Listen("unix", c.socketPath)
if err != nil {
log.Fatal("error listening on socket %q:", c.socketPath, err)
}
go server(listener, outputFile)
for i := 0; ; i++ {
conn, err := net.Dial("unix", c.socketPath)
if err != nil {
log.Fatal("error dialing:", err)
}
if _, err := conn.Write([]byte(strconv.Itoa(i))); err != nil {
log.Fatal("error writing:", err)
}
conn.Close()
time.Sleep(100 * time.Millisecond)
}
}
func server(listener net.Listener, out *os.File) {
buf := make([]byte, 16)
for {
c, err := listener.Accept()
if err != nil {
log.Fatal("error accepting connection:", err)
}
nr, err := c.Read(buf)
if err != nil {
log.Fatal("error reading from buf:", err)
}
data := buf[0:nr]
fmt.Fprint(out, string(data)+"\n")
}
}

View File

@ -1,83 +0,0 @@
// Copyright 2018 Google Inc.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
// Binary uds-test-app opens a socket and reads a series of numbers
// which are then written to an output file.
package main
import (
"flag"
"fmt"
"log"
"net"
"os"
"strconv"
"time"
)
var (
fileName = flag.String("file", "", "name of output file")
socketPath = flag.String("socket", "", "path to socket")
)
func server(listener net.Listener, f *os.File) {
buf := make([]byte, 16)
for {
c, err := listener.Accept()
if err != nil {
log.Fatal("error accepting connection:", err)
}
nr, err := c.Read(buf)
if err != nil {
log.Fatal("error reading from buf:", err)
}
data := buf[0:nr]
fmt.Fprintf(f, string(data)+"\n")
}
}
func main() {
flag.Parse()
if *fileName == "" || *socketPath == "" {
log.Fatalf("Flags cannot be empty, given: fileName=%s, socketPath=%s", *fileName, *socketPath)
}
outputFile, err := os.OpenFile(*fileName, os.O_WRONLY|os.O_CREATE, 0666)
if err != nil {
log.Fatal("error opening output file:", err)
}
socket := *socketPath
defer os.Remove(socket)
listener, err := net.Listen("unix", socket)
if err != nil {
log.Fatal("error listening on socket:", err)
}
go server(listener, outputFile)
for i := 0; ; i++ {
conn, err := net.Dial("unix", socket)
if err != nil {
log.Fatal("error dialing:", err)
}
if _, err := conn.Write([]byte(strconv.Itoa(i))); err != nil {
log.Fatal("error writing:", err)
}
conn.Close()
time.Sleep(100 * time.Millisecond)
}
}