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 {
log.Printf("Error decoding config file: %s", err)
return
}
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()
msg := &message.Message{}
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 {
log.Printf("Error reading scriptFile: %s\n", err.Error())
return
}
msg.SetPayload(string(code))
conf, err := ioutil.ReadFile(*scriptConfig)
if err != nil {
log.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:
log.Printf("Invalid action: %s", *action)
}
f1, _ := message.NewField("action", *action, "")
msg.AddField(f1)
err = manager.SendMessage(msg)
if err != nil {
log.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 := `
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.0
[CounterSandbox%d.settings]
type = "lua"
filename = ""
preserve_data = true
memory_limit = 32767
instruction_limit = 1000
output_limit = 1024
`
var config SbmgrConfig
if _, err := toml.DecodeFile(*configFile, &config); err != nil {
log.Printf("Error decoding config file: %s", err)
return
}
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, 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, message.Field_RAW)
msg.AddField(f)
f1, _ := message.NewField("action", *action, message.Field_RAW)
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)
msg.SetPayload(string(code))
f, _ := message.NewField("name", fmt.Sprintf("CounterSandbox%d", i), message.Field_RAW)
msg.AddField(f)
f1, _ := message.NewField("action", *action, message.Field_RAW)
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)
}
}
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
inject_payload("txt", "rate", string.format("Got %d messages. %0.2f msg/sec", count, rate))
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
inject_payload("txt", "summary", string.format("AGG Sum. Min: %0.2f Max: %0.2f Mean: %0.2f", min, max, sum/samples))
rates = {}
end
end
`
confFmt := `
[CounterSandbox%d]
type = "SandboxFilter"
message_matcher = "Type == 'hekabench'"
ticker_interval = 1
filename = ""
preserve_data = true
`
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()
switch *action {
case "load":
for i := 0; i < *numItems; i++ {
conf := fmt.Sprintf(confFmt, i)
msg := &message.Message{}
msg.SetLogger(pipeline.HEKA_DAEMON)
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 {
client.LogError.Printf("Error sending message: %s\n", err.Error())
}
}
case "unload":
for i := 0; i < *numItems; i++ {
msg := &message.Message{}
msg.SetLogger(pipeline.HEKA_DAEMON)
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 {
client.LogError.Printf("Error sending message: %s\n", err.Error())
}
}
default:
client.LogError.Printf("Invalid action: %s\n", *action)
}
}