func NewLoggregatorClient(loggregatorAddress string, logger *gosteno.Logger, bufferSize int) LoggregatorClient {
loggregatorClient := &udpLoggregatorClient{}
la, err := net.ResolveUDPAddr("udp", loggregatorAddress)
if err != nil {
logger.Fatalf("Error resolving loggregator address %s, %s", loggregatorAddress, err)
}
connection, err := net.ListenPacket("udp", "")
if err != nil {
logger.Fatalf("Error opening udp stuff")
}
loggregatorClient.loggregatorAddress = la.IP.String()
loggregatorClient.sendChannel = make(chan []byte, bufferSize)
go func() {
for dataToSend := range loggregatorClient.sendChannel {
if len(dataToSend) > 0 {
writeCount, err := connection.WriteTo(dataToSend, la)
if err != nil {
logger.Errorf("Writing to loggregator %s failed %s", loggregatorAddress, err)
continue
}
logger.Debugf("Wrote %d bytes to %s", writeCount, loggregatorAddress)
atomic.AddUint64(&loggregatorClient.sentMessageCount, 1)
atomic.AddUint64(&loggregatorClient.sentByteCount, uint64(writeCount))
} else {
logger.Debugf("Skipped writing of 0 byte message to %s", loggregatorAddress)
}
}
}()
return loggregatorClient
}
func NewLoggregatorClient(loggregatorAddress string, logger *gosteno.Logger, bufferSize int) *udpLoggregatorClient {
loggregatorClient := &udpLoggregatorClient{make(chan []byte, bufferSize)}
connection, err := net.Dial("udp", loggregatorAddress)
if err != nil {
logger.Fatalf("Error resolving loggregator address %s, %s", loggregatorAddress, err)
panic(err)
}
go func() {
for {
dataToSend := <-loggregatorClient.sendChannel
if len(dataToSend) > 0 {
writeCount, err := connection.Write(dataToSend)
logger.Debugf("Wrote %d bytes to %s", writeCount, loggregatorAddress)
if err != nil {
logger.Errorf("Writing to loggregator %s failed %s", loggregatorAddress, err)
}
} else {
logger.Debugf("Skipped writing of 0 byte message to %s", loggregatorAddress)
}
}
}()
return loggregatorClient
}
func generateCert(logger *gosteno.Logger) {
// see: http://golang.org/src/pkg/crypto/tls/generate_cert.go
host := "localhost"
validFrom := "Jan 1 15:04:05 2011"
validFor := 10 * 365 * 24 * time.Hour
isCA := true
rsaBits := 1024
if len(host) == 0 {
logger.Fatalf("Missing required --host parameter")
}
priv, err := rsa.GenerateKey(rand.Reader, rsaBits)
if err != nil {
logger.Fatalf("failed to generate private key: %s", err)
panic(err)
}
var notBefore time.Time
if len(validFrom) == 0 {
notBefore = time.Now()
} else {
notBefore, err = time.Parse("Jan 2 15:04:05 2006", validFrom)
if err != nil {
logger.Fatalf("Failed to parse creation date: %s\n", err)
panic(err)
}
}
notAfter := notBefore.Add(validFor)
// end of ASN.1 time
endOfTime := time.Date(2049, 12, 31, 23, 59, 59, 0, time.UTC)
if notAfter.After(endOfTime) {
notAfter = endOfTime
}
template := x509.Certificate{
SerialNumber: new(big.Int).SetInt64(0),
Subject: pkix.Name{
Organization: []string{"Loggregator TrafficController TEST"},
},
NotBefore: notBefore,
NotAfter: notAfter,
KeyUsage: x509.KeyUsageKeyEncipherment | x509.KeyUsageDigitalSignature,
ExtKeyUsage: []x509.ExtKeyUsage{x509.ExtKeyUsageServerAuth},
BasicConstraintsValid: true,
}
hosts := strings.Split(host, ",")
for _, h := range hosts {
if ip := net.ParseIP(h); ip != nil {
template.IPAddresses = append(template.IPAddresses, ip)
} else {
template.DNSNames = append(template.DNSNames, h)
}
}
if isCA {
template.IsCA = true
template.KeyUsage |= x509.KeyUsageCertSign
}
derBytes, err := x509.CreateCertificate(rand.Reader, &template, &template, &priv.PublicKey, priv)
if err != nil {
logger.Fatalf("Failed to create certificate: %s", err)
panic(err)
}
certOut, err := os.Create("cert.pem")
if err != nil {
logger.Fatalf("failed to open cert.pem for writing: %s", err)
panic(err)
}
pem.Encode(certOut, &pem.Block{Type: "CERTIFICATE", Bytes: derBytes})
certOut.Close()
logger.Info("written cert.pem\n")
keyOut, err := os.OpenFile("key.pem", os.O_WRONLY|os.O_CREATE|os.O_TRUNC, 0600)
if err != nil {
logger.Fatalf("failed to open key.pem for writing: %s", err)
panic(err)
}
pem.Encode(keyOut, &pem.Block{Type: "RSA PRIVATE KEY", Bytes: x509.MarshalPKCS1PrivateKey(priv)})
keyOut.Close()
logger.Info("written key.pem\n")
}
func New(logger *gosteno.Logger,
host string,
config *config.Config,
storeAdapter storeadapter.StoreAdapter,
messageDrainBufferSize uint,
dropsondeOrigin string,
dialTimeout time.Duration) *Doppler {
keepAliveInterval := 30 * time.Second
appStoreCache := cache.NewAppServiceCache()
appStoreWatcher, newAppServiceChan, deletedAppServiceChan := store.NewAppServiceStoreWatcher(storeAdapter, appStoreCache, logger)
var udpListener listeners.Listener
var tlsListener listeners.Listener
var dropsondeBytesChan <-chan []byte
listenerEnvelopeChan := make(chan *events.Envelope)
if config.EnableTLSTransport {
tlsConfig := &tls.Config{
Certificates: []tls.Certificate{config.TLSListenerConfig.Cert},
}
var err error
tlsListener, err = listeners.NewTLSListener("dropsondeListener", fmt.Sprintf("%s:%d", host, config.TLSListenerConfig.Port), tlsConfig, listenerEnvelopeChan, logger)
if err != nil {
logger.Fatalf("Failed to create a TLS Listener: %s", err)
}
}
udpListener, dropsondeBytesChan = listeners.NewUDPListener(fmt.Sprintf("%s:%d", host, config.DropsondeIncomingMessagesPort), logger, "dropsondeListener")
signatureVerifier := signature.NewVerifier(logger, config.SharedSecret)
unmarshallerCollection := dropsonde_unmarshaller.NewDropsondeUnmarshallerCollection(logger, config.UnmarshallerCount)
blacklist := blacklist.New(config.BlackListIps)
metricTTL := time.Duration(config.ContainerMetricTTLSeconds) * time.Second
sinkTimeout := time.Duration(config.SinkInactivityTimeoutSeconds) * time.Second
sinkIOTimeout := time.Duration(config.SinkIOTimeoutSeconds) * time.Second
sinkManager := sinkmanager.New(config.MaxRetainedLogMessages, config.SkipCertVerify, blacklist, logger, messageDrainBufferSize, dropsondeOrigin, sinkTimeout, sinkIOTimeout, metricTTL, dialTimeout)
websocketServer, err := websocketserver.New(fmt.Sprintf("%s:%d", host, config.OutgoingPort), sinkManager, keepAliveInterval, config.MessageDrainBufferSize, dropsondeOrigin, logger)
if err != nil {
logger.Fatalf("Failed to create the websocket server: %s", err)
}
return &Doppler{
Logger: logger,
udpListener: udpListener,
tlsListener: tlsListener,
sinkManager: sinkManager,
messageRouter: sinkserver.NewMessageRouter(sinkManager, logger),
websocketServer: websocketServer,
newAppServiceChan: newAppServiceChan,
deletedAppServiceChan: deletedAppServiceChan,
appStoreWatcher: appStoreWatcher,
storeAdapter: storeAdapter,
dropsondeBytesChan: dropsondeBytesChan,
dropsondeUnmarshallerCollection: unmarshallerCollection,
envelopeChan: listenerEnvelopeChan,
signatureVerifier: signatureVerifier,
dropsondeVerifiedBytesChan: make(chan []byte),
uptimeMonitor: monitor.NewUptimeMonitor(time.Duration(config.MonitorIntervalSeconds) * time.Second),
}
}