Exemplo n.º 1
0
func newHealthChecker() *healthChecker {
	return &healthChecker{
		clients:               make(map[cluster.MemberID]*clientHealth),
		disconnectedThreshold: defaultDisconnectedThreshold,
		logger:                logging.GetLogger(module),
	}
}
Exemplo n.º 2
0
func newInMemoryRegistry(conf *Config, rep replication.Replication) Registry {
	var lentry = logging.GetLogger(module)

	if conf == nil {
		conf = DefaultConfig
	}

	registry := &inMemoryRegistry{
		namespaces: make(map[auth.Namespace]Catalog),
		rep:        rep,
		logger:     lentry,
		conf:       conf}

	if rep != nil {
		// Starts a synchronization operation with remote peers
		// Synchronization is blocking, executes once
		registry.synchronize()

		// Once Synchronization is complete, handle incoming replication events
		// Starts an end point to enable incoming replication events from remote peers to do
		// a registration to the local catalog
		go registry.replicate()
	}

	return registry
}
Exemplo n.º 3
0
// MiddlewareFunc makes AccessLogApacheMiddleware implement the Middleware interface.
func (mw *AccessLog) MiddlewareFunc(h rest.HandlerFunc) rest.HandlerFunc {
	mw.logger = logging.GetLogger(module).WithField("apptype", "service-discovery")

	return func(w rest.ResponseWriter, r *rest.Request) {
		// We log the message in a defer function to make sure that the message
		// is logged even if a panic occurs in some handler in the chain
		defer func() {
			reqID, ok := r.Env[SdRequestID].(string)
			if !ok {
				reqID = "Unknown"
			}

			l := mw.logger.WithFields(log.Fields{
				"sd-request-id": reqID,
				"namespace":     mw.namespace(r),
				"method":        mw.method(r),
				"protocol":      mw.protocol(r),
				"returncode":    mw.statusCode(r),
				"byteswritten":  mw.bytesWritten(r),
				"elapsedtime":   mw.elapsedTime(r)})

			if len(headersWhitelist) > 0 {
				l = l.WithField("headers", mw.headers(r))
			}
			l.Infof("%s %s %s %s", mw.remoteAddr(r), r.Method, r.RequestURI, r.Proto)
		}()

		// call the handler
		h(w, r)
	}
}
Exemplo n.º 4
0
func newHealthChecker(membership Membership, threshold int) *healthChecker {
	hc := &healthChecker{
		membership:         membership,
		threshold:          threshold,
		clusterSize:        threshold, // initialize "healthy"
		subsizeTimestamp:   time.Now(),
		subsizeGracePeriod: defaultSubsizeThreshold,
		logger:             logging.GetLogger(module),
	}
	hc.RecordSize()
	membership.RegisterListener(hc)
	return hc
}
Exemplo n.º 5
0
func newRegistrator(backend backend, member Member, membership Membership, interval time.Duration) *registrator {
	reg := &registrator{
		backend:    backend,
		member:     member,
		membership: membership,
		interval:   interval,
		rejoin:     make(chan struct{}),
		done:       make(chan struct{}),
		logger:     logging.GetLogger(module),
	}
	reg.listener = &ongoingListener{reg: reg}
	return reg
}
Exemplo n.º 6
0
func newMembership(backend backend, ttl, interval time.Duration) *membership {
	m := &membership{
		backend:     backend,
		cache:       make(map[MemberID]*member),
		ttl:         ttl,
		interval:    interval,
		sizeMetric:  metrics.NewRegisteredGauge(membershipSizeMetricName, metrics.DefaultRegistry),
		churnMetric: metrics.NewRegisteredMeter(membershipChurnMetricName, metrics.DefaultRegistry),
		logger:      logging.GetLogger(module),
	}

	m.sizeMetric.Update(0)

	return m
}
Exemplo n.º 7
0
func newReplicatedCatalog(namespace auth.Namespace, conf *Config, replicator replication.Replicator) Catalog {
	logger := logging.GetLogger(module).WithFields(log.Fields{"namespace": namespace})

	if conf == nil {
		conf = DefaultConfig
	}

	localMemberCatalog := newInMemoryCatalog(conf)
	if replicator == nil {
		return localMemberCatalog
	}

	rpc := &replicatedCatalog{
		local:         localMemberCatalog,
		replicator:    replicator,
		notifyChannel: channels.NewChannelTimeout(256),
		logger:        logger,
	}
	go rpc.handleMsgs()

	rpc.logger.Infof("Replicated-Catalog creation done")
	return rpc
}
Exemplo n.º 8
0
import (
	"time"

	"github.com/Sirupsen/logrus"
	"github.com/amalgam8/registry/utils/logging"
	gometrics "github.com/rcrowley/go-metrics"
)

// interval at which the metrics registry is dumped
const dumpInterval = 10 * time.Minute

// module name to be used in logging
const moduleName = "METRICS"

var logger = logging.GetLogger(moduleName)

// DumpPeriodically logs the values of the entire go-metrics registry, periodically.
// This function blocks, so should be called within a separate goroutine.
func DumpPeriodically() {
	dumpPeriodically(dumpInterval, gometrics.DefaultRegistry)
}

func dumpPeriodically(interval time.Duration, registry gometrics.Registry) {
	for range time.Tick(interval) {
		dumpRegistry(registry)
	}
}

func dumpRegistry(registry gometrics.Registry) {
	logger.Info("Dumping metrics registry")
Exemplo n.º 9
0
// New creates a new eureka Server instance
func New(registry store.Registry) *Routes {
	return &Routes{
		registry: registry,
		logger:   logging.GetLogger(module),
	}
}
Exemplo n.º 10
0
// 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
}