Skip to content

Commit

Permalink
enable host name and default resolv.conf and hosts file in none network
Browse files Browse the repository at this point in the history 
Signed-off-by: Shubharanshu Mahapatra <shubhum@amazon.com>
  • Loading branch information
@Shubhranshu153
Shubhranshu153 committed Feb 3, 2025
1 parent 8ef14b7 commit 18ab021
Show file tree
Hide file tree
Showing 2 changed files with 531 additions and 10 deletions.
332 changes: 332 additions & 0 deletions cmd/nerdctl/container/container_run_network_linux_test.go
View file
Original file line number Diff line number Diff line change
Expand Up @@ -517,6 +517,7 @@ func TestSharedNetworkStack(t *testing.T) {
if runtime.GOOS != "linux" {
t.Skip("--network=container:<container name|id> only supports linux now")
}

base := testutil.NewBase(t)

containerName := testutil.Identifier(t)
Expand Down Expand Up @@ -544,6 +545,221 @@ func TestSharedNetworkStack(t *testing.T) {
AssertOutContains(testutil.NginxAlpineIndexHTMLSnippet)
}

func TestSharedNetworkSetup(t *testing.T) {
nerdtest.Setup()
testCase := &test.Case{
Require: test.Not(test.Windows),
Setup: func(data test.Data, helpers test.Helpers) {
data.Set("containerName1", data.Identifier("-container1"))
containerName1 := data.Get("containerName1")
helpers.Ensure("run", "-d", "--name", containerName1,
testutil.NginxAlpineImage)
},
Cleanup: func(data test.Data, helpers test.Helpers) {
helpers.Anyhow("rm", "-f", data.Identifier("-container1"))
},
SubTests: []*test.Case{
{
Description: "Test both have same /etc/hosts",
Command: func(data test.Data, helpers test.Helpers) test.TestableCommand {
containerName2 := data.Identifier()
var cmd test.TestableCommand
cmd = helpers.Command()
cmd.WithArgs("run", "--name", containerName2,
"--network=container:"+data.Get("containerName1"),
testutil.AlpineImage, "cat", "/etc/hosts")
return cmd
},
Expected: func(data test.Data, helpers test.Helpers) *test.Expected {
return &test.Expected{
Output: func(stdout string, info string, t *testing.T) {
containerName1 := data.Get("containerName1")
assert.Assert(t, strings.Contains(helpers.Capture("exec", containerName1, "cat", "/etc/hosts"), stdout), info)
},
}
},
},
{
Description: "Test both have same /etc/resolv.conf",
Command: func(data test.Data, helpers test.Helpers) test.TestableCommand {
containerName2 := data.Identifier()
var cmd test.TestableCommand
cmd = helpers.Command()
cmd.WithArgs("run", "--name", containerName2,
"--network=container:"+data.Get("containerName1"),
testutil.AlpineImage, "cat", "/etc/resolv.conf")
return cmd
},
Expected: func(data test.Data, helpers test.Helpers) *test.Expected {
return &test.Expected{
Output: func(stdout string, info string, t *testing.T) {
containerName1 := data.Get("containerName1")
assert.Assert(t, strings.Compare(helpers.Capture("exec", containerName1, "cat", "/etc/resolv.conf"), stdout) == 0, info)
},
}
},
},
{
Description: "Test uts is not supported in shared network",
Command: func(data test.Data, helpers test.Helpers) test.TestableCommand {
containerName2 := data.Identifier()
var cmd test.TestableCommand
cmd = helpers.Command()
cmd.WithArgs("run", "-d", "--name", containerName2, "--uts", "host",
"--network=container:"+data.Get("containerName1"),
testutil.AlpineImage)
return cmd
},
Expected: func(data test.Data, helpers test.Helpers) *test.Expected {
return &test.Expected{
ExitCode: 1,
}
},
},
{
Description: "Test dns is not supported",
Command: func(data test.Data, helpers test.Helpers) test.TestableCommand {
containerName2 := data.Identifier()
var cmd test.TestableCommand
cmd = helpers.Command()
cmd.WithArgs("run", "-d", "--name", containerName2, "--dns", "0.1.2.3",
"--network=container:"+data.Get("containerName1"),
testutil.AlpineImage)
return cmd
},
Expected: func(data test.Data, helpers test.Helpers) *test.Expected {
return &test.Expected{
ExitCode: 1,
}
},
},
{
Description: "Test dns options is not supported",
Command: func(data test.Data, helpers test.Helpers) test.TestableCommand {
containerName2 := data.Identifier()
var cmd test.TestableCommand
cmd = helpers.Command()
cmd.WithArgs("run", "-d", "--name", containerName2, "--dns-options", "attempts:5",
"--network=container:"+data.Get("containerName1"),
testutil.AlpineImage)
return cmd
},
Expected: func(data test.Data, helpers test.Helpers) *test.Expected {
return &test.Expected{
ExitCode: 1,
}
},
},
{
Description: "Test publish is not supported",
Command: func(data test.Data, helpers test.Helpers) test.TestableCommand {
containerName2 := data.Identifier()
var cmd test.TestableCommand
cmd = helpers.Command()
cmd.WithArgs("run", "-d", "--name", containerName2, "--publish", "80:8080",
"--network=container:"+data.Get("containerName1"),
testutil.AlpineImage)
return cmd
},
Expected: func(data test.Data, helpers test.Helpers) *test.Expected {
return &test.Expected{
ExitCode: 1,
}
},
},
{
Description: "Test hostname is not supported",
Command: func(data test.Data, helpers test.Helpers) test.TestableCommand {
containerName2 := data.Identifier()
var cmd test.TestableCommand
cmd = helpers.Command()
cmd.WithArgs("run", "-d", "--name", containerName2, "--hostname", "test",
"--network=container:"+data.Get("containerName1"),
testutil.AlpineImage)
return cmd
},
Expected: func(data test.Data, helpers test.Helpers) *test.Expected {
return &test.Expected{
ExitCode: 1,
}
},
},
},
}
testCase.Run(t)
}

func TestSharedNetworkWithNone(t *testing.T) {
nerdtest.Setup()
testCase := &test.Case{
Require: test.Not(test.Windows),
Setup: func(data test.Data, helpers test.Helpers) {
data.Set("containerName1", data.Identifier("-container1"))
data.Set("containerName2", data.Identifier("-container2"))
containerName1 := data.Get("containerName1")
helpers.Ensure("run", "-d", "--name", containerName1, "--network", "none",
testutil.NginxAlpineImage)
containerName2 := data.Identifier("-container2")
helpers.Ensure("run", "-d", "--name", containerName2,
"--network=container:"+containerName1,
testutil.NginxAlpineImage)
},
Cleanup: func(data test.Data, helpers test.Helpers) {
helpers.Anyhow("rm", "-f", data.Identifier("-container1"), data.Identifier("-container2"))
},
SubTests: []*test.Case{
{
Description: "Check that a container can be attached to another container with network none",
Expected: func(data test.Data, helpers test.Helpers) *test.Expected {
return &test.Expected{
Output: func(stdout string, info string, t *testing.T) {
containerName2 := data.Get("containerName2")
assert.Assert(t, helpers.Capture("container", "inspect", "-f", "'{{.State.Running}}'", containerName2), info)
},
}
},
},
{
Description: "Test both have same /etc/hosts",
Command: func(data test.Data, helpers test.Helpers) test.TestableCommand {
containerName2 := data.Get("containerName2")
var cmd test.TestableCommand
cmd = helpers.Command()
cmd.WithArgs("exec", containerName2, "cat", "/etc/hosts")
return cmd
},
Expected: func(data test.Data, helpers test.Helpers) *test.Expected {
return &test.Expected{
Output: func(stdout string, info string, t *testing.T) {
containerName1 := data.Get("containerName1")
assert.Assert(t, strings.Contains(helpers.Capture("exec", containerName1, "cat", "/etc/hosts"), stdout), info)
},
}
},
},
{
Description: "Test both have same /etc/resolv.conf",
Command: func(data test.Data, helpers test.Helpers) test.TestableCommand {
containerName2 := data.Get("containerName2")
var cmd test.TestableCommand
cmd = helpers.Command()
cmd.WithArgs("exec", containerName2, "cat", "/etc/resolv.conf")
return cmd
},
Expected: func(data test.Data, helpers test.Helpers) *test.Expected {
return &test.Expected{
Output: func(stdout string, info string, t *testing.T) {
containerName1 := data.Get("containerName1")
assert.Assert(t, strings.Compare(helpers.Capture("exec", containerName1, "cat", "/etc/resolv.conf"), stdout) == 0, info)
},
}
},
},
},
}
testCase.Run(t)
}

func TestRunContainerInExistingNetNS(t *testing.T) {
if rootlessutil.IsRootless() {
t.Skip("Can't create new netns in rootless mode")
Expand Down Expand Up @@ -669,6 +885,8 @@ func TestHostsFileMounts(t *testing.T) {
"sh", "-euxc", "echo >> /etc/hosts").AssertOK()
base.Cmd("run", "--rm", "-v", "/etc/hosts:/etc/hosts", "--network", "host", testutil.CommonImage,
"sh", "-euxc", "head -n -1 /etc/hosts > temp && cat temp > /etc/hosts").AssertOK()
base.Cmd("run", "--rm", "--network", "none", testutil.CommonImage,
"sh", "-euxc", "echo >> /etc/hosts").AssertOK()

base.Cmd("run", "--rm", testutil.CommonImage,
"sh", "-euxc", "echo >> /etc/resolv.conf").AssertOK()
Expand All @@ -681,6 +899,8 @@ func TestHostsFileMounts(t *testing.T) {
"sh", "-euxc", "echo >> /etc/resolv.conf").AssertOK()
base.Cmd("run", "--rm", "-v", "/etc/resolv.conf:/etc/resolv.conf", "--network", "host", testutil.CommonImage,
"sh", "-euxc", "head -n -1 /etc/resolv.conf > temp && cat temp > /etc/resolv.conf").AssertOK()
base.Cmd("run", "--rm", "--network", "host", testutil.CommonImage,
"sh", "-euxc", "echo >> /etc/resolv.conf").AssertOK()
}

func TestRunContainerWithStaticIP6(t *testing.T) {
Expand Down Expand Up @@ -752,3 +972,115 @@ func TestRunContainerWithStaticIP6(t *testing.T) {
})
}
}

