refactoring of ydb-go-sdk version

internal/meta/meta.go

@@ -7,6 +7,7 @@ import (
 	"google.golang.org/grpc/metadata"
 
 	"github.com/ydb-platform/ydb-go-sdk/v3/internal/credentials"
+	"github.com/ydb-platform/ydb-go-sdk/v3/internal/version"
 	"github.com/ydb-platform/ydb-go-sdk/v3/internal/xerrors"
 	"github.com/ydb-platform/ydb-go-sdk/v3/trace"
 )
@@ -83,7 +84,7 @@ func (m *Meta) meta(ctx context.Context) (_ metadata.MD, err error) {
 	}
 
 	if len(md.Get(HeaderVersion)) == 0 {
-		md.Set(HeaderVersion, "ydb-go-sdk/"+Version)
+		md.Set(HeaderVersion, "ydb-go-sdk/"+version.Version)
 	}
 
 	if m.requestsType != "" {

internal/meta/test/meta_test.go

@@ -9,6 +9,7 @@ import (
 
 	"github.com/ydb-platform/ydb-go-sdk/v3/internal/credentials"
 	internal "github.com/ydb-platform/ydb-go-sdk/v3/internal/meta"
+	"github.com/ydb-platform/ydb-go-sdk/v3/internal/version"
 	"github.com/ydb-platform/ydb-go-sdk/v3/meta"
 	"github.com/ydb-platform/ydb-go-sdk/v3/trace"
 )
@@ -45,7 +46,7 @@ func TestMetaRequiredHeaders(t *testing.T) {
 	require.Equal(t, []string{"userAgent", "user-agent"}, md.Get(internal.HeaderUserAgent))
 	require.Equal(t, []string{"traceID"}, md.Get(internal.HeaderTraceID))
 	require.Equal(t, []string{
-		"ydb-go-sdk/" + internal.VersionMajor + "." + internal.VersionMinor + "." + internal.VersionPatch,
+		"ydb-go-sdk/" + version.Major + "." + version.Minor + "." + version.Patch,
 	}, md.Get(internal.HeaderVersion))
 	require.Equal(t, []string{"some-user-value"}, md.Get("some-user-header"))
 }

internal/version/parse.go

@@ -0,0 +1,93 @@
+package version
+
+import (
+	"strconv"
+	"strings"
+
+	"github.com/ydb-platform/ydb-go-sdk/v3/internal/xerrors"
+)
+
+type version struct {
+	Major  uint64
+	Minor  uint64
+	Patch  uint64
+	Suffix string
+}
+
+func (lhs version) Less(rhs version) bool {
+	if lhs.Major < rhs.Major {
+		return true
+	}
+	if lhs.Major > rhs.Major {
+		return false
+	}
+	if lhs.Minor < rhs.Minor {
+		return true
+	}
+	if lhs.Minor > rhs.Minor {
+		return false
+	}
+	if lhs.Patch < rhs.Patch {
+		return true
+	}
+	if lhs.Patch > rhs.Patch {
+		return false
+	}
+	return lhs.Suffix < rhs.Suffix
+}
+
+// Lt compare lhs and rhs as (lhs < rhs)
+func Lt(lhs, rhs string) bool {
+	v1, err := parse(lhs)
+	if err != nil {
+		return false
+	}
+	v2, err := parse(rhs)
+	if err != nil {
+		return false
+	}
+	return v1.Less(v2)
+}
+
+// Gte compare lhs and rhs as (lhs >= rhs)
+func Gte(lhs, rhs string) bool {
+	v1, err := parse(lhs)
+	if err != nil {
+		return false
+	}
+	v2, err := parse(rhs)
+	if err != nil {
+		return false
+	}
+	if v1.Less(v2) {
+		return false
+	}
+	return true
+}
+
+func parse(s string) (v version, err error) {
+	ss := strings.SplitN(s, "-", 2)
+	if len(ss) == 2 {
+		v.Suffix = ss[1]
+	}
+	sss := strings.SplitN(ss[0], ".", 3)
+	if len(sss) == 3 {
+		v.Patch, err = strconv.ParseUint(sss[2], 10, 64)
+		if err != nil {
+			return version{}, xerrors.WithStackTrace(err)
+		}
+	}
+	if len(sss) >= 2 {
+		v.Minor, err = strconv.ParseUint(sss[1], 10, 64)
+		if err != nil {
+			return version{}, xerrors.WithStackTrace(err)
+		}
+	}
+	if len(sss) >= 1 {
+		v.Major, err = strconv.ParseUint(sss[0], 10, 64)
+		if err != nil {
+			return version{}, xerrors.WithStackTrace(err)
+		}
+	}
+	return v, nil
+}

internal/version/parse_test.go

@@ -0,0 +1,182 @@
+package version
+
+import (
+	"testing"
+
+	"github.com/stretchr/testify/require"
+)
+
+func TestParse(t *testing.T) {
+	for _, tt := range []struct {
+		s   string
+		v   version
+		err bool
+	}{
+		{
+			s:   "1",
+			v:   version{Major: 1},
+			err: false,
+		},
+		{
+			s:   "1.2",
+			v:   version{Major: 1, Minor: 2},
+			err: false,
+		},
+		{
+			s:   "1.2.3",
+			v:   version{Major: 1, Minor: 2, Patch: 3},
+			err: false,
+		},
+		{
+			s:   "1.2.3-alpha",
+			v:   version{Major: 1, Minor: 2, Patch: 3, Suffix: "alpha"},
+			err: false,
+		},
+		{
+			s:   "22.5",
+			v:   version{Major: 22, Minor: 5},
+			err: false,
+		},
+		{
+			s:   "23.1",
+			v:   version{Major: 23, Minor: 1},
+			err: false,
+		},
+		{
+			s:   "23.2",
+			v:   version{Major: 23, Minor: 2},
+			err: false,
+		},
+		{
+			s:   "trunk",
+			v:   version{},
+			err: true,
+		},
+	} {
+		t.Run(tt.s, func(t *testing.T) {
+			v, err := parse(tt.s)
+			if tt.err {
+				require.Error(t, err)
+			} else {
+				require.NoError(t, err)
+				require.Equal(t, tt.v, v)
+			}
+		})
+	}
+}
+
+func TestLt(t *testing.T) {
+	for _, tt := range []struct {
+		lhs  string
+		rhs  string
+		less bool
+	}{
+		{
+			lhs:  "1",
+			rhs:  "2",
+			less: true,
+		},
+		{
+			lhs:  "2",
+			rhs:  "1",
+			less: false,
+		},
+		{
+			lhs:  "1",
+			rhs:  "1",
+			less: false,
+		},
+		{
+			lhs:  "22.5",
+			rhs:  "23.1",
+			less: true,
+		},
+		{
+			lhs:  "23.1",
+			rhs:  "22.5",
+			less: false,
+		},
+		{
+			lhs:  "trunk",
+			rhs:  "22.5",
+			less: false,
+		},
+		{
+			lhs:  "trunk",
+			rhs:  "23.1",
+			less: false,
+		},
+		{
+			lhs:  "22.5",
+			rhs:  "trunk",
+			less: false,
+		},
+		{
+			lhs:  "23.1",
+			rhs:  "trunk",
+			less: false,
+		},
+	} {
+		t.Run("", func(t *testing.T) {
+			require.Equal(t, tt.less, Lt(tt.lhs, tt.rhs))
+		})
+	}
+}
+
+func TestGte(t *testing.T) {
+	for _, tt := range []struct {
+		lhs  string
+		rhs  string
+		less bool
+	}{
+		{
+			lhs:  "1",
+			rhs:  "2",
+			less: false,
+		},
+		{
+			lhs:  "2",
+			rhs:  "1",
+			less: true,
+		},
+		{
+			lhs:  "1",
+			rhs:  "1",
+			less: true,
+		},
+		{
+			lhs:  "22.5",
+			rhs:  "23.1",
+			less: false,
+		},
+		{
+			lhs:  "23.1",
+			rhs:  "22.5",
+			less: true,
+		},
+		{
+			lhs:  "trunk",
+			rhs:  "22.5",
+			less: false,
+		},
+		{
+			lhs:  "trunk",
+			rhs:  "23.1",
+			less: false,
+		},
+		{
+			lhs:  "22.5",
+			rhs:  "trunk",
+			less: false,
+		},
+		{
+			lhs:  "23.1",
+			rhs:  "trunk",
+			less: false,
+		},
+	} {
+		t.Run("", func(t *testing.T) {
+			require.Equal(t, tt.less, Gte(tt.lhs, tt.rhs))
+		})
+	}
+}

internal/version/version.go

@@ -0,0 +1,9 @@
+package version
+
+const (
+	Major = "3"
+	Minor = "48"
+	Patch = "8"
+)
+
+const Version = Major + "." + Minor + "." + Patch

log/discovery.go

@@ -25,14 +25,14 @@ func internalDiscovery(l *wrapper, d trace.Detailer) (t trace.Discovery) {
 		return func(info trace.DiscoveryDiscoverDoneInfo) {
 			if info.Error == nil {
 				l.Log(WithLevel(ctx, INFO), "done",
-					latency(start),
+					latencyField(start),
 					Stringer("endpoints", endpoints(info.Endpoints)),
 				)
 			} else {
 				l.Log(WithLevel(ctx, ERROR), "failed",
 					Error(info.Error),
-					latency(start),
-					version(),
+					latencyField(start),
+					versionField(),
 				)
 			}
 		}
@@ -47,15 +47,15 @@ func internalDiscovery(l *wrapper, d trace.Detailer) (t trace.Discovery) {
 		return func(info trace.DiscoveryWhoAmIDoneInfo) {
 			if info.Error == nil {
 				l.Log(ctx, "done",
-					latency(start),
+					latencyField(start),
 					String("user", info.User),
 					Strings("groups", info.Groups),
 				)
 			} else {
 				l.Log(WithLevel(ctx, WARN), "failed",
 					Error(info.Error),
-					latency(start),
-					version(),
+					latencyField(start),
+					versionField(),
 				)
 			}
 		}