As for interface casting

Co-authored-by: Gorbunov Kirill Andreevich <kgorbunov@mtsbank.ru>
Reviewed-on: #299
Co-authored-by: Кирилл Горбунов <kirya_gorbunov_2015@mail.ru>
Co-committed-by: Кирилл Горбунов <kirya_gorbunov_2015@mail.ru>

logger/logger_test.go

@@ -1,138 +0,0 @@
-package logger
-
-import (
-	"bytes"
-	"context"
-	"log"
-	"testing"
-)
-
-func TestContext(t *testing.T) {
-	ctx := context.TODO()
-	buf := bytes.NewBuffer(nil)
-	l := NewLogger(WithLevel(TraceLevel), WithOutput(buf))
-	if err := l.Init(); err != nil {
-		t.Fatal(err)
-	}
-
-	nl, ok := FromContext(NewContext(ctx, l.Fields("key", "val")))
-	if !ok {
-		t.Fatal("context without logger")
-	}
-	nl.Info(ctx, "message")
-	if !bytes.Contains(buf.Bytes(), []byte(`"key":"val"`)) {
-		t.Fatalf("logger fields not works, buf contains: %s", buf.Bytes())
-	}
-}
-
-func TestFields(t *testing.T) {
-	ctx := context.TODO()
-	buf := bytes.NewBuffer(nil)
-	l := NewLogger(WithLevel(TraceLevel), WithOutput(buf))
-	if err := l.Init(); err != nil {
-		t.Fatal(err)
-	}
-
-	nl := l.Fields("key", "val")
-
-	nl.Info(ctx, "message")
-	if !bytes.Contains(buf.Bytes(), []byte(`"key":"val"`)) {
-		t.Fatalf("logger fields not works, buf contains: %s", buf.Bytes())
-	}
-}
-
-func TestFromContextWithFields(t *testing.T) {
-	ctx := context.TODO()
-	buf := bytes.NewBuffer(nil)
-	var ok bool
-	l := NewLogger(WithLevel(TraceLevel), WithOutput(buf))
-	if err := l.Init(); err != nil {
-		t.Fatal(err)
-	}
-	nl := l.Fields("key", "val")
-
-	ctx = NewContext(ctx, nl)
-
-	l, ok = FromContext(ctx)
-	if !ok {
-		t.Fatalf("context does not have logger")
-	}
-
-	l.Info(ctx, "message")
-	if !bytes.Contains(buf.Bytes(), []byte(`"key":"val"`)) {
-		t.Fatalf("logger fields not works, buf contains: %s", buf.Bytes())
-	}
-}
-
-func TestClone(t *testing.T) {
-	ctx := context.TODO()
-	buf := bytes.NewBuffer(nil)
-	l := NewLogger(WithLevel(TraceLevel), WithOutput(buf))
-	if err := l.Init(); err != nil {
-		t.Fatal(err)
-	}
-	nl := l.Clone(WithLevel(ErrorLevel))
-	if err := nl.Init(); err != nil {
-		t.Fatal(err)
-	}
-	nl.Info(ctx, "info message")
-	if len(buf.Bytes()) != 0 {
-		t.Fatal("message must not be logged")
-	}
-	l.Info(ctx, "info message")
-	if len(buf.Bytes()) == 0 {
-		t.Fatal("message must be logged")
-	}
-}
-
-func TestRedirectStdLogger(t *testing.T) {
-	buf := bytes.NewBuffer(nil)
-	l := NewLogger(WithLevel(TraceLevel), WithOutput(buf))
-	if err := l.Init(); err != nil {
-		t.Fatal(err)
-	}
-	fn := RedirectStdLogger(l, ErrorLevel)
-	defer fn()
-	log.Print("test")
-	if !bytes.Contains(buf.Bytes(), []byte(`"level":"error","msg":"test","timestamp"`)) {
-		t.Fatalf("logger error, buf %s", buf.Bytes())
-	}
-}
-
-func TestStdLogger(t *testing.T) {
-	buf := bytes.NewBuffer(nil)
-	l := NewLogger(WithLevel(TraceLevel), WithOutput(buf))
-	if err := l.Init(); err != nil {
-		t.Fatal(err)
-	}
-	lg := NewStdLogger(l, ErrorLevel)
-	lg.Print("test")
-	if !bytes.Contains(buf.Bytes(), []byte(`"level":"error","msg":"test","timestamp"`)) {
-		t.Fatalf("logger error, buf %s", buf.Bytes())
-	}
-}
-
-func TestLogger(t *testing.T) {
-	ctx := context.TODO()
-	buf := bytes.NewBuffer(nil)
-	l := NewLogger(WithLevel(TraceLevel), WithOutput(buf))
-	if err := l.Init(); err != nil {
-		t.Fatal(err)
-	}
-	l.Trace(ctx, "trace_msg1")
-	l.Warn(ctx, "warn_msg1")
-	l.Fields("error", "test").Info(ctx, "error message")
-	l.Warn(ctx, "first", " ", "second")
-	if !bytes.Contains(buf.Bytes(), []byte(`"level":"trace","msg":"trace_msg1"`)) {
-		t.Fatalf("logger error, buf %s", buf.Bytes())
-	}
-	if !bytes.Contains(buf.Bytes(), []byte(`"warn","msg":"warn_msg1"`)) {
-		t.Fatalf("logger error, buf %s", buf.Bytes())
-	}
-	if !bytes.Contains(buf.Bytes(), []byte(`"error":"test","level":"info","msg":"error message"`)) {
-		t.Fatalf("logger error, buf %s", buf.Bytes())
-	}
-	if !bytes.Contains(buf.Bytes(), []byte(`"level":"warn","msg":"first second"`)) {
-		t.Fatalf("logger error, buf %s", buf.Bytes())
-	}
-}

