This repository has been archived on 2024-03-03. You can view files and clone it, but cannot push or open issues or pull requests.
minifaas/app.go

146 lines
3.1 KiB
Go

package main
import (
"context"
"io"
"log"
"net/http"
"os"
"time"
"github.com/docker/docker/pkg/stdcopy"
"github.com/gin-gonic/gin"
"nhooyr.io/websocket"
"github.com/nemunaire/minifaas/config"
"github.com/nemunaire/minifaas/engine/docker"
"github.com/nemunaire/minifaas/ui"
)
type App struct {
router *gin.Engine
srv *http.Server
cfg *config.Config
}
func NewApp(cfg *config.Config) App {
//Check rights on artifacts directory
os.MkdirAll("./artifacts", os.ModePerm)
if !cfg.Dev {
gin.SetMode(gin.ReleaseMode)
}
gin.ForceConsoleColor()
router := gin.Default()
ui.DeclareRoutes(router, cfg)
artifacts := http.Dir("./artifacts")
router.GET("/artifacts/*path", func(c *gin.Context) {
if c.Param("path") == "/" {
c.JSON(http.StatusForbidden, gin.H{"error": "Forbidden"})
} else {
c.FileFromFS(c.Param("path"), artifacts)
}
})
router.GET("/api/version", func(c *gin.Context) {
c.JSON(http.StatusOK, gin.H{"version": 0.1})
})
router.GET("/api/run", func(c *gin.Context) {
ctrid, err := RunJob("counter")
if err != nil {
c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
return
}
c.JSON(http.StatusOK, gin.H{"jobid": ctrid})
})
router.GET("/api/jobs/:jobid/volumes", func(c *gin.Context) {
volumes, err := docker.GetArtifactsVolumes(c.Param("jobid"))
if err != nil {
c.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
return
}
c.JSON(http.StatusOK, volumes)
})
router.GET("/api/jobs/:jobid/logs", func(c *gin.Context) {
// Check ID exists
_, err := docker.GetContainer(c.Param("jobid"))
if err != nil {
c.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
return
}
ws, err := websocket.Accept(c.Writer, c.Request, nil)
if err != nil {
log.Fatal("error get connection", err)
}
defer ws.Close(websocket.StatusInternalError, "the sky is falling")
for !docker.HasStarted(c.Param("jobid")) {
time.Sleep(500 * time.Millisecond)
}
stream, err := docker.Logs(c.Param("jobid"))
if err != nil {
ws.Close(websocket.StatusNormalClosure, "")
log.Fatal("Something goes wrong during log access:", err)
}
r, w := io.Pipe()
ctx, cancel := context.WithTimeout(c.Request.Context(), time.Second*10)
defer cancel()
go func(reader io.Reader) {
buf := make([]byte, 128)
for {
n, err := reader.Read(buf)
if err != nil {
break
}
ws.Write(ctx, websocket.MessageText, buf[:n])
}
}(r)
_, err = stdcopy.StdCopy(w, w, stream)
if err != nil && err != io.EOF {
log.Fatal("Something goes wrong during stream:", err)
}
ws.Close(websocket.StatusNormalClosure, "")
})
app := App{
router: router,
cfg: cfg,
}
return app
}
func (app *App) Start() {
app.srv = &http.Server{
Addr: app.cfg.Bind,
Handler: app.router,
}
log.Printf("Ready, listening on %s\n", app.cfg.Bind)
if err := app.srv.ListenAndServe(); err != nil && err != http.ErrServerClosed {
log.Fatalf("listen: %s\n", err)
}
}
func (app *App) Stop() {
ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
defer cancel()
if err := app.srv.Shutdown(ctx); err != nil {
log.Fatal("Server Shutdown:", err)
}
}