func TestMultipleRegistrations(t *testing.T) { testcases := []struct { name string // component checker health.Checker // health checker }{ {"component-alive", healthy}, {"component-up", healthy}, {"component-failed", failed}, {"component-dead", failed}, {"component-ok", healthy}, } for _, tc := range testcases { health.Register(tc.name, tc.checker) } assert.Len(t, health.Components(), len(testcases)) // all registered all := health.RunChecks() for _, tc := range testcases { assert.Contains(t, health.Components(), tc.name) _, found := all[tc.name] assert.True(t, found) assert.EqualValues(t, all[tc.name], tc.checker.Check(), tc.name) } teardown() }
func TestDeregisterHealthCheck(t *testing.T) { health.Register(COMPONENT, healthy) health.Unregister(COMPONENT) assert.Len(t, health.Components(), 0) assert.NotContains(t, health.Components(), COMPONENT) all := health.RunChecks() assert.Len(t, all, 0) teardown() }
func TestRegister(t *testing.T) { health.Register(COMPONENT, healthy) assert.Len(t, health.Components(), 1) assert.Contains(t, health.Components(), COMPONENT) all := health.RunChecks() status, found := all[COMPONENT] assert.True(t, found) assert.EqualValues(t, status, healthy.Check()) teardown() }
func TestRegisterDuplicateHealthCheck(t *testing.T) { health.Register(COMPONENT, healthy) health.RegisterFunc(COMPONENT, alwaysFailing) // replace with failing health check assert.Len(t, health.Components(), 1) assert.Contains(t, health.Components(), COMPONENT) all := health.RunChecks() status, found := all[COMPONENT] assert.True(t, found) assert.EqualValues(t, status, alwaysFailing()) teardown() }
func TestHealthCheckExecuteUnhealthy(t *testing.T) { health.Register(COMPONENT, &stubHealthCheck{healthy: false}) checks := health.RunChecks() for component, hc := range checks { assert.Equal(t, component, COMPONENT) assert.False(t, hc.Healthy) assert.Equal(t, FAILING, hc.Properties["message"]) } teardown() }
func TestHealthCheckExecuteHealthy(t *testing.T) { health.Register(COMPONENT, &stubHealthCheck{healthy: true}) checks := health.RunChecks() for component, hc := range checks { assert.Equal(t, component, COMPONENT) assert.True(t, hc.Healthy) assert.Empty(t, hc.Properties["cause"]) } teardown() }
// New creates and initializes a new cluster with the given configuration. // Nil argument results with default values for the configuration. func New(conf *Config) (Cluster, error) { conf = defaultize(conf) b, err := newBackend(conf) if err != nil { return nil, err } m := newMembership(b, conf.TTL, conf.ScanInterval) c := &cluster{backend: b, membership: m, conf: conf} m.StartMonitoring() hc := newHealthChecker(m, conf.Size) health.Register(module, hc) return c, nil }
// New - Create a new replication instance func New(conf *Config) (Replication, error) { var lentry = logging.GetLogger(module) if conf == nil { err := fmt.Errorf("Nil conf") lentry.WithFields(log.Fields{ "error": err, }).Error("Failed to create replication server") return nil, err } if conf.Membership == nil || conf.Registrator == nil { err := fmt.Errorf("Nil cluster membership and/or registrator") lentry.WithFields(log.Fields{ "error": err, }).Error("Failed to create replication server") return nil, err } // Make sure that the listening port is free address := fmt.Sprintf("%s:%d", conf.Registrator.Self().IP(), conf.Registrator.Self().Port()) listener, err := net.Listen("tcp", address) if err != nil { lentry.WithFields(log.Fields{ "error": err, }).Error("Failed to create replication server") return nil, err } tr := &http.Transport{MaxIdleConnsPerHost: 1} hc := &http.Client{Transport: tr} logger := lentry.WithFields(log.Fields{"Member-ID": conf.Registrator.Self().ID()}) // Instantiate a server s := &server{ listener: listener, httpclient: hc, transport: tr, broadcast: channels.NewChannelTimeout(512), repair: channels.NewChannelTimeout(512), newPeers: make(chan *peer), closingPeers: make(chan *peer, 8), peers: make(map[cluster.MemberID]*peer), mux: http.NewServeMux(), replicators: make(map[auth.Namespace]*replicator), clients: make(map[cluster.MemberID]*client), selfID: conf.Registrator.Self().ID(), membership: conf.Membership, registrator: conf.Registrator, notifyChannel: make(chan *InMessage, 512), syncReqChannel: make(chan chan []byte, 8), health: newHealthChecker(), done: make(chan struct{}), logger: logger, } health.Register(module, s.health) logger.Info("Replication server created") return s, nil }