Merge branch 'main' of https://github.com/rookie-ninja/rk-boot

Author: 陆丹峰

.github/workflows/ci.yml

@@ -14,7 +14,7 @@ jobs:
     - name: Setup Go
       uses: actions/setup-go@v2
       with:
-        go-version: 1.17
+        go-version: 1.18
     - name: Setup golangci-lint
       uses: golangci/golangci-lint-action@v2.5.2
     - name: Run linter

README.md

@@ -10,22 +10,50 @@ import (
 	"context"
 	"embed"
 	"fmt"
-	"github.com/rookie-ninja/rk-entry/v2/entry"
-	"github.com/rookie-ninja/rk-entry/v2/middleware"
-	"go.uber.org/zap"
-	"io/ioutil"
 	"os"
-	"path"
+	"path/filepath"
 	"runtime/debug"
+
+	rkentry "github.com/rookie-ninja/rk-entry/v2/entry"
+	rkmid "github.com/rookie-ninja/rk-entry/v2/middleware"
+	"go.uber.org/zap"
 )
 
+type hookFuncM map[string]map[string]func(ctx context.Context)
+
+func newHookFuncM() hookFuncM {
+	return map[string]map[string]func(ctx context.Context){}
+}
+
+func (m hookFuncM) addFunc(entryType, entryName string, f func(ctx context.Context)) {
+	if _, ok := m[entryType]; !ok {
+		m[entryType] = make(map[string]func(ctx context.Context))
+	}
+
+	m[entryType][entryName] = f
+}
+
+func (m hookFuncM) getFunc(entryType, entryName string) func(ctx context.Context) {
+	if inner, ok := m[entryType]; ok {
+		if f, ok := inner[entryName]; ok {
+			return f
+		}
+	}
+
+	return func(ctx context.Context) {}
+}
+
 // Boot is a structure for bootstrapping rk style application
 type Boot struct {
-	bootConfigPath string                       `yaml:"-" json:"-"`
-	embedFS        *embed.FS                    `yaml:"-" json:"-"`
-	bootConfigRaw  []byte                       `yaml:"-" json:"-"`
-	preloadF       map[string]map[string]func() `yaml:"-" json:"-"`
-	EventId        string                       `yaml:"-" json:"-"`
+	bootConfigPath string    `yaml:"-" json:"-"`
+	embedFS        *embed.FS `yaml:"-" json:"-"`
+	bootConfigRaw  []byte    `yaml:"-" json:"-"`
+	beforeHookF    hookFuncM `yaml:"-" json:"-"`
+	afterHookF     hookFuncM `yaml:"-" json:"-"`
+	EventId        string    `yaml:"-" json:"-"`
+	pluginEntries  map[string]map[string]rkentry.Entry
+	userEntries    map[string]map[string]rkentry.Entry
+	webEntries     map[string]map[string]rkentry.Entry
 }
 
 // BootOption is used as options while bootstrapping from code
