feat(os/gcfg): Add file watcher with custom callback support

contrib/config/nacos/nacos.go

@@ -15,6 +15,7 @@ import (
 	"github.com/nacos-group/nacos-sdk-go/v2/common/constant"
 	"github.com/nacos-group/nacos-sdk-go/v2/vo"
 
+	"github.com/gogf/gf/v2/container/gmap"
 	"github.com/gogf/gf/v2/encoding/gjson"
 	"github.com/gogf/gf/v2/errors/gerror"
 	"github.com/gogf/gf/v2/frame/g"
@@ -32,9 +33,10 @@ type Config struct {
 
 // Client implements gcfg.Adapter implementing using nacos service.
 type Client struct {
-	config Config                      // Config object when created.
-	client config_client.IConfigClient // Nacos config client.
-	value  *g.Var                      // Configmap content cached. It is `*gjson.Json` value internally.
+	config   Config                      // Config object when created.
+	client   config_client.IConfigClient // Nacos config client.
+	value    *g.Var                      // Configmap content cached. It is `*gjson.Json` value internally.
+	watchers *gmap.StrAnyMap             // Watchers for watching file changes.
 }
 
 // New creates and returns gcfg.Adapter implementing using nacos service.
@@ -46,8 +48,9 @@ func New(ctx context.Context, config Config) (adapter gcfg.Adapter, err error) {
 	}
 
 	client := &Client{
-		config: config,
-		value:  g.NewVar(nil, true),
+		config:   config,
+		value:    g.NewVar(nil, true),
+		watchers: gmap.NewStrAnyMap(true),
 	}
 
 	client.client, err = clients.CreateConfigClient(map[string]any{
@@ -131,6 +134,13 @@ func (c *Client) addWatcher() error {
 		if c.config.OnConfigChange != nil {
 			go c.config.OnConfigChange(namespace, group, dataId, data)
 		}
+		c.watchers.Iterator(func(k string, v any) bool {
+			if watcherFunc, ok := v.(func(ctx context.Context)); ok {
+				adapterCtx := NewNacosAdapterCtx().WithOperation(OperationUpdate).WithNamespace(namespace).WithGroup(group).WithDataId(dataId).WithSetContent(data)
+				go watcherFunc(adapterCtx.Ctx)
+			}
+			return true
+		})
 	}
 
 	if err := c.client.ListenConfig(c.config.ConfigParam); err != nil {
@@ -139,3 +149,27 @@ func (c *Client) addWatcher() error {
 
 	return nil
 }
+
+func (c *Client) AddWatcher(name string, f func(ctx context.Context)) {
+	c.watchers.Set(name, f)
+}
+
+// RemoveWatcher removes the watcher for the specified configuration file.
+func (c *Client) RemoveWatcher(name string) {
+	c.watchers.Remove(name)
+}
+
+// GetWatcherNames returns all watcher names.
+func (c *Client) GetWatcherNames() []string {
+	return c.watchers.Keys()
+}
+
+// notifyWatchers notifies all watchers.
+func (c *Client) notifyWatchers(ctx context.Context) {
+	c.watchers.Iterator(func(k string, v any) bool {
+		if fn, ok := v.(func(ctx context.Context)); ok {
+			go fn(ctx)
+		}
+		return true
+	})
+}

contrib/config/nacos/nacos_adapter_ctx.go

@@ -0,0 +1,123 @@
+package nacos
+
+import (
+	"context"
+
+	"github.com/gogf/gf/v2/os/gcfg"
+	"github.com/gogf/gf/v2/os/gctx"
+)
+
+const (
+	// KeyNamespace is the context key for namespace
+	KeyNamespace gctx.StrKey = "namespace"
+	// KeyGroup is the context key for group
+	KeyGroup gctx.StrKey = "group"
+	// KeyDataId is the context key for dataId
+	KeyDataId gctx.StrKey = "dataId"
+)
+
+const (
+	// OperationUpdate represents the update operation
+	OperationUpdate = "update"
+)
+
+// NacosAdapterCtx is the context adapter for Nacos configuration
+type NacosAdapterCtx struct {
+	Ctx context.Context
+}
+
+// NewNacosAdapterCtx creates and returns a new NacosAdapterCtx.
+// If context is provided, it will be used; otherwise, a background context is created.
+func NewNacosAdapterCtx(ctx ...context.Context) *NacosAdapterCtx {
+	if len(ctx) > 0 {
+		return &NacosAdapterCtx{
+			Ctx: ctx[0],
+		}
+	}
+	return &NacosAdapterCtx{Ctx: context.Background()}
+}
+
+// GetNacosAdapterCtx creates a new NacosAdapterCtx with the given context
+func GetNacosAdapterCtx(ctx context.Context) *NacosAdapterCtx {
+	return &NacosAdapterCtx{Ctx: ctx}
+}
+
+// WithOperation sets the operation in the context
+func (n *NacosAdapterCtx) WithOperation(operation ...string) *NacosAdapterCtx {
+	if len(operation) > 0 {
+		n.Ctx = context.WithValue(n.Ctx, gcfg.OperationWrite, operation[0])
+	}
+	return n
+}
+
+// WithNamespace sets the namespace in the context
+func (n *NacosAdapterCtx) WithNamespace(namespace ...string) *NacosAdapterCtx {
+	if len(namespace) > 0 {
+		n.Ctx = context.WithValue(n.Ctx, KeyNamespace, namespace[0])
+	}
+	return n
+}
+
+// WithGroup sets the group in the context
+func (n *NacosAdapterCtx) WithGroup(group ...string) *NacosAdapterCtx {
+	if len(group) > 0 {
+		n.Ctx = context.WithValue(n.Ctx, KeyGroup, group[0])
+	}
+	return n
+}
+
+// WithDataId sets the dataId in the context
+func (n *NacosAdapterCtx) WithDataId(dataId ...string) *NacosAdapterCtx {
+	if len(dataId) > 0 {
+		n.Ctx = context.WithValue(n.Ctx, KeyDataId, dataId[0])
+	}
+	return n
+}
+
+// WithSetContent sets the content in the context
+func (n *NacosAdapterCtx) WithSetContent(content ...string) *NacosAdapterCtx {
+	if len(content) > 0 {
+		n.Ctx = context.WithValue(n.Ctx, gcfg.KeySetContent, content[0])
+	}
+	return n
+}
+
+// GetNamespace retrieves the namespace from the context
+func (n *NacosAdapterCtx) GetNamespace() string {
+	if v := n.Ctx.Value(KeyNamespace); v != nil {
+		return v.(string)
+	}
+	return ""
+}
+
+// GetGroup retrieves the group from the context
+func (n *NacosAdapterCtx) GetGroup() string {
+	if v := n.Ctx.Value(KeyGroup); v != nil {
+		return v.(string)
+	}
+	return ""
+}
+
+// GetDataId retrieves the dataId from the context
+func (n *NacosAdapterCtx) GetDataId() string {
+	if v := n.Ctx.Value(KeyDataId); v != nil {
+		return v.(string)
+	}
+	return ""
+}
+
+// GetSetContent retrieves the content from the context
+func (n *NacosAdapterCtx) GetSetContent() string {
+	if v := n.Ctx.Value(gcfg.KeySetContent); v != nil {
+		return v.(string)
+	}
+	return ""
+}
+
+// GetOperation retrieves the operation from the context
+func (n *NacosAdapterCtx) GetOperation() string {
+	if v := n.Ctx.Value(OperationUpdate); v != nil {
+		return v.(string)
+	}
+	return ""
+}

contrib/config/nacos/nacos_test.go

@@ -7,6 +7,7 @@
 package nacos_test
 
 import (
+	"context"
 	"net/url"
 	"testing"
 	"time"
@@ -16,6 +17,7 @@ import (
 
 	"github.com/gogf/gf/v2/encoding/gjson"
 	"github.com/gogf/gf/v2/frame/g"
+	"github.com/gogf/gf/v2/os/gcfg"
 	"github.com/gogf/gf/v2/os/gctx"
 	"github.com/gogf/gf/v2/test/gtest"
 	"github.com/gogf/gf/v2/util/guid"
@@ -76,6 +78,16 @@ func TestNacosOnConfigChangeFunc(t *testing.T) {
 				gtest.Assert("gf", g.Cfg().MustGet(gctx.GetInitCtx(), "app.name").String())
 			},
 		})
+		if watcherAdapter, ok := adapter.(gcfg.WatcherAdapter); ok {
+			watcherAdapter.AddWatcher("test", func(ctx context.Context) {
+				adapterCtx := nacos.GetNacosAdapterCtx(ctx)
+				gtest.Assert("public", adapterCtx.GetNamespace())
+				gtest.Assert("test", adapterCtx.GetGroup())
+				gtest.Assert("config.toml", adapterCtx.GetDataId())
+				gtest.Assert(nacos.OperationUpdate, adapterCtx.GetOperation())
+				gtest.Assert("gf", g.Cfg().MustGet(gctx.GetInitCtx(), "app.name").String())
+			})
+		}
 		g.Cfg().SetAdapter(adapter)
 		t.Assert(g.Cfg().Available(ctx), true)
 		appName, err := g.Cfg().Get(ctx, "app.name")
@@ -97,5 +109,8 @@ func TestNacosOnConfigChangeFunc(t *testing.T) {
 		t.AssertNil(err)
 		_, err = g.Client().Post(ctx, configPublishUrl+"&content="+url.QueryEscape(res2))
 		t.AssertNil(err)
+		if watcherAdapter, ok := adapter.(gcfg.WatcherAdapter); ok {
+			t.Assert(watcherAdapter.GetWatcherNames()[0], "test")
+		}
 	})
 }

os/gcfg/gcfg_adaper.go

@@ -28,3 +28,13 @@ type Adapter interface {
 	// you can implement this function if necessary.
 	Data(ctx context.Context) (data map[string]any, err error)
 }
+
+// WatcherAdapter is the interface for configuration watcher.
+type WatcherAdapter interface {
+	// AddWatcher adds a watcher function for specified `pattern` and `resource`.
+	AddWatcher(name string, fn func(ctx context.Context))
+	// RemoveWatcher removes the watcher function for specified `pattern` and `resource`.
+	RemoveWatcher(name string)
+	// GetWatcherNames returns all watcher names.
+	GetWatcherNames() []string
+}

os/gcfg/gcfg_adapter_content.go

@@ -9,6 +9,7 @@ package gcfg
 import (
 	"context"
 
+	"github.com/gogf/gf/v2/container/gmap"
 	"github.com/gogf/gf/v2/container/gvar"
 	"github.com/gogf/gf/v2/encoding/gjson"
 	"github.com/gogf/gf/v2/errors/gerror"
@@ -17,14 +18,16 @@ import (
 // AdapterContent implements interface Adapter using content.
 // The configuration content supports the coding types as package `gjson`.
 type AdapterContent struct {
-	jsonVar *gvar.Var // The pared JSON object for configuration content, type: *gjson.Json.
+	jsonVar  *gvar.Var       // The pared JSON object for configuration content, type: *gjson.Json.
+	watchers *gmap.StrAnyMap // Watchers for watching file changes.
 }
 
 // NewAdapterContent returns a new configuration management object using custom content.
 // The parameter `content` specifies the default configuration content for reading.
 func NewAdapterContent(content ...string) (*AdapterContent, error) {
 	a := &AdapterContent{
-		jsonVar: gvar.New(nil, true),
+		jsonVar:  gvar.New(nil, true),
+		watchers: gmap.NewStrAnyMap(true),
 	}
 	if len(content) > 0 {
 		if err := a.SetContent(content[0]); err != nil {
@@ -42,6 +45,8 @@ func (a *AdapterContent) SetContent(content string) error {
 		return gerror.Wrap(err, `load configuration content failed`)
 	}
 	a.jsonVar.Set(j)
+	adapterCtx := NewAdapterContentCtx().WithOperation(OperationSet).WithSetContent(content)
+	a.notifyWatchers(adapterCtx.Ctx)
 	return nil
 }
 
@@ -74,3 +79,28 @@ func (a *AdapterContent) Data(ctx context.Context) (data map[string]any, err err
 	}
 	return a.jsonVar.Val().(*gjson.Json).Var().Map(), nil
 }
+
+// AddWatcher adds a watcher for the specified configuration file.
+func (a *AdapterContent) AddWatcher(name string, fn func(ctx context.Context)) {
+	a.watchers.Set(name, fn)
+}
+
+// RemoveWatcher removes the watcher for the specified configuration file.
+func (a *AdapterContent) RemoveWatcher(name string) {
+	a.watchers.Remove(name)
+}
+
+// GetWatcherNames returns all watcher names.
+func (a *AdapterContent) GetWatcherNames() []string {
+	return a.watchers.Keys()
+}
+
+// notifyWatchers notifies all watchers.
+func (a *AdapterContent) notifyWatchers(ctx context.Context) {
+	a.watchers.Iterator(func(k string, v any) bool {
+		if fn, ok := v.(func(ctx context.Context)); ok {
+			go fn(ctx)
+		}
+		return true
+	})
+}

os/gcfg/gcfg_adapter_content_ctx.go

@@ -0,0 +1,70 @@
+// Copyright GoFrame Author(https://goframe.org). All Rights Reserved.
+//
+// This Source Code Form is subject to the terms of the MIT License.
+// If a copy of the MIT was not distributed with this file,
+// You can obtain one at https://github.com/gogf/gf.
+
+// Package gcfg provides reading, caching and managing for configuration.
+package gcfg
+
+import (
+	"context"
+)
+
+// AdapterContentCtx is the context for AdapterContent.
+type AdapterContentCtx struct {
+	// Ctx is the context with configuration values
+	Ctx context.Context
+}
+
+// NewAdapterContentCtx creates and returns a new AdapterContentCtx.
+// If ctx is provided, it uses that context, otherwise it creates a background context.
+func NewAdapterContentCtx(ctx ...context.Context) *AdapterContentCtx {
+	if len(ctx) > 0 {
+		return &AdapterContentCtx{
+			Ctx: ctx[0],
+		}
+	}
+	return &AdapterContentCtx{Ctx: context.Background()}
+}
+
+// GetAdapterContentCtx creates and returns an AdapterContentCtx with the given context.
+func GetAdapterContentCtx(ctx context.Context) *AdapterContentCtx {
+	return &AdapterContentCtx{Ctx: ctx}
+}
+
+// WithOperation sets the operation in the context and returns the updated AdapterContentCtx.
+// If operation is not provided, it does nothing.
+func (a *AdapterContentCtx) WithOperation(operation ...string) *AdapterContentCtx {
+	if len(operation) > 0 {
+		a.Ctx = context.WithValue(a.Ctx, KeyOperation, operation[0])
+	}
+	return a
+}
+
+// WithSetContent sets the content in the context and returns the updated AdapterContentCtx.
+// If content is not provided, it does nothing.
+func (a *AdapterContentCtx) WithSetContent(content ...string) *AdapterContentCtx {
+	if len(content) > 0 {
+		a.Ctx = context.WithValue(a.Ctx, KeySetContent, content[0])
+	}
+	return a
+}
+
+// GetOperation retrieves the operation from the context.
+// Returns empty string if not found.
+func (a *AdapterContentCtx) GetOperation() string {
+	if v := a.Ctx.Value(KeyOperation); v != nil {
+		return v.(string)
+	}
+	return ""
+}
+
+// GetSetContent retrieves the content from the context.
+// Returns empty string if not found.
+func (a *AdapterContentCtx) GetSetContent() string {
+	if v := a.Ctx.Value(KeySetContent); v != nil {
+		return v.(string)
+	}
+	return ""
+}