func spawnOrFail(t *testing.T, cmd string) *gexpect.ExpectSubprocess {
t.Logf("Running command: %v", cmd)
child, err := gexpect.Spawn(cmd)
if err != nil {
t.Fatalf("Cannot exec rkt: %v", err)
}
return child
}
func (a *GoroutineAssistant) SpawnOrFail(cmd string) *gexpect.ExpectSubprocess {
a.t.Logf("Command: %v", cmd)
child, err := gexpect.Spawn(cmd)
if err != nil {
a.Fatalf("Cannot exec rkt: %v", err)
}
return child
}
func TestImageGCTreeStore(t *testing.T) {
ctx := testutils.NewRktRunCtx()
defer ctx.Cleanup()
expectedTreeStores := 2
// If overlayfs is not supported only the stage1 image is rendered in the treeStore
if !common.SupportsOverlay() {
expectedTreeStores = 1
}
// at this point we know that RKT_INSPECT_IMAGE env var is not empty
referencedACI := os.Getenv("RKT_INSPECT_IMAGE")
cmd := fmt.Sprintf("%s --insecure-options=image run --mds-register=false %s", ctx.Cmd(), referencedACI)
t.Logf("Running %s: %v", referencedACI, cmd)
child, err := gexpect.Spawn(cmd)
if err != nil {
t.Fatalf("Cannot exec: %v", err)
}
if err := child.Wait(); err != nil {
t.Fatalf("rkt didn't terminate correctly: %v", err)
}
treeStoreIDs, err := getTreeStoreIDs(ctx)
if err != nil {
t.Fatalf("unexpected error: %v", err)
}
// We expect 2 treeStoreIDs for stage1 and app (only 1 if overlay is not supported/enabled)
if len(treeStoreIDs) != expectedTreeStores {
t.Fatalf("expected %d entries in the treestore but found %d entries", expectedTreeStores, len(treeStoreIDs))
}
runImageGC(t, ctx)
treeStoreIDs, err = getTreeStoreIDs(ctx)
if err != nil {
t.Fatalf("unexpected error: %v", err)
}
// We expect 1/2 treeStoreIDs again as no pod gc has been executed
if len(treeStoreIDs) != expectedTreeStores {
t.Fatalf("expected %d entries in the treestore but found %d entries", expectedTreeStores, len(treeStoreIDs))
}
runGC(t, ctx)
runImageGC(t, ctx)
treeStoreIDs, err = getTreeStoreIDs(ctx)
if err != nil {
t.Fatalf("unexpected error: %v", err)
}
if len(treeStoreIDs) != 0 {
t.Fatalf("expected empty treestore but found %d entries", len(treeStoreIDs))
}
}
func removeImage(t *testing.T, ctx *testutils.RktRunCtx, images ...string) {
cmd := fmt.Sprintf("%s image rm %s", ctx.Cmd(), strings.Join(images, " "))
child, err := gexpect.Spawn(cmd)
if err != nil {
t.Fatalf("Cannot exec: %v", err)
}
if err := expectWithOutput(child, rmImageOk); err != nil {
t.Fatalf("Expected %q but not found: %v", rmImageOk, err)
}
if err := child.Wait(); err != nil {
t.Fatalf("rkt didn't terminate correctly: %v", err)
}
}
func main() {
waitChan := make(chan string)
fmt.Printf("Starting screen.. \n")
child, err := gexpect.Spawn("screen")
if err != nil {
panic(err)
}
sender, reciever := child.AsyncInteractChannels()
go func() {
waitString := ""
count := 0
for {
select {
case waitString = <-waitChan:
count++
case msg, open := <-reciever:
if !open {
return
}
fmt.Printf("Recieved: %s\n", msg)
if strings.Contains(msg, waitString) {
if count >= 1 {
waitChan <- msg
count -= 1
}
}
}
}
}()
wait := func(str string) {
waitChan <- str
<-waitChan
}
fmt.Printf("Waiting until started.. \n")
wait(" ")
fmt.Printf("Sending Enter.. \n")
sender <- "\n"
wait("$")
fmt.Printf("Sending echo.. \n")
sender <- "echo Hello World\n"
wait("Hello World")
fmt.Printf("Received echo. \n")
}
func getImageID(ctx *testutils.RktRunCtx, name string) (string, error) {
cmd := fmt.Sprintf(`/bin/sh -c "%s image list --fields=id,name --no-legend | grep %s | awk '{print $1}'"`, ctx.Cmd(), name)
child, err := gexpect.Spawn(cmd)
if err != nil {
return "", fmt.Errorf("Cannot exec rkt: %v", err)
}
imageID, err := child.ReadLine()
imageID = strings.TrimSpace(imageID)
imageID = string(bytes.Trim([]byte(imageID), "\x00"))
if err != nil {
return "", fmt.Errorf("Cannot exec: %v", err)
}
if err := child.Wait(); err != nil {
return "", fmt.Errorf("rkt didn't terminate correctly: %v", err)
}
return imageID, nil
}
func main() {
fmt.Printf("Starting python.. \n")
child, err := gexpect.Spawn("python")
if err != nil {
panic(err)
}
fmt.Printf("Expecting >>>.. \n")
child.Expect(">>>")
fmt.Printf("print 'Hello World'..\n")
child.SendLine("print 'Hello World'")
child.Expect(">>>")
fmt.Printf("Interacting.. \n")
child.Interact()
fmt.Printf("Done \n")
child.Close()
}
func removeImage(ctx *testutils.RktRunCtx, image string, shouldWork bool) error {
expect := fmt.Sprintf(rmImageReferenced, image)
if shouldWork {
expect = rmImageOk
}
cmd := fmt.Sprintf("%s image rm %s", ctx.Cmd(), image)
child, err := gexpect.Spawn(cmd)
if err != nil {
return fmt.Errorf("Cannot exec: %v", err)
}
if err := expectWithOutput(child, expect); err != nil {
return fmt.Errorf("Expected %q but not found: %v", expect, err)
}
if err := child.Wait(); err != nil {
return fmt.Errorf("rkt didn't terminate correctly: %v", err)
}
return nil
}
func runSignImage(t *testing.T, ctx *testutils.RktRunCtx, imageFile string) {
dir, err := os.Getwd()
if err != nil {
t.Fatalf("Cannot get current working directory: %v", err)
}
cmd := fmt.Sprintf("gpg --no-default-keyring --secret-keyring %s/secring.gpg --keyring %s/pubring.gpg --default-key D9DCEF41 --output %s.asc --detach-sig %s",
dir, dir, imageFile, imageFile)
t.Logf("%s\n", cmd)
child, err := gexpect.Spawn(cmd)
if err != nil {
t.Fatalf("Cannot exec gpg: %s", err)
}
err = child.Wait()
if err != nil {
t.Fatalf("gpg terminate as expected: %v", err)
}
}
func TestPrepareAppEnsureEtcHosts(t *testing.T) {
etcHostsCreateImage := patchTestACI("rkt-inspect-etc-hosts-create.aci", "--exec=/inspect --read-file")
defer os.Remove(etcHostsCreateImage)
etcHostsExistsImage := patchTestACI("rkt-inspect-etc-hosts-exists.aci", "--exec=/inspect --read-file", "--mounts=etc,path=/etc,readOnly=false")
defer os.Remove(etcHostsExistsImage)
ctx := testutils.NewRktRunCtx()
defer ctx.Cleanup()
tmpdir := createTempDirOrPanic("rkt-tests.")
defer os.RemoveAll(tmpdir)
tmpetc := createTempDirOrPanic("rkt-tests-etc.")
defer os.RemoveAll(tmpetc)
tmpfile := filepath.Join(tmpetc, "hosts")
if err := ioutil.WriteFile(tmpfile, []byte(`<<<preexisting etc>>>`), 0600); err != nil {
t.Fatalf("Cannot create etc/hosts file: %v", err)
}
for i, tt := range etcHostsTests {
cmd := strings.Replace(tt.rktCmd, "^TMPDIR^", tmpdir, -1)
cmd = strings.Replace(cmd, "^RKT_BIN^", ctx.Cmd(), -1)
cmd = strings.Replace(cmd, "^ETC_HOSTS_CREATE^", etcHostsCreateImage, -1)
cmd = strings.Replace(cmd, "^ETC_HOSTS_EXISTS^", etcHostsExistsImage, -1)
cmd = strings.Replace(cmd, "^TMPETC^", tmpetc, -1)
t.Logf("Running test #%v: %v", i, cmd)
child, err := gexpect.Spawn(cmd)
if err != nil {
t.Fatalf("Cannot exec rkt #%v: %v", i, err)
}
_, _, err = expectRegexTimeoutWithOutput(child, tt.expectRegEx, time.Minute)
if err != nil {
t.Fatalf("Expected %q but not found #%v: %v", tt.expectRegEx, i, err)
}
err = child.Wait()
if err != nil {
t.Fatalf("rkt didn't terminate correctly: %v", err)
}
}
}
func TestUserns(t *testing.T) {
image := patchTestACI("rkt-inspect-stat.aci", "--exec=/inspect --stat-file")
defer os.Remove(image)
ctx := testutils.NewRktRunCtx()
defer ctx.Cleanup()
for i, tt := range usernsTests {
for _, userNsOpt := range []string{"", "--private-users"} {
runCmd := tt.runCmd
runCmd = strings.Replace(runCmd, "^IMAGE^", image, -1)
runCmd = strings.Replace(runCmd, "^RKT_BIN^", ctx.Cmd(), -1)
runCmd = strings.Replace(runCmd, "^FILE^", tt.file, -1)
runCmd = strings.Replace(runCmd, "^USERNS^", userNsOpt, -1)
t.Logf("Running 'run' test #%v: %v", i, runCmd)
child, err := gexpect.Spawn(runCmd)
if err != nil {
t.Fatalf("Cannot exec rkt #%v: %v", i, err)
}
err = expectWithOutput(child, tt.file+": mode: "+tt.expectMode)
if err != nil {
t.Fatalf("Expected %q but not found: %v", tt.expectMode, err)
}
err = expectWithOutput(child, tt.file+": user: "******"Expected %q but not found: %v", tt.expectUid, err)
}
err = expectWithOutput(child, tt.file+": group: "+tt.expectGid)
if err != nil {
t.Fatalf("Expected %q but not found: %v", tt.expectGid, err)
}
err = child.Wait()
if err != nil {
t.Fatalf("rkt didn't terminate correctly: %v", err)
}
ctx.Reset()
}
}
}
func main() {
log.Printf("Testing Ftp... ")
child, err := gexpect.Spawn("ftp ftp.openbsd.org")
if err != nil {
panic(err)
}
child.Expect("Name")
child.SendLine("anonymous")
child.Expect("Password")
child.SendLine("*****@*****.**")
child.Expect("ftp> ")
child.SendLine("cd /pub/OpenBSD/3.7/packages/i386")
child.Expect("ftp> ")
child.SendLine("bin")
child.Expect("ftp> ")
child.SendLine("prompt")
child.Expect("ftp> ")
child.SendLine("pwd")
child.Expect("ftp> ")
log.Printf("Success\n")
}
