1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
|
// +build !remoteclient
package integration
import (
"fmt"
"io"
"os"
"path/filepath"
"strings"
"syscall"
"time"
"github.com/containers/libpod/pkg/rootless"
. "github.com/containers/libpod/test/utils"
. "github.com/onsi/ginkgo"
. "github.com/onsi/gomega"
"golang.org/x/sys/unix"
)
const sigCatch = "trap \"echo FOO >> /h/fifo \" 8; echo READY >> /h/fifo; while :; do sleep 0.25; done"
const sigCatch2 = "trap \"echo Received\" SIGFPE; while :; do sleep 0.25; done"
var _ = Describe("Podman run with --sig-proxy", func() {
var (
tmpdir string
err error
podmanTest *PodmanTestIntegration
)
BeforeEach(func() {
tmpdir, err = CreateTempDirInTempDir()
if err != nil {
os.Exit(1)
}
podmanTest = PodmanTestCreate(tmpdir)
podmanTest.Setup()
podmanTest.SeedImages()
})
AfterEach(func() {
podmanTest.Cleanup()
f := CurrentGinkgoTestDescription()
processTestResult(f)
})
Specify("signals are forwarded to container using sig-proxy", func() {
if podmanTest.Host.Arch == "ppc64le" {
Skip("Doesn't work on ppc64le")
}
signal := syscall.SIGFPE
// Set up a socket for communication
udsDir := filepath.Join(tmpdir, "socket")
os.Mkdir(udsDir, 0700)
udsPath := filepath.Join(udsDir, "fifo")
syscall.Mkfifo(udsPath, 0600)
if rootless.IsRootless() {
podmanTest.RestoreArtifact(fedoraMinimal)
}
_, pid := podmanTest.PodmanPID([]string{"run", "-it", "-v", fmt.Sprintf("%s:/h:Z", udsDir), fedoraMinimal, "bash", "-c", sigCatch})
uds, _ := os.OpenFile(udsPath, os.O_RDONLY|syscall.O_NONBLOCK, 0600)
defer uds.Close()
// Wait for the script in the container to alert us that it is READY
counter := 0
for {
buf := make([]byte, 1024)
n, err := uds.Read(buf[:])
if err != nil && err != io.EOF {
fmt.Println(err)
return
}
data := string(buf[0:n])
if strings.Contains(data, "READY") {
break
}
time.Sleep(1 * time.Second)
if counter == 15 {
Fail("Timed out waiting for READY from container")
}
counter++
}
// Ok, container is up and running now and so is the script
if err := unix.Kill(pid, signal); err != nil {
Fail(fmt.Sprintf("error killing podman process %d: %v", pid, err))
}
// The sending of the signal above will send FOO to the socket; here we
// listen to the socket for that.
counter = 0
for {
buf := make([]byte, 1024)
n, err := uds.Read(buf[:])
if err != nil {
fmt.Println(err)
return
}
data := string(buf[0:n])
if strings.Contains(data, "FOO") {
break
}
time.Sleep(1 * time.Second)
if counter == 15 {
Fail("timed out waiting for FOO from container")
}
counter++
}
})
Specify("signals are not forwarded to container with sig-proxy false", func() {
signal := syscall.SIGFPE
if rootless.IsRootless() {
podmanTest.RestoreArtifact(fedoraMinimal)
}
session, pid := podmanTest.PodmanPID([]string{"run", "--name", "test2", "--sig-proxy=false", fedoraMinimal, "bash", "-c", sigCatch2})
ok := WaitForContainer(podmanTest)
Expect(ok).To(BeTrue())
// Kill with given signal
// Should be no output, SIGPOLL is usually ignored
if err := unix.Kill(pid, signal); err != nil {
Fail(fmt.Sprintf("error killing podman process %d: %v", pid, err))
}
// Kill with -9 to guarantee the container dies
killSession := podmanTest.Podman([]string{"kill", "-s", "9", "test2"})
killSession.WaitWithDefaultTimeout()
Expect(killSession.ExitCode()).To(Equal(0))
session.WaitWithDefaultTimeout()
Expect(session.ExitCode()).ToNot(Equal(0))
ok, _ = session.GrepString("Received")
Expect(ok).To(BeFalse())
})
})
|
