func main() {
flag.Parse()
maxProcs := runtime.NumCPU()
prevMaxProcs := runtime.GOMAXPROCS(maxProcs)
log.Println("set GOMAXPROCS to", maxProcs, "was", prevMaxProcs)
if *binPath == "" {
log.Fatalln("must specify -bin with linux backend")
}
if *depotPath == "" {
log.Fatalln("must specify -depot with linux backend")
}
if *rootFSPath == "" {
log.Fatalln("must specify -rootfs with linux backend")
}
uidPool := uid_pool.New(uint32(*uidPoolStart), uint32(*uidPoolSize))
_, ipNet, err := net.ParseCIDR(*networkPool)
if err != nil {
log.Fatalln("error parsing CIDR:", err)
}
networkPool := network_pool.New(ipNet)
// TODO: use /proc/sys/net/ipv4/ip_local_port_range by default (end + 1)
portPool := port_pool.New(uint32(*portPoolStart), uint32(*portPoolSize))
runner := linux_command_runner.New(*debug)
quotaManager, err := quota_manager.New(*depotPath, *binPath, runner)
if err != nil {
log.Fatalln("error creating quota manager:", err)
}
if *disableQuotas {
quotaManager.Disable()
}
graphDriver, err := graphdriver.New(*graphRoot)
if err != nil {
log.Fatalln("error constructing graph driver:", err)
}
graph, err := graph.NewGraph(*graphRoot, graphDriver)
if err != nil {
log.Fatalln("error constructing graph:", err)
}
reg, err := registry.NewRegistry(nil, nil, *dockerRegistry)
if err != nil {
log.Fatalln(err)
}
pool := container_pool.New(
*binPath,
*depotPath,
*rootFSPath,
repository_fetcher.Retryable{repository_fetcher.New(reg, graph)},
graphDriver,
uidPool,
networkPool,
portPool,
strings.Split(*denyNetworks, ","),
strings.Split(*allowNetworks, ","),
runner,
quotaManager,
)
systemInfo := system_info.NewProvider(*depotPath)
backend := linux_backend.New(pool, systemInfo, *snapshotsPath)
log.Println("setting up backend")
err = backend.Setup()
if err != nil {
log.Fatalln("failed to set up backend:", err)
}
log.Println("starting server; listening with", *listenNetwork, "on", *listenAddr)
graceTime := *containerGraceTime
wardenServer := server.New(*listenNetwork, *listenAddr, graceTime, backend)
err = wardenServer.Start()
if err != nil {
log.Fatalln("failed to start:", err)
}
signals := make(chan os.Signal, 1)
go func() {
<-signals
log.Println("stopping...")
wardenServer.Stop()
os.Exit(0)
}()
signal.Notify(signals, syscall.SIGINT, syscall.SIGTERM, syscall.SIGHUP)
select {}
}
"github.com/cloudfoundry-incubator/garden/warden"
"github.com/cloudfoundry-incubator/garden/warden/fake_backend"
"github.com/cloudfoundry-incubator/warden-linux/linux_backend"
"github.com/cloudfoundry-incubator/warden-linux/linux_backend/container_pool/fake_container_pool"
"github.com/cloudfoundry-incubator/warden-linux/system_info/fake_system_info"
)
var _ = Describe("Setup", func() {
var fakeContainerPool *fake_container_pool.FakeContainerPool
var fakeSystemInfo *fake_system_info.FakeProvider
var linuxBackend *linux_backend.LinuxBackend
BeforeEach(func() {
fakeContainerPool = fake_container_pool.New()
fakeSystemInfo = fake_system_info.NewFakeProvider()
linuxBackend = linux_backend.New(fakeContainerPool, fakeSystemInfo, "")
})
It("sets up the container pool", func() {
err := linuxBackend.Setup()
Expect(err).ToNot(HaveOccurred())
Expect(fakeContainerPool.DidSetup).To(BeTrue())
})
})
var _ = Describe("Start", func() {
var fakeContainerPool *fake_container_pool.FakeContainerPool
var fakeSystemInfo *fake_system_info.FakeProvider
var tmpdir string