func TestNoneNetworkHostName(t *testing.T) {
nerdtest.Setup()
testCase := &test.Case{
Require: test.Not(test.Windows),
Setup: func(data test.Data, helpers test.Helpers) {
data.Set("containerName1", data.Identifier())
},
Cleanup: func(data test.Data, helpers test.Helpers) {
helpers.Anyhow("rm", "-f", data.Identifier())
},
Command: func(data test.Data, helpers test.Helpers) test.TestableCommand {
return helpers.Command("run", "-d", "--name", data.Identifier(), "--network", "none", testutil.NginxAlpineImage)
},
Expected: func(data test.Data, helpers test.Helpers) *test.Expected {
return &test.Expected{
Output: func(stdout string, info string, t *testing.T) {
hostname := stdout
if len(hostname) > 12 {
hostname = hostname[:12]
}
assert.Assert(t, strings.Compare(strings.TrimSpace(helpers.Capture("exec", data.Identifier(), "cat", "/etc/hostname")), hostname) == 0, info)
},
}
},
}
testCase.Run(t)
}

func TestHostNetworkHostName(t *testing.T) {
nerdtest.Setup()
testCase := &test.Case{
Require: test.Not(test.Windows),
Setup: func(data test.Data, helpers test.Helpers) {
data.Set("containerName1", data.Identifier())
},
Cleanup: func(data test.Data, helpers test.Helpers) {
helpers.Anyhow("rm", "-f", data.Identifier())
},
Command: func(data test.Data, helpers test.Helpers) test.TestableCommand {
return helpers.Custom("cat", "/etc/hostname")
},
Expected: func(data test.Data, helpers test.Helpers) *test.Expected {
return &test.Expected{
Output: func(stdout string, info string, t *testing.T) {
hostname := stdout
if len(hostname) > 12 {
hostname = hostname[:12]
}
assert.Assert(t, strings.Compare(strings.TrimSpace(helpers.Capture("run", "--name", data.Identifier(), "--network", "host", testutil.AlpineImage, "cat", "/etc/hostname")), strings.TrimSpace(hostname)) == 0, info)
},
}
},
}
testCase.Run(t)
}

