Merge branch 'develop' into dependabot/go_modules/develop/golang.org/x/net-0.51.0

Author: marle3003

.github/workflows/release.yml

@@ -17,6 +17,7 @@ jobs:
       - uses: actions/setup-go@v5
         with:
           go-version: 1.25.5
+      - run: npm install -g npm@latest
       - uses: ./.github/actions/build-release-notes
       - uses: actions/setup-node@v4
         with:
@@ -144,4 +145,5 @@ jobs:
       - name: Publish
         run: task publish-npm-package VERSION=${GITHUB_REF##*/v}
         env:
-          CGO_ENABLED: 0
+          CGO_ENABLED: 0
+          NPM_AUTH_TOKEN: ${{ secrets.NPM_TOKEN }}

Taskfile.yml

@@ -47,7 +47,7 @@ tasks:
     dir: npm
     cmds:
       - npm version {{.VERSION}}
-      - npm publish
+      - npm publish --provenance
   npm-build-windows:
     cmds:
       - go build -o ./npm/dist/mokapi-windows-amd64/mokapi.exe -ldflags="-X mokapi/version.BuildVersion={{.VERSION}}" ./cmd/mokapi

acceptance/cmd_test.go

@@ -9,6 +9,7 @@ import (
 	"mokapi/config/static"
 	"mokapi/engine"
 	"mokapi/feature"
+	"mokapi/health"
 	"mokapi/providers/asyncapi3"
 	"mokapi/providers/directory"
 	mail2 "mokapi/providers/mail"
@@ -63,14 +64,29 @@ func Start(cfg *static.Config) (*Cmd, error) {
 		app.UpdateConfig(e)
 	})
 
+	apiHandler := api.New(app, cfg.Api)
 	if u, err := api.BuildUrl(cfg.Api); err == nil {
-		err = http.AddInternalService("api", u, api.New(app, cfg.Api))
+		err = http.AddInternalService("api", u, apiHandler)
 		if err != nil {
 			return nil, err
 		}
 	} else {
 		return nil, err
 	}
+	if cfg.Health.Enabled {
+		if u, err := health.BuildUrl(cfg.Health); err == nil {
+			if cfg.Api.Port == cfg.Health.Port {
+				apiHandler.RegisterHealthHandler(u.Path, health.New(cfg.Health))
+			} else {
+				err = http.AddInternalService("health", u, health.New(cfg.Health))
+				if err != nil {
+					return nil, err
+				}
+			}
+		} else {
+			return nil, err
+		}
+	}
 
 	pool := safe.NewPool(context.Background())
 	s := server.NewServer(pool, app, watcher, kafka, http, mailManager, ldap, scriptEngine)

acceptance/petstore_test.go

@@ -24,6 +24,7 @@ type PetStoreSuite struct{ BaseSuite }
 func (suite *PetStoreSuite) SetupSuite() {
 	cfg := static.NewConfig()
 	cfg.Api.Port = try.GetFreePort()
+	cfg.Health.Port = cfg.Api.Port
 	cfg.Providers.File.Directories = []static.FileConfig{{Path: "./petstore"}}
 	cfg.Api.Search.Enabled = true
 	suite.initCmd(cfg)
@@ -392,3 +393,10 @@ func (suite *PetStoreSuite) TestSearch_Paging() {
 		}),
 	)
 }
+
+func (suite *PetStoreSuite) TestHealth() {
+	try.GetRequest(suite.T(), fmt.Sprintf("http://127.0.0.1:%v/health", suite.cfg.Api.Port), nil,
+		try.HasStatusCode(http.StatusOK),
+		try.HasBody(`{"status":"healthy"}`),
+	)
+}

api/handler.go

@@ -19,13 +19,20 @@ import (
 	log "github.com/sirupsen/logrus"
 )
 
