// openPorts create ZMQ sockets and start socket monitoring loops
func openPorts() {
filePort, err = utils.CreateInputPort("readfile.file", *fileEndpoint, fileCh)
utils.AssertError(err)
outPort, err = utils.CreateOutputPort("readfile.out", *outputEndpoint, outCh)
utils.AssertError(err)
if *errorEndpoint != "" {
errPort, err = utils.CreateOutputPort("readfile.err", *errorEndpoint, errCh)
utils.AssertError(err)
}
}
// openPorts create ZMQ sockets and start socket monitoring loops
func openPorts() {
inPort, err = utils.CreateInputPort("fs/walk.dir", *inputEndpoint, inCh)
utils.AssertError(err)
outPort, err = utils.CreateOutputPort("fs/walk.file", *outputEndpoint, outCh)
utils.AssertError(err)
if *errorEndpoint != "" {
errPort, err = utils.CreateOutputPort("fs/walk.err", *errorEndpoint, errCh)
utils.AssertError(err)
}
}
// openPorts create ZMQ sockets and start socket monitoring loops
func openPorts() {
cmdPort, err = utils.CreateInputPort("exec.cmd", *cmdEndpoint, cmdCh)
utils.AssertError(err)
if *outputEndpoint != "" {
outPort, err = utils.CreateOutputPort("exec.out", *outputEndpoint, outCh)
utils.AssertError(err)
}
if *errorEndpoint != "" {
errPort, err = utils.CreateOutputPort("exec.err", *errorEndpoint, errCh)
utils.AssertError(err)
}
}
func openPorts() {
optsPort, err = utils.CreateInputPort("mqtt-property.options", *optionsEndpoint, nil)
utils.AssertError(err)
tmplPort, err = utils.CreateInputPort("mqtt-property.template", *templateEndpoint, nil)
utils.AssertError(err)
propPort, err = utils.CreateOutputPort("mqtt-property.property", *propertyEndpoint, outCh)
utils.AssertError(err)
if *errorEndpoint != "" {
errPort, err = utils.CreateOutputPort("mqtt-property.err", *errorEndpoint, nil)
utils.AssertError(err)
}
}
// openPorts create ZMQ sockets and start socket monitoring loops
func openPorts() {
inPort, err = utils.CreateInputPort("passthru.in", *inputEndpoint, inCh)
utils.AssertError(err)
outPort, err = utils.CreateOutputPort("passthru.out", *outputEndpoint, outCh)
utils.AssertError(err)
}
// openPorts create ZMQ sockets and start socket monitoring loops
func openPorts() {
inPort, err = utils.CreateInputPort("debug/crasher.in", *inputEndpoint, inCh)
utils.AssertError(err)
outPort, err = utils.CreateOutputPort("debug/crasher.out", *outputEndpoint, outCh)
utils.AssertError(err)
}
// openPorts create ZMQ sockets and start socket monitoring loops
func openPorts() {
intervalPort, err = utils.CreateInputPort("ticker.interval", *intervalEndpoint, nil)
utils.AssertError(err)
outPort, err = utils.CreateOutputPort("ticker.out", *outputEndpoint, outCh)
utils.AssertError(err)
}
// openPorts create ZMQ sockets and start socket monitoring loops
func openPorts() {
inPort, err = utils.CreateInputPort("", *inputEndpoint, nil)
utils.AssertError(err)
outPort, err = utils.CreateOutputPort("bonjour/discover.out", *outputEndpoint, outCh)
utils.AssertError(err)
}
// openPorts create ZMQ sockets and start socket monitoring loops
func openPorts() {
reqPort, err = utils.CreateInputPort("http/client.req", *requestEndpoint, reqCh)
utils.AssertError(err)
if *responseEndpoint != "" {
respPort, err = utils.CreateOutputPort("http/client.resp", *responseEndpoint, respCh)
utils.AssertError(err)
}
if *bodyEndpoint != "" {
bodyPort, err = utils.CreateOutputPort("http/client.body", *bodyEndpoint, bodyCh)
utils.AssertError(err)
}
if *errorEndpoint != "" {
errPort, err = utils.CreateOutputPort("http/client.err", *errorEndpoint, errCh)
utils.AssertError(err)
}
}
// openPorts create ZMQ sockets and start socket monitoring loops
func openPorts() {
inPort, err = utils.CreateInputPort("fs/watchdog.in", *inputEndpoint, nil)
utils.AssertError(err)
if *errorEndpoint != "" {
errPort, err = utils.CreateOutputPort("fs/watchdog.err", *errorEndpoint, errCh)
utils.AssertError(err)
}
}
func openPorts() {
requestPort, err = utils.CreateInputPort(*requestEndpoint)
utils.AssertError(err)
failPort, err = utils.CreateOutputPort(*failEndpoint)
utils.AssertError(err)
successes := strings.Split(*successEndpoint, ",")
successPorts = make(map[string]*zmq.Socket, len(successes))
var port *zmq.Socket
for i, endpoint := range patterns {
port, err = utils.CreateOutputPort(strings.TrimSpace(successes[i]))
utils.AssertError(err)
successPorts
}
}
// openPorts create ZMQ sockets and start socket monitoring loops
func openPorts() {
optionsPort, err = utils.CreateInputPort("distinct.options", *optionsEndpoint, nil)
utils.AssertError(err)
inPort, err = utils.CreateInputPort("distinct.in", *inputEndpoint, inCh)
utils.AssertError(err)
outPort, err = utils.CreateOutputPort("distinct.out", *outputEndpoint, outCh)
utils.AssertError(err)
}
func openPorts() {
// Data
dataports := strings.Split(*dataEndpoint, ",")
if len(dataports) == 0 {
flag.Usage()
os.Exit(1)
}
dataPortsArray = []*zmq.Socket{}
poller = zmq.NewPoller()
for i, endpoint := range dataports {
endpoint = strings.TrimSpace(endpoint)
log.Printf("Connecting DATA[%v]=%s", i, endpoint)
port, err := utils.CreateInputPort(fmt.Sprintf("context.data-%s", i), endpoint, inCh)
utils.AssertError(err)
dataPortsArray = append(dataPortsArray, port)
poller.Add(port, zmq.POLLIN)
}
// Template
tmplPort, err = utils.CreateInputPort("context.tmpl", *templateEndpoint, nil)
utils.AssertError(err)
// Update
if *updatedEndpoint != "" {
updPort, err = utils.CreateOutputPort("context.update", *updatedEndpoint, outCh)
utils.AssertError(err)
}
// Match
if *matchedEndpoint != "" {
matchPort, err = utils.CreateOutputPort("context.match", *matchedEndpoint, outCh)
utils.AssertError(err)
}
// Error
if *errorEndpoint != "" {
errPort, err = utils.CreateOutputPort("context.err", *errorEndpoint, nil)
utils.AssertError(err)
}
}
// openPorts create ZMQ sockets and start socket monitoring loops
func openPorts() {
delayPort, err = utils.CreateInputPort("delay.delay", *delayEndpoint, nil)
utils.AssertError(err)
inPort, err = utils.CreateInputPort("delay.in", *inputEndpoint, inCh)
utils.AssertError(err)
outPort, err = utils.CreateOutputPort("delay.out", *outputEndpoint, outCh)
utils.AssertError(err)
}
// openPorts create ZMQ sockets and start socket monitoring loops
func openPorts() {
patternPort, err = utils.CreateInputPort("submatch.pattern", *patternEndpoint, nil)
utils.AssertError(err)
inPort, err = utils.CreateInputPort("submatch.in", *inputEndpoint, inCh)
utils.AssertError(err)
mapPort, err = utils.CreateOutputPort("submatch.map", *mapEndpoint, mapCh)
utils.AssertError(err)
}
// openPorts create ZMQ sockets and start socket monitoring loops
func openPorts() {
tplPort, err = utils.CreateInputPort("template.tpl", *tplEndpoint, nil)
utils.AssertError(err)
inPort, err = utils.CreateInputPort("template.in", *inputEndpoint, inCh)
utils.AssertError(err)
outPort, err = utils.CreateOutputPort("template.out", *outputEndpoint, outCh)
utils.AssertError(err)
}
func openPorts() {
var err error
// Input sockets
// Interval socket
intPort, err = utils.CreateInputPort("http-property.int", *intervalEndpoint, nil)
utils.AssertError(err)
// Request socket
reqPort, err = utils.CreateInputPort("http-property.req", *requestEndpoint, nil)
utils.AssertError(err)
// Property template socket
tmplPort, err = utils.CreateInputPort("http-property.tmpl", *templateEndpoint, nil)
utils.AssertError(err)
// Output sockets
// Property socket
if *propertyEndpoint != "" {
propPort, err = utils.CreateOutputPort("http-property.prop", *propertyEndpoint, outCh)
utils.AssertError(err)
}
// Response socket
if *responseEndpoint != "" {
respPort, err = utils.CreateOutputPort("http-property.resp", *responseEndpoint, outCh)
utils.AssertError(err)
}
// Response body socket
if *bodyEndpoint != "" {
bodyPort, err = utils.CreateOutputPort("http-property.body", *bodyEndpoint, outCh)
utils.AssertError(err)
}
// Error socket
if *errorEndpoint != "" {
errPort, err = utils.CreateOutputPort("http-property.err", *errorEndpoint, outCh)
utils.AssertError(err)
}
}
// openPorts create ZMQ sockets and start socket monitoring loops
func openPorts() {
optionsPort, err = utils.CreateInputPort("influxdb/write.options", *optionsEndpoint, nil)
utils.AssertError(err)
inPort, err = utils.CreateInputPort("influxdb/write.in", *inputEndpoint, inCh)
utils.AssertError(err)
if *errorEndpoint != "" {
errPort, err = utils.CreateOutputPort("influxdb/write.err", *errorEndpoint, errCh)
utils.AssertError(err)
}
}
// openPorts create ZMQ sockets and start socket monitoring loops
func openPorts() {
outports := strings.Split(*outputEndpoint, ",")
if len(outports) == 0 {
flag.Usage()
os.Exit(1)
}
inPort, err = utils.CreateInputPort("splitter.in", *inputEndpoint, inCh)
utils.AssertError(err)
outPortArray = []*zmq.Socket{}
for i, endpoint := range outports {
endpoint = strings.TrimSpace(endpoint)
log.Printf("Connecting OUT[%v]=%s", i, endpoint)
port, err = utils.CreateOutputPort(fmt.Sprintf("splitter.out[%v]", i), endpoint, outCh)
outPortArray = append(outPortArray, port)
}
}
// openPorts create ZMQ sockets and start socket monitoring loops
func openPorts() {
inports := strings.Split(*inputEndpoint, ",")
if len(inports) == 0 {
flag.Usage()
exitCh <- syscall.SIGTERM
return
}
inPortArray = []*zmq.Socket{}
poller = zmq.NewPoller()
for i, endpoint := range inports {
endpoint = strings.TrimSpace(endpoint)
log.Printf("Binding IN[%v]=%s", i, endpoint)
port, err = utils.CreateInputPort(fmt.Sprintf("joiner.in[%v]", i), endpoint, inCh)
utils.AssertError(err)
inPortArray = append(inPortArray, port)
poller.Add(port, zmq.POLLIN)
}
outPort, err = utils.CreateOutputPort("joiner.out", *outputEndpoint, outCh)
utils.AssertError(err)
}
func main() {
flag.Parse()
if *jsonFlag {
doc, _ := registryEntry.JSON()
fmt.Println(string(doc))
os.Exit(0)
}
log.SetFlags(0)
if *debug {
log.SetOutput(os.Stdout)
} else {
log.SetOutput(ioutil.Discard)
}
validateArgs()
openPorts()
defer closePorts()
exitCh := utils.HandleInterruption()
// Wait for the configuration on the options port
var bindAddr string
for {
log.Println("Waiting for configuration...")
ip, err := optionsPort.RecvMultipart(0)
if err != nil {
log.Println("Error receiving IP:", err.Error())
continue
}
if !runtime.IsValidIP(ip) || !runtime.IsPacket(ip) {
continue
}
bindAddr = string(ip[1])
break
}
optionsPort.Close()
// Data from http handler and data to http handler
inCh := make(chan httputils.HTTPResponse)
outCh := make(chan HandlerRequest)
go func(ctx *zmq.Context, endpoint string) {
outPort, err = utils.CreateOutputPort(context, endpoint)
utils.AssertError(err)
// Map of uuid to requests
dataMap := make(map[string]chan httputils.HTTPResponse)
// Start listening in/out channels
for {
select {
case data := <-outCh:
dataMap[data.Request.Id] = data.ResponseCh
ip, _ := httputils.Request2IP(data.Request)
outPort.SendMultipart(ip, 0)
case resp := <-inCh:
if respCh, ok := dataMap[resp.Id]; ok {
log.Println("Resolved channel for response", resp.Id)
respCh <- resp
delete(dataMap, resp.Id)
continue
}
log.Println("Didn't find request handler mapping for a given ID", resp.Id)
}
}
}(context, *outputEndpoint)
// Web server goroutine
go func() {
mux := http.NewServeMux()
mux.HandleFunc("/", Handler(outCh))
s := &http.Server{
Handler: mux,
ReadTimeout: 10 * time.Second,
WriteTimeout: 10 * time.Second,
MaxHeaderBytes: 1 << 20,
}
ln, err := net.Listen("tcp", bindAddr)
if err != nil {
log.Println(err.Error())
exitCh <- syscall.SIGTERM
return
}
log.Printf("Starting listening %v", bindAddr)
err = s.Serve(ln)
if err != nil {
log.Println(err.Error())
exitCh <- syscall.SIGTERM
return
}
}()
// Process incoming message forever
for {
ip, err := inPort.RecvMultipart(0)
if err != nil {
log.Println("Error receiving message:", err.Error())
continue
}
if !runtime.IsValidIP(ip) {
log.Println("Received invalid IP")
continue
}
resp, err := httputils.IP2Response(ip)
if err != nil {
log.Printf("Error converting IP to response: %s", err.Error())
continue
}
inCh <- *resp
}
}
// mainLoop initiates all ports and handles the traffic
func mainLoop() {
service := NewService()
openPorts()
defer closePorts()
go func() {
outPort, err = utils.CreateOutputPort("tcp/server.out", *outputEndpoint, outCh)
utils.AssertError(err)
for data := range service.Output {
outPort.SendMessage(runtime.NewOpenBracket())
outPort.SendMessage(runtime.NewPacket(data[0]))
outPort.SendMessage(runtime.NewPacket(data[1]))
outPort.SendMessage(runtime.NewCloseBracket())
}
}()
waitCh := make(chan bool)
go func() {
total := 0
for {
select {
case v := <-inCh:
if !v {
log.Println("IN port is closed. Interrupting execution")
exitCh <- syscall.SIGTERM
break
} else {
total++
}
case v := <-outCh:
if !v {
log.Println("OUT port is closed. Interrupting execution")
exitCh <- syscall.SIGTERM
break
} else {
total++
}
}
if total >= 2 && waitCh != nil {
waitCh <- true
}
}
}()
log.Println("Waiting for port connections to establish... ")
select {
case <-waitCh:
log.Println("Ports connected")
waitCh = nil
case <-time.Tick(30 * time.Second):
log.Println("Timeout: port connections were not established within provided interval")
exitCh <- syscall.SIGTERM
return
}
// Wait for the configuration on the options port
log.Println("Waiting for configuration...")
var bindAddr string
for {
ip, err := optionsPort.RecvMessageBytes(0)
if err != nil {
log.Println("Error receiving IP:", err.Error())
continue
}
if !runtime.IsValidIP(ip) || !runtime.IsPacket(ip) {
continue
}
bindAddr = string(ip[1])
break
}
optionsPort.Close()
// Create binding address listener
laddr, err := net.ResolveTCPAddr("tcp", bindAddr)
if err != nil {
log.Fatalln(err)
}
listener, err := net.ListenTCP("tcp", laddr)
if err != nil {
log.Fatalln(err)
}
log.Println("Listening on", listener.Addr())
go service.Serve(listener)
log.Println("Started...")
var (
connID string
data []byte
)
for {
ip, err := inPort.RecvMessageBytes(0)
if err != nil {
log.Println("Error receiving message:", err.Error())
continue
}
if !runtime.IsValidIP(ip) {
continue
}
switch {
case runtime.IsOpenBracket(ip):
connID = ""
data = nil
case runtime.IsPacket(ip):
if connID == "" {
connID = string(ip[1])
} else {
data = ip[1]
}
case runtime.IsCloseBracket(ip):
service.Dispatch(connID, data)
}
}
}
// mainLoop initiates all ports and handles the traffic
func mainLoop() {
// Setup watcher
watcher, err := fsnotify.NewWatcher()
if err != nil {
exitCh <- syscall.SIGTERM
return
}
defer watcher.Close()
openPorts()
defer closePorts()
// Process events
go func() {
// Socket to send messages to task sink
outPort, err = utils.CreateOutputPort("fs/watchdog.out", *outputEndpoint, errCh)
if err != nil {
exitCh <- syscall.SIGTERM
return
}
for {
select {
case ev := <-watcher.Event:
log.Println("Event:", ev)
if ev.IsCreate() {
if isDir(ev.Name) {
err = filepath.Walk(ev.Name, func(path string, info os.FileInfo, err error) error {
if err != nil {
return err
}
if info.IsDir() {
// we need to watch every subdirectory explicitely
watcher.Watch(path)
log.Println("Added to watch:", path)
} else {
// Consider every file found in the created directory as just created
outPort.SendMessage(runtime.NewPacket([]byte(path)))
}
return nil
})
if err != nil {
log.Println("Error walking directory:", err.Error())
}
} else {
outPort.SendMessage(runtime.NewPacket([]byte(ev.Name)))
}
} else if ev.IsDelete() && isDir(ev.Name) {
watcher.RemoveWatch(ev.Name)
log.Println("Removed from watch:", ev.Name)
}
case err := <-watcher.Error:
log.Println("Error:", err)
}
}
}()
go func() {
for {
select {
case v := <-outCh:
if !v {
log.Println("CREATED port is closed. Interrupting execution")
exitCh <- syscall.SIGTERM
break
}
case v := <-errCh:
if !v {
log.Println("ERR port is closed. Interrupting execution")
exitCh <- syscall.SIGTERM
break
}
}
}
}()
// Main loop
log.Println("Started")
for {
ip, err := inPort.RecvMessageBytes(0)
if err != nil {
continue
}
if !runtime.IsValidIP(ip) {
continue
}
dir := string(ip[1])
err = filepath.Walk(dir, func(path string, info os.FileInfo, err error) error {
if err != nil {
return err
}
if info.IsDir() {
watcher.Watch(path)
log.Println("Added to watch:", path)
}
return nil
})
if err != nil {
log.Printf("ERROR opening file %s: %s", dir, err.Error())
if errPort != nil {
errPort.SendMessage(runtime.NewPacket([]byte(err.Error())))
}
continue
}
}
}
// mainLoop initiates all ports and handles the traffic
func mainLoop() {
openPorts()
defer closePorts()
// Receiver routine
go func() {
inPort, err = utils.CreateInputPort("websocket/server.in", *inputEndpoint, inCh)
utils.AssertError(err)
defer inPort.Close()
for {
ip, err := inPort.RecvMessageBytes(0)
if err != nil {
continue
}
if !runtime.IsValidIP(ip) {
continue
}
msg, err := wsutils.IP2Message(ip)
if err != nil {
log.Println("Failed to convert IP to Message:", err.Error())
continue
}
log.Printf("Received response: %#v\n", msg)
DefaultHub.Outgoing <- *msg
}
}()
// Sender routine
go func() {
outPort, err = utils.CreateOutputPort("websocket/server.out", *outputEndpoint, outCh)
utils.AssertError(err)
defer outPort.Close()
for msg := range DefaultHub.Incoming {
log.Printf("Received data from connection: %#v\n", msg)
ip, err := wsutils.Message2IP(&msg)
if err != nil {
log.Println("Failed to convert Message to IP:", err.Error())
continue
}
outPort.SendMessageDontwait(ip)
}
}()
waitCh := make(chan bool)
go func() {
total := 0
for {
select {
case v := <-inCh:
if !v {
log.Println("IN port is closed. Interrupting execution")
exitCh <- syscall.SIGTERM
break
} else {
total++
}
case v := <-outCh:
if !v {
log.Println("OUT port is closed. Interrupting execution")
exitCh <- syscall.SIGTERM
break
} else {
total++
}
}
if total >= 2 && waitCh != nil {
waitCh <- true
}
}
}()
log.Println("Waiting for port connections to establish... ")
select {
case <-waitCh:
log.Println("Ports connected")
waitCh = nil
case <-time.Tick(30 * time.Second):
log.Println("Timeout: port connections were not established within provided interval")
exitCh <- syscall.SIGTERM
return
}
log.Println("Waiting for configuration...")
var bindAddr string
for {
ip, err := optionsPort.RecvMessageBytes(0)
if err != nil {
continue
}
if !runtime.IsValidIP(ip) || !runtime.IsPacket(ip) {
continue
}
bindAddr = string(ip[1])
break
}
optionsPort.Close()
// Configure & start websocket server
http.Handle("/", websocket.Handler(WebHandler))
go DefaultHub.Start()
// Listen & serve
log.Printf("Listening %v", bindAddr)
log.Printf("Web-socket endpoint: ws://%s/", bindAddr)
if err := http.ListenAndServe(bindAddr, nil); err != nil {
log.Fatal("ListenAndServe Error:", err)
}
}