func TestNoneNetworkDnsConfigs(t *testing.T) {
nerdtest.Setup()
testCase := &test.Case{
Require: test.Not(test.Windows),
Setup: func(data test.Data, helpers test.Helpers) {
data.Set("containerName1", data.Identifier())
},
Cleanup: func(data test.Data, helpers test.Helpers) {
helpers.Anyhow("rm", "-f", data.Identifier())
},
Command: func(data test.Data, helpers test.Helpers) test.TestableCommand {
return helpers.Command("run", "-d", "--name", data.Identifier(), "--network", "none", "--dns", "0.1.2.3", "--dns-search", "example.com", "--dns-options", "timeout:3", "--dns-options", "attempts:5", testutil.NginxAlpineImage)
},
Expected: func(data test.Data, helpers test.Helpers) *test.Expected {
return &test.Expected{
Output: func(stdout string, info string, t *testing.T) {
assert.Assert(t, strings.Contains(helpers.Capture("exec", data.Identifier(), "cat", "/etc/resolv.conf"), "0.1.2.3"), info)
assert.Assert(t, strings.Contains(helpers.Capture("exec", data.Identifier(), "cat", "/etc/resolv.conf"), "example.com"), info)
assert.Assert(t, strings.Contains(helpers.Capture("exec", data.Identifier(), "cat", "/etc/resolv.conf"), "attempts:5"), info)
assert.Assert(t, strings.Contains(helpers.Capture("exec", data.Identifier(), "cat", "/etc/resolv.conf"), "timeout:3"), info)

},
}
},
}
testCase.Run(t)
}

