func (p *dockerProvisioner) usePlatformImage(app provision.App) bool {
maxLayers, _ := config.GetUint("docker:max-layers")
if maxLayers == 0 {
maxLayers = 10
}
deploys := app.GetDeploys()
return deploys%maxLayers == 0 || app.GetUpdatePlatform()
}
func maxMemoryValue() uint {
if maxMemory > 0 {
return maxMemory
}
var err error
maxMemory, err = config.GetUint("api:request:maxMemory")
if err != nil {
panic("You should configure a api:request:maxMemory for gandalf.")
}
return maxMemory
}
func (p *dockerProvisioner) initDockerCluster() error {
debug, _ := config.GetBool("debug")
clusterLog.SetDebug(debug)
clusterLog.SetLogger(log.GetStdLogger())
var err error
if p.storage == nil {
p.storage, err = buildClusterStorage()
if err != nil {
return err
}
}
if p.collectionName == "" {
var name string
name, err = config.GetString("docker:collection")
if err != nil {
return err
}
p.collectionName = name
}
var nodes []cluster.Node
TotalMemoryMetadata, _ := config.GetString("docker:scheduler:total-memory-metadata")
maxUsedMemory, _ := config.GetFloat("docker:scheduler:max-used-memory")
p.scheduler = &segregatedScheduler{
maxMemoryRatio: float32(maxUsedMemory),
TotalMemoryMetadata: TotalMemoryMetadata,
provisioner: p,
}
caPath, _ := config.GetString("docker:tls:root-path")
if caPath != "" {
p.caCert, err = ioutil.ReadFile(filepath.Join(caPath, "ca.pem"))
if err != nil {
return err
}
p.clientCert, err = ioutil.ReadFile(filepath.Join(caPath, "cert.pem"))
if err != nil {
return err
}
p.clientKey, err = ioutil.ReadFile(filepath.Join(caPath, "key.pem"))
if err != nil {
return err
}
}
p.cluster, err = cluster.New(p.scheduler, p.storage, nodes...)
if err != nil {
return err
}
p.cluster.AddHook(cluster.HookEventBeforeContainerCreate, &internalNodeContainer.ClusterHook{Provisioner: p})
if tsuruHealer.HealerInstance != nil {
healer := hookHealer{p: p}
p.cluster.Healer = healer
p.cluster.AddHook(cluster.HookEventBeforeNodeUnregister, healer)
}
healContainersSeconds, _ := config.GetInt("docker:healing:heal-containers-timeout")
if healContainersSeconds > 0 {
contHealerInst := healer.NewContainerHealer(healer.ContainerHealerArgs{
Provisioner: p,
MaxUnresponsiveTime: time.Duration(healContainersSeconds) * time.Second,
Done: make(chan bool),
Locker: &appLocker{},
})
shutdown.Register(contHealerInst)
go contHealerInst.RunContainerHealer()
}
activeMonitoring, _ := config.GetInt("docker:healing:active-monitoring-interval")
if activeMonitoring > 0 {
p.cluster.StartActiveMonitoring(time.Duration(activeMonitoring) * time.Second)
}
autoScale := p.initAutoScaleConfig()
if autoScale.Enabled {
shutdown.Register(autoScale)
go autoScale.run()
}
limitMode, _ := config.GetString("docker:limit:mode")
if limitMode == "global" {
p.actionLimiter = &provision.MongodbLimiter{}
} else {
p.actionLimiter = &provision.LocalLimiter{}
}
actionLimit, _ := config.GetUint("docker:limit:actions-per-host")
if actionLimit > 0 {
p.actionLimiter.Initialize(actionLimit)
}
return nil
}
