feat: add playground command

Makefile

@@ -98,11 +98,13 @@ build: $(CLI_BIN) ## Build
 
 .PHONY: build-wasm
 build-wasm: fmt vet ## Build the wasm binary
+	@echo Build wasm binary... >&2
 	@GOOS=js GOARCH=wasm go build -o ./playground/assets/main.wasm -ldflags=$(LD_FLAGS) ./cmd/wasm/main.go
 
 .PHONY: serve
 serve: build-wasm ## Serve static files.
-	python3 -m http.server -d playground/ 8080
+	@echo Serve playground... >&2
+	@python3 -m http.server -d playground/ 8080
 
 ###########
 # CODEGEN #
@@ -224,7 +226,7 @@ codegen-mkdocs: codegen-docs ## Generate mkdocs website
 
 .PHONY: codegen-schema-openapi
 codegen-schema-openapi: $(KIND) $(HELM) ## Generate openapi schemas (v2 and v3)
-	@echo Generate openapi schema... >&2
+	@echo Generate openapi schemas... >&2
 	@rm -rf ./schemas
 	@mkdir -p ./schemas/openapi/v2
 	@mkdir -p ./schemas/openapi/v3/apis/json.kyverno.io
@@ -237,15 +239,21 @@ codegen-schema-openapi: $(KIND) $(HELM) ## Generate openapi schemas (v2 and v3)
 
 .PHONY: codegen-schema-json
 codegen-schema-json: codegen-schema-openapi ## Generate json schemas
+	@echo Generate json schemas... >&2
 	@$(PIP) install openapi2jsonschema
 	@rm -rf ./schemas/json
 	@openapi2jsonschema ./schemas/openapi/v2/schema.json --kubernetes --stand-alone --expanded -o ./schemas/json
 
 .PHONY: codegen-schema-all
 codegen-schema-all: codegen-schema-openapi codegen-schema-json ## Generate openapi and json schemas
 
