func NewFileAndLoggregatorAccessLogger(f io.Writer, loggregatorUrl, loggregatorSharedSecret string, index uint) *FileAndLoggregatorAccessLogger {
a := &FileAndLoggregatorAccessLogger{
writer: f,
channel: make(chan AccessLogRecord, 128),
index: index,
}
if isValidUrl(loggregatorUrl) {
a.emitter, _ = emitter.NewEmitter(loggregatorUrl, "RTR", strconv.FormatUint(uint64(index), 10), loggregatorSharedSecret, steno.NewLogger("router.loggregator"))
} else {
log.Errorf("Invalid loggregator url %s", loggregatorUrl)
}
return a
}
func (r *Router) subscribeRegistry(subject string, successCallback func(*registryMessage)) {
callback := func(message *yagnats.Message) {
payload := message.Payload
var msg registryMessage
err := json.Unmarshal(payload, &msg)
if err != nil {
logMessage := fmt.Sprintf("%s: Error unmarshalling JSON (%d; %s): %s", subject, len(payload), payload, err)
log.Warnd(map[string]interface{}{"payload": string(payload)}, logMessage)
}
logMessage := fmt.Sprintf("%s: Received message", subject)
log.Debugd(map[string]interface{}{"message": msg}, logMessage)
successCallback(&msg)
}
_, err := r.mbusClient.Subscribe(subject, callback)
if err != nil {
log.Errorf("Error subscribing to %s: %s", subject, err)
}
}
func (r *Router) Run() {
var err error
natsMembers := []yagnats.ConnectionProvider{}
for _, info := range r.config.Nats {
natsMembers = append(natsMembers, &yagnats.ConnectionInfo{
Addr: fmt.Sprintf("%s:%d", info.Host, info.Port),
Username: info.User,
Password: info.Pass,
})
}
natsInfo := &yagnats.ConnectionCluster{natsMembers}
for {
err = r.mbusClient.Connect(natsInfo)
if err == nil {
break
}
log.Errorf("Could not connect to NATS: %s", err)
time.Sleep(500 * time.Millisecond)
}
r.RegisterComponent()
// Subscribe register/unregister router
r.SubscribeRegister()
r.HandleGreetings()
r.SubscribeUnregister()
// Kickstart sending start messages
r.SendStartMessage()
// Send start again on reconnect
r.mbusClient.ConnectedCallback = func() {
r.SendStartMessage()
}
// Schedule flushing active app's app_id
r.ScheduleFlushApps()
// Wait for one start message send interval, such that the router's registry
// can be populated before serving requests.
if r.config.StartResponseDelayInterval != 0 {
log.Infof("Waiting %s before listening...", r.config.StartResponseDelayInterval)
time.Sleep(r.config.StartResponseDelayInterval)
}
listen, err := net.Listen("tcp", fmt.Sprintf(":%d", r.config.Port))
if err != nil {
log.Fatalf("net.Listen: %s", err)
}
util.WritePidFile(r.config.Pidfile)
log.Infof("Listening on %s", listen.Addr())
server := http.Server{Handler: r.proxy}
go func() {
err := server.Serve(listen)
if err != nil {
log.Fatalf("proxy.Serve: %s", err)
}
}()
}