@@ -53,8 +81,12 @@ func NewBoot(opts ...BootOption) *Boot {
 	defer syncLog("N/A")
 
 	boot := &Boot{
-		EventId:  rkmid.GenerateRequestId(),
-		preloadF: map[string]map[string]func(){},
+		EventId:       rkmid.GenerateRequestId(nil),
+		beforeHookF:   newHookFuncM(),
+		afterHookF:    newHookFuncM(),
+		pluginEntries: map[string]map[string]rkentry.Entry{},
+		userEntries:   map[string]map[string]rkentry.Entry{},
+		webEntries:    map[string]map[string]rkentry.Entry{},
 	}
 
 	for i := range opts {
@@ -64,59 +96,83 @@ func NewBoot(opts ...BootOption) *Boot {
 	raw := boot.readYAML()
 
 	// Register entries need to pre-build.
-	rkentry.BootstrapPreloadEntryYAML(raw)
+	rkentry.BootstrapBuiltInEntryFromYAML(raw)
+
+	for _, f := range rkentry.ListPluginEntryRegFunc() {
+		for _, v := range f(raw) {
+			if boot.pluginEntries[v.GetType()] == nil {
+				boot.pluginEntries[v.GetType()] = make(map[string]rkentry.Entry)
+			}
+			boot.pluginEntries[v.GetType()][v.GetName()] = v
+		}
+	}
 
-	// Register entries
-	regFuncList := rkentry.ListEntryRegFunc()
-	for i := range regFuncList {
-		regFuncList[i](raw)
+	for _, f := range rkentry.ListUserEntryRegFunc() {
+		for _, v := range f(raw) {
+			if boot.userEntries[v.GetType()] == nil {
+				boot.userEntries[v.GetType()] = make(map[string]rkentry.Entry)
+			}
+			boot.userEntries[v.GetType()][v.GetName()] = v
+		}
+	}
+
+	for _, f := range rkentry.ListWebFrameEntryRegFunc() {
+		for _, v := range f(raw) {
+			if boot.webEntries[v.GetType()] == nil {
+				boot.webEntries[v.GetType()] = make(map[string]rkentry.Entry)
+			}
+			boot.webEntries[v.GetType()][v.GetName()] = v
+		}
 	}
 
 	return boot
 }
 
-// AddPreloadFuncBeforeBootstrap run functions before certain entry Bootstrap()
-func (boot *Boot) AddPreloadFuncBeforeBootstrap(entry rkentry.Entry, f func()) {
-	if entry == nil || f == nil {
+// AddHookFuncBeforeBootstrap run functions before certain entry Bootstrap()
+func (boot *Boot) AddHookFuncBeforeBootstrap(entryType, entryName string, f func(ctx context.Context)) {
+	if f == nil {
 		return
 	}
 
-	entryName := entry.GetName()
-	entryType := entry.GetType()
+	boot.beforeHookF.addFunc(entryType, entryName, f)
+}
 
-	if _, ok := boot.preloadF[entryType]; !ok {
-		boot.preloadF[entryType] = make(map[string]func())
+// AddHookFuncAfterBootstrap run functions before certain entry Bootstrap()
+func (boot *Boot) AddHookFuncAfterBootstrap(entryType, entryName string, f func(ctx context.Context)) {
+	if f == nil {
+		return
 	}
 
-	boot.preloadF[entryType][entryName] = f
+	boot.afterHookF.addFunc(entryType, entryName, f)
 }
 
-// Bootstrap entries in rkentry.GlobalAppCtx including bellow:
-//
-// Internal entries:
-// 1: rkentry.AppInfoEntry
-// 2: rkentry.ConfigEntry
-// 3: rkentry.LoggerEntry
-// 4: rkentry.EventEntry
-// 5: rkentry.CertEntry
-//
-// External entries:
-// User defined entries
+// Bootstrap entries as sequence of plugin, user defined and web framework
 func (boot *Boot) Bootstrap(ctx context.Context) {
 	defer syncLog(boot.EventId)
 
 	ctx = context.WithValue(ctx, "eventId", boot.EventId)
 
-	// Bootstrap external entries
-	for _, m := range rkentry.GlobalAppCtx.ListEntries() {
-		for _, entry := range m {
-			if m, ok := boot.preloadF[entry.GetType()]; ok {
-				if v, ok := m[entry.GetName()]; ok {
-					v()
-				}
-			}
+	for entryType, byEntryName := range boot.pluginEntries {
+		for entryName, e := range byEntryName {
+			boot.beforeHookF.getFunc(entryType, entryName)(ctx)
+			e.Bootstrap(ctx)
+			boot.afterHookF.getFunc(entryType, entryName)(ctx)
+		}
+	}
 
-			entry.Bootstrap(ctx)
+	for entryType, byEntryName := range boot.userEntries {
+		for entryName, e := range byEntryName {
+			boot.beforeHookF.getFunc(entryType, entryName)(ctx)
+			e.Bootstrap(ctx)
+			boot.afterHookF.getFunc(entryType, entryName)(ctx)
+		}
+	}
+
+	for entryType, byEntryName := range boot.webEntries {
+		for entryName, e := range byEntryName {
+			boot.beforeHookF.getFunc(entryType, entryName)(ctx)
+			e.Bootstrap(ctx)
+			boot.afterHookF.getFunc(entryType, entryName)(ctx)
 		}
 	}
 }
@@ -148,17 +204,7 @@ func (boot *Boot) AddShutdownHookFunc(name string, f rkentry.ShutdownHook) {
 	rkentry.GlobalAppCtx.AddShutdownHook(name, f)
 }
 
-// Interrupt entries in rkentry.GlobalAppCtx including bellow:
-//
-// Internal entries:
-// 1: rkentry.AppInfoEntry
-// 2: rkentry.ConfigEntry
-// 3: rkentry.ZapLoggerEntry
-// 4: rkentry.EventLoggerEntry
-// 5: rkentry.CertEntry
-//
-// External entries:
-// User defined entries
+// Interrupt entries as sequence of plugin, user defined and web framework
 func (boot *Boot) interrupt(ctx context.Context) {
 	defer syncLog(boot.EventId)
 
@@ -192,12 +238,12 @@ func (boot *Boot) readYAML() []byte {
 	if len(boot.bootConfigPath) < 1 {
 		boot.bootConfigPath = "boot.yaml"
 	}
-	if !path.IsAbs(boot.bootConfigPath) {
+	if !filepath.IsAbs(boot.bootConfigPath) {
 		wd, _ := os.Getwd()
-		boot.bootConfigPath = path.Join(wd, boot.bootConfigPath)
+		boot.bootConfigPath = filepath.Join(wd, boot.bootConfigPath)
 	}
 
-	res, err := ioutil.ReadFile(boot.bootConfigPath)
+	res, err := os.ReadFile(boot.bootConfigPath)
 	if err != nil {
 		rkentry.ShutdownWithError(err)
 	}
@@ -231,6 +277,6 @@ func syncLog(eventId string) {
 			event.Sync()
 		}
 
-		panic(r)
+		os.Exit(1)
 	}
 }

boot.go

@@ -9,6 +9,7 @@ import (
 	"context"
 	"embed"
 	"encoding/json"
+	"fmt"
 	"github.com/rookie-ninja/rk-entry/v2/entry"
 	"github.com/stretchr/testify/assert"
 	"syscall"
@@ -24,14 +25,25 @@ myEntry:
   enabled: true
 `
 
+	triggerBefore := false
+	triggerAfter := false
+
 	boot := NewBoot(WithBootConfigRaw([]byte(config)))
 	boot.AddShutdownHookFunc("ut-shutdown", func() {
 		// noop
 	})
+	boot.AddHookFuncBeforeBootstrap("myEntry", "ut", func(ctx context.Context) {
+		triggerBefore = true
+	})
+	boot.AddHookFuncAfterBootstrap("myEntry", "ut", func(ctx context.Context) {
+		triggerAfter = true
+	})
 
 	boot.Bootstrap(context.TODO())
 
 	assert.Len(t, rkentry.GlobalAppCtx.ListEntriesByType("myEntry"), 1)
+	assert.True(t, triggerBefore)
+	assert.True(t, triggerAfter)
 
 	go func() {
 		boot.WaitForShutdownSig(context.TODO())
@@ -51,28 +63,15 @@ func TestNewBoot_WithEmbedCase(t *testing.T) {
 	myEntry := rkentry.GlobalAppCtx.GetEntry("myEntry", "ut")
 	assert.NotNil(t, myEntry)
 
-	preCall := false
-
-	boot.AddPreloadFuncBeforeBootstrap(myEntry, func() {
-		preCall = true
-	})
-
 	boot.Bootstrap(context.TODO())
 	boot.interrupt(context.TODO())
 
-	assert.True(t, preCall)
-
 	rkentry.GlobalAppCtx.RemoveEntry(rkentry.GlobalAppCtx.GetEntry("myEntry", "ut"))
 }
 
-func TestNewBoot_EmptyConfig(t *testing.T) {
-	defer assertPanic(t)
-
-	NewBoot()
-}
-
 func assertPanic(t *testing.T) {
 	if r := recover(); r != nil {
+		fmt.Println("adsfadfafd")
 		// Expect panic to be called with non nil error
 		assert.True(t, true)
 	} else {
@@ -83,7 +82,7 @@ func assertPanic(t *testing.T) {
 
 // Register entry, must be in init() function since we need to register entry at beginning
 func init() {
-	rkentry.RegisterEntryRegFunc(RegisterMyEntriesFromConfig)
+	rkentry.RegisterUserEntryRegFunc(RegisterMyEntriesFromConfig)
 }
 
 // A struct which is for unmarshalled YAML