+.PHONY: codegen-playground
+codegen-playground: build-wasm ## Generate playground
+	@echo Generate playground... >&2
+	cp -r ./playground/* ./pkg/server/ui/dist
+
 .PHONY: codegen
-codegen: codegen-crds codegen-deepcopy codegen-register codegen-client codegen-docs codegen-mkdocs codegen-schema-all ## Rebuild all generated code and docs
+codegen: codegen-crds codegen-deepcopy codegen-register codegen-client codegen-docs codegen-mkdocs codegen-schema-all codegen-playground ## Rebuild all generated code and docs
 
 .PHONY: verify-codegen
 verify-codegen: codegen ## Verify all generated code and docs are up to date

cmd/wasm/main.go

@@ -1,17 +1,3 @@
-// Copyright 2023 Undistro Authors
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//     http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
 //go:build js && wasm
 
 package main
@@ -20,35 +6,28 @@ import (
 	"context"
 	"os/signal"
 	"syscall"
-	"time"
 
-	server "github.com/kyverno/kyverno-json/pkg/server/wasm"
+	"github.com/gin-gonic/gin"
+	"github.com/kyverno/kyverno-json/pkg/server"
+	"github.com/kyverno/kyverno-json/pkg/server/playground"
 )
 
 func main() {
 	// initialise gin framework
-	// gin.SetMode(c.ginFlags.mode)
-	// tonic.SetBindHook(tonic.DefaultBindingHookMaxBodyBytes(int64(c.ginFlags.maxBodySize)))
+	gin.SetMode(gin.DebugMode)
 	// create server
-	server, err := server.New(true, true)
+	router, err := server.New(true, true)
 	if err != nil {
 		panic(err)
 	}
 	// register playground routes
-	if err := server.AddPlaygroundRoutes(); err != nil {
+	if err := playground.AddRoutes(router.Group(server.PlaygroundPrefix)); err != nil {
 		panic(err)
 	}
 	// run server
 	ctx, stop := signal.NotifyContext(context.Background(), syscall.SIGINT, syscall.SIGTERM)
 	defer stop()
-	shutdown := server.Run(ctx)
+	server.RunWasm(ctx, router)
 	<-ctx.Done()
 	stop()
-	if shutdown != nil {
-		ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
-		defer cancel()
-		if err := shutdown(ctx); err != nil {
-			panic(err)
-		}
-	}
 }

docs/user/commands/kyverno-json.md

@@ -22,6 +22,7 @@ kyverno-json [flags]
 * [kyverno-json completion](kyverno-json_completion.md)	 - Generate the autocompletion script for the specified shell
 * [kyverno-json docs](kyverno-json_docs.md)	 - Generates reference documentation.
 * [kyverno-json jp](kyverno-json_jp.md)	 - Provides a command-line interface to JMESPath, enhanced with custom functions.
+* [kyverno-json playground](kyverno-json_playground.md)	 - playground
 * [kyverno-json scan](kyverno-json_scan.md)	 - scan
 * [kyverno-json serve](kyverno-json_serve.md)	 - serve
 * [kyverno-json version](kyverno-json_version.md)	 - Prints the version informations.

docs/user/commands/kyverno-json_playground.md

@@ -0,0 +1,28 @@
+## kyverno-json playground
+
+playground
+
+### Synopsis
+
+Serve playground
+
+```
+kyverno-json playground [flags]
+```
+
+### Options
+
+```
+      --gin-cors                enable gin cors (default true)
+      --gin-log                 enable gin logger (default true)
+      --gin-max-body-size int   gin max body size (default 2097152)
+      --gin-mode string         gin run mode (default "release")
+  -h, --help                    help for playground
+      --server-host string      server host (default "0.0.0.0")
+      --server-port int         server port (default 8080)
+```
+
+### SEE ALSO
+
+* [kyverno-json](kyverno-json.md)	 - kyverno-json is a CLI tool to apply policies to json resources.
+

pkg/commands/playground/command.go

@@ -0,0 +1,27 @@
+package playground
+
+import (
+	"github.com/gin-gonic/gin"
+	"github.com/spf13/cobra"
+)
+
+func Command(parents ...string) *cobra.Command {
+	var command options
+	cmd := &cobra.Command{
+		Use:          "playground",
+		Short:        "playground",
+		Long:         "Serve playground",
+		Args:         cobra.NoArgs,
+		SilenceUsage: true,
+		RunE:         command.Run,
+	}
+	// server flags
+	cmd.Flags().StringVar(&command.serverFlags.host, "server-host", "0.0.0.0", "server host")
+	cmd.Flags().IntVar(&command.serverFlags.port, "server-port", 8080, "server port")
+	// gin flags
+	cmd.Flags().StringVar(&command.ginFlags.mode, "gin-mode", gin.ReleaseMode, "gin run mode")
+	cmd.Flags().BoolVar(&command.ginFlags.log, "gin-log", true, "enable gin logger")
+	cmd.Flags().BoolVar(&command.ginFlags.cors, "gin-cors", true, "enable gin cors")
+	cmd.Flags().IntVar(&command.ginFlags.maxBodySize, "gin-max-body-size", 2*1024*1024, "gin max body size")
+	return cmd
+}

pkg/commands/playground/options.go

@@ -0,0 +1,60 @@
+package playground
+
+import (
+	"context"
+	"os/signal"
+	"syscall"
+	"time"
+
+	"github.com/gin-gonic/gin"
+	"github.com/kyverno/kyverno-json/pkg/server"
+	"github.com/kyverno/kyverno-json/pkg/server/ui"
+	"github.com/loopfz/gadgeto/tonic"
+	"github.com/spf13/cobra"
+)
+
+type options struct {
+	serverFlags serverFlags
+	ginFlags    ginFlags
+}
+
+type serverFlags struct {
+	host string
+	port int
+}
+
+type ginFlags struct {
+	mode        string
+	log         bool
+	cors        bool
+	maxBodySize int
+}
+
+func (c *options) Run(_ *cobra.Command, _ []string) error {
+	// initialise gin framework
+	gin.SetMode(c.ginFlags.mode)
+	tonic.SetBindHook(tonic.DefaultBindingHookMaxBodyBytes(int64(c.ginFlags.maxBodySize)))
+	// create router
+	router, err := server.New(c.ginFlags.log, c.ginFlags.cors)
+	if err != nil {
+		return err
+	}
+	// register api routes
+	if err := ui.AddRoutes(router); err != nil {
+		return err
+	}
+	// run server
+	ctx, stop := signal.NotifyContext(context.Background(), syscall.SIGINT, syscall.SIGTERM)
+	defer stop()
+	shutdown := server.Run(ctx, router, c.serverFlags.host, c.serverFlags.port)
+	<-ctx.Done()
+	stop()
+	if shutdown != nil {
+		ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
+		defer cancel()
+		if err := shutdown(ctx); err != nil {
+			return err
+		}
+	}
+	return nil
+}

pkg/commands/root.go

@@ -4,6 +4,7 @@ import (
 	"github.com/kyverno/kyverno-json/pkg/command"
 	"github.com/kyverno/kyverno-json/pkg/commands/docs"
 	"github.com/kyverno/kyverno-json/pkg/commands/jp"
+	"github.com/kyverno/kyverno-json/pkg/commands/playground"
 	"github.com/kyverno/kyverno-json/pkg/commands/scan"
 	"github.com/kyverno/kyverno-json/pkg/commands/serve"
 	"github.com/kyverno/kyverno-json/pkg/commands/version"
@@ -28,6 +29,7 @@ func RootCommand() *cobra.Command {
 	cmd.AddCommand(
 		docs.Command("kyverno-json"),
 		jp.Command("kyverno-json"),
+		playground.Command(),
 		scan.Command(),
 		serve.Command("kyverno-json"),
 		version.Command("kyverno-json"),

pkg/commands/serve/options.go

@@ -9,7 +9,7 @@ import (
 	"github.com/gin-gonic/gin"
 	"github.com/kyverno/kyverno-json/pkg/client/clientset/versioned"
 	"github.com/kyverno/kyverno-json/pkg/server"
-	"github.com/kyverno/kyverno-json/pkg/server/api"
+	"github.com/kyverno/kyverno-json/pkg/server/scan"
 	restutils "github.com/kyverno/kyverno-json/pkg/utils/rest"
 	"github.com/loopfz/gadgeto/tonic"
 	"github.com/spf13/cobra"
@@ -42,8 +42,8 @@ func (c *options) Run(_ *cobra.Command, _ []string) error {
 	// initialise gin framework
 	gin.SetMode(c.ginFlags.mode)
 	tonic.SetBindHook(tonic.DefaultBindingHookMaxBodyBytes(int64(c.ginFlags.maxBodySize)))
-	// create server
-	server, err := server.New(c.ginFlags.log, c.ginFlags.cors)
+	// create router
+	router, err := server.New(c.ginFlags.log, c.ginFlags.cors)
 	if err != nil {
 		return err
 	}
@@ -55,19 +55,17 @@ func (c *options) Run(_ *cobra.Command, _ []string) error {
 	if err != nil {
 		return err
 	}
-	config := api.Configuration{
-		PolicyProvider: &provider{
-			client: client,
-		},
+	provider := &provider{
+		client: client,
 	}
 	// register api routes
-	if err := server.AddApiRoutes(config); err != nil {
+	if err := scan.AddRoutes(router.Group(server.ApiPrefix), provider); err != nil {
 		return err
 	}
 	// run server
 	ctx, stop := signal.NotifyContext(context.Background(), syscall.SIGINT, syscall.SIGTERM)
 	defer stop()
-	shutdown := server.Run(ctx, c.serverFlags.host, c.serverFlags.port)
+	shutdown := server.Run(ctx, router, c.serverFlags.host, c.serverFlags.port)
 	<-ctx.Done()
 	stop()
 	if shutdown != nil {

pkg/server/linux.go

@@ -0,0 +1,25 @@
+//go:build !js && !wasm
+
+package server
+
+import (
+	"context"
+	"fmt"
+	"net/http"
+	"time"
+)
+
+func Run(_ context.Context, s Server, host string, port int) Shutdown {
+	address := fmt.Sprintf("%v:%v", host, port)
+	srv := &http.Server{
+		Addr:              address,
+		Handler:           s.Handler(),
+		ReadHeaderTimeout: 3 * time.Second,
+	}
+	go func() {
+		if err := srv.ListenAndServe(); err != nil && err != http.ErrServerClosed {
+			panic(err)
+		}
+	}()
+	return srv.Shutdown
+}

pkg/server/playground/scan/handler.go → pkg/server/playground/handler.go

@@ -1,4 +1,4 @@
-package scan
+package playground
 
 import (
 	"context"

pkg/server/playground/scan/request.go → pkg/server/playground/request.go

@@ -1,4 +1,4 @@
-package scan
+package playground
 
 type Request struct {
 	Payload       string   `json:"payload"`

pkg/server/playground/scan/response.go → pkg/server/playground/response.go

@@ -1,4 +1,4 @@
-package scan
+package playground
 
 import (
 	"github.com/kyverno/kyverno-json/pkg/apis/v1alpha1"

pkg/server/playground/routes.go

@@ -2,12 +2,13 @@ package playground
 
 import (
 	"github.com/gin-gonic/gin"
-	"github.com/kyverno/kyverno-json/pkg/server/playground/scan"
 )
 
 func AddRoutes(group *gin.RouterGroup) error {
-	if err := scan.AddRoutes(group); err != nil {
+	handler, err := newHandler()
+	if err != nil {
 		return err
 	}
+	group.POST("/scan", handler)
 	return nil
 }