logger/slog/slog.go

@@ -7,6 +7,7 @@ import (
 	"os"
 	"runtime"
 	"strconv"
+	"sync"
 	"time"
 
 	"go.unistack.org/micro/v3/logger"
@@ -72,9 +73,11 @@ type slogLogger struct {
 	sourceKey  string
 	timeKey    string
 	opts       logger.Options
+	mu         sync.RWMutex
 }
 
 func (s *slogLogger) Clone(opts ...logger.Option) logger.Logger {
+	s.mu.RLock()
 	options := s.opts
 
 	for _, o := range opts {
@@ -112,6 +115,8 @@ func (s *slogLogger) Clone(opts ...logger.Option) logger.Logger {
 	handler := slog.NewJSONHandler(options.Out, handleOpt)
 	l.slog = slog.New(handler).With(options.Fields...)
 
+	s.mu.RUnlock()
+
 	return l
 }
 
@@ -128,6 +133,7 @@ func (s *slogLogger) Options() logger.Options {
 }
 
 func (s *slogLogger) Fields(attrs ...interface{}) logger.Logger {
+	s.mu.RLock()
 	nl := &slogLogger{
 		opts:       s.opts,
 		levelKey:   s.levelKey,
@@ -140,17 +146,20 @@ func (s *slogLogger) Fields(attrs ...interface{}) logger.Logger {
 
 	handleOpt := &slog.HandlerOptions{
 		ReplaceAttr: nl.renameAttr,
-		Level:       s.leveler,
+		Level:       nl.leveler,
 		AddSource:   true,
 	}
 
 	handler := slog.NewJSONHandler(s.opts.Out, handleOpt)
 	nl.slog = slog.New(handler).With(attrs...)
 
+	s.mu.RUnlock()
+
 	return nl
 }
 
 func (s *slogLogger) Init(opts ...logger.Option) error {
+	s.mu.Lock()
 	for _, o := range opts {
 		o(&s.opts)
 	}
@@ -180,6 +189,8 @@ func (s *slogLogger) Init(opts ...logger.Option) error {
 
 	slog.SetDefault(s.slog)
 
+	s.mu.Unlock()
+
 	return nil
 }
 

micro.go

@@ -0,0 +1,94 @@
+package micro
+
+import (
+	"reflect"
+
+	"go.unistack.org/micro/v3/broker"
+	"go.unistack.org/micro/v3/client"
+	"go.unistack.org/micro/v3/codec"
+	"go.unistack.org/micro/v3/flow"
+	"go.unistack.org/micro/v3/fsm"
+	"go.unistack.org/micro/v3/logger"
+	"go.unistack.org/micro/v3/meter"
+	"go.unistack.org/micro/v3/register"
+	"go.unistack.org/micro/v3/resolver"
+	"go.unistack.org/micro/v3/router"
+	"go.unistack.org/micro/v3/selector"
+	"go.unistack.org/micro/v3/server"
+	"go.unistack.org/micro/v3/store"
+	"go.unistack.org/micro/v3/sync"
+	"go.unistack.org/micro/v3/tracer"
+)
+
+func As(b any, target any) bool {
+	if b == nil {
+		return false
+	}
+	if target == nil {
+		return false
+	}
+	val := reflect.ValueOf(target)
+	typ := val.Type()
+	if typ.Kind() != reflect.Ptr || val.IsNil() {
+		return false
+	}
+	targetType := typ.Elem()
+	if targetType.Kind() != reflect.Interface {
+		switch {
+		case targetType.Implements(brokerType):
+			break
+		case targetType.Implements(loggerType):
+			break
+		case targetType.Implements(clientType):
+			break
+		case targetType.Implements(serverType):
+			break
+		case targetType.Implements(codecType):
+			break
+		case targetType.Implements(flowType):
+			break
+		case targetType.Implements(fsmType):
+			break
+		case targetType.Implements(meterType):
+			break
+		case targetType.Implements(registerType):
+			break
+		case targetType.Implements(resolverType):
+			break
+		case targetType.Implements(selectorType):
+			break
+		case targetType.Implements(storeType):
+			break
+		case targetType.Implements(syncType):
+			break
+		case targetType.Implements(serviceType):
+			break
+		case targetType.Implements(routerType):
+			break
+		default:
+			return false
+		}
+	}
+	if reflect.TypeOf(b).AssignableTo(targetType) {
+		val.Elem().Set(reflect.ValueOf(b))
+		return true
+	}
+	return false
+}
+
+var brokerType = reflect.TypeOf((*broker.Broker)(nil)).Elem()
+var loggerType = reflect.TypeOf((*logger.Logger)(nil)).Elem()
+var clientType = reflect.TypeOf((*client.Client)(nil)).Elem()
+var serverType = reflect.TypeOf((*server.Server)(nil)).Elem()
+var codecType = reflect.TypeOf((*codec.Codec)(nil)).Elem()
+var flowType = reflect.TypeOf((*flow.Flow)(nil)).Elem()
+var fsmType = reflect.TypeOf((*fsm.FSM)(nil)).Elem()
+var meterType = reflect.TypeOf((*meter.Meter)(nil)).Elem()
+var registerType = reflect.TypeOf((*register.Register)(nil)).Elem()
+var resolverType = reflect.TypeOf((*resolver.Resolver)(nil)).Elem()
+var routerType = reflect.TypeOf((*router.Router)(nil)).Elem()
+var selectorType = reflect.TypeOf((*selector.Selector)(nil)).Elem()
+var storeType = reflect.TypeOf((*store.Store)(nil)).Elem()
+var syncType = reflect.TypeOf((*sync.Sync)(nil)).Elem()
+var tracerType = reflect.TypeOf((*tracer.Tracer)(nil)).Elem()
+var serviceType = reflect.TypeOf((*Service)(nil)).Elem()

micro_test.go

@@ -0,0 +1,115 @@
+package micro
+
+import (
+	"context"
+	"fmt"
+	"reflect"
+	"testing"
+
+	"go.unistack.org/micro/v3/broker"
+	"go.unistack.org/micro/v3/fsm"
+)
+
+func TestAs(t *testing.T) {
+	var b *bro
+	broTarget := &bro{name: "kafka"}
+	fsmTarget := &fsmT{name: "fsm"}
+
+	testCases := []struct {
+		b      any
+		target any
+		match  bool
+		want   any
+	}{
+		{
+			broTarget,
+			&b,
+			true,
+			broTarget,
+		},
+		{
+			nil,
+			&b,
+			false,
+			nil,
+		},
+		{
+			fsmTarget,
+			&b,
+			false,
+			nil,
+		},
+	}
+	for i, tc := range testCases {
+		name := fmt.Sprintf("%d:As(Errorf(..., %v), %v)", i, tc.b, tc.target)
+		// Clear the target pointer, in case it was set in a previous test.
+		rtarget := reflect.ValueOf(tc.target)
+		rtarget.Elem().Set(reflect.Zero(reflect.TypeOf(tc.target).Elem()))
+		t.Run(name, func(t *testing.T) {
+			match := As(tc.b, tc.target)
+			if match != tc.match {
+				t.Fatalf("match: got %v; want %v", match, tc.match)
+			}
+			if !match {
+				return
+			}
+			if got := rtarget.Elem().Interface(); got != tc.want {
+				t.Fatalf("got %#v, want %#v", got, tc.want)
+			}
+		})
+	}
+}
+
+type bro struct {
+	name string
+}
+
+func (p *bro) Name() string { return p.name }
+
+func (p *bro) Init(opts ...broker.Option) error { return nil }
+
+// Options returns broker options
+func (p *bro) Options() broker.Options { return broker.Options{} }
+
+// Address return configured address
+func (p *bro) Address() string { return "" }
+
+// Connect connects to broker
+func (p *bro) Connect(ctx context.Context) error { return nil }
+
+// Disconnect disconnect from broker
+func (p *bro) Disconnect(ctx context.Context) error { return nil }
+
+// Publish message, msg can be single broker.Message or []broker.Message
+func (p *bro) Publish(ctx context.Context, topic string, msg *broker.Message, opts ...broker.PublishOption) error {
+	return nil
+}
+
+// BatchPublish messages to broker with multiple topics
+func (p *bro) BatchPublish(ctx context.Context, msgs []*broker.Message, opts ...broker.PublishOption) error {
+	return nil
+}
+
+// BatchSubscribe subscribes to topic messages via handler
+func (p *bro) BatchSubscribe(ctx context.Context, topic string, h broker.BatchHandler, opts ...broker.SubscribeOption) (broker.Subscriber, error) {
+	return nil, nil
+}
+
+// Subscribe subscribes to topic message via handler
+func (p *bro) Subscribe(ctx context.Context, topic string, handler broker.Handler, opts ...broker.SubscribeOption) (broker.Subscriber, error) {
+	return nil, nil
+}
+
+// String type of broker
+func (p *bro) String() string { return p.name }
+
+type fsmT struct {
+	name string
+}
+
+func (f *fsmT) Start(ctx context.Context, a interface{}, o ...Option) (interface{}, error) {
+	return nil, nil
+}
+func (f *fsmT) Current() string                  { return f.name }
+func (f *fsmT) Reset()                           {}
+func (f *fsmT) State(s string, sf fsm.StateFunc) {}