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 {}
}