func newConvergence(db *SQLDB) *convergence {
pool, err := workpool.NewWorkPool(db.convergenceWorkersSize)
if err != nil {
panic(fmt.Sprintf("failing to create workpool is irrecoverable %v", err))
}
return &convergence{
SQLDB: db,
guidsToStartRequests: map[string]*auctioneer.LRPStartRequest{},
keysToRetire: []*models.ActualLRPKey{},
pool: pool,
}
}
func NewStoreAdapter(urls []string, concurrentRequests int) storeadapter.StoreAdapter {
workPool, err := workpool.NewWorkPool(concurrentRequests)
if err != nil {
panic(err)
}
options := &etcdstoreadapter.ETCDOptions{
ClusterUrls: urls,
}
etcdStoreAdapter, err := etcdstoreadapter.New(options, workPool)
if err != nil {
panic(err)
}
etcdStoreAdapter.Connect()
return etcdStoreAdapter
}
func (twp *TaskCompletionWorkPool) Run(signals <-chan os.Signal, ready chan<- struct{}) error {
cbWorkPool, err := workpool.NewWorkPool(twp.maxWorkers)
logger := twp.logger
logger.Info("starting")
if err != nil {
logger.Error("creation-failed", err)
return err
}
twp.callbackWorkPool = cbWorkPool
close(ready)
logger.Info("started")
defer logger.Info("finished")
<-signals
twp.callbackWorkPool.Stop()
return nil
}
func NewDesiredLRPGenerator(
errTolerance float64,
metricPrefix string,
workpoolSize int,
bbsClient bbs.InternalClient,
datadogClient *datadog.Client,
) *DesiredLRPGenerator {
workPool, err := workpool.NewWorkPool(workpoolSize)
if err != nil {
panic(err)
}
return &DesiredLRPGenerator{
errorTolerance: errTolerance,
metricPrefix: metricPrefix,
bbsClient: bbsClient,
workPool: workPool,
datadogClient: datadogClient,
}
}
func defaultStoreAdapterProvider(conf *config.Config) storeadapter.StoreAdapter {
workPool, err := workpool.NewWorkPool(conf.EtcdMaxConcurrentRequests)
if err != nil {
panic(err)
}
options := &etcdstoreadapter.ETCDOptions{
ClusterUrls: conf.EtcdUrls,
}
if conf.EtcdRequireTLS {
options.IsSSL = true
options.CertFile = conf.EtcdTLSClientConfig.CertFile
options.KeyFile = conf.EtcdTLSClientConfig.KeyFile
options.CAFile = conf.EtcdTLSClientConfig.CAFile
}
etcdStoreAdapter, err := etcdstoreadapter.New(options, workPool)
if err != nil {
panic(err)
}
return etcdStoreAdapter
}
func main() {
flag.Parse()
conf, err := config.ParseConfig(*configFile)
if err != nil {
panic(err)
}
log := logger.NewLogger(*debug, *logFilePath, "syslog_drain_binder", conf.Syslog)
dropsonde.Initialize(conf.MetronAddress, "syslog_drain_binder")
workPool, err := workpool.NewWorkPool(conf.EtcdMaxConcurrentRequests)
if err != nil {
panic(err)
}
options := &etcdstoreadapter.ETCDOptions{
ClusterUrls: conf.EtcdUrls,
}
if conf.EtcdRequireTLS {
options.IsSSL = true
options.CertFile = conf.EtcdTLSClientConfig.CertFile
options.KeyFile = conf.EtcdTLSClientConfig.KeyFile
options.CAFile = conf.EtcdTLSClientConfig.CAFile
}
adapter, err := etcdstoreadapter.New(options, workPool)
if err != nil {
panic(err)
}
updateInterval := time.Duration(conf.UpdateIntervalSeconds) * time.Second
politician := elector.NewElector(conf.InstanceName, adapter, updateInterval, log)
drainTTL := time.Duration(conf.DrainUrlTtlSeconds) * time.Second
store := etcd_syslog_drain_store.NewEtcdSyslogDrainStore(adapter, drainTTL, log)
dumpChan := registerGoRoutineDumpSignalChannel()
ticker := time.NewTicker(updateInterval)
for {
select {
case <-dumpChan:
signalmanager.DumpGoRoutine()
case <-ticker.C:
if politician.IsLeader() {
err = politician.StayAsLeader()
if err != nil {
log.Errorf("Error when staying leader: %s", err.Error())
politician.Vacate()
continue
}
} else {
err = politician.RunForElection()
if err != nil {
log.Errorf("Error when running for leader: %s", err.Error())
politician.Vacate()
continue
}
}
log.Debugf("Polling %s for updates", conf.CloudControllerAddress)
drainUrls, err := Poll(conf.CloudControllerAddress, conf.BulkApiUsername, conf.BulkApiPassword, conf.PollingBatchSize, conf.SkipCertVerify)
if err != nil {
log.Errorf("Error when polling cloud controller: %s", err.Error())
politician.Vacate()
continue
}
metrics.IncrementCounter("pollCount")
var totalDrains int
for _, drainList := range drainUrls {
totalDrains += len(drainList)
}
metrics.SendValue("totalDrains", float64(totalDrains), "drains")
log.Debugf("Updating drain URLs for %d application(s)", len(drainUrls))
err = store.UpdateDrains(drainUrls)
if err != nil {
log.Errorf("Error when updating ETCD: %s", err.Error())
politician.Vacate()
continue
}
}
}
}