debug needed

servers/webserver/handlers.go

@@ -0,0 +1,70 @@
+package webserver
+
+import (
+	"net/http"
+	"os"
+
+	"github.com/gin-gonic/gin"
+	"github.com/pion/webrtc/v3"
+	"github.com/sirupsen/logrus"
+)
+
+type Response struct {
+	Succeed bool        `json:"succeed"`
+	Message string      `json:"message"`
+	Data    interface{} `json:"data"`
+}
+
+func (s *Server) getInstruction(c *gin.Context) {
+	f, _ := os.ReadFile(s.options.InstructionFile)
+	c.JSON(http.StatusOK, Response{
+		Succeed: true,
+		Message: "",
+		Data:    string(f),
+	})
+}
+
+func (s *Server) exchangeSDP(c *gin.Context) {
+	var offer *webrtc.SessionDescription
+	if err := c.BindJSON(offer); err != nil {
+		c.JSON(http.StatusBadRequest, Response{
+			Succeed: false,
+			Message: "bad request",
+			Data:    err.Error(),
+		})
+		logrus.Error(err)
+		return
+	}
+
+	answer, err := s.rtcConnector.Regist(offer)
+	if err != nil {
+		c.JSON(http.StatusInternalServerError, Response{
+			Succeed: false,
+			Message: "internal error",
+			Data:    err.Error(),
+		})
+		return
+	}
+
+	c.JSON(http.StatusOK, Response{
+		Succeed: true,
+		Message: "",
+		Data:    answer,
+	})
+}
+
+func (s *Server) getICEConfig(c *gin.Context) {
+	c.JSON(http.StatusOK, Response{
+		Succeed: true,
+		Message: "",
+		Data:    s.options.WebRTC.STUNServers,
+	})
+}
+
+func (s *Server) getName(c *gin.Context) {
+	c.JSON(http.StatusOK, Response{
+		Succeed: true,
+		Message: "",
+		Data:    s.options.Name,
+	})
+}

servers/webserver/loginit.go

@@ -0,0 +1,7 @@
+package webserver
+
+import "github.com/sirupsen/logrus"
+
+func init() {
+	logrus.Info("web server loaded")
+}

servers/webserver/options.go

@@ -0,0 +1,21 @@
+package webserver
+
+import (
+	"git.sense-t.eu.org/ACE/ace/lib/webrtcconnection"
+)
+
+type Options struct {
+	Name            string                    `yaml:"name"`
+	Listen          string                    `yaml:"listen"`
+	InstructionFile string                    `yaml:"instruction_file"`
+	WebRTC          *webrtcconnection.Options `yaml:"webrtc"`
+}
+
+func ExampleOptions() *Options {
+	return &Options{
+		Name:            "ACE-test",
+		Listen:          "localhost:8080",
+		InstructionFile: "",
+		WebRTC:          webrtcconnection.ExampleOptions(),
+	}
+}

servers/webserver/routers.go

@@ -0,0 +1,12 @@
+package webserver
+
+import "github.com/gin-contrib/static"
+
+func (s *Server) setupRoute() {
+	s.webServer.
+		Use(static.Serve("/", newFS())).
+		POST("/api/v1/sdp", s.exchangeSDP).
+		GET("/api/v1/instruction", s.getInstruction).
+		GET("/api/v1/iceserver/url", s.getICEConfig).
+		GET("/api/v1/name", s.getName)
+}

servers/webserver/server.go

@@ -0,0 +1,40 @@
+package webserver
+
+import (
+	"git.sense-t.eu.org/ACE/ace/lib/webrtcconnection"
+	"github.com/gin-gonic/gin"
+	"github.com/sirupsen/logrus"
+)
+
+type Server struct {
+	options      *Options
+	webServer    *gin.Engine
+	rtcConnector *webrtcconnection.Connection
+}
+
+var DefaultServer *Server
+
+func NewServer(o *Options) *Server {
+	s := &Server{
+		options:      o,
+		webServer:    gin.New(),
+		rtcConnector: webrtcconnection.New(o.WebRTC),
+	}
+	return s
+}
+
+func (s *Server) Run() error {
+	logrus.Debug("webserver running")
+	defer logrus.Debug("webserver exit")
+	s.setupRoute()
+	return s.webServer.Run(s.options.Listen)
+}
+
+func Setup(o *Options) {
+	DefaultServer = NewServer(o)
+	go func() {
+		if err := DefaultServer.Run(); err != nil {
+			logrus.Fatal("cannot run webserver with error: ", err)
+		}
+	}()
+}

servers/webserver/static.go

@@ -0,0 +1,37 @@
+package webserver
+
+import (
+	"embed"
+	"io/fs"
+	"net/http"
+	"strings"
+)
+
+//go:generate cp -r ../../web/dist ./
+//go:embed dist
+var staticFiles embed.FS
+
+type ginFS struct {
+	fs http.FileSystem
+}
+
+func newFS() *ginFS {
+	f, _ := fs.Sub(staticFiles, "dist")
+	return &ginFS{
+		fs: http.FS(f),
+	}
+}
+
+func (s *ginFS) Exists(prefix string, filepath string) bool {
+	if p := strings.TrimPrefix(filepath, prefix); len(p) < len(filepath) {
+		if _, err := s.fs.Open(p); err != nil {
+			return false
+		}
+		return true
+	}
+	return false
+}
+
+func (s *ginFS) Open(name string) (http.File, error) {
+	return s.fs.Open(name)
+}