コード例 #1
0
ファイル: main.go プロジェクト: vishnuvr/cascades
// 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)
	}
}
コード例 #2
0
ファイル: main.go プロジェクト: vishnuvr/cascades
// 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)
	}
}
コード例 #3
0
ファイル: main.go プロジェクト: vishnuvr/cascades
// 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)
	}
}
コード例 #4
0
ファイル: main.go プロジェクト: voxadam/cascades-caf
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)
	}
}
コード例 #5
0
ファイル: main.go プロジェクト: vishnuvr/cascades
// 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)
}
コード例 #6
0
ファイル: main.go プロジェクト: vishnuvr/cascades
// 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)
}
コード例 #7
0
ファイル: main.go プロジェクト: vishnuvr/cascades
// 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)
}
コード例 #8
0
ファイル: main.go プロジェクト: voxadam/cascades-bonjour
// 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)
}
コード例 #9
0
ファイル: main.go プロジェクト: voxadam/cascades-http
// 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)
	}
}
コード例 #10
0
ファイル: main.go プロジェクト: vishnuvr/cascades
// 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)
	}
}
コード例 #11
0
ファイル: main.go プロジェクト: voxadam/cascades-http
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
	}
}
コード例 #12
0
ファイル: main.go プロジェクト: vishnuvr/cascades
// 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)
}
コード例 #13
0
ファイル: main.go プロジェクト: voxadam/cascades-caf
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)
	}
}
コード例 #14
0
ファイル: main.go プロジェクト: vishnuvr/cascades
// 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)
}
コード例 #15
0
ファイル: main.go プロジェクト: vishnuvr/cascades
// 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)
}
コード例 #16
0
ファイル: main.go プロジェクト: vishnuvr/cascades
// 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)
}
コード例 #17
0
ファイル: main.go プロジェクト: voxadam/cascades-caf
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)

	}
}
コード例 #18
0
ファイル: main.go プロジェクト: voxadam/cascades-influxdb
// 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)
	}
}
コード例 #19
0
ファイル: main.go プロジェクト: vishnuvr/cascades
// 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)
	}
}
コード例 #20
0
ファイル: main.go プロジェクト: vishnuvr/cascades
// 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)
}
コード例 #21
0
ファイル: main.go プロジェクト: voxadam/cascades-http
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
	}
}
コード例 #22
0
ファイル: main.go プロジェクト: voxadam/cascades-sockets
// 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)
		}
	}
}
コード例 #23
0
ファイル: main.go プロジェクト: vishnuvr/cascades
// 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
		}
	}
}
コード例 #24
0
ファイル: main.go プロジェクト: voxadam/cascades-websocket
// 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)
	}
}