133 lines
3.0 KiB
Go
133 lines
3.0 KiB
Go
package net
|
|
|
|
import (
|
|
"encoding/json"
|
|
"fmt"
|
|
"git.timovolkmann.de/gyrogpsc/dispatcher"
|
|
"git.timovolkmann.de/gyrogpsc/serial_ubx"
|
|
"github.com/gorilla/websocket"
|
|
"github.com/tidwall/pretty"
|
|
"html/template"
|
|
"log"
|
|
"net"
|
|
"net/http"
|
|
"os"
|
|
)
|
|
|
|
func echo(d *dispatcher.Dispatcher) func(w http.ResponseWriter, r *http.Request) {
|
|
var upgrader = websocket.Upgrader{} // use default options
|
|
return func(w http.ResponseWriter, r *http.Request) {
|
|
fmt.Println("upgrading to ws")
|
|
c, err := upgrader.Upgrade(w, r, nil)
|
|
if err != nil {
|
|
log.Print("upgrade:", err)
|
|
return
|
|
}
|
|
//defer c.Close()
|
|
go func() {
|
|
for {
|
|
if _, _, err := c.NextReader(); err != nil {
|
|
c.Close()
|
|
break
|
|
}
|
|
}
|
|
}()
|
|
|
|
dispatcherId, channel := d.Subscribe()
|
|
defer d.Unsubscribe(dispatcherId)
|
|
for {
|
|
log.Println("")
|
|
//if err != nil {
|
|
// log.Println("read:", err)
|
|
// break
|
|
//}
|
|
cmsg := <-channel
|
|
err = c.WriteMessage(websocket.TextMessage, []byte(cmsg))
|
|
if err != nil {
|
|
log.Println("write:", err)
|
|
|
|
break
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
func home(w http.ResponseWriter, r *http.Request) {
|
|
//var homeTemplate = template.Must(template.New("").ParseFiles("index.html"))
|
|
tpl, err := template.ParseFiles("index.html")
|
|
if err != nil {
|
|
log.Fatalln(err)
|
|
}
|
|
err = tpl.Execute(w, "ws://"+r.Host+"/echo")
|
|
if err != nil {
|
|
log.Fatalln(err)
|
|
}
|
|
}
|
|
|
|
func NewHttpServer(d *dispatcher.Dispatcher, httpPort string) {
|
|
http.HandleFunc("/echo", echo(d))
|
|
http.HandleFunc("/", home)
|
|
http.Handle("/static/", http.StripPrefix("/static/", http.FileServer(http.Dir("."))))
|
|
|
|
log.Fatal(http.ListenAndServe(httpPort, nil))
|
|
}
|
|
|
|
func SerialUbxCollector(d *dispatcher.Dispatcher, serialPort string) {
|
|
r, err := serial_ubx.Setup(serialPort)
|
|
if err != nil {
|
|
log.Fatalln(err)
|
|
}
|
|
|
|
for {
|
|
meas, err := r.NextMeasurement()
|
|
if err != nil {
|
|
continue
|
|
}
|
|
fmt.Println(meas)
|
|
measjson, err := json.Marshal(meas)
|
|
d.Publish(string(measjson))
|
|
}
|
|
}
|
|
|
|
func TcpJsonCollector(d *dispatcher.Dispatcher, tcpPort string) {
|
|
listener, err := net.Listen("tcp", tcpPort)
|
|
if err != nil {
|
|
fmt.Println("Error listening:", err.Error())
|
|
os.Exit(1)
|
|
}
|
|
// Close the listener when the application closes.
|
|
defer listener.Close()
|
|
|
|
for {
|
|
// Listen for an incoming connection.
|
|
conn, err := listener.Accept()
|
|
if err != nil {
|
|
fmt.Println("Error accepting: ", err.Error())
|
|
os.Exit(1)
|
|
}
|
|
// Handle connections in a new goroutine.
|
|
go handleTcpJsonSensorData(conn, d)
|
|
}
|
|
}
|
|
|
|
// Handles incoming requests.
|
|
func handleTcpJsonSensorData(conn net.Conn, d *dispatcher.Dispatcher) {
|
|
defer conn.Close()
|
|
// Make a buffer to hold incoming data.
|
|
for {
|
|
buf := make([]byte, 2048)
|
|
// Read the incoming connection into the buffer.
|
|
_, err := conn.Read(buf)
|
|
if err != nil {
|
|
fmt.Println("Error reading:", err.Error())
|
|
break
|
|
}
|
|
json := pretty.Pretty(buf)
|
|
fmt.Println(string(json))
|
|
d.Publish(string(json))
|
|
// Send a response back to person contacting us.
|
|
//conn.Write([]byte("success"))
|
|
// Close the connection when you're done with it.
|
|
}
|
|
}
|