+type Handler interface {
+	http.Handler
+	RegisterHealthHandler(path string, h http.Handler)
+}
+
 type handler struct {
-	config     static.Api
-	path       string
-	base       string
-	app        *runtime.App
-	fileServer http.Handler
-	index      string
+	config        static.Api
+	path          string
+	base          string
+	app           *runtime.App
+	fileServer    http.Handler
+	index         string
+	healthPath    string
+	healthHandler http.Handler
 }
 
 type info struct {
@@ -67,7 +74,7 @@ type apiError struct {
 	Message string `json:"message"`
 }
 
-func New(app *runtime.App, config static.Api) http.Handler {
+func New(app *runtime.App, config static.Api) Handler {
 	h := &handler{
 		config: config,
 		path:   config.Path,
@@ -99,6 +106,11 @@ func BuildUrl(cfg static.Api) (*url.URL, error) {
 	return url.Parse(s)
 }
 
+func (h *handler) RegisterHealthHandler(path string, handler http.Handler) {
+	h.healthPath = path
+	h.healthHandler = handler
+}
+
 func (h *handler) ServeHTTP(w http.ResponseWriter, r *http.Request) {
 	if r.Method != "GET" && r.Method != "POST" {
 		http.Error(w, fmt.Sprintf("method %v is not allowed", r.Method), http.StatusMethodNotAllowed)
@@ -140,8 +152,8 @@ func (h *handler) ServeHTTP(w http.ResponseWriter, r *http.Request) {
 		h.handleFakerTree(w, r)
 	case strings.HasPrefix(p, "/api/search"):
 		h.getSearchResults(w, r)
-	case strings.HasPrefix(p, "/health"):
-		handleHealth(w, r)
+	case strings.HasPrefix(p, h.healthPath) && h.healthHandler != nil:
+		h.healthHandler.ServeHTTP(w, r)
 	case h.fileServer != nil:
 		if r.Method != "GET" {
 			http.Error(w, fmt.Sprintf("method %v is not allowed", r.Method), http.StatusMethodNotAllowed)
@@ -293,22 +305,3 @@ func getPageInfo(r *http.Request) (index int, limit int, err error) {
 	}
 	return
 }
-
-func handleHealth(w http.ResponseWriter, r *http.Request) {
-	if r.Method != http.MethodGet {
-		w.WriteHeader(http.StatusMethodNotAllowed)
-		return
-	}
-
-	if strings.HasSuffix(r.URL.Path, "/health/live") {
-		w.Header().Set("Content-Type", "application/json")
-		w.WriteHeader(http.StatusOK)
-		_, _ = w.Write([]byte(`{"status":"alive"}`))
-	} else if strings.HasSuffix(r.URL.Path, "/health/ready") {
-		w.Header().Set("Content-Type", "application/json")
-		w.WriteHeader(http.StatusOK)
-		_, _ = w.Write([]byte(`{"status":"ready"}`))
-	} else {
-		http.NotFound(w, r)
-	}
-}

api/handler_test.go

@@ -3,6 +3,7 @@ package api_test
 import (
 	"mokapi/api"
 	"mokapi/config/static"
+	"mokapi/health"
 	"mokapi/providers/openapi"
 	"mokapi/runtime"
 	"mokapi/runtime/runtimetest"
@@ -218,54 +219,32 @@ func TestHandler_Health(t *testing.T) {
 			name: "POST is not allowed",
 			cfg:  &static.Config{},
 			test: func(t *testing.T, h http.Handler) {
-				r := httptest.NewRequest(http.MethodPatch, "http://foo.api/health/live", nil)
+				r := httptest.NewRequest(http.MethodPatch, "http://foo.api/health", nil)
 				rr := httptest.NewRecorder()
 				h.ServeHTTP(rr, r)
 				require.Equal(t, http.StatusMethodNotAllowed, rr.Code)
 			},
 		},
 		{
-			name: "GET /health/live",
+			name: "GET /health",
 			cfg:  &static.Config{},
 			test: func(t *testing.T, h http.Handler) {
-				r := httptest.NewRequest(http.MethodGet, "http://foo.api/health/live", nil)
+				r := httptest.NewRequest(http.MethodGet, "http://foo.api/health", nil)
 				rr := httptest.NewRecorder()
 				h.ServeHTTP(rr, r)
 				require.Equal(t, http.StatusOK, rr.Code)
-				require.Equal(t, `{"status":"alive"}`, rr.Body.String())
-			},
-		},
-		{
-			name: "GET /health/ready",
-			cfg:  &static.Config{},
-			test: func(t *testing.T, h http.Handler) {
-				r := httptest.NewRequest(http.MethodGet, "http://foo.api/health/ready", nil)
-				rr := httptest.NewRecorder()
-				h.ServeHTTP(rr, r)
-				require.Equal(t, http.StatusOK, rr.Code)
-				require.Equal(t, `{"status":"ready"}`, rr.Body.String())
+				require.Equal(t, `{"status":"healthy"}`, rr.Body.String())
 			},
 		},
 		{
 			name: "use path but request does not adapt",
 			cfg:  &static.Config{Api: static.Api{Path: "/foo"}},
 			test: func(t *testing.T, h http.Handler) {
-				r := httptest.NewRequest(http.MethodGet, "http://foo.api/health/ready", nil)
-				rr := httptest.NewRecorder()
-				h.ServeHTTP(rr, r)
-				require.Equal(t, http.StatusOK, rr.Code)
-				require.Equal(t, `{"status":"ready"}`, rr.Body.String())
-			},
-		},
-		{
-			name: "use path and request adapt",
-			cfg:  &static.Config{Api: static.Api{Path: "/foo"}},
-			test: func(t *testing.T, h http.Handler) {
-				r := httptest.NewRequest(http.MethodGet, "http://foo.api/foo/health/ready", nil)
+				r := httptest.NewRequest(http.MethodGet, "http://foo.api/health", nil)
 				rr := httptest.NewRecorder()
 				h.ServeHTTP(rr, r)
 				require.Equal(t, http.StatusOK, rr.Code)
-				require.Equal(t, `{"status":"ready"}`, rr.Body.String())
+				require.Equal(t, `{"status":"healthy"}`, rr.Body.String())
 			},
 		},
 	}
@@ -277,6 +256,7 @@ func TestHandler_Health(t *testing.T) {
 			t.Parallel()
 
 			h := api.New(runtime.New(tc.cfg), tc.cfg.Api)
+			h.RegisterHealthHandler("/health", health.New(static.Health{}))
 			tc.test(t, h)
 		})
 	}

cmd/mokapi/main_test.go

@@ -84,6 +84,11 @@ api:
         enabled: true
         indexPath: ""
         inMemory: false
+health:
+    enabled: true
+    path: /health
+    port: 8080
+    log: false
 rootCaCert: ""
 rootCaKey: ""
 configs: []

config/dynamic/provider/git/git.go

@@ -15,7 +15,6 @@ import (
 	"time"
 
 	"github.com/go-git/go-git/v5"
-	"github.com/go-git/go-git/v5/config"
 	"github.com/go-git/go-git/v5/plumbing"
 	"github.com/go-git/go-git/v5/plumbing/transport/client"
 	"github.com/go-git/go-git/v5/plumbing/transport/http"
@@ -271,9 +270,9 @@ func pull(r *repository) {
 	if r.repo == nil {
 		return
 	}
-	err := r.repo.Fetch(&git.FetchOptions{RefSpecs: []config.RefSpec{"refs/*:refs/*", "HEAD:refs/heads/HEAD"}})
+	err := r.repo.Fetch(&git.FetchOptions{})
 	if errors.Is(err, git.ErrForceNeeded) {
-		err = r.repo.Fetch(&git.FetchOptions{RefSpecs: []config.RefSpec{"+refs/*:refs/*", "HEAD:refs/heads/HEAD"}})
+		err = r.repo.Fetch(&git.FetchOptions{})
 	}
 	if err != nil {
 		if !errors.Is(err, git.NoErrAlreadyUpToDate) {

config/static/static_config.go

@@ -18,6 +18,7 @@ type Config struct {
 	ConfigFile       string            `json:"-" yaml:"-" flag:"config-file"`
 	Providers        Providers         `json:"providers" yaml:"providers"`
 	Api              Api               `json:"api" yaml:"api"`
+	Health           Health            `json:"health" yaml:"health"`
 	RootCaCert       tls.FileOrContent `json:"rootCaCert" yaml:"rootCaCert" name:"root-ca-cert"`
 	RootCaKey        tls.FileOrContent `json:"rootCaKey" yaml:"rootCaKey" name:"root-ca-cert"`
 	Configs          Configs           `json:"configs" yaml:"configs" explode:"config"`
@@ -39,6 +40,10 @@ func NewConfig() *Config {
 	cfg.Api.Dashboard = true
 	cfg.Api.Search.Enabled = true
 
+	cfg.Health.Enabled = true
+	cfg.Health.Port = 8080
+	cfg.Health.Path = "/health"
+
 	cfg.Providers.File.SkipPrefix = []string{"_"}
 	cfg.Event.Store = map[string]Store{"default": {Size: 100}}
 	cfg.DataGen.OptionalProperties = "0.85"
@@ -286,3 +291,10 @@ func (fc *FileConfig) Set(v any) error {
 	}
 	return fmt.Errorf("expected string, got %T", v)
 }
+
+type Health struct {
+	Enabled bool   `yaml:"enabled" json:"enabled"`
+	Path    string `yaml:"path" json:"path"`
+	Port    int    `yaml:"port" json:"port"`
+	Log     bool   `yaml:"log" json:"log"`
+}

health/http_handler.go

@@ -0,0 +1,59 @@
+package health
+
+import (
+	"fmt"
+	"mokapi/config/static"
+	"mokapi/lib"
+	"net/http"
+	"net/url"
+
+	log "github.com/sirupsen/logrus"
+)
+
+type handler struct {
+	path string
+	log  bool
+}
+
+func New(cfg static.Health) http.Handler {
+	return &handler{path: healthPath(cfg), log: cfg.Log}
+}
+
+func BuildUrl(cfg static.Health) (*url.URL, error) {
+	s := fmt.Sprintf("http://:%v%v", cfg.Port, healthPath(cfg))
+	return url.Parse(s)
+}
+
+func (h *handler) ServeHTTP(w http.ResponseWriter, r *http.Request) {
+	if r.Method != "GET" {
+		w.Header().Set("Allow", http.MethodGet)
+		http.Error(w, fmt.Sprintf("method %v is not allowed", r.Method), http.StatusMethodNotAllowed)
+		if h.log {
+			log.Warnf("healthcheck: method not allowed: %v %v", r.Method, lib.GetUrl(r))
+		}
+		return
+	}
+
+	switch r.URL.Path {
+	case h.path:
+		w.Header().Set("Content-Type", "application/json")
+		w.WriteHeader(http.StatusOK)
+		_, _ = w.Write([]byte(`{"status":"healthy"}`))
+		if h.log {
+			log.Infof("healthcheck: %v %v: healthy", r.Method, lib.GetUrl(r))
+		}
+	default:
+		http.NotFound(w, r)
+		if h.log {
+			log.Debugf("healthcheck: not found: %v %v", r.Method, lib.GetUrl(r))
+		}
+	}
+}
+
+func healthPath(cfg static.Health) string {
+	path := "/health"
+	if cfg.Path != "" {
+		path = cfg.Path
+	}
+	return path
+}