func TestHostNetworkDnsConfigs(t *testing.T) {
nerdtest.Setup()
testCase := &test.Case{
Require: test.Not(test.Windows),
Setup: func(data test.Data, helpers test.Helpers) {
data.Set("containerName1", data.Identifier())
},
Cleanup: func(data test.Data, helpers test.Helpers) {
helpers.Anyhow("rm", "-f", data.Identifier())
},
Command: func(data test.Data, helpers test.Helpers) test.TestableCommand {
return helpers.Command("run", "-d", "--name", data.Identifier(), "--network", "host", "--dns", "0.1.2.3", "--dns-search", "example.com", "--dns-options", "timeout:3", "--dns-options", "attempts:5", testutil.NginxAlpineImage)
},
Expected: func(data test.Data, helpers test.Helpers) *test.Expected {
return &test.Expected{
Output: func(stdout string, info string, t *testing.T) {
assert.Assert(t, strings.Contains(helpers.Capture("exec", data.Identifier(), "cat", "/etc/resolv.conf"), "0.1.2.3"), info)
assert.Assert(t, strings.Contains(helpers.Capture("exec", data.Identifier(), "cat", "/etc/resolv.conf"), "example.com"), info)
assert.Assert(t, strings.Contains(helpers.Capture("exec", data.Identifier(), "cat", "/etc/resolv.conf"), "attempts:5"), info)
assert.Assert(t, strings.Contains(helpers.Capture("exec", data.Identifier(), "cat", "/etc/resolv.conf"), "timeout:3"), info)

},
}
},
}
testCase.Run(t)
}
Loading

0 comments on commit 18ab021

Please sign in to comment.