// New returns an instance of the scheduler
// The MetricManager must be set before the scheduler can be started.
// The MetricManager must be started before it can be used.
func New(cfg *Config) *scheduler {
schedulerLogger.WithFields(log.Fields{
"_block": "New",
"value": cfg.WorkManagerQueueSize,
}).Info("Setting work manager queue size")
schedulerLogger.WithFields(log.Fields{
"_block": "New",
"value": cfg.WorkManagerPoolSize,
}).Info("Setting work manager pool size")
opts := []workManagerOption{
CollectQSizeOption(cfg.WorkManagerQueueSize),
CollectWkrSizeOption(cfg.WorkManagerPoolSize),
PublishQSizeOption(cfg.WorkManagerQueueSize),
PublishWkrSizeOption(cfg.WorkManagerPoolSize),
ProcessQSizeOption(cfg.WorkManagerQueueSize),
ProcessWkrSizeOption(cfg.WorkManagerPoolSize),
}
s := &scheduler{
tasks: newTaskCollection(),
eventManager: gomit.NewEventController(),
taskWatcherColl: newTaskWatcherCollection(),
}
// we are setting the size of the queue and number of workers for
// collect, process and publish consistently for now
s.workManager = newWorkManager(opts...)
s.workManager.Start()
s.eventManager.RegisterHandler(HandlerRegistrationName, s)
return s
}
// New returns a new pluginControl instance
func New(opts ...PluginControlOpt) *pluginControl {
c := &pluginControl{}
c.Config = NewConfig()
// Initialize components
//
// Event Manager
c.eventManager = gomit.NewEventController()
controlLogger.WithFields(log.Fields{
"_block": "new",
}).Debug("pevent controller created")
// Metric Catalog
c.metricCatalog = newMetricCatalog()
controlLogger.WithFields(log.Fields{
"_block": "new",
}).Debug("metric catalog created")
// Plugin Manager
c.pluginManager = newPluginManager()
controlLogger.WithFields(log.Fields{
"_block": "new",
}).Debug("plugin manager created")
// Plugin Manager needs a reference to the metric catalog
c.pluginManager.SetMetricCatalog(c.metricCatalog)
// Signing Manager
c.signingManager = &psigning.SigningManager{}
controlLogger.WithFields(log.Fields{
"_block": "new",
}).Debug("signing manager created")
// Plugin Runner
c.pluginRunner = newRunner()
controlLogger.WithFields(log.Fields{
"_block": "new",
}).Debug("runner created")
c.pluginRunner.AddDelegates(c.eventManager)
c.pluginRunner.SetEmitter(c.eventManager)
c.pluginRunner.SetMetricCatalog(c.metricCatalog)
c.pluginRunner.SetPluginManager(c.pluginManager)
// Start stuff
err := c.pluginRunner.Start()
if err != nil {
panic(err)
}
// apply options
// it is important that this happens last, as an option may
// require that an internal member of c be constructed.
for _, opt := range opts {
opt(c)
}
return c
}
// New returns an instance of the scheduler
// The MetricManager must be set before the scheduler can be started.
// The MetricManager must be started before it can be used.
func New(opts ...workManagerOption) *scheduler {
s := &scheduler{
tasks: newTaskCollection(),
logger: log.WithFields(log.Fields{
"_module": "scheduler",
}),
eventManager: gomit.NewEventController(),
taskWatcherColl: newTaskWatcherCollection(),
}
// we are setting the size of the queue and number of workers for
// collect, process and publish consistently for now
s.workManager = newWorkManager(opts...)
s.workManager.Start()
s.eventManager.RegisterHandler(HandlerRegistrationName, s)
return s
}
func New(cfg *Config) (*tribe, error) {
cfg.MemberlistConfig.Name = cfg.Name
cfg.MemberlistConfig.BindAddr = cfg.BindAddr
cfg.MemberlistConfig.BindPort = cfg.BindPort
logger := logger.WithFields(log.Fields{
"port": cfg.MemberlistConfig.BindPort,
"addr": cfg.MemberlistConfig.BindAddr,
"name": cfg.MemberlistConfig.Name,
})
tribe := &tribe{
agreements: map[string]*agreement.Agreement{},
members: map[string]*agreement.Member{},
taskStateResponses: map[string]*taskStateQueryResponse{},
taskStartStopCache: newCache(),
msgBuffer: make([]msg, 512),
intentBuffer: []msg{},
logger: logger.WithField("_name", cfg.MemberlistConfig.Name),
tags: map[string]string{
agreement.RestPort: strconv.Itoa(cfg.RestAPIPort),
agreement.RestProtocol: cfg.RestAPIProto,
agreement.RestInsecureSkipVerify: cfg.RestAPIInsecureSkipVerify,
},
pluginWorkQueue: make(chan worker.PluginRequest, 999),
taskWorkQueue: make(chan worker.TaskRequest, 999),
workerQuitChan: make(chan struct{}),
workerWaitGroup: &sync.WaitGroup{},
config: cfg,
EventManager: gomit.NewEventController(),
}
tribe.broadcasts = &memberlist.TransmitLimitedQueue{
NumNodes: func() int {
return len(tribe.memberlist.Members())
},
RetransmitMult: memberlist.DefaultLANConfig().RetransmitMult,
}
//configure delegates
cfg.MemberlistConfig.Delegate = &delegate{tribe: tribe}
cfg.MemberlistConfig.Events = &memberDelegate{tribe: tribe}
ml, err := memberlist.Create(cfg.MemberlistConfig)
if err != nil {
logger.Error(err)
return nil, err
}
tribe.memberlist = ml
if cfg.Seed != "" {
_, err := ml.Join([]string{cfg.Seed})
if err != nil {
logger.WithFields(log.Fields{
"seed": cfg.Seed,
}).Error(errMemberlistJoin)
return nil, errMemberlistJoin
}
logger.WithFields(log.Fields{
"seed": cfg.Seed,
}).Infoln("tribe started")
return tribe, nil
}
logger.WithFields(log.Fields{
"seed": "none",
}).Infoln("tribe started")
return tribe, nil
}
import (
"testing"
"time"
"github.com/intelsdi-x/snap/control/plugin"
"github.com/intelsdi-x/snap/core"
"github.com/intelsdi-x/snap/pkg/schedule"
"github.com/intelsdi-x/snap/scheduler/wmap"
log "github.com/Sirupsen/logrus"
"github.com/intelsdi-x/gomit"
. "github.com/smartystreets/goconvey/convey"
)
var (
emitter = gomit.NewEventController()
)
func TestTask(t *testing.T) {
log.SetLevel(log.FatalLevel)
Convey("Task", t, func() {
sampleWFMap := wmap.Sample()
wf, errs := wmapToWorkflow(sampleWFMap)
So(errs, ShouldBeEmpty)
c := &mockMetricManager{}
c.setAcceptedContentType("rabbitmq", core.PublisherPluginType, 5, []string{plugin.SnapGOBContentType})
mgrs := newManagers(c)
err := wf.BindPluginContentTypes(&mgrs)
So(err, ShouldBeNil)
Convey("task + simple schedule", func() {
sch := schedule.NewSimpleSchedule(time.Millisecond * 100)
func TestMonitor(t *testing.T) {
Convey("monitor", t, func() {
aps := newAvailablePlugins()
ap1 := &availablePlugin{
pluginType: plugin.CollectorPluginType,
version: 1,
name: "test",
client: new(MockUnhealthyPluginCollectorClient),
healthChan: make(chan error, 1),
emitter: gomit.NewEventController(),
}
aps.insert(ap1)
ap2 := &availablePlugin{
pluginType: plugin.PublisherPluginType,
version: 1,
name: "test",
client: new(MockUnhealthyPluginCollectorClient),
healthChan: make(chan error, 1),
emitter: gomit.NewEventController(),
}
aps.insert(ap2)
ap3 := &availablePlugin{
pluginType: plugin.ProcessorPluginType,
version: 1,
name: "test",
client: new(MockUnhealthyPluginCollectorClient),
healthChan: make(chan error, 1),
emitter: gomit.NewEventController(),
}
aps.insert(ap3)
Convey("newMonitor", func() {
m := newMonitor(MonitorDurationOption(time.Millisecond * 123))
So(m, ShouldHaveSameTypeAs, &monitor{})
So(m.duration, ShouldResemble, time.Millisecond*123)
})
Convey("start", func() {
m := newMonitor()
m.Option(MonitorDurationOption(time.Millisecond * 200))
So(m.duration, ShouldResemble, time.Millisecond*200)
m.Start(aps)
So(m.State, ShouldEqual, MonitorStarted)
time.Sleep(1 * time.Second)
Convey("health monitor", func() {
for _, ap := range aps.all() {
So(ap, ShouldNotBeNil)
So(ap.(*availablePlugin).failedHealthChecks, ShouldBeGreaterThan, 3)
}
})
})
Convey("stop", func() {
m := newMonitor()
m.Start(aps)
So(m.State, ShouldEqual, MonitorStarted)
m.Stop()
So(m.State, ShouldEqual, MonitorStopped)
})
Convey("override MonitorDuration", func() {
m := newMonitor()
oldOpt := m.Option(MonitorDurationOption(time.Millisecond * 200))
So(m.duration, ShouldResemble, time.Millisecond*200)
m.Option(oldOpt)
So(m.duration, ShouldResemble, time.Second*1)
})
})
}
// New returns a new pluginControl instance
func New(cfg *Config) *pluginControl {
// construct a slice of options from the input configuration
opts := []PluginControlOpt{
MaxRunningPlugins(cfg.MaxRunningPlugins),
CacheExpiration(cfg.CacheExpiration.Duration),
OptSetConfig(cfg),
}
c := &pluginControl{}
c.Config = cfg
// Initialize components
// Event Manager
c.eventManager = gomit.NewEventController()
controlLogger.WithFields(log.Fields{
"_block": "new",
}).Debug("pevent controller created")
// Metric Catalog
c.metricCatalog = newMetricCatalog()
controlLogger.WithFields(log.Fields{
"_block": "new",
}).Debug("metric catalog created")
// Plugin Manager
c.pluginManager = newPluginManager()
controlLogger.WithFields(log.Fields{
"_block": "new",
}).Debug("plugin manager created")
// Plugin Manager needs a reference to the metric catalog
c.pluginManager.SetMetricCatalog(c.metricCatalog)
// Signing Manager
c.signingManager = &psigning.SigningManager{}
controlLogger.WithFields(log.Fields{
"_block": "new",
}).Debug("signing manager created")
// Plugin Runner
c.pluginRunner = newRunner()
controlLogger.WithFields(log.Fields{
"_block": "new",
}).Debug("runner created")
c.pluginRunner.AddDelegates(c.eventManager)
c.pluginRunner.SetEmitter(c.eventManager)
c.pluginRunner.SetMetricCatalog(c.metricCatalog)
c.pluginRunner.SetPluginManager(c.pluginManager)
// Pass runner events to control main module
c.eventManager.RegisterHandler(c.Name(), c)
// Create subscription group - used for managing a group of subscriptions
c.subscriptionGroups = newSubscriptionGroups(c)
// Start stuff
err := c.pluginRunner.Start()
if err != nil {
panic(err)
}
// apply options
// it is important that this happens last, as an option may
// require that an internal member of c be constructed.
for _, opt := range opts {
opt(c)
}
return c
}