func wireContainerizer(log lager.Logger, depotPath, iodaemonPath, nstarPath, tarPath, defaultRootFSPath string) *rundmc.Containerizer { depot := depot.New(depotPath) startChecker := rundmc.StartChecker{Expect: "Pid 1 Running", Timeout: 3 * time.Second} stateChecker := rundmc.StateChecker{StateFileDir: OciStateDir} commandRunner := linux_command_runner.New() runcrunner := runrunc.New( process_tracker.New(path.Join(os.TempDir(), fmt.Sprintf("garden-%s", *tag), "processes"), iodaemonPath, commandRunner), commandRunner, wireUidGenerator(), goci.RuncBinary("runc"), &goci.BndlLoader{}, runrunc.LookupFunc(runrunc.LookupUser), ) baseBundle := goci.Bundle(). WithNamespaces(PrivilegedContainerNamespaces...). WithResources(&specs.Resources{}). WithMounts( goci.Mount{Name: "proc", Type: "proc", Source: "proc", Destination: "/proc"}, goci.Mount{Name: "tmp", Type: "tmpfs", Source: "tmpfs", Destination: "/tmp"}, ).WithRootFS(defaultRootFSPath). WithProcess(goci.Process("/bin/sh", "-c", `echo "Pid 1 Running"; read x`)). WithDevices(specs.Device{Path: "/dev/null", Type: 'c', Major: 1, Minor: 3, UID: 0, GID: 0, Permissions: "rwm", FileMode: 0666}) nstar := rundmc.NewNstarRunner(nstarPath, tarPath, linux_command_runner.New()) return rundmc.New(depot, &rundmc.BundleTemplate{Bndl: baseBundle}, runcrunner, startChecker, stateChecker, nstar) }
func wireContainerizer(depotPath, iodaemonPath, defaultRootFSPath string) *rundmc.Containerizer { depot := depot.New(depotPath) startCheck := rundmc.StartChecker{Expect: "Pid 1 Running", Timeout: 3 * time.Second} runcrunner := runrunc.New( process_tracker.New(path.Join(os.TempDir(), fmt.Sprintf("garden-%s", *tag), "processes"), iodaemonPath, linux_command_runner.New()), linux_command_runner.New(), wireUidGenerator(), goci.RuncBinary("runc"), ) baseBundle := goci.Bundle(). WithNamespaces(PrivilegedContainerNamespaces...). WithResources(&specs.Resources{}). WithMounts(goci.Mount{Name: "proc", Type: "proc", Source: "proc", Destination: "/proc"}). WithRootFS(defaultRootFSPath). WithProcess(goci.Process("/bin/sh", "-c", `echo "Pid 1 Running"; read x`)) return rundmc.New(depot, &rundmc.BundleTemplate{baseBundle}, runcrunner, startCheck) }
var _ = Describe("Process tracker", func() { var ( processTracker process_tracker.ProcessTracker tmpdir string ) BeforeEach(func() { var err error tmpdir, err = ioutil.TempDir("", "process-tracker-tests") Expect(err).ToNot(HaveOccurred()) err = os.MkdirAll(filepath.Join(tmpdir, "bin"), 0755) Expect(err).ToNot(HaveOccurred()) processTracker = process_tracker.New(tmpdir, iodaemonBin, linux_command_runner.New()) }) AfterEach(func() { os.RemoveAll(tmpdir) }) Describe("Running processes", func() { It("runs the process and returns its exit code", func() { cmd := exec.Command("bash", "-c", "exit 42") process, err := processTracker.Run("555", cmd, garden.ProcessIO{}, nil, nil) Expect(err).NotTo(HaveOccurred()) status, err := process.Wait() Expect(err).ToNot(HaveOccurred())
func main() { depotDir := flag.String( "depot", "/var/vcap/data/garden-runc/depot", "the depot directory to store containers in", ) listenNetwork := flag.String( "listenNetwork", "tcp", "how to listen on the address (unix, tcp, etc.)", ) listenAddr := flag.String( "listenAddr", "0.0.0.0:7777", "address to listen on", ) containerGraceTime := flag.Duration( "containerGraceTime", 0, "time after which to destroy idle containers", ) cf_lager.AddFlags(flag.CommandLine) flag.Parse() logger, _ := cf_lager.New("garden-runc") runner := &logging.Runner{ CommandRunner: linux_command_runner.New(), Logger: logger, } iodaemonBin, err := gexec.Build("github.com/cloudfoundry-incubator/garden-linux/iodaemon/cmd/iodaemon") if err != nil { panic(err) } gdnr := &gardener.Gardener{ Volumizer: &gardenshed.Shed{}, Containerizer: &rundmc.Containerizer{ Repo: rundmc.Depot{ Dir: *depotDir, ActualContainerProvider: &rundmc.RuncContainerFactory{ Tracker: process_tracker.New("/tmp", iodaemonBin, runner), }, }, }, } server := server.New(*listenNetwork, *listenAddr, *containerGraceTime, gdnr, logger) if err := server.Start(); err != nil { logger.Fatal("failed-to-start-server", err) } logger.Info("started", lager.Data{ "network": *listenNetwork, "addr": *listenAddr, }) signals := make(chan os.Signal, 1) go func() { <-signals server.Stop() os.Exit(0) }() signal.Notify(signals, syscall.SIGINT, syscall.SIGTERM, syscall.SIGHUP) select {} }