// openPorts create ZMQ sockets and start socket monitoring loops func openPorts() { optionsPort, err = utils.CreateInputPort("tcp/server.options", *optionsEndpoint, nil) utils.AssertError(err) inPort, err = utils.CreateInputPort("tcp/server.in", *inputEndpoint, inCh) 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() { context, err = zmq.NewContext() utils.AssertError(err) optionsPort, err = utils.CreateInputPort(context, *optionsEndpoint) utils.AssertError(err) inPort, err = utils.CreateInputPort(context, *inputEndpoint) utils.AssertError(err) }
// 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) }
// 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() { 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) } }
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("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() { 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("fs/watchdog.in", *inputEndpoint, nil) utils.AssertError(err) if *errorEndpoint != "" { errPort, err = utils.CreateOutputPort("fs/watchdog.err", *errorEndpoint, errCh) 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) } }
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() { 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) } }
// 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() { 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) } }
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() { 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) }
// 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) } }
// openPorts create ZMQ sockets and start socket monitoring loops func openPorts() { inPort, err = utils.CreateInputPort("drop.in", *inputEndpoint, inCh) utils.AssertError(err) }
// openPorts create ZMQ sockets and start socket monitoring loops func openPorts() { inPort, err = utils.CreateInputPort("bonjour/discover.options", *inputEndpoint, nil) utils.AssertError(err) }
// openPorts create ZMQ sockets and start socket monitoring loops func openPorts() { optionsPort, err = utils.CreateInputPort("websocket/server.options", *optionsEndpoint, nil) utils.AssertError(err) }