func createSender(test FloodTest) (sender *client.NetworkSender, err error) { if test.UseTls { var goTlsConfig *tls.Config goTlsConfig, err = tcp.CreateGoTlsConfig(&test.Tls) if err != nil { return } sender, err = client.NewTlsSender(test.Sender, test.IpAddress, goTlsConfig) } else { sender, err = client.NewNetworkSender(test.Sender, test.IpAddress) } return }
func (nl *NetworkLogger) Init(app *Application, config interface{}) (err error) { conf := config.(*NetworkLoggerConfig) if len(conf.Addr) == 0 { return fmt.Errorf("NetworkLogger: Missing remote address") } switch conf.Format { case "json", "protobuf": var sender client.Sender if conf.UseTLS { sender, err = client.NewTlsSender(conf.Proto, conf.Addr, nil) } else { sender, err = client.NewNetworkSender(conf.Proto, conf.Addr) } if err != nil { return err } hostname := app.Hostname() if conf.Format == "json" { nl.LogEmitter = NewJSONEmitter(sender, conf.EnvVersion, hostname, conf.Name) } else { nl.LogEmitter = NewProtobufEmitter(sender, conf.EnvVersion, hostname, conf.Name) } case "text": var conn net.Conn if conf.UseTLS { conn, err = tls.Dial(conf.Proto, conf.Addr, nil) } else { conn, err = net.Dial(conf.Proto, conf.Addr) } if err != nil { return err } nl.LogEmitter = NewTextEmitter(conn) default: return fmt.Errorf("NetworkLogger: Unrecognized log format '%s'", conf.Format) } nl.filter = LogLevel(conf.Filter) return nil }
func main() { configFile := flag.String("config", "flood.toml", "Heka Flood configuration file") configTest := flag.String("test", "default", "Test section to load") flag.Parse() if flag.NFlag() == 0 { flag.PrintDefaults() os.Exit(0) } var config FloodConfig if _, err := toml.DecodeFile(*configFile, &config); err != nil { client.LogError.Printf("Error decoding config file: %s", err) return } var test FloodTest var ok bool if test, ok = config[*configTest]; !ok { client.LogError.Printf("Configuration test: '%s' was not found", *configTest) return } if test.MsgInterval != "" { var err error if test.msgInterval, err = time.ParseDuration(test.MsgInterval); err != nil { client.LogError.Printf("Invalid message_interval duration %s: %s", test.MsgInterval, err.Error()) return } } if test.PprofFile != "" { profFile, err := os.Create(test.PprofFile) if err != nil { client.LogError.Fatalln(err) } pprof.StartCPUProfile(profFile) defer pprof.StopCPUProfile() } if test.MaxMessageSize > 0 { message.SetMaxMessageSize(test.MaxMessageSize) } var sender *client.NetworkSender var err error if test.UseTls { var goTlsConfig *tls.Config goTlsConfig, err = tcp.CreateGoTlsConfig(&test.Tls) if err != nil { client.LogError.Fatalf("Error creating TLS config: %s\n", err) } sender, err = client.NewTlsSender(test.Sender, test.IpAddress, goTlsConfig) } else { sender, err = client.NewNetworkSender(test.Sender, test.IpAddress) } if err != nil { client.LogError.Fatalf("Error creating sender: %s\n", err) } unsignedEncoder := client.NewProtobufEncoder(nil) signedEncoder := client.NewProtobufEncoder(&test.Signer) oversizedEncoder := &OversizedEncoder{} var numTestMessages = 1 var unsignedMessages [][]byte var signedMessages [][]byte var oversizedMessages [][]byte rdm := &randomDataMaker{ src: rand.NewSource(time.Now().UnixNano()), asciiOnly: test.AsciiOnly, } if test.VariableSizeMessages { numTestMessages = 64 unsignedMessages = makeVariableMessage(unsignedEncoder, numTestMessages, rdm, false) signedMessages = makeVariableMessage(signedEncoder, numTestMessages, rdm, false) oversizedMessages = makeVariableMessage(oversizedEncoder, 1, rdm, true) } else { if test.StaticMessageSize == 0 { test.StaticMessageSize = 1000 } unsignedMessages = makeFixedMessage(unsignedEncoder, test.StaticMessageSize, rdm) signedMessages = makeFixedMessage(signedEncoder, test.StaticMessageSize, rdm) } // wait for sigint sigChan := make(chan os.Signal, 1) signal.Notify(sigChan, syscall.SIGINT) var msgsSent, bytesSent, msgsDelivered uint64 var corruptPercentage, lastCorruptPercentage, signedPercentage, lastSignedPercentage, oversizedPercentage, lastOversizedPercentage float64 var corrupt bool // set up counter loop ticker := time.NewTicker(time.Duration(time.Second)) go timerLoop(&msgsSent, &bytesSent, ticker) test.CorruptPercentage /= 100.0 test.SignedPercentage /= 100.0 test.OversizedPercentage /= 100.0 var buf []byte for gotsigint := false; !gotsigint; { runtime.Gosched() select { case <-sigChan: gotsigint = true continue default: } msgId := rand.Int() % numTestMessages corruptPercentage = math.Floor(float64(msgsSent) * test.CorruptPercentage) if corruptPercentage != lastCorruptPercentage { lastCorruptPercentage = corruptPercentage corrupt = true } else { corrupt = false } signedPercentage = math.Floor(float64(msgsSent) * test.SignedPercentage) if signedPercentage != lastSignedPercentage { lastSignedPercentage = signedPercentage buf = signedMessages[msgId] } else { oversizedPercentage = math.Floor(float64(msgsSent) * test.OversizedPercentage) if oversizedPercentage != lastOversizedPercentage { lastOversizedPercentage = oversizedPercentage buf = oversizedMessages[0] } else { buf = unsignedMessages[msgId] } } bytesSent += uint64(len(buf)) if err = sendMessage(sender, buf, corrupt); err != nil { client.LogError.Printf("Error sending message: %s\n", err.Error()) } else { msgsDelivered++ } msgsSent++ if test.NumMessages != 0 && msgsSent >= test.NumMessages { break } if test.msgInterval != 0 { time.Sleep(test.msgInterval) } } sender.Close() client.LogInfo.Println("Clean shutdown: ", msgsSent, " messages sent; ", msgsDelivered, " messages delivered.") }
func main() { configFile := flag.String("config", "sbmgr.toml", "Sandbox manager configuration file") scriptFile := flag.String("script", "xyz.lua", "Sandbox script file") scriptConfig := flag.String("scriptconfig", "xyz.toml", "Sandbox script configuration file") filterName := flag.String("filtername", "filter", "Sandbox filter name (used on unload)") action := flag.String("action", "load", "Sandbox manager action") flag.Parse() var config SbmgrConfig if _, err := toml.DecodeFile(*configFile, &config); err != nil { client.LogError.Printf("Error decoding config file: %s", err) return } var sender *client.NetworkSender var err error if config.UseTls { var goTlsConfig *tls.Config goTlsConfig, err = tcp.CreateGoTlsConfig(&config.Tls) if err != nil { client.LogError.Fatalf("Error creating TLS config: %s\n", err) } sender, err = client.NewTlsSender("tcp", config.IpAddress, goTlsConfig) } else { sender, err = client.NewNetworkSender("tcp", config.IpAddress) } if err != nil { client.LogError.Fatalf("Error creating sender: %s\n", err.Error()) } encoder := client.NewProtobufEncoder(&config.Signer) manager := client.NewClient(sender, encoder) hostname, _ := os.Hostname() msg := &message.Message{} msg.SetLogger(pipeline.HEKA_DAEMON) // identify the message as 'internal' for filtering purposes msg.SetType("heka.control.sandbox") msg.SetTimestamp(time.Now().UnixNano()) msg.SetUuid(uuid.NewRandom()) msg.SetHostname(hostname) switch *action { case "load": code, err := ioutil.ReadFile(*scriptFile) if err != nil { client.LogError.Printf("Error reading scriptFile: %s\n", err.Error()) return } msg.SetPayload(string(code)) conf, err := ioutil.ReadFile(*scriptConfig) if err != nil { client.LogError.Printf("Error reading scriptConfig: %s\n", err.Error()) return } f, _ := message.NewField("config", string(conf), "toml") msg.AddField(f) case "unload": f, _ := message.NewField("name", *filterName, "") msg.AddField(f) default: client.LogError.Printf("Invalid action: %s", *action) } f1, _ := message.NewField("action", *action, "") msg.AddField(f1) err = manager.SendMessage(msg) if err != nil { client.LogError.Printf("Error sending message: %s\n", err.Error()) } }
func main() { configFile := flag.String("config", "sbmgrload.toml", "Sandbox manager load configuration file") action := flag.String("action", "load", "load/unload") numItems := flag.Int("num", 1, "Number of sandboxes to load/unload") flag.Parse() code := ` require "string" require "table" require "os" lastTime = os.time() * 1e9 lastCount = 0 count = 0 rate = 0.0 rates = {} function process_message () count = count + 1 return 0 end function timer_event(ns) local msgsSent = count - lastCount if msgsSent == 0 then return end local elapsedTime = ns - lastTime if elapsedTime == 0 then return end lastCount = count lastTime = ns rate = msgsSent / (elapsedTime / 1e9) rates[#rates+1] = rate output(string.format("Got %d messages. %0.2f msg/sec", count, rate)) inject_message() local samples = #rates if samples == 10 then -- generate a summary every 10 samples table.sort(rates) local min = rates[1] local max = rates[samples] local sum = 0 for i, val in ipairs(rates) do sum = sum + val end output(string.format("AGG Sum. Min: %0.2f Max: %0.2f Mean: %0.2f", min, max, sum/samples)) inject_message() rates = {} end end ` confFmt := ` [CounterSandbox%d] type = "SandboxFilter" message_matcher = "Type == 'hekabench'" ticker_interval = 1 script_type = "lua" filename = "" preserve_data = true ` var config SbmgrConfig if _, err := toml.DecodeFile(*configFile, &config); err != nil { log.Printf("Error decoding config file: %s", err) return } var sender *client.NetworkSender var err error if config.UseTls { var goTlsConfig *tls.Config goTlsConfig, err = tcp.CreateGoTlsConfig(&config.Tls) if err != nil { log.Fatalf("Error creating TLS config: %s\n", err) } sender, err = client.NewTlsSender("tcp", config.IpAddress, goTlsConfig) } else { sender, err = client.NewNetworkSender("tcp", config.IpAddress) } if err != nil { log.Fatalf("Error creating sender: %s\n", err.Error()) } encoder := client.NewProtobufEncoder(&config.Signer) manager := client.NewClient(sender, encoder) hostname, _ := os.Hostname() switch *action { case "load": for i := 0; i < *numItems; i++ { conf := fmt.Sprintf(confFmt, i) msg := &message.Message{} msg.SetType("heka.control.sandbox") msg.SetTimestamp(time.Now().UnixNano()) msg.SetUuid(uuid.NewRandom()) msg.SetHostname(hostname) msg.SetPayload(code) f, _ := message.NewField("config", conf, "toml") msg.AddField(f) f1, _ := message.NewField("action", *action, "") msg.AddField(f1) err = manager.SendMessage(msg) if err != nil { log.Printf("Error sending message: %s\n", err.Error()) } } case "unload": for i := 0; i < *numItems; i++ { msg := &message.Message{} msg.SetType("heka.control.sandbox") msg.SetTimestamp(time.Now().UnixNano()) msg.SetUuid(uuid.NewRandom()) msg.SetHostname(hostname) f, _ := message.NewField("name", fmt.Sprintf("CounterSandbox%d", i), "") msg.AddField(f) f1, _ := message.NewField("action", *action, "") msg.AddField(f1) err = manager.SendMessage(msg) if err != nil { log.Printf("Error sending message: %s\n", err.Error()) } } default: log.Printf("Invalid action: %s\n", *action) } }