func GetAllApp() []App {
log.LogStd("Retrieving Apps for Cache...", false)
var apps []App
defer func() {
if r := recover(); r != nil {
log.LogError("Recovered in caching.GetAllApp()", r)
}
}()
for _, app := range gcfClient.ListApps() {
log.LogStd(fmt.Sprintf("App [%s] Found...", app.Name), false)
apps = append(apps, App{app.Name, app.Guid, app.SpaceData.Entity.Name, app.SpaceData.Entity.Guid, app.SpaceData.Entity.OrgData.Entity.Name, app.SpaceData.Entity.OrgData.Entity.Guid})
}
FillDatabase(apps)
log.LogStd(fmt.Sprintf("Found [%d] Apps!", len(apps)), false)
return apps
}
func SetupEventRouting(wantedEvents string) {
selectedEvents = make(map[string]bool)
for _, event := range strings.Split(wantedEvents, ",") {
if isAuthorizedEvent(event) {
selectedEvents[event] = true
log.LogStd(fmt.Sprintf("Event Type [%s] is included in the fireshose!", event), false)
} else {
log.LogError(fmt.Sprintf("Rejected Event Name [%s] - See wanted/selected events arg. Check Your Command Line Arguments!", event), "")
}
}
// If any event is not authorize we fallback to the default one
if len(selectedEvents) < 1 {
selectedEvents["LogMessage"] = true
}
}
func SetupEventRouting(wantedEvents string) error {
selectedEvents = make(map[string]bool)
if wantedEvents == "" {
selectedEvents["LogMessage"] = true
} else {
for _, event := range strings.Split(wantedEvents, ",") {
if isAuthorizedEvent(strings.TrimSpace(event)) {
selectedEvents[strings.TrimSpace(event)] = true
log.LogStd(fmt.Sprintf("Event Type [%s] is included in the fireshose!", event), false)
} else {
return fmt.Errorf("Rejected Event Name [%s] - Valid events: %s", event, GetListAuthorizedEventEvents())
}
}
}
return nil
}
func LogEventTotals(logTotalsTime time.Duration, dopplerEndpoint string) {
firehoseEventTotals := time.NewTicker(logTotalsTime)
count := uint64(0)
startTime := time.Now()
totalTime := startTime
go func() {
for range firehoseEventTotals.C {
elapsedTime := time.Since(startTime).Seconds()
totalElapsedTime := time.Since(totalTime).Seconds()
startTime = time.Now()
output, lastCount := getEventTotals(totalElapsedTime, elapsedTime, count, dopplerEndpoint)
count = lastCount
log.LogStd(output, true)
}
}()
}
func GetAppInfo(appGuid string) App {
defer func() {
if r := recover(); r != nil {
log.LogError(fmt.Sprintf("Recovered from panic retrieving App Info for App Guid: %s", appGuid), r)
}
}()
var d []byte
var app App
appdb.View(func(tx *bolt.Tx) error {
log.LogStd(fmt.Sprintf("Looking for App %s in Cache!\n", appGuid), false)
b := tx.Bucket([]byte("AppBucket"))
d = cloneBytes(b.Get([]byte(appGuid)))
return nil
})
err := json.Unmarshal([]byte(d), &app)
if err != nil {
return App{}
}
return app
}
func (c ConsoleDebugPrinter) Print(title, dump string) {
log.LogStd(title, false)
log.LogStd(dump, false)
}
func main() {
kingpin.Version(version)
kingpin.Parse()
logging.LogStd(fmt.Sprintf("Starting firehose-to-syslog %s ", version), true)
logging.SetupLogging(*syslogServer, *debug)
c := cfclient.Config{
ApiAddress: *apiEndpoint,
Username: *user,
Password: *password,
SkipSslValidation: *skipSSLValidation,
}
cfClient := cfclient.NewClient(&c)
if len(*dopplerEndpoint) > 0 {
cfClient.Endpoint.DopplerEndpoint = *dopplerEndpoint
}
logging.LogStd(fmt.Sprintf("Using %s as doppler endpoint", cfClient.Endpoint.DopplerEndpoint), true)
logging.LogStd("Setting up event routing!", true)
err := events.SetupEventRouting(*wantedEvents)
if err != nil {
log.Fatal("Error setting up event routing: ", err)
os.Exit(1)
}
//Use bolt for in-memory - file caching
db, err := bolt.Open(*boltDatabasePath, 0600, &bolt.Options{Timeout: 1 * time.Second})
if err != nil {
log.Fatal("Error opening bolt db: ", err)
os.Exit(1)
}
defer db.Close()
if *modeProf != "" {
switch *modeProf {
case "cpu":
defer profile.Start(profile.CPUProfile, profile.ProfilePath(*pathProf)).Stop()
case "mem":
defer profile.Start(profile.MemProfile, profile.ProfilePath(*pathProf)).Stop()
case "block":
defer profile.Start(profile.BlockProfile, profile.ProfilePath(*pathProf)).Stop()
default:
// do nothing
}
}
caching.SetCfClient(cfClient)
caching.SetAppDb(db)
caching.CreateBucket()
//Let's Update the database the first time
logging.LogStd("Start filling app/space/org cache.", true)
apps := caching.GetAllApp()
logging.LogStd(fmt.Sprintf("Done filling cache! Found [%d] Apps", len(apps)), true)
// Ticker Pooling the CC every X sec
ccPooling := time.NewTicker(*tickerTime)
go func() {
for range ccPooling.C {
apps = caching.GetAllApp()
}
}()
// Parse extra fields from cmd call
extraFields, err := extrafields.ParseExtraFields(*extraFields)
if err != nil {
log.Fatal("Error parsing extra fields: ", err)
os.Exit(1)
}
if *logEventTotals == true {
events.LogEventTotals(*logEventTotalsTime, *dopplerEndpoint)
}
if logging.Connect() || *debug {
logging.LogStd("Connected to Syslog Server! Connecting to Firehose...", true)
firehose := firehose.CreateFirehoseChan(cfClient.Endpoint.DopplerEndpoint, cfClient.GetToken(), *subscriptionId, *skipSSLValidation)
if firehose != nil {
logging.LogStd("Firehose Subscription Succesfull! Routing events...", true)
events.RouteEvents(firehose, extraFields)
} else {
logging.LogError("Failed connecting to Firehose...Please check settings and try again!", "")
}
} else {
logging.LogError("Failed connecting to the Syslog Server...Please check settings and try again!", "")
}
}
func main() {
kingpin.Version(version)
kingpin.Parse()
logging.LogStd(fmt.Sprintf("Starting firehose-to-syslog %s ", version), true)
logging.SetupLogging(*syslogServer, *debug)
c := cfclient.Config{
ApiAddress: *apiEndpoint,
Username: *user,
Password: *password,
SkipSslValidation: *skipSSLValidation,
}
cfClient := cfclient.NewClient(&c)
if len(*dopplerEndpoint) > 0 {
cfClient.Endpoint.DopplerAddress = *dopplerEndpoint
}
logging.LogStd(fmt.Sprintf("Using %s as doppler endpoint", cfClient.Endpoint.DopplerAddress), true)
//Use bolt for in-memory - file caching
db, err := bolt.Open(*boltDatabasePath, 0600, &bolt.Options{Timeout: 1 * time.Second})
if err != nil {
log.Fatal("Error opening bolt db: ", err)
os.Exit(1)
}
defer db.Close()
caching.SetCfClient(cfClient)
caching.SetAppDb(db)
caching.CreateBucket()
//Let's Update the database the first time
logging.LogStd("Start filling app/space/org cache.", true)
apps := caching.GetAllApp()
logging.LogStd(fmt.Sprintf("Done filling cache! Found [%d] Apps", len(apps)), true)
logging.LogStd("Setting up event routing!", true)
events.SetupEventRouting(*wantedEvents)
// Ticker Pooling the CC every X sec
ccPooling := time.NewTicker(*tickerTime)
go func() {
for range ccPooling.C {
apps = caching.GetAllApp()
}
}()
if logging.Connect() || *debug {
logging.LogStd("Connected to Syslog Server! Connecting to Firehose...", true)
firehose := firehose.CreateFirehoseChan(cfClient.Endpoint.DopplerAddress, cfClient.GetToken(), *subscriptionId, *skipSSLValidation)
if firehose != nil {
logging.LogStd("Firehose Subscription Succesfull! Routing events...", true)
events.RouteEvents(firehose)
} else {
logging.LogError("Failed connecting to Firehose...Please check settings and try again!", "")
}
} else {
logging.LogError("Failed connecting to the Syslog Server...Please check settings and try again!", "")
}
}