github.com/schwarzm/garden-linux@v0.0.0-20150507151835-33bca2147c47/integration/networking/networking_suite_test.go (about)

     1  package networking_test
     2  
     3  import (
     4  	"encoding/json"
     5  	"fmt"
     6  	"log"
     7  	"net"
     8  	"os"
     9  	"os/exec"
    10  	"strconv"
    11  	"syscall"
    12  
    13  	"github.com/cloudfoundry-incubator/garden"
    14  	"github.com/cloudfoundry-incubator/garden-linux/integration/runner"
    15  	. "github.com/onsi/ginkgo"
    16  	. "github.com/onsi/gomega"
    17  	"github.com/onsi/gomega/gexec"
    18  	"github.com/tedsuo/ifrit"
    19  
    20  	"testing"
    21  )
    22  
    23  var binPath = "../../old/linux_backend/bin" // relative to test suite directory
    24  var rootFSPath = os.Getenv("GARDEN_TEST_ROOTFS")
    25  var graphPath = os.Getenv("GARDEN_TEST_GRAPHPATH")
    26  
    27  var gardenBin string
    28  
    29  var gardenRunner *runner.Runner
    30  var gardenProcess ifrit.Process
    31  
    32  var client garden.Client
    33  var externalIP net.IP
    34  
    35  func startGarden(argv ...string) garden.Client {
    36  	gardenAddr := fmt.Sprintf("/tmp/garden_%d.sock", GinkgoParallelNode())
    37  
    38  	{ // Check this test suite is in the correct directory
    39  		b, err := os.Open(binPath)
    40  		Expect(err).ToNot(HaveOccurred())
    41  		b.Close()
    42  	}
    43  
    44  	gardenRunner = runner.New("unix", gardenAddr, gardenBin, binPath, rootFSPath, graphPath, argv...)
    45  
    46  	gardenProcess = ifrit.Invoke(gardenRunner)
    47  
    48  	return gardenRunner.NewClient()
    49  }
    50  
    51  func ensureGardenRunning() {
    52  	if err := client.Ping(); err != nil {
    53  		client = startGarden()
    54  	}
    55  	Expect(client.Ping()).ToNot(HaveOccurred())
    56  }
    57  
    58  func checkConnection(container garden.Container, ip string, port int) error {
    59  	process, err := container.Run(garden.ProcessSpec{
    60  		Path: "sh",
    61  		Args: []string{"-c", fmt.Sprintf("echo hello | nc -w1 %s %d", ip, port)},
    62  	}, garden.ProcessIO{Stdout: GinkgoWriter, Stderr: GinkgoWriter})
    63  	if err != nil {
    64  		return err
    65  	}
    66  
    67  	exitCode, err := process.Wait()
    68  	if err != nil {
    69  		return err
    70  	}
    71  
    72  	if exitCode == 0 {
    73  		return nil
    74  	} else {
    75  		return fmt.Errorf("Request failed. Process exited with code %d", exitCode)
    76  	}
    77  }
    78  
    79  func checkInternet(container garden.Container) error {
    80  	return checkConnection(container, externalIP.String(), 80)
    81  }
    82  
    83  func TestNetworking(t *testing.T) {
    84  	if rootFSPath == "" {
    85  		log.Println("GARDEN_TEST_ROOTFS undefined; skipping")
    86  		return
    87  	}
    88  
    89  	var beforeSuite struct {
    90  		GardenPath    string
    91  		ExampleDotCom net.IP
    92  	}
    93  
    94  	SynchronizedBeforeSuite(func() []byte {
    95  		var err error
    96  		beforeSuite.GardenPath, err = gexec.Build("github.com/cloudfoundry-incubator/garden-linux", "-a", "-race", "-tags", "daemon")
    97  		Expect(err).ToNot(HaveOccurred())
    98  
    99  		ips, err := net.LookupIP("www.example.com")
   100  		Expect(err).ToNot(HaveOccurred())
   101  		Expect(ips).ToNot(BeEmpty())
   102  		beforeSuite.ExampleDotCom = ips[0]
   103  
   104  		b, err := json.Marshal(beforeSuite)
   105  		Expect(err).ToNot(HaveOccurred())
   106  
   107  		return b
   108  	}, func(paths []byte) {
   109  		err := json.Unmarshal(paths, &beforeSuite)
   110  		Expect(err).ToNot(HaveOccurred())
   111  
   112  		gardenBin = beforeSuite.GardenPath
   113  		externalIP = beforeSuite.ExampleDotCom
   114  	})
   115  
   116  	AfterEach(func() {
   117  		ensureGardenRunning()
   118  		gardenProcess.Signal(syscall.SIGQUIT)
   119  		Eventually(gardenProcess.Wait(), "10s").Should(Receive())
   120  	})
   121  
   122  	SynchronizedAfterSuite(func() {
   123  		//noop
   124  	}, func() {
   125  		gexec.CleanupBuildArtifacts()
   126  	})
   127  
   128  	RegisterFailHandler(Fail)
   129  	RunSpecs(t, "Networking Suite")
   130  }
   131  
   132  // networking test utility functions
   133  func containerIfName(container garden.Container) string {
   134  	return ifNamePrefix(container) + "-1"
   135  }
   136  
   137  func hostIfName(container garden.Container) string {
   138  	return ifNamePrefix(container) + "-0"
   139  }
   140  
   141  func ifNamePrefix(container garden.Container) string {
   142  	return "w" + strconv.Itoa(GinkgoParallelNode()) + container.Handle()
   143  }
   144  
   145  func dumpIP() {
   146  	cmd := exec.Command("ip", "a")
   147  	op, err := cmd.CombinedOutput()
   148  	Expect(err).ToNot(HaveOccurred())
   149  	fmt.Println("IP status:\n", string(op))
   150  
   151  	cmd = exec.Command("iptables", "--verbose", "--exact", "--numeric", "--list")
   152  	op, err = cmd.CombinedOutput()
   153  	Expect(err).ToNot(HaveOccurred())
   154  	fmt.Println("IP tables chains:\n", string(op))
   155  
   156  	cmd = exec.Command("iptables", "--list-rules")
   157  	op, err = cmd.CombinedOutput()
   158  	Expect(err).ToNot(HaveOccurred())
   159  	fmt.Println("IP tables rules:\n", string(op))
   160  }