repo stringlengths 6 47 | file_url stringlengths 77 269 | file_path stringlengths 5 186 | content stringlengths 0 32.8k | language stringclasses 1
value | license stringclasses 7
values | commit_sha stringlengths 40 40 | retrieved_at stringdate 2026-01-07 08:35:43 2026-01-07 08:55:24 | truncated bool 2
classes |
|---|---|---|---|---|---|---|---|---|
zeromicro/go-zero | https://github.com/zeromicro/go-zero/blob/8e7e5695eb2095917864b5d6615dab4c90bde3ac/zrpc/resolver/internal/register_k8s.go | zrpc/resolver/internal/register_k8s.go | //go:build !no_k8s
package internal
import "google.golang.org/grpc/resolver"
var k8sResolverBuilder kubeBuilder
// RegisterResolver registers the direct, etcd, discov and k8s schemes to the resolver.
func RegisterResolver() {
register()
resolver.Register(&k8sResolverBuilder)
}
| go | MIT | 8e7e5695eb2095917864b5d6615dab4c90bde3ac | 2026-01-07T08:36:18.042207Z | false |
zeromicro/go-zero | https://github.com/zeromicro/go-zero/blob/8e7e5695eb2095917864b5d6615dab4c90bde3ac/zrpc/resolver/internal/etcdbuilder.go | zrpc/resolver/internal/etcdbuilder.go | package internal
type etcdBuilder struct {
discovBuilder
}
func (b *etcdBuilder) Scheme() string {
return EtcdScheme
}
| go | MIT | 8e7e5695eb2095917864b5d6615dab4c90bde3ac | 2026-01-07T08:36:18.042207Z | false |
zeromicro/go-zero | https://github.com/zeromicro/go-zero/blob/8e7e5695eb2095917864b5d6615dab4c90bde3ac/zrpc/resolver/internal/resolver.go | zrpc/resolver/internal/resolver.go | package internal
import (
"fmt"
"google.golang.org/grpc/resolver"
)
const (
// DirectScheme stands for direct scheme.
DirectScheme = "direct"
// DiscovScheme stands for discov scheme.
DiscovScheme = "discov"
// EtcdScheme stands for etcd scheme.
EtcdScheme = "etcd"
// KubernetesScheme stands for k8s scheme.
KubernetesScheme = "k8s"
// EndpointSepChar is the separator cha in endpoints.
EndpointSepChar = ','
subsetSize = 32
)
var (
// EndpointSep is the separator string in endpoints.
EndpointSep = fmt.Sprintf("%c", EndpointSepChar)
directResolverBuilder directBuilder
discovResolverBuilder discovBuilder
etcdResolverBuilder etcdBuilder
)
func register() {
resolver.Register(&directResolverBuilder)
resolver.Register(&discovResolverBuilder)
resolver.Register(&etcdResolverBuilder)
}
type nopResolver struct {
cc resolver.ClientConn
}
func (r *nopResolver) Close() {
}
func (r *nopResolver) ResolveNow(_ resolver.ResolveNowOptions) {
}
| go | MIT | 8e7e5695eb2095917864b5d6615dab4c90bde3ac | 2026-01-07T08:36:18.042207Z | false |
zeromicro/go-zero | https://github.com/zeromicro/go-zero/blob/8e7e5695eb2095917864b5d6615dab4c90bde3ac/zrpc/resolver/internal/register.go | zrpc/resolver/internal/register.go | //go:build no_k8s
package internal
// RegisterResolver registers the direct, etcd and discov schemes to the resolver.
func RegisterResolver() {
register()
}
| go | MIT | 8e7e5695eb2095917864b5d6615dab4c90bde3ac | 2026-01-07T08:36:18.042207Z | false |
zeromicro/go-zero | https://github.com/zeromicro/go-zero/blob/8e7e5695eb2095917864b5d6615dab4c90bde3ac/zrpc/resolver/internal/resolver_test.go | zrpc/resolver/internal/resolver_test.go | package internal
import (
"testing"
"github.com/stretchr/testify/assert"
"google.golang.org/grpc/resolver"
"google.golang.org/grpc/serviceconfig"
)
func TestNopResolver(t *testing.T) {
assert.NotPanics(t, func() {
RegisterResolver()
// make sure ResolveNow & Close don't panic
var r nopResolver
r.ResolveNow(resolver.ResolveNowOptions{})
r.Close()
})
}
type mockedClientConn struct {
state resolver.State
err error
}
func (m *mockedClientConn) UpdateState(state resolver.State) error {
m.state = state
return m.err
}
func (m *mockedClientConn) ReportError(_ error) {
}
func (m *mockedClientConn) NewAddress(_ []resolver.Address) {
}
func (m *mockedClientConn) NewServiceConfig(_ string) {
}
func (m *mockedClientConn) ParseServiceConfig(_ string) *serviceconfig.ParseResult {
return nil
}
| go | MIT | 8e7e5695eb2095917864b5d6615dab4c90bde3ac | 2026-01-07T08:36:18.042207Z | false |
zeromicro/go-zero | https://github.com/zeromicro/go-zero/blob/8e7e5695eb2095917864b5d6615dab4c90bde3ac/zrpc/resolver/internal/subset_test.go | zrpc/resolver/internal/subset_test.go | package internal
import (
"strconv"
"testing"
"github.com/stretchr/testify/assert"
"github.com/zeromicro/go-zero/core/mathx"
)
func TestSubset(t *testing.T) {
tests := []struct {
name string
set int
sub int
}{
{
name: "more vals to subset",
set: 100,
sub: 36,
},
{
name: "less vals to subset",
set: 100,
sub: 200,
},
}
for _, test := range tests {
test := test
t.Run(test.name, func(t *testing.T) {
var vals []string
for i := 0; i < test.set; i++ {
vals = append(vals, strconv.Itoa(i))
}
m := make(map[any]int)
for i := 0; i < 1000; i++ {
set := subset(append([]string(nil), vals...), test.sub)
if test.sub < test.set {
assert.Equal(t, test.sub, len(set))
} else {
assert.Equal(t, test.set, len(set))
}
for _, val := range set {
m[val]++
}
}
assert.True(t, mathx.CalcEntropy(m) > 0.95)
})
}
}
| go | MIT | 8e7e5695eb2095917864b5d6615dab4c90bde3ac | 2026-01-07T08:36:18.042207Z | false |
zeromicro/go-zero | https://github.com/zeromicro/go-zero/blob/8e7e5695eb2095917864b5d6615dab4c90bde3ac/zrpc/resolver/internal/directbuilder.go | zrpc/resolver/internal/directbuilder.go | package internal
import (
"strings"
"github.com/zeromicro/go-zero/zrpc/resolver/internal/targets"
"google.golang.org/grpc/resolver"
)
type directBuilder struct{}
func (d *directBuilder) Build(target resolver.Target, cc resolver.ClientConn, _ resolver.BuildOptions) (
resolver.Resolver, error) {
endpoints := strings.FieldsFunc(targets.GetEndpoints(target), func(r rune) bool {
return r == EndpointSepChar
})
endpoints = subset(endpoints, subsetSize)
addrs := make([]resolver.Address, 0, len(endpoints))
for _, val := range endpoints {
addrs = append(addrs, resolver.Address{
Addr: val,
})
}
if err := cc.UpdateState(resolver.State{
Addresses: addrs,
}); err != nil {
return nil, err
}
return &nopResolver{cc: cc}, nil
}
func (d *directBuilder) Scheme() string {
return DirectScheme
}
| go | MIT | 8e7e5695eb2095917864b5d6615dab4c90bde3ac | 2026-01-07T08:36:18.042207Z | false |
zeromicro/go-zero | https://github.com/zeromicro/go-zero/blob/8e7e5695eb2095917864b5d6615dab4c90bde3ac/zrpc/resolver/internal/discovbuilder_test.go | zrpc/resolver/internal/discovbuilder_test.go | package internal
import (
"fmt"
"net/url"
"strings"
"testing"
"github.com/stretchr/testify/assert"
"go.etcd.io/etcd/client/v3/mock/mockserver"
"google.golang.org/grpc/resolver"
"google.golang.org/grpc/serviceconfig"
)
func TestDiscovBuilder_Scheme(t *testing.T) {
var b discovBuilder
assert.Equal(t, DiscovScheme, b.Scheme())
}
func TestDiscovBuilder_Build(t *testing.T) {
servers, err := mockserver.StartMockServers(2)
assert.NoError(t, err)
t.Cleanup(func() {
servers.Stop()
})
var addrs []string
for _, server := range servers.Servers {
addrs = append(addrs, server.Address)
}
u, err := url.Parse(fmt.Sprintf("%s://%s", DiscovScheme, strings.Join(addrs, ",")))
assert.NoError(t, err)
var b discovBuilder
_, err = b.Build(resolver.Target{
URL: *u,
}, mockClientConn{}, resolver.BuildOptions{})
assert.Error(t, err)
}
type mockClientConn struct{}
func (m mockClientConn) UpdateState(_ resolver.State) error {
return nil
}
func (m mockClientConn) ReportError(_ error) {
}
func (m mockClientConn) NewAddress(_ []resolver.Address) {
}
func (m mockClientConn) NewServiceConfig(_ string) {
}
func (m mockClientConn) ParseServiceConfig(_ string) *serviceconfig.ParseResult {
return nil
}
| go | MIT | 8e7e5695eb2095917864b5d6615dab4c90bde3ac | 2026-01-07T08:36:18.042207Z | false |
zeromicro/go-zero | https://github.com/zeromicro/go-zero/blob/8e7e5695eb2095917864b5d6615dab4c90bde3ac/zrpc/resolver/internal/kubebuilder.go | zrpc/resolver/internal/kubebuilder.go | //go:build !no_k8s
package internal
import (
"context"
"fmt"
"time"
"github.com/zeromicro/go-zero/core/logx"
"github.com/zeromicro/go-zero/core/threading"
"github.com/zeromicro/go-zero/zrpc/resolver/internal/kube"
"google.golang.org/grpc/resolver"
v1 "k8s.io/apimachinery/pkg/apis/meta/v1"
"k8s.io/client-go/informers"
"k8s.io/client-go/kubernetes"
"k8s.io/client-go/rest"
)
const (
resyncInterval = 5 * time.Minute
serviceSelector = "kubernetes.io/service-name="
)
type kubeResolver struct {
cc resolver.ClientConn
inf informers.SharedInformerFactory
stopCh chan struct{}
}
func (r *kubeResolver) Close() {
close(r.stopCh)
}
func (r *kubeResolver) ResolveNow(_ resolver.ResolveNowOptions) {}
func (r *kubeResolver) start() {
threading.GoSafe(func() {
r.inf.Start(r.stopCh)
})
}
type kubeBuilder struct{}
func (b *kubeBuilder) Build(target resolver.Target, cc resolver.ClientConn,
_ resolver.BuildOptions) (resolver.Resolver, error) {
svc, err := kube.ParseTarget(target)
if err != nil {
return nil, err
}
config, err := rest.InClusterConfig()
if err != nil {
return nil, err
}
cs, err := kubernetes.NewForConfig(config)
if err != nil {
return nil, err
}
if svc.Port == 0 {
endpointSlices, err := cs.DiscoveryV1().EndpointSlices(svc.Namespace).List(context.Background(),
v1.ListOptions{
LabelSelector: serviceSelector + svc.Name,
})
if err != nil {
return nil, err
}
if len(endpointSlices.Items) == 0 {
return nil, fmt.Errorf("no endpoint slices found for service %s in namespace %s",
svc.Name, svc.Namespace)
}
// Find the first slice with a valid port.
// Since this resolver is used for in-cluster service discovery,
// we expect at least one port to be available.
var foundPort bool
for _, slice := range endpointSlices.Items {
if len(slice.Ports) > 0 && slice.Ports[0].Port != nil {
svc.Port = int(*slice.Ports[0].Port)
foundPort = true
break
}
}
if !foundPort {
return nil, fmt.Errorf("no valid port found in endpoint slices for service %s in namespace %s",
svc.Name, svc.Namespace)
}
}
handler := kube.NewEventHandler(func(endpoints []string) {
endpoints = subset(endpoints, subsetSize)
addrs := make([]resolver.Address, 0, len(endpoints))
for _, val := range endpoints {
addrs = append(addrs, resolver.Address{
Addr: fmt.Sprintf("%s:%d", val, svc.Port),
})
}
if err := cc.UpdateState(resolver.State{
Addresses: addrs,
}); err != nil {
logx.Error(err)
}
})
inf := informers.NewSharedInformerFactoryWithOptions(cs, resyncInterval,
informers.WithNamespace(svc.Namespace),
informers.WithTweakListOptions(func(options *v1.ListOptions) {
options.LabelSelector = serviceSelector + svc.Name
}))
in := inf.Discovery().V1().EndpointSlices()
_, err = in.Informer().AddEventHandler(handler)
if err != nil {
return nil, err
}
// get the initial endpoint slices, cannot use the previous endpoint slices,
// because the endpoint slices may be updated before/after the informer is started.
endpointSlices, err := cs.DiscoveryV1().EndpointSlices(svc.Namespace).List(
context.Background(), v1.ListOptions{
LabelSelector: serviceSelector + svc.Name,
})
if err != nil {
return nil, err
}
// Aggregate endpoints from all EndpointSlices.
// Use OnAdd (not Update) to accumulate addresses across multiple slices.
for _, endpointSlice := range endpointSlices.Items {
handler.OnAdd(&endpointSlice, false)
}
r := &kubeResolver{
cc: cc,
inf: inf,
stopCh: make(chan struct{}),
}
r.start()
return r, nil
}
func (b *kubeBuilder) Scheme() string {
return KubernetesScheme
}
| go | MIT | 8e7e5695eb2095917864b5d6615dab4c90bde3ac | 2026-01-07T08:36:18.042207Z | false |
zeromicro/go-zero | https://github.com/zeromicro/go-zero/blob/8e7e5695eb2095917864b5d6615dab4c90bde3ac/zrpc/resolver/internal/etcdbuilder_test.go | zrpc/resolver/internal/etcdbuilder_test.go | package internal
import (
"testing"
"github.com/stretchr/testify/assert"
)
func TestEtcdBuilder_Scheme(t *testing.T) {
assert.Equal(t, EtcdScheme, new(etcdBuilder).Scheme())
}
| go | MIT | 8e7e5695eb2095917864b5d6615dab4c90bde3ac | 2026-01-07T08:36:18.042207Z | false |
zeromicro/go-zero | https://github.com/zeromicro/go-zero/blob/8e7e5695eb2095917864b5d6615dab4c90bde3ac/zrpc/resolver/internal/subset.go | zrpc/resolver/internal/subset.go | package internal
import "math/rand"
func subset(set []string, sub int) []string {
rand.Shuffle(len(set), func(i, j int) {
set[i], set[j] = set[j], set[i]
})
if len(set) <= sub {
return set
}
return set[:sub]
}
| go | MIT | 8e7e5695eb2095917864b5d6615dab4c90bde3ac | 2026-01-07T08:36:18.042207Z | false |
zeromicro/go-zero | https://github.com/zeromicro/go-zero/blob/8e7e5695eb2095917864b5d6615dab4c90bde3ac/zrpc/resolver/internal/targets/endpoints.go | zrpc/resolver/internal/targets/endpoints.go | package targets
import (
"strings"
"google.golang.org/grpc/resolver"
)
const slashSeparator = "/"
// GetAuthority returns the authority of the target.
func GetAuthority(target resolver.Target) string {
return target.URL.Host
}
// GetEndpoints returns the endpoints from the given target.
func GetEndpoints(target resolver.Target) string {
return strings.Trim(target.URL.Path, slashSeparator)
}
| go | MIT | 8e7e5695eb2095917864b5d6615dab4c90bde3ac | 2026-01-07T08:36:18.042207Z | false |
zeromicro/go-zero | https://github.com/zeromicro/go-zero/blob/8e7e5695eb2095917864b5d6615dab4c90bde3ac/zrpc/resolver/internal/targets/endpoints_test.go | zrpc/resolver/internal/targets/endpoints_test.go | package targets
import (
"net/url"
"testing"
"github.com/stretchr/testify/assert"
"google.golang.org/grpc/resolver"
)
func TestGetAuthority(t *testing.T) {
tests := []struct {
name string
url string
want string
}{
{
name: "test",
url: "direct://my_authority/localhost",
want: "my_authority",
},
{
name: "test with port",
url: "direct://my_authority/localhost:8080",
want: "my_authority",
},
{
name: "test with multiple hosts",
url: "direct://my_authority1,my_authority2/localhost,localhost",
want: "my_authority1,my_authority2",
},
{
name: "test with multiple hosts with port",
url: "direct://my_authority1:3000,my_authority2:3001/localhost:8080,localhost:8081",
want: "my_authority1:3000,my_authority2:3001",
},
}
for _, test := range tests {
t.Run(test.name, func(t *testing.T) {
uri, err := url.Parse(test.url)
assert.Nil(t, err)
target := resolver.Target{
URL: *uri,
}
assert.Equal(t, test.want, GetAuthority(target))
})
}
}
func TestGetEndpoints(t *testing.T) {
tests := []struct {
name string
url string
want string
}{
{
name: "test",
url: "direct:///localhost",
want: "localhost",
},
{
name: "test with port",
url: "direct:///localhost:8080",
want: "localhost:8080",
},
{
name: "test with multiple hosts",
url: "direct:///localhost,localhost",
want: "localhost,localhost",
},
{
name: "test with multiple hosts with port",
url: "direct:///localhost:8080,localhost:8081",
want: "localhost:8080,localhost:8081",
},
}
for _, test := range tests {
t.Run(test.name, func(t *testing.T) {
uri, err := url.Parse(test.url)
assert.Nil(t, err)
target := resolver.Target{
URL: *uri,
}
assert.Equal(t, test.want, GetEndpoints(target))
})
}
}
| go | MIT | 8e7e5695eb2095917864b5d6615dab4c90bde3ac | 2026-01-07T08:36:18.042207Z | false |
zeromicro/go-zero | https://github.com/zeromicro/go-zero/blob/8e7e5695eb2095917864b5d6615dab4c90bde3ac/zrpc/resolver/internal/kube/eventhandler_test.go | zrpc/resolver/internal/kube/eventhandler_test.go | package kube
import (
"testing"
"github.com/stretchr/testify/assert"
discoveryv1 "k8s.io/api/discovery/v1"
metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
)
func TestAdd(t *testing.T) {
var endpoints []string
h := NewEventHandler(func(change []string) {
endpoints = change
})
h.OnAdd("bad", false)
h.OnAdd(&discoveryv1.EndpointSlice{
Endpoints: []discoveryv1.Endpoint{
{
Addresses: []string{"0.0.0.1"},
},
{
Addresses: []string{"0.0.0.2"},
},
{
Addresses: []string{"0.0.0.3"},
},
},
}, false)
assert.ElementsMatch(t, []string{"0.0.0.1", "0.0.0.2", "0.0.0.3"}, endpoints)
}
func TestDelete(t *testing.T) {
var endpoints []string
h := NewEventHandler(func(change []string) {
endpoints = change
})
h.OnAdd(&discoveryv1.EndpointSlice{
Endpoints: []discoveryv1.Endpoint{
{
Addresses: []string{"0.0.0.1"},
},
{
Addresses: []string{"0.0.0.2"},
},
{
Addresses: []string{"0.0.0.3"},
},
},
}, false)
h.OnDelete("bad")
h.OnDelete(&discoveryv1.EndpointSlice{
Endpoints: []discoveryv1.Endpoint{
{
Addresses: []string{"0.0.0.1"},
},
{
Addresses: []string{"0.0.0.2"},
},
},
})
assert.ElementsMatch(t, []string{"0.0.0.3"}, endpoints)
}
func TestUpdate(t *testing.T) {
var endpoints []string
h := NewEventHandler(func(change []string) {
endpoints = change
})
h.OnUpdate(&discoveryv1.EndpointSlice{
Endpoints: []discoveryv1.Endpoint{
{
Addresses: []string{"0.0.0.1"},
},
{
Addresses: []string{"0.0.0.2"},
},
},
ObjectMeta: metav1.ObjectMeta{
ResourceVersion: "1",
},
}, &discoveryv1.EndpointSlice{
Endpoints: []discoveryv1.Endpoint{
{
Addresses: []string{"0.0.0.1"},
},
{
Addresses: []string{"0.0.0.2"},
},
{
Addresses: []string{"0.0.0.3"},
},
},
ObjectMeta: metav1.ObjectMeta{
ResourceVersion: "2",
},
})
assert.ElementsMatch(t, []string{"0.0.0.1", "0.0.0.2", "0.0.0.3"}, endpoints)
}
func TestUpdateNoChange(t *testing.T) {
h := NewEventHandler(func(change []string) {
assert.Fail(t, "should not called")
})
h.OnUpdate(&discoveryv1.EndpointSlice{
Endpoints: []discoveryv1.Endpoint{
{
Addresses: []string{"0.0.0.1"},
},
{
Addresses: []string{"0.0.0.2"},
},
},
ObjectMeta: metav1.ObjectMeta{
ResourceVersion: "1",
},
}, &discoveryv1.EndpointSlice{
Endpoints: []discoveryv1.Endpoint{
{
Addresses: []string{"0.0.0.1"},
},
{
Addresses: []string{"0.0.0.2"},
},
},
ObjectMeta: metav1.ObjectMeta{
ResourceVersion: "1",
},
})
}
func TestUpdateChangeWithDifferentVersion(t *testing.T) {
var endpoints []string
h := NewEventHandler(func(change []string) {
endpoints = change
})
h.OnAdd(&discoveryv1.EndpointSlice{
Endpoints: []discoveryv1.Endpoint{
{
Addresses: []string{"0.0.0.1"},
},
{
Addresses: []string{"0.0.0.3"},
},
},
}, false)
h.OnUpdate(&discoveryv1.EndpointSlice{
Endpoints: []discoveryv1.Endpoint{
{
Addresses: []string{"0.0.0.1"},
},
{
Addresses: []string{"0.0.0.3"},
},
},
ObjectMeta: metav1.ObjectMeta{
ResourceVersion: "1",
},
}, &discoveryv1.EndpointSlice{
Endpoints: []discoveryv1.Endpoint{
{
Addresses: []string{"0.0.0.1"},
},
{
Addresses: []string{"0.0.0.2"},
},
},
ObjectMeta: metav1.ObjectMeta{
ResourceVersion: "2",
},
})
assert.ElementsMatch(t, []string{"0.0.0.1", "0.0.0.2"}, endpoints)
}
func TestUpdateNoChangeWithDifferentVersion(t *testing.T) {
var endpoints []string
h := NewEventHandler(func(change []string) {
endpoints = change
})
h.OnAdd(&discoveryv1.EndpointSlice{
Endpoints: []discoveryv1.Endpoint{
{
Addresses: []string{"0.0.0.1"},
},
{
Addresses: []string{"0.0.0.2"},
},
},
}, false)
h.OnUpdate("bad", &discoveryv1.EndpointSlice{
Endpoints: []discoveryv1.Endpoint{
{
Addresses: []string{"0.0.0.1"},
},
},
})
h.OnUpdate(&discoveryv1.EndpointSlice{
Endpoints: []discoveryv1.Endpoint{
{
Addresses: []string{"0.0.0.1"},
},
},
}, "bad")
h.OnUpdate(&discoveryv1.EndpointSlice{
Endpoints: []discoveryv1.Endpoint{
{
Addresses: []string{"0.0.0.1"},
},
{
Addresses: []string{"0.0.0.2"},
},
},
ObjectMeta: metav1.ObjectMeta{
ResourceVersion: "1",
},
}, &discoveryv1.EndpointSlice{
Endpoints: []discoveryv1.Endpoint{
{
Addresses: []string{"0.0.0.1"},
},
{
Addresses: []string{"0.0.0.2"},
},
},
ObjectMeta: metav1.ObjectMeta{
ResourceVersion: "2",
},
})
assert.ElementsMatch(t, []string{"0.0.0.1", "0.0.0.2"}, endpoints)
}
| go | MIT | 8e7e5695eb2095917864b5d6615dab4c90bde3ac | 2026-01-07T08:36:18.042207Z | false |
zeromicro/go-zero | https://github.com/zeromicro/go-zero/blob/8e7e5695eb2095917864b5d6615dab4c90bde3ac/zrpc/resolver/internal/kube/targetparser_test.go | zrpc/resolver/internal/kube/targetparser_test.go | package kube
import (
"net/url"
"testing"
"github.com/stretchr/testify/assert"
"google.golang.org/grpc/resolver"
)
func TestParseTarget(t *testing.T) {
tests := []struct {
name string
input string
expect Service
hasErr bool
}{
{
name: "normal case",
input: "k8s://ns1/my-svc:8080",
expect: Service{
Namespace: "ns1",
Name: "my-svc",
Port: 8080,
},
},
{
name: "normal case",
input: "k8s:///my-svc:8080",
expect: Service{
Namespace: defaultNamespace,
Name: "my-svc",
Port: 8080,
},
},
{
name: "no port",
input: "k8s://ns1/my-svc:",
hasErr: true,
},
{
name: "no port, no colon",
input: "k8s://ns1/my-svc",
expect: Service{
Namespace: "ns1",
Name: "my-svc",
},
},
{
name: "bad port",
input: "k8s://ns1/my-svc:800a",
hasErr: true,
},
{
name: "bad endpoint",
input: "k8s://ns1:800/:",
hasErr: true,
},
}
for _, test := range tests {
t.Run(test.name, func(t *testing.T) {
uri, err := url.Parse(test.input)
if assert.NoError(t, err) {
svc, err := ParseTarget(resolver.Target{URL: *uri})
if test.hasErr {
assert.NotNil(t, err)
} else {
assert.Nil(t, err)
assert.Equal(t, test.expect, svc)
}
}
})
}
}
| go | MIT | 8e7e5695eb2095917864b5d6615dab4c90bde3ac | 2026-01-07T08:36:18.042207Z | false |
zeromicro/go-zero | https://github.com/zeromicro/go-zero/blob/8e7e5695eb2095917864b5d6615dab4c90bde3ac/zrpc/resolver/internal/kube/eventhandler.go | zrpc/resolver/internal/kube/eventhandler.go | package kube
import (
"sync"
"github.com/zeromicro/go-zero/core/lang"
"github.com/zeromicro/go-zero/core/logx"
"k8s.io/api/discovery/v1"
"k8s.io/client-go/tools/cache"
)
var _ cache.ResourceEventHandler = (*EventHandler)(nil)
// EventHandler is ResourceEventHandler implementation.
type EventHandler struct {
update func([]string)
endpoints map[string]lang.PlaceholderType
lock sync.Mutex
}
// NewEventHandler returns an EventHandler.
func NewEventHandler(update func([]string)) *EventHandler {
return &EventHandler{
update: update,
endpoints: make(map[string]lang.PlaceholderType),
}
}
// OnAdd handles the endpoints add events.
func (h *EventHandler) OnAdd(obj any, _ bool) {
endpoints, ok := obj.(*v1.EndpointSlice)
if !ok {
logx.Errorf("%v is not an object with type *v1.EndpointSlice", obj)
return
}
h.lock.Lock()
defer h.lock.Unlock()
var changed bool
for _, point := range endpoints.Endpoints {
for _, address := range point.Addresses {
if _, ok := h.endpoints[address]; !ok {
h.endpoints[address] = lang.Placeholder
changed = true
}
}
}
if changed {
h.notify()
}
}
// OnDelete handles the endpoints delete events.
func (h *EventHandler) OnDelete(obj any) {
endpoints, ok := obj.(*v1.EndpointSlice)
if !ok {
logx.Errorf("%v is not an object with type *v1.EndpointSlice", obj)
return
}
h.lock.Lock()
defer h.lock.Unlock()
var changed bool
for _, point := range endpoints.Endpoints {
for _, address := range point.Addresses {
if _, ok := h.endpoints[address]; ok {
delete(h.endpoints, address)
changed = true
}
}
}
if changed {
h.notify()
}
}
// OnUpdate handles the endpoints update events.
func (h *EventHandler) OnUpdate(oldObj, newObj any) {
oldEndpointSlices, ok := oldObj.(*v1.EndpointSlice)
if !ok {
logx.Errorf("%v is not an object with type *v1.EndpointSlice", oldObj)
return
}
newEndpointSlices, ok := newObj.(*v1.EndpointSlice)
if !ok {
logx.Errorf("%v is not an object with type *v1.EndpointSlice", newObj)
return
}
if oldEndpointSlices.ResourceVersion == newEndpointSlices.ResourceVersion {
return
}
h.Update(newEndpointSlices)
}
// Update updates the endpoints.
func (h *EventHandler) Update(endpoints *v1.EndpointSlice) {
h.lock.Lock()
defer h.lock.Unlock()
old := h.endpoints
h.endpoints = make(map[string]lang.PlaceholderType)
for _, point := range endpoints.Endpoints {
for _, address := range point.Addresses {
h.endpoints[address] = lang.Placeholder
}
}
if diff(old, h.endpoints) {
h.notify()
}
}
func (h *EventHandler) notify() {
targets := make([]string, 0, len(h.endpoints))
for k := range h.endpoints {
targets = append(targets, k)
}
h.update(targets)
}
func diff(o, n map[string]lang.PlaceholderType) bool {
if len(o) != len(n) {
return true
}
for k := range o {
if _, ok := n[k]; !ok {
return true
}
}
return false
}
| go | MIT | 8e7e5695eb2095917864b5d6615dab4c90bde3ac | 2026-01-07T08:36:18.042207Z | false |
zeromicro/go-zero | https://github.com/zeromicro/go-zero/blob/8e7e5695eb2095917864b5d6615dab4c90bde3ac/zrpc/resolver/internal/kube/targetparser.go | zrpc/resolver/internal/kube/targetparser.go | package kube
import (
"strconv"
"strings"
"github.com/zeromicro/go-zero/zrpc/resolver/internal/targets"
"google.golang.org/grpc/resolver"
)
const (
colon = ":"
defaultNamespace = "default"
)
var emptyService Service
// Service represents a service with namespace, name and port.
type Service struct {
Namespace string
Name string
Port int
}
// ParseTarget parses the resolver.Target.
func ParseTarget(target resolver.Target) (Service, error) {
var service Service
service.Namespace = targets.GetAuthority(target)
if len(service.Namespace) == 0 {
service.Namespace = defaultNamespace
}
endpoints := targets.GetEndpoints(target)
if strings.Contains(endpoints, colon) {
segs := strings.SplitN(endpoints, colon, 2)
service.Name = segs[0]
port, err := strconv.Atoi(segs[1])
if err != nil {
return emptyService, err
}
service.Port = port
} else {
service.Name = endpoints
}
return service, nil
}
| go | MIT | 8e7e5695eb2095917864b5d6615dab4c90bde3ac | 2026-01-07T08:36:18.042207Z | false |
zeromicro/go-zero | https://github.com/zeromicro/go-zero/blob/8e7e5695eb2095917864b5d6615dab4c90bde3ac/zrpc/internal/rpcserver_test.go | zrpc/internal/rpcserver_test.go | package internal
import (
"sync"
"testing"
"time"
"github.com/stretchr/testify/assert"
"github.com/zeromicro/go-zero/core/proc"
"github.com/zeromicro/go-zero/internal/mock"
"google.golang.org/grpc"
)
func TestRpcServer(t *testing.T) {
server := NewRpcServer("localhost:54321", WithRpcHealth(true))
server.SetName("mock")
var wg, wgDone sync.WaitGroup
var grpcServer *grpc.Server
var lock sync.Mutex
wg.Add(1)
wgDone.Add(1)
go func() {
err := server.Start(func(server *grpc.Server) {
lock.Lock()
mock.RegisterDepositServiceServer(server, new(mock.DepositServer))
grpcServer = server
lock.Unlock()
wg.Done()
})
assert.Nil(t, err)
wgDone.Done()
}()
wg.Wait()
time.Sleep(100 * time.Millisecond)
lock.Lock()
grpcServer.GracefulStop()
lock.Unlock()
proc.Shutdown()
wgDone.Wait()
}
func TestRpcServer_WithBadAddress(t *testing.T) {
server := NewRpcServer("localhost:111111", WithRpcHealth(true))
server.SetName("mock")
err := server.Start(func(server *grpc.Server) {
mock.RegisterDepositServiceServer(server, new(mock.DepositServer))
})
assert.NotNil(t, err)
proc.WrapUp()
}
| go | MIT | 8e7e5695eb2095917864b5d6615dab4c90bde3ac | 2026-01-07T08:36:18.042207Z | false |
zeromicro/go-zero | https://github.com/zeromicro/go-zero/blob/8e7e5695eb2095917864b5d6615dab4c90bde3ac/zrpc/internal/client.go | zrpc/internal/client.go | package internal
import (
"context"
"errors"
"fmt"
"strings"
"time"
"github.com/zeromicro/go-zero/zrpc/internal/clientinterceptors"
"github.com/zeromicro/go-zero/zrpc/resolver"
"google.golang.org/grpc"
"google.golang.org/grpc/credentials"
"google.golang.org/grpc/credentials/insecure"
)
const (
dialTimeout = time.Second * 3
separator = '/'
)
func init() {
resolver.Register()
}
type (
// Client interface wraps the Conn method.
Client interface {
Conn() *grpc.ClientConn
}
// A ClientOptions is a client options.
ClientOptions struct {
NonBlock bool
Timeout time.Duration
Secure bool
DialOptions []grpc.DialOption
}
// ClientOption defines the method to customize a ClientOptions.
ClientOption func(options *ClientOptions)
client struct {
conn *grpc.ClientConn
middlewares ClientMiddlewaresConf
}
)
// NewClient returns a Client.
func NewClient(target string, middlewares ClientMiddlewaresConf, opts ...ClientOption) (Client, error) {
cli := client{
middlewares: middlewares,
}
if err := cli.dial(target, opts...); err != nil {
return nil, err
}
return &cli, nil
}
func (c *client) Conn() *grpc.ClientConn {
return c.conn
}
func (c *client) buildDialOptions(opts ...ClientOption) []grpc.DialOption {
var cliOpts ClientOptions
for _, opt := range opts {
opt(&cliOpts)
}
var options []grpc.DialOption
if !cliOpts.Secure {
options = append([]grpc.DialOption(nil),
grpc.WithTransportCredentials(insecure.NewCredentials()))
}
if !cliOpts.NonBlock {
options = append(options, grpc.WithBlock())
}
options = append(options,
grpc.WithChainUnaryInterceptor(c.buildUnaryInterceptors(cliOpts.Timeout)...),
grpc.WithChainStreamInterceptor(c.buildStreamInterceptors()...),
)
return append(options, cliOpts.DialOptions...)
}
func (c *client) buildStreamInterceptors() []grpc.StreamClientInterceptor {
var interceptors []grpc.StreamClientInterceptor
if c.middlewares.Trace {
interceptors = append(interceptors, clientinterceptors.StreamTracingInterceptor)
}
return interceptors
}
func (c *client) buildUnaryInterceptors(timeout time.Duration) []grpc.UnaryClientInterceptor {
var interceptors []grpc.UnaryClientInterceptor
if c.middlewares.Trace {
interceptors = append(interceptors, clientinterceptors.UnaryTracingInterceptor)
}
if c.middlewares.Duration {
interceptors = append(interceptors, clientinterceptors.DurationInterceptor)
}
if c.middlewares.Prometheus {
interceptors = append(interceptors, clientinterceptors.PrometheusInterceptor)
}
if c.middlewares.Breaker {
interceptors = append(interceptors, clientinterceptors.BreakerInterceptor)
}
if c.middlewares.Timeout {
interceptors = append(interceptors, clientinterceptors.TimeoutInterceptor(timeout))
}
return interceptors
}
func (c *client) dial(server string, opts ...ClientOption) error {
options := c.buildDialOptions(opts...)
timeCtx, cancel := context.WithTimeout(context.Background(), dialTimeout)
defer cancel()
conn, err := grpc.DialContext(timeCtx, server, options...)
if err != nil {
service := server
if errors.Is(err, context.DeadlineExceeded) {
pos := strings.LastIndexByte(server, separator)
// len(server) - 1 is the index of last char
if 0 < pos && pos < len(server)-1 {
service = server[pos+1:]
}
}
return fmt.Errorf("rpc dial: %s, error: %s, make sure rpc service %q is already started",
server, err.Error(), service)
}
c.conn = conn
return nil
}
// WithBlock sets the dialing to be blocking.
// Deprecated: blocking dials are not recommended by gRPC.
// See https://github.com/grpc/grpc-go/blob/master/Documentation/anti-patterns.md
func WithBlock() ClientOption {
return func(options *ClientOptions) {
options.NonBlock = false
}
}
// WithDialOption returns a func to customize a ClientOptions with given dial option.
func WithDialOption(opt grpc.DialOption) ClientOption {
return func(options *ClientOptions) {
options.DialOptions = append(options.DialOptions, opt)
}
}
// WithNonBlock sets the dialing to be nonblock.
func WithNonBlock() ClientOption {
return func(options *ClientOptions) {
options.NonBlock = true
}
}
// WithStreamClientInterceptor returns a func to customize a ClientOptions with given interceptor.
func WithStreamClientInterceptor(interceptor grpc.StreamClientInterceptor) ClientOption {
return func(options *ClientOptions) {
options.DialOptions = append(options.DialOptions,
grpc.WithChainStreamInterceptor(interceptor))
}
}
// WithTimeout returns a func to customize a ClientOptions with given timeout.
func WithTimeout(timeout time.Duration) ClientOption {
return func(options *ClientOptions) {
options.Timeout = timeout
}
}
// WithTransportCredentials return a func to make the gRPC calls secured with given credentials.
func WithTransportCredentials(creds credentials.TransportCredentials) ClientOption {
return func(options *ClientOptions) {
options.Secure = true
options.DialOptions = append(options.DialOptions, grpc.WithTransportCredentials(creds))
}
}
// WithUnaryClientInterceptor returns a func to customize a ClientOptions with given interceptor.
func WithUnaryClientInterceptor(interceptor grpc.UnaryClientInterceptor) ClientOption {
return func(options *ClientOptions) {
options.DialOptions = append(options.DialOptions,
grpc.WithChainUnaryInterceptor(interceptor))
}
}
| go | MIT | 8e7e5695eb2095917864b5d6615dab4c90bde3ac | 2026-01-07T08:36:18.042207Z | false |
zeromicro/go-zero | https://github.com/zeromicro/go-zero/blob/8e7e5695eb2095917864b5d6615dab4c90bde3ac/zrpc/internal/rpcpubserver_test.go | zrpc/internal/rpcpubserver_test.go | package internal
import (
"testing"
"github.com/stretchr/testify/assert"
"github.com/zeromicro/go-zero/core/discov"
"github.com/zeromicro/go-zero/core/netx"
)
func TestNewRpcPubServer(t *testing.T) {
s, err := NewRpcPubServer(discov.EtcdConf{
User: "user",
Pass: "pass",
ID: 10,
}, "")
assert.NoError(t, err)
assert.NotPanics(t, func() {
s.Start(nil)
})
}
func TestFigureOutListenOn(t *testing.T) {
tests := []struct {
input string
expect string
}{
{
input: "192.168.0.5:1234",
expect: "192.168.0.5:1234",
},
{
input: "0.0.0.0:8080",
expect: netx.InternalIp() + ":8080",
},
{
input: ":8080",
expect: netx.InternalIp() + ":8080",
},
{
input: "",
expect: netx.InternalIp(),
},
}
for _, test := range tests {
val := figureOutListenOn(test.input)
assert.Equal(t, test.expect, val)
}
}
| go | MIT | 8e7e5695eb2095917864b5d6615dab4c90bde3ac | 2026-01-07T08:36:18.042207Z | false |
zeromicro/go-zero | https://github.com/zeromicro/go-zero/blob/8e7e5695eb2095917864b5d6615dab4c90bde3ac/zrpc/internal/server_test.go | zrpc/internal/server_test.go | package internal
import (
"context"
"testing"
"github.com/stretchr/testify/assert"
"google.golang.org/grpc"
)
func TestBaseRpcServer_AddOptions(t *testing.T) {
server := newBaseRpcServer("foo", &rpcServerOptions{})
var opt grpc.EmptyServerOption
server.AddOptions(opt)
assert.Contains(t, server.options, opt)
}
func TestBaseRpcServer_AddStreamInterceptors(t *testing.T) {
server := newBaseRpcServer("foo", &rpcServerOptions{})
var vals []int
f := func(_ any, _ grpc.ServerStream, _ *grpc.StreamServerInfo, _ grpc.StreamHandler) error {
vals = append(vals, 1)
return nil
}
server.AddStreamInterceptors(f)
for _, each := range server.streamInterceptors {
assert.Nil(t, each(nil, nil, nil, nil))
}
assert.ElementsMatch(t, []int{1}, vals)
}
func TestBaseRpcServer_AddUnaryInterceptors(t *testing.T) {
server := newBaseRpcServer("foo", &rpcServerOptions{})
var vals []int
f := func(ctx context.Context, req any, info *grpc.UnaryServerInfo, handler grpc.UnaryHandler) (
resp any, err error) {
vals = append(vals, 1)
return nil, nil
}
server.AddUnaryInterceptors(f)
for _, each := range server.unaryInterceptors {
_, err := each(context.Background(), nil, nil, nil)
assert.Nil(t, err)
}
assert.ElementsMatch(t, []int{1}, vals)
}
| go | MIT | 8e7e5695eb2095917864b5d6615dab4c90bde3ac | 2026-01-07T08:36:18.042207Z | false |
zeromicro/go-zero | https://github.com/zeromicro/go-zero/blob/8e7e5695eb2095917864b5d6615dab4c90bde3ac/zrpc/internal/config.go | zrpc/internal/config.go | package internal
import "github.com/zeromicro/go-zero/zrpc/internal/serverinterceptors"
type (
// StatConf defines the stat config.
StatConf = serverinterceptors.StatConf
// ClientMiddlewaresConf defines whether to use client middlewares.
ClientMiddlewaresConf struct {
Trace bool `json:",default=true"`
Duration bool `json:",default=true"`
Prometheus bool `json:",default=true"`
Breaker bool `json:",default=true"`
Timeout bool `json:",default=true"`
}
// ServerMiddlewaresConf defines whether to use server middlewares.
ServerMiddlewaresConf struct {
Trace bool `json:",default=true"`
Recover bool `json:",default=true"`
Stat bool `json:",default=true"`
StatConf StatConf `json:",optional"`
Prometheus bool `json:",default=true"`
Breaker bool `json:",default=true"`
}
// MethodTimeoutConf defines specified timeout for gRPC methods.
MethodTimeoutConf = serverinterceptors.MethodTimeoutConf
)
| go | MIT | 8e7e5695eb2095917864b5d6615dab4c90bde3ac | 2026-01-07T08:36:18.042207Z | false |
zeromicro/go-zero | https://github.com/zeromicro/go-zero/blob/8e7e5695eb2095917864b5d6615dab4c90bde3ac/zrpc/internal/client_test.go | zrpc/internal/client_test.go | package internal
import (
"context"
"net"
"strings"
"sync"
"testing"
"time"
"github.com/stretchr/testify/assert"
"google.golang.org/grpc"
)
func TestWithDialOption(t *testing.T) {
var options ClientOptions
agent := grpc.WithUserAgent("chrome")
opt := WithDialOption(agent)
opt(&options)
assert.Contains(t, options.DialOptions, agent)
}
func TestWithTimeout(t *testing.T) {
var options ClientOptions
opt := WithTimeout(time.Second)
opt(&options)
assert.Equal(t, time.Second, options.Timeout)
}
func TestWithNonBlock(t *testing.T) {
var options ClientOptions
opt := WithNonBlock()
opt(&options)
assert.True(t, options.NonBlock)
}
func TestWithBlock(t *testing.T) {
var options ClientOptions
opt := WithBlock()
opt(&options)
assert.False(t, options.NonBlock)
}
func TestWithStreamClientInterceptor(t *testing.T) {
var options ClientOptions
opt := WithStreamClientInterceptor(func(ctx context.Context, desc *grpc.StreamDesc,
cc *grpc.ClientConn, method string, streamer grpc.Streamer,
opts ...grpc.CallOption) (grpc.ClientStream, error) {
return nil, nil
})
opt(&options)
assert.Equal(t, 1, len(options.DialOptions))
}
func TestWithTransportCredentials(t *testing.T) {
var options ClientOptions
opt := WithTransportCredentials(nil)
opt(&options)
assert.Equal(t, 1, len(options.DialOptions))
}
func TestWithUnaryClientInterceptor(t *testing.T) {
var options ClientOptions
opt := WithUnaryClientInterceptor(func(ctx context.Context, method string, req, reply any,
cc *grpc.ClientConn, invoker grpc.UnaryInvoker, opts ...grpc.CallOption) error {
return nil
})
opt(&options)
assert.Equal(t, 1, len(options.DialOptions))
}
func TestBuildDialOptions(t *testing.T) {
c := client{
middlewares: ClientMiddlewaresConf{
Trace: true,
Duration: true,
Prometheus: true,
Breaker: true,
Timeout: true,
},
}
agent := grpc.WithUserAgent("chrome")
opts := c.buildDialOptions(WithDialOption(agent))
assert.Contains(t, opts, agent)
}
func TestClientDial(t *testing.T) {
var addr string
var wg sync.WaitGroup
wg.Add(1)
server := grpc.NewServer()
go func() {
lis, err := net.Listen("tcp", "localhost:0")
assert.NoError(t, err)
defer lis.Close()
addr = lis.Addr().String()
wg.Done()
server.Serve(lis)
}()
wg.Wait()
c, err := NewClient(addr, ClientMiddlewaresConf{
Trace: true,
Duration: true,
Prometheus: true,
Breaker: true,
Timeout: true,
})
assert.NoError(t, err)
assert.NotNil(t, c.Conn())
server.Stop()
}
func TestClientDialFail(t *testing.T) {
_, err := NewClient("localhost:54321", ClientMiddlewaresConf{
Trace: true,
Duration: true,
Prometheus: true,
Breaker: true,
Timeout: true,
})
assert.Error(t, err)
assert.True(t, strings.Contains(err.Error(), "localhost:54321"))
_, err = NewClient("localhost:54321/fail", ClientMiddlewaresConf{
Trace: true,
Duration: true,
Prometheus: true,
Breaker: true,
Timeout: true,
})
assert.Error(t, err)
assert.True(t, strings.Contains(err.Error(), "localhost:54321/fail"))
}
| go | MIT | 8e7e5695eb2095917864b5d6615dab4c90bde3ac | 2026-01-07T08:36:18.042207Z | false |
zeromicro/go-zero | https://github.com/zeromicro/go-zero/blob/8e7e5695eb2095917864b5d6615dab4c90bde3ac/zrpc/internal/rpcpubserver.go | zrpc/internal/rpcpubserver.go | package internal
import (
"os"
"strings"
"github.com/zeromicro/go-zero/core/discov"
"github.com/zeromicro/go-zero/core/netx"
)
const (
allEths = "0.0.0.0"
envPodIp = "POD_IP"
)
// NewRpcPubServer returns a Server.
func NewRpcPubServer(etcd discov.EtcdConf, listenOn string,
opts ...ServerOption) (Server, error) {
registerEtcd := func() error {
pubListenOn := figureOutListenOn(listenOn)
var pubOpts []discov.PubOption
if etcd.HasAccount() {
pubOpts = append(pubOpts, discov.WithPubEtcdAccount(etcd.User, etcd.Pass))
}
if etcd.HasTLS() {
pubOpts = append(pubOpts, discov.WithPubEtcdTLS(etcd.CertFile, etcd.CertKeyFile,
etcd.CACertFile, etcd.InsecureSkipVerify))
}
if etcd.HasID() {
pubOpts = append(pubOpts, discov.WithId(etcd.ID))
}
pubClient := discov.NewPublisher(etcd.Hosts, etcd.Key, pubListenOn, pubOpts...)
return pubClient.KeepAlive()
}
server := keepAliveServer{
registerEtcd: registerEtcd,
Server: NewRpcServer(listenOn, opts...),
}
return server, nil
}
type keepAliveServer struct {
registerEtcd func() error
Server
}
func (s keepAliveServer) Start(fn RegisterFn) error {
if err := s.registerEtcd(); err != nil {
return err
}
return s.Server.Start(fn)
}
func figureOutListenOn(listenOn string) string {
fields := strings.Split(listenOn, ":")
if len(fields) == 0 {
return listenOn
}
host := fields[0]
if len(host) > 0 && host != allEths {
return listenOn
}
ip := os.Getenv(envPodIp)
if len(ip) == 0 {
ip = netx.InternalIp()
}
if len(ip) == 0 {
return listenOn
}
return strings.Join(append([]string{ip}, fields[1:]...), ":")
}
| go | MIT | 8e7e5695eb2095917864b5d6615dab4c90bde3ac | 2026-01-07T08:36:18.042207Z | false |
zeromicro/go-zero | https://github.com/zeromicro/go-zero/blob/8e7e5695eb2095917864b5d6615dab4c90bde3ac/zrpc/internal/rpclogger.go | zrpc/internal/rpclogger.go | package internal
import (
"github.com/zeromicro/go-zero/core/logx"
"google.golang.org/grpc/grpclog"
)
// because grpclog.errorLog is not exported, we need to define our own.
const errorLevel = 2
// A Logger is a rpc logger.
type Logger struct{}
func init() {
grpclog.SetLoggerV2(new(Logger))
}
// Error logs the given args into error log.
func (l *Logger) Error(args ...any) {
logx.Error(args...)
}
// Errorf logs the given args with format into error log.
func (l *Logger) Errorf(format string, args ...any) {
logx.Errorf(format, args...)
}
// Errorln logs the given args into error log with newline.
func (l *Logger) Errorln(args ...any) {
logx.Error(args...)
}
// Fatal logs the given args into error log.
func (l *Logger) Fatal(args ...any) {
logx.Error(args...)
}
// Fatalf logs the given args with format into error log.
func (l *Logger) Fatalf(format string, args ...any) {
logx.Errorf(format, args...)
}
// Fatalln logs args into error log with newline.
func (l *Logger) Fatalln(args ...any) {
logx.Error(args...)
}
// Info ignores the grpc info logs.
func (l *Logger) Info(_ ...any) {
// ignore builtin grpc info
}
// Infoln ignores the grpc info logs.
func (l *Logger) Infoln(_ ...any) {
// ignore builtin grpc info
}
// Infof ignores the grpc info logs.
func (l *Logger) Infof(_ string, _ ...any) {
// ignore builtin grpc info
}
// V checks if meet required log level.
func (l *Logger) V(v int) bool {
return v >= errorLevel
}
// Warning ignores the grpc warning logs.
func (l *Logger) Warning(_ ...any) {
// ignore builtin grpc warning
}
// Warningf ignores the grpc warning logs.
func (l *Logger) Warningf(_ string, _ ...any) {
// ignore builtin grpc warning
}
// Warningln ignores the grpc warning logs.
func (l *Logger) Warningln(_ ...any) {
// ignore builtin grpc warning
}
| go | MIT | 8e7e5695eb2095917864b5d6615dab4c90bde3ac | 2026-01-07T08:36:18.042207Z | false |
zeromicro/go-zero | https://github.com/zeromicro/go-zero/blob/8e7e5695eb2095917864b5d6615dab4c90bde3ac/zrpc/internal/rpclogger_test.go | zrpc/internal/rpclogger_test.go | package internal
import (
"testing"
"github.com/stretchr/testify/assert"
"github.com/zeromicro/go-zero/core/logx/logtest"
)
const content = "foo"
func TestLoggerError(t *testing.T) {
c := logtest.NewCollector(t)
logger := new(Logger)
logger.Error(content)
assert.Contains(t, c.String(), content)
}
func TestLoggerErrorf(t *testing.T) {
c := logtest.NewCollector(t)
logger := new(Logger)
logger.Errorf(content)
assert.Contains(t, c.String(), content)
}
func TestLoggerErrorln(t *testing.T) {
c := logtest.NewCollector(t)
logger := new(Logger)
logger.Errorln(content)
assert.Contains(t, c.String(), content)
}
func TestLoggerFatal(t *testing.T) {
c := logtest.NewCollector(t)
logger := new(Logger)
logger.Fatal(content)
assert.Contains(t, c.String(), content)
}
func TestLoggerFatalf(t *testing.T) {
c := logtest.NewCollector(t)
logger := new(Logger)
logger.Fatalf(content)
assert.Contains(t, c.String(), content)
}
func TestLoggerFatalln(t *testing.T) {
c := logtest.NewCollector(t)
logger := new(Logger)
logger.Fatalln(content)
assert.Contains(t, c.String(), content)
}
func TestLoggerInfo(t *testing.T) {
c := logtest.NewCollector(t)
logger := new(Logger)
logger.Info(content)
assert.Empty(t, c.String())
}
func TestLoggerInfof(t *testing.T) {
c := logtest.NewCollector(t)
logger := new(Logger)
logger.Infof(content)
assert.Empty(t, c.String())
}
func TestLoggerWarning(t *testing.T) {
c := logtest.NewCollector(t)
logger := new(Logger)
logger.Warning(content)
assert.Empty(t, c.String())
}
func TestLoggerInfoln(t *testing.T) {
c := logtest.NewCollector(t)
logger := new(Logger)
logger.Infoln(content)
assert.Empty(t, c.String())
}
func TestLoggerWarningf(t *testing.T) {
c := logtest.NewCollector(t)
logger := new(Logger)
logger.Warningf(content)
assert.Empty(t, c.String())
}
func TestLoggerWarningln(t *testing.T) {
c := logtest.NewCollector(t)
logger := new(Logger)
logger.Warningln(content)
assert.Empty(t, c.String())
}
func TestLogger_V(t *testing.T) {
logger := new(Logger)
// grpclog.fatalLog
assert.True(t, logger.V(3))
// grpclog.infoLog
assert.False(t, logger.V(0))
}
| go | MIT | 8e7e5695eb2095917864b5d6615dab4c90bde3ac | 2026-01-07T08:36:18.042207Z | false |
zeromicro/go-zero | https://github.com/zeromicro/go-zero/blob/8e7e5695eb2095917864b5d6615dab4c90bde3ac/zrpc/internal/server.go | zrpc/internal/server.go | package internal
import (
"time"
"google.golang.org/grpc"
"google.golang.org/grpc/health"
"google.golang.org/grpc/keepalive"
)
const defaultConnectionIdleDuration = time.Minute * 5
type (
// RegisterFn defines the method to register a server.
RegisterFn func(*grpc.Server)
// Server interface represents a rpc server.
Server interface {
AddOptions(options ...grpc.ServerOption)
AddStreamInterceptors(interceptors ...grpc.StreamServerInterceptor)
AddUnaryInterceptors(interceptors ...grpc.UnaryServerInterceptor)
SetName(string)
Start(register RegisterFn) error
}
baseRpcServer struct {
address string
health *health.Server
options []grpc.ServerOption
streamInterceptors []grpc.StreamServerInterceptor
unaryInterceptors []grpc.UnaryServerInterceptor
}
)
func newBaseRpcServer(address string, rpcServerOpts *rpcServerOptions) *baseRpcServer {
var h *health.Server
if rpcServerOpts.health {
h = health.NewServer()
}
return &baseRpcServer{
address: address,
health: h,
options: []grpc.ServerOption{grpc.KeepaliveParams(keepalive.ServerParameters{
MaxConnectionIdle: defaultConnectionIdleDuration,
})},
}
}
func (s *baseRpcServer) AddOptions(options ...grpc.ServerOption) {
s.options = append(s.options, options...)
}
func (s *baseRpcServer) AddStreamInterceptors(interceptors ...grpc.StreamServerInterceptor) {
s.streamInterceptors = append(s.streamInterceptors, interceptors...)
}
func (s *baseRpcServer) AddUnaryInterceptors(interceptors ...grpc.UnaryServerInterceptor) {
s.unaryInterceptors = append(s.unaryInterceptors, interceptors...)
}
| go | MIT | 8e7e5695eb2095917864b5d6615dab4c90bde3ac | 2026-01-07T08:36:18.042207Z | false |
zeromicro/go-zero | https://github.com/zeromicro/go-zero/blob/8e7e5695eb2095917864b5d6615dab4c90bde3ac/zrpc/internal/rpcserver.go | zrpc/internal/rpcserver.go | package internal
import (
"fmt"
"net"
"github.com/zeromicro/go-zero/core/proc"
"github.com/zeromicro/go-zero/internal/health"
"google.golang.org/grpc"
"google.golang.org/grpc/health/grpc_health_v1"
)
const probeNamePrefix = "zrpc"
type (
// ServerOption defines the method to customize a rpcServerOptions.
ServerOption func(options *rpcServerOptions)
rpcServerOptions struct {
health bool
}
rpcServer struct {
*baseRpcServer
name string
healthManager health.Probe
}
)
// NewRpcServer returns a Server.
func NewRpcServer(addr string, opts ...ServerOption) Server {
var options rpcServerOptions
for _, opt := range opts {
opt(&options)
}
return &rpcServer{
baseRpcServer: newBaseRpcServer(addr, &options),
healthManager: health.NewHealthManager(fmt.Sprintf("%s-%s", probeNamePrefix, addr)),
}
}
func (s *rpcServer) SetName(name string) {
s.name = name
}
func (s *rpcServer) Start(register RegisterFn) error {
lis, err := net.Listen("tcp", s.address)
if err != nil {
return err
}
unaryInterceptorOption := grpc.ChainUnaryInterceptor(s.unaryInterceptors...)
streamInterceptorOption := grpc.ChainStreamInterceptor(s.streamInterceptors...)
options := append(s.options, unaryInterceptorOption, streamInterceptorOption)
server := grpc.NewServer(options...)
register(server)
// register the health check service
if s.health != nil {
grpc_health_v1.RegisterHealthServer(server, s.health)
s.health.Resume()
}
s.healthManager.MarkReady()
health.AddProbe(s.healthManager)
// we need to make sure all others are wrapped up,
// so we do graceful stop at shutdown phase instead of wrap up phase
waitForCalled := proc.AddShutdownListener(func() {
if s.health != nil {
s.health.Shutdown()
}
server.GracefulStop()
})
defer waitForCalled()
return server.Serve(lis)
}
// WithRpcHealth returns a func that sets rpc health switch to a Server.
func WithRpcHealth(health bool) ServerOption {
return func(options *rpcServerOptions) {
options.health = health
}
}
| go | MIT | 8e7e5695eb2095917864b5d6615dab4c90bde3ac | 2026-01-07T08:36:18.042207Z | false |
zeromicro/go-zero | https://github.com/zeromicro/go-zero/blob/8e7e5695eb2095917864b5d6615dab4c90bde3ac/zrpc/internal/serverinterceptors/statinterceptor.go | zrpc/internal/serverinterceptors/statinterceptor.go | package serverinterceptors
import (
"context"
"encoding/json"
"sync"
"time"
"github.com/zeromicro/go-zero/core/collection"
"github.com/zeromicro/go-zero/core/lang"
"github.com/zeromicro/go-zero/core/logx"
"github.com/zeromicro/go-zero/core/stat"
"github.com/zeromicro/go-zero/core/syncx"
"github.com/zeromicro/go-zero/core/timex"
"google.golang.org/grpc"
"google.golang.org/grpc/peer"
)
const defaultSlowThreshold = time.Millisecond * 500
var (
ignoreContentMethods sync.Map
slowThreshold = syncx.ForAtomicDuration(defaultSlowThreshold)
)
// StatConf defines the static configuration for stat interceptor.
type StatConf struct {
SlowThreshold time.Duration `json:",default=500ms"`
IgnoreContentMethods []string `json:",optional"`
}
// DontLogContentForMethod disable logging content for given method.
// Deprecated: use StatConf instead.
func DontLogContentForMethod(method string) {
ignoreContentMethods.Store(method, lang.Placeholder)
}
// SetSlowThreshold sets the slow threshold.
// Deprecated: use StatConf instead.
func SetSlowThreshold(threshold time.Duration) {
slowThreshold.Set(threshold)
}
// UnaryStatInterceptor returns a func that uses given metrics to report stats.
func UnaryStatInterceptor(metrics *stat.Metrics, conf StatConf) grpc.UnaryServerInterceptor {
staticNotLoggingContentMethods := collection.NewSet[string]()
staticNotLoggingContentMethods.Add(conf.IgnoreContentMethods...)
return func(ctx context.Context, req any, info *grpc.UnaryServerInfo,
handler grpc.UnaryHandler) (resp any, err error) {
startTime := timex.Now()
defer func() {
duration := timex.Since(startTime)
metrics.Add(stat.Task{
Duration: duration,
})
logDuration(ctx, info.FullMethod, req, duration,
staticNotLoggingContentMethods, conf.SlowThreshold)
}()
return handler(ctx, req)
}
}
func isSlow(duration, durationThreshold time.Duration) bool {
// Prioritize explicit config over global setting
if durationThreshold > 0 {
return duration > durationThreshold
}
return duration > slowThreshold.Load()
}
func logDuration(ctx context.Context, method string, req any, duration time.Duration,
ignoreMethods *collection.Set[string], durationThreshold time.Duration) {
var addr string
client, ok := peer.FromContext(ctx)
if ok {
addr = client.Addr.String()
}
logger := logx.WithContext(ctx).WithDuration(duration)
if !shouldLogContent(method, ignoreMethods) {
if isSlow(duration, durationThreshold) {
logger.Slowf("[RPC] slowcall - %s - %s", addr, method)
}
} else {
content, err := json.Marshal(req)
if err != nil {
logx.WithContext(ctx).Errorf("%s - %s", addr, err.Error())
} else if isSlow(duration, durationThreshold) {
logger.Slowf("[RPC] slowcall - %s - %s - %s", addr, method, string(content))
} else {
logger.Infof("%s - %s - %s", addr, method, string(content))
}
}
}
func shouldLogContent(method string, ignoreMethods *collection.Set[string]) bool {
_, ok := ignoreContentMethods.Load(method)
return !ok && !ignoreMethods.Contains(method)
}
| go | MIT | 8e7e5695eb2095917864b5d6615dab4c90bde3ac | 2026-01-07T08:36:18.042207Z | false |
zeromicro/go-zero | https://github.com/zeromicro/go-zero/blob/8e7e5695eb2095917864b5d6615dab4c90bde3ac/zrpc/internal/serverinterceptors/statinterceptor_test.go | zrpc/internal/serverinterceptors/statinterceptor_test.go | package serverinterceptors
import (
"context"
"net"
"sync"
"testing"
"time"
"github.com/stretchr/testify/assert"
"github.com/zeromicro/go-zero/core/collection"
"github.com/zeromicro/go-zero/core/lang"
"github.com/zeromicro/go-zero/core/stat"
"github.com/zeromicro/go-zero/core/syncx"
"google.golang.org/grpc"
"google.golang.org/grpc/peer"
)
func TestSetSlowThreshold(t *testing.T) {
assert.Equal(t, defaultSlowThreshold, slowThreshold.Load())
SetSlowThreshold(time.Second)
// reset slowThreshold
t.Cleanup(func() {
slowThreshold = syncx.ForAtomicDuration(defaultSlowThreshold)
})
assert.Equal(t, time.Second, slowThreshold.Load())
}
func TestUnaryStatInterceptor(t *testing.T) {
metrics := stat.NewMetrics("mock")
interceptor := UnaryStatInterceptor(metrics, StatConf{})
_, err := interceptor(context.Background(), nil, &grpc.UnaryServerInfo{
FullMethod: "/",
}, func(ctx context.Context, req any) (any, error) {
return nil, nil
})
assert.Nil(t, err)
}
func TestLogDuration(t *testing.T) {
addrs, err := net.InterfaceAddrs()
assert.Nil(t, err)
assert.True(t, len(addrs) > 0)
tests := []struct {
name string
ctx context.Context
req any
duration time.Duration
durationThreshold time.Duration
}{
{
name: "normal",
ctx: context.Background(),
req: "foo",
},
{
name: "bad req",
ctx: context.Background(),
req: make(chan lang.PlaceholderType), // not marshalable
},
{
name: "timeout",
ctx: context.Background(),
req: "foo",
duration: time.Second,
durationThreshold: time.Millisecond * 500,
},
{
name: "timeout",
ctx: peer.NewContext(context.Background(), &peer.Peer{
Addr: addrs[0],
}),
req: "foo",
},
{
name: "timeout",
ctx: context.Background(),
req: "foo",
duration: slowThreshold.Load() + time.Second,
},
}
for _, test := range tests {
test := test
t.Run(test.name, func(t *testing.T) {
t.Parallel()
assert.NotPanics(t, func() {
logDuration(test.ctx, "foo", test.req, test.duration,
collection.NewSet[string](), test.durationThreshold)
})
})
}
}
func TestLogDurationWithoutContent(t *testing.T) {
addrs, err := net.InterfaceAddrs()
assert.Nil(t, err)
assert.True(t, len(addrs) > 0)
tests := []struct {
name string
ctx context.Context
req any
duration time.Duration
durationThreshold time.Duration
}{
{
name: "normal",
ctx: context.Background(),
req: "foo",
},
{
name: "bad req",
ctx: context.Background(),
req: make(chan lang.PlaceholderType), // not marshalable
},
{
name: "timeout",
ctx: context.Background(),
req: "foo",
duration: time.Second,
durationThreshold: time.Millisecond * 500,
},
{
name: "timeout",
ctx: peer.NewContext(context.Background(), &peer.Peer{
Addr: addrs[0],
}),
req: "foo",
},
{
name: "timeout",
ctx: context.Background(),
req: "foo",
duration: slowThreshold.Load() + time.Second,
},
}
DontLogContentForMethod("foo")
// reset ignoreContentMethods
t.Cleanup(func() {
ignoreContentMethods = sync.Map{}
})
for _, test := range tests {
test := test
t.Run(test.name, func(t *testing.T) {
t.Parallel()
assert.NotPanics(t, func() {
logDuration(test.ctx, "foo", test.req, test.duration,
collection.NewSet[string](), test.durationThreshold)
})
})
}
}
func Test_shouldLogContent(t *testing.T) {
type args struct {
method string
staticNotLoggingContentMethods []string
}
tests := []struct {
name string
args args
want bool
setup func()
}{
{
"empty",
args{
method: "foo",
},
true,
nil,
},
{
"static",
args{
method: "foo",
staticNotLoggingContentMethods: []string{"foo"},
},
false,
nil,
},
{
"dynamic",
args{
method: "foo",
},
false,
func() {
DontLogContentForMethod("foo")
},
},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
if tt.setup != nil {
tt.setup()
}
// reset ignoreContentMethods
t.Cleanup(func() {
ignoreContentMethods = sync.Map{}
})
set := collection.NewSet[string]()
set.Add(tt.args.staticNotLoggingContentMethods...)
assert.Equalf(t, tt.want, shouldLogContent(tt.args.method, set),
"shouldLogContent(%v, %v)", tt.args.method, tt.args.staticNotLoggingContentMethods)
})
}
}
func Test_isSlow(t *testing.T) {
type args struct {
duration time.Duration
staticSlowThreshold time.Duration
}
tests := []struct {
name string
args args
want bool
setup func()
}{
{
"default",
args{
duration: time.Millisecond * 501,
},
true,
nil,
},
{
"static",
args{
duration: time.Millisecond * 200,
staticSlowThreshold: time.Millisecond * 100,
},
true,
nil,
},
{
"dynamic",
args{
duration: time.Millisecond * 200,
},
true,
func() {
SetSlowThreshold(time.Millisecond * 100)
},
},
{
"config_priority_fix",
args{
duration: time.Millisecond * 600,
staticSlowThreshold: time.Millisecond * 1000,
},
false,
nil,
},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
if tt.setup != nil {
tt.setup()
}
// reset slowThreshold
t.Cleanup(func() {
slowThreshold = syncx.ForAtomicDuration(defaultSlowThreshold)
})
assert.Equalf(t, tt.want, isSlow(tt.args.duration, tt.args.staticSlowThreshold),
"isSlow(%v, %v)", tt.args.duration, tt.args.staticSlowThreshold)
})
}
}
| go | MIT | 8e7e5695eb2095917864b5d6615dab4c90bde3ac | 2026-01-07T08:36:18.042207Z | false |
zeromicro/go-zero | https://github.com/zeromicro/go-zero/blob/8e7e5695eb2095917864b5d6615dab4c90bde3ac/zrpc/internal/serverinterceptors/prometheusinterceptor_test.go | zrpc/internal/serverinterceptors/prometheusinterceptor_test.go | package serverinterceptors
import (
"context"
"testing"
"github.com/stretchr/testify/assert"
"github.com/zeromicro/go-zero/core/prometheus"
"google.golang.org/grpc"
)
func TestUnaryPromMetricInterceptor_Disabled(t *testing.T) {
_, err := UnaryPrometheusInterceptor(context.Background(), nil, &grpc.UnaryServerInfo{
FullMethod: "/",
}, func(ctx context.Context, req any) (any, error) {
return nil, nil
})
assert.Nil(t, err)
}
func TestUnaryPromMetricInterceptor_Enabled(t *testing.T) {
prometheus.StartAgent(prometheus.Config{
Host: "localhost",
Path: "/",
})
_, err := UnaryPrometheusInterceptor(context.Background(), nil, &grpc.UnaryServerInfo{
FullMethod: "/",
}, func(ctx context.Context, req any) (any, error) {
return nil, nil
})
assert.Nil(t, err)
}
| go | MIT | 8e7e5695eb2095917864b5d6615dab4c90bde3ac | 2026-01-07T08:36:18.042207Z | false |
zeromicro/go-zero | https://github.com/zeromicro/go-zero/blob/8e7e5695eb2095917864b5d6615dab4c90bde3ac/zrpc/internal/serverinterceptors/tracinginterceptor.go | zrpc/internal/serverinterceptors/tracinginterceptor.go | package serverinterceptors
import (
"context"
ztrace "github.com/zeromicro/go-zero/core/trace"
"go.opentelemetry.io/otel"
"go.opentelemetry.io/otel/baggage"
"go.opentelemetry.io/otel/codes"
"go.opentelemetry.io/otel/trace"
"google.golang.org/grpc"
gcodes "google.golang.org/grpc/codes"
"google.golang.org/grpc/metadata"
"google.golang.org/grpc/status"
)
// UnaryTracingInterceptor is a grpc.UnaryServerInterceptor for opentelemetry.
func UnaryTracingInterceptor(ctx context.Context, req any, info *grpc.UnaryServerInfo,
handler grpc.UnaryHandler) (any, error) {
ctx, span := startSpan(ctx, info.FullMethod)
defer span.End()
ztrace.MessageReceived.Event(ctx, 1, req)
resp, err := handler(ctx, req)
if err != nil {
s, ok := status.FromError(err)
if ok {
span.SetStatus(codes.Error, s.Message())
span.SetAttributes(ztrace.StatusCodeAttr(s.Code()))
ztrace.MessageSent.Event(ctx, 1, s.Proto())
} else {
span.SetStatus(codes.Error, err.Error())
}
return nil, err
}
span.SetAttributes(ztrace.StatusCodeAttr(gcodes.OK))
ztrace.MessageSent.Event(ctx, 1, resp)
return resp, nil
}
// StreamTracingInterceptor returns a grpc.StreamServerInterceptor for opentelemetry.
func StreamTracingInterceptor(svr any, ss grpc.ServerStream, info *grpc.StreamServerInfo,
handler grpc.StreamHandler) error {
ctx, span := startSpan(ss.Context(), info.FullMethod)
defer span.End()
if err := handler(svr, wrapServerStream(ctx, ss)); err != nil {
s, ok := status.FromError(err)
if ok {
span.SetStatus(codes.Error, s.Message())
span.SetAttributes(ztrace.StatusCodeAttr(s.Code()))
} else {
span.SetStatus(codes.Error, err.Error())
}
return err
}
span.SetAttributes(ztrace.StatusCodeAttr(gcodes.OK))
return nil
}
// serverStream wraps around the embedded grpc.ServerStream,
// and intercepts the RecvMsg and SendMsg method call.
type serverStream struct {
grpc.ServerStream
ctx context.Context
receivedMessageID int
sentMessageID int
}
func (w *serverStream) Context() context.Context {
return w.ctx
}
func (w *serverStream) RecvMsg(m any) error {
err := w.ServerStream.RecvMsg(m)
if err == nil {
w.receivedMessageID++
ztrace.MessageReceived.Event(w.Context(), w.receivedMessageID, m)
}
return err
}
func (w *serverStream) SendMsg(m any) error {
err := w.ServerStream.SendMsg(m)
w.sentMessageID++
ztrace.MessageSent.Event(w.Context(), w.sentMessageID, m)
return err
}
func startSpan(ctx context.Context, method string) (context.Context, trace.Span) {
md, ok := metadata.FromIncomingContext(ctx)
if !ok {
md = metadata.MD{}
}
bags, spanCtx := ztrace.Extract(ctx, otel.GetTextMapPropagator(), &md)
ctx = baggage.ContextWithBaggage(ctx, bags)
tr := otel.Tracer(ztrace.TraceName)
name, attr := ztrace.SpanInfo(method, ztrace.PeerFromCtx(ctx))
return tr.Start(trace.ContextWithRemoteSpanContext(ctx, spanCtx), name,
trace.WithSpanKind(trace.SpanKindServer), trace.WithAttributes(attr...))
}
// wrapServerStream wraps the given grpc.ServerStream with the given context.
func wrapServerStream(ctx context.Context, ss grpc.ServerStream) *serverStream {
return &serverStream{
ServerStream: ss,
ctx: ctx,
}
}
| go | MIT | 8e7e5695eb2095917864b5d6615dab4c90bde3ac | 2026-01-07T08:36:18.042207Z | false |
zeromicro/go-zero | https://github.com/zeromicro/go-zero/blob/8e7e5695eb2095917864b5d6615dab4c90bde3ac/zrpc/internal/serverinterceptors/sheddinginterceptor_test.go | zrpc/internal/serverinterceptors/sheddinginterceptor_test.go | package serverinterceptors
import (
"context"
"testing"
"github.com/stretchr/testify/assert"
"github.com/zeromicro/go-zero/core/load"
"github.com/zeromicro/go-zero/core/stat"
"google.golang.org/grpc"
"google.golang.org/grpc/codes"
"google.golang.org/grpc/status"
)
func TestUnarySheddingInterceptor(t *testing.T) {
tests := []struct {
name string
allow bool
handleErr error
expect error
}{
{
name: "allow",
allow: true,
handleErr: nil,
expect: nil,
},
{
name: "allow",
allow: true,
handleErr: context.DeadlineExceeded,
expect: context.DeadlineExceeded,
},
{
name: "reject",
allow: false,
handleErr: nil,
expect: status.Error(codes.ResourceExhausted, load.ErrServiceOverloaded.Error()),
},
}
for _, test := range tests {
test := test
t.Run(test.name, func(t *testing.T) {
t.Parallel()
shedder := mockedShedder{allow: test.allow}
metrics := stat.NewMetrics("mock")
interceptor := UnarySheddingInterceptor(shedder, metrics)
_, err := interceptor(context.Background(), nil, &grpc.UnaryServerInfo{
FullMethod: "/",
}, func(ctx context.Context, req any) (any, error) {
return nil, test.handleErr
})
assert.Equal(t, test.expect, err)
})
}
}
type mockedShedder struct {
allow bool
}
func (m mockedShedder) Allow() (load.Promise, error) {
if m.allow {
return mockedPromise{}, nil
}
return nil, load.ErrServiceOverloaded
}
type mockedPromise struct{}
func (m mockedPromise) Pass() {
}
func (m mockedPromise) Fail() {
}
| go | MIT | 8e7e5695eb2095917864b5d6615dab4c90bde3ac | 2026-01-07T08:36:18.042207Z | false |
zeromicro/go-zero | https://github.com/zeromicro/go-zero/blob/8e7e5695eb2095917864b5d6615dab4c90bde3ac/zrpc/internal/serverinterceptors/breakerinterceptor_test.go | zrpc/internal/serverinterceptors/breakerinterceptor_test.go | package serverinterceptors
import (
"context"
"testing"
"github.com/stretchr/testify/assert"
"github.com/zeromicro/go-zero/core/breaker"
"google.golang.org/grpc"
"google.golang.org/grpc/codes"
"google.golang.org/grpc/status"
)
func TestStreamBreakerInterceptor(t *testing.T) {
err := StreamBreakerInterceptor(nil, nil, &grpc.StreamServerInfo{
FullMethod: "any",
}, func(_ any, _ grpc.ServerStream) error {
return status.New(codes.DeadlineExceeded, "any").Err()
})
assert.NotNil(t, err)
}
func TestUnaryBreakerInterceptor(t *testing.T) {
_, err := UnaryBreakerInterceptor(context.Background(), nil, &grpc.UnaryServerInfo{
FullMethod: "any",
}, func(_ context.Context, _ any) (any, error) {
return nil, status.New(codes.DeadlineExceeded, "any").Err()
})
assert.NotNil(t, err)
}
func TestUnaryBreakerInterceptorOK(t *testing.T) {
_, err := UnaryBreakerInterceptor(context.Background(), nil, &grpc.UnaryServerInfo{
FullMethod: "any",
}, func(_ context.Context, _ any) (any, error) {
return nil, nil
})
assert.NoError(t, err)
}
func TestUnaryBreakerInterceptor_Unavailable(t *testing.T) {
_, err := UnaryBreakerInterceptor(context.Background(), nil, &grpc.UnaryServerInfo{
FullMethod: "any",
}, func(_ context.Context, _ any) (any, error) {
return nil, breaker.ErrServiceUnavailable
})
assert.NotNil(t, err)
code := status.Code(err)
assert.Equal(t, codes.Unavailable, code)
}
func TestUnaryBreakerInterceptor_Deadline(t *testing.T) {
for i := 0; i < 1000; i++ {
_, err := UnaryBreakerInterceptor(context.Background(), nil, &grpc.UnaryServerInfo{
FullMethod: "any",
}, func(_ context.Context, _ any) (any, error) {
return nil, context.DeadlineExceeded
})
switch status.Code(err) {
case codes.Unavailable:
default:
assert.Equal(t, context.DeadlineExceeded, err)
}
}
var dropped bool
for i := 0; i < 100; i++ {
_, err := UnaryBreakerInterceptor(context.Background(), nil, &grpc.UnaryServerInfo{
FullMethod: "any",
}, func(_ context.Context, _ any) (any, error) {
return nil, context.DeadlineExceeded
})
switch status.Code(err) {
case codes.Unavailable:
dropped = true
default:
assert.Equal(t, context.DeadlineExceeded, err)
}
}
assert.True(t, dropped)
}
| go | MIT | 8e7e5695eb2095917864b5d6615dab4c90bde3ac | 2026-01-07T08:36:18.042207Z | false |
zeromicro/go-zero | https://github.com/zeromicro/go-zero/blob/8e7e5695eb2095917864b5d6615dab4c90bde3ac/zrpc/internal/serverinterceptors/timeoutinterceptor_test.go | zrpc/internal/serverinterceptors/timeoutinterceptor_test.go | package serverinterceptors
import (
"context"
"sync"
"testing"
"time"
"github.com/stretchr/testify/assert"
"google.golang.org/grpc"
"google.golang.org/grpc/codes"
"google.golang.org/grpc/status"
)
var (
deadlineExceededErr = status.Error(codes.DeadlineExceeded, context.DeadlineExceeded.Error())
canceledErr = status.Error(codes.Canceled, context.Canceled.Error())
)
func TestUnaryTimeoutInterceptor(t *testing.T) {
interceptor := UnaryTimeoutInterceptor(time.Millisecond * 10)
_, err := interceptor(context.Background(), nil, &grpc.UnaryServerInfo{
FullMethod: "/",
}, func(ctx context.Context, req any) (any, error) {
return nil, nil
})
assert.Nil(t, err)
}
func TestUnaryTimeoutInterceptor_panic(t *testing.T) {
interceptor := UnaryTimeoutInterceptor(time.Millisecond * 10)
assert.Panics(t, func() {
_, _ = interceptor(context.Background(), nil, &grpc.UnaryServerInfo{
FullMethod: "/",
}, func(ctx context.Context, req any) (any, error) {
panic("any")
})
})
}
func TestUnaryTimeoutInterceptor_timeout(t *testing.T) {
const timeout = time.Millisecond * 10
interceptor := UnaryTimeoutInterceptor(timeout)
ctx, cancel := context.WithTimeout(context.Background(), time.Minute)
defer cancel()
var wg sync.WaitGroup
wg.Add(1)
_, err := interceptor(ctx, nil, &grpc.UnaryServerInfo{
FullMethod: "/",
}, func(ctx context.Context, req any) (any, error) {
defer wg.Done()
tm, ok := ctx.Deadline()
assert.True(t, ok)
assert.True(t, tm.Before(time.Now().Add(timeout+time.Millisecond)))
return nil, nil
})
wg.Wait()
assert.Nil(t, err)
}
func TestUnaryTimeoutInterceptor_timeoutExpire(t *testing.T) {
const timeout = time.Millisecond * 10
interceptor := UnaryTimeoutInterceptor(timeout)
ctx, cancel := context.WithTimeout(context.Background(), time.Millisecond)
defer cancel()
var wg sync.WaitGroup
wg.Add(1)
_, err := interceptor(ctx, nil, &grpc.UnaryServerInfo{
FullMethod: "/",
}, func(ctx context.Context, req any) (any, error) {
defer wg.Done()
time.Sleep(time.Millisecond * 50)
return nil, nil
})
wg.Wait()
assert.EqualValues(t, deadlineExceededErr, err)
}
func TestUnaryTimeoutInterceptor_cancel(t *testing.T) {
const timeout = time.Minute * 10
interceptor := UnaryTimeoutInterceptor(timeout)
ctx, cancel := context.WithCancel(context.Background())
cancel()
var wg sync.WaitGroup
wg.Add(1)
_, err := interceptor(ctx, nil, &grpc.UnaryServerInfo{
FullMethod: "/",
}, func(ctx context.Context, req any) (any, error) {
defer wg.Done()
time.Sleep(time.Millisecond * 50)
return nil, nil
})
wg.Wait()
assert.EqualValues(t, canceledErr, err)
}
type tempServer struct {
timeout time.Duration
}
func (s *tempServer) run(duration time.Duration) {
time.Sleep(duration)
}
func TestUnaryTimeoutInterceptor_TimeoutStrategy(t *testing.T) {
type args struct {
interceptorTimeout time.Duration
contextTimeout time.Duration
serverTimeout time.Duration
runTime time.Duration
fullMethod string
}
var tests = []struct {
name string
args args
wantErr error
}{
{
name: "do not timeout with interceptor timeout",
args: args{
interceptorTimeout: time.Second,
contextTimeout: time.Second * 5,
serverTimeout: time.Second * 3,
runTime: time.Millisecond * 50,
fullMethod: "/",
},
wantErr: nil,
},
{
name: "timeout with interceptor timeout",
args: args{
interceptorTimeout: time.Second,
contextTimeout: time.Second * 5,
serverTimeout: time.Second * 3,
runTime: time.Second * 2,
fullMethod: "/",
},
wantErr: deadlineExceededErr,
},
}
for _, tt := range tests {
tt := tt
t.Run(tt.name, func(t *testing.T) {
t.Parallel()
interceptor := UnaryTimeoutInterceptor(tt.args.interceptorTimeout)
ctx, cancel := context.WithTimeout(context.Background(), tt.args.contextTimeout)
defer cancel()
svr := &tempServer{timeout: tt.args.serverTimeout}
_, err := interceptor(ctx, nil, &grpc.UnaryServerInfo{
Server: svr,
FullMethod: tt.args.fullMethod,
}, func(ctx context.Context, req interface{}) (interface{}, error) {
svr.run(tt.args.runTime)
return nil, nil
})
t.Logf("error: %+v", err)
assert.EqualValues(t, tt.wantErr, err)
})
}
}
func TestUnaryTimeoutInterceptor_SpecifiedTimeout(t *testing.T) {
type args struct {
interceptorTimeout time.Duration
contextTimeout time.Duration
method string
methodTimeout time.Duration
runTime time.Duration
}
var tests = []struct {
name string
args args
wantErr error
}{
{
name: "do not timeout without set timeout for full method",
args: args{
interceptorTimeout: time.Second,
contextTimeout: time.Second * 5,
method: "/run",
runTime: time.Millisecond * 50,
},
wantErr: nil,
},
{
name: "do not timeout with set timeout for full method",
args: args{
interceptorTimeout: time.Second,
contextTimeout: time.Second * 5,
method: "/run/do_not_timeout",
methodTimeout: time.Second * 3,
runTime: time.Second * 2,
},
wantErr: nil,
},
{
name: "timeout with set timeout for full method",
args: args{
interceptorTimeout: time.Second,
contextTimeout: time.Second * 5,
method: "/run/timeout",
methodTimeout: time.Millisecond * 100,
runTime: time.Millisecond * 500,
},
wantErr: deadlineExceededErr,
},
}
for _, tt := range tests {
tt := tt
t.Run(tt.name, func(t *testing.T) {
t.Parallel()
var specifiedTimeouts []MethodTimeoutConf
if tt.args.methodTimeout > 0 {
specifiedTimeouts = []MethodTimeoutConf{
{
FullMethod: tt.args.method,
Timeout: tt.args.methodTimeout,
},
}
}
interceptor := UnaryTimeoutInterceptor(tt.args.interceptorTimeout, specifiedTimeouts...)
ctx, cancel := context.WithTimeout(context.Background(), tt.args.contextTimeout)
defer cancel()
_, err := interceptor(ctx, nil, &grpc.UnaryServerInfo{
FullMethod: tt.args.method,
}, func(ctx context.Context, req interface{}) (interface{}, error) {
time.Sleep(tt.args.runTime)
return nil, nil
})
t.Logf("error: %+v", err)
assert.EqualValues(t, tt.wantErr, err)
})
}
}
| go | MIT | 8e7e5695eb2095917864b5d6615dab4c90bde3ac | 2026-01-07T08:36:18.042207Z | false |
zeromicro/go-zero | https://github.com/zeromicro/go-zero/blob/8e7e5695eb2095917864b5d6615dab4c90bde3ac/zrpc/internal/serverinterceptors/authinterceptor_test.go | zrpc/internal/serverinterceptors/authinterceptor_test.go | package serverinterceptors
import (
"context"
"testing"
"github.com/stretchr/testify/assert"
"github.com/zeromicro/go-zero/core/stores/redis/redistest"
"github.com/zeromicro/go-zero/zrpc/internal/auth"
"google.golang.org/grpc"
"google.golang.org/grpc/metadata"
)
func TestStreamAuthorizeInterceptor(t *testing.T) {
tests := []struct {
name string
app string
token string
strict bool
hasError bool
}{
{
name: "strict=false",
strict: false,
hasError: false,
},
{
name: "strict=true",
strict: true,
hasError: true,
},
{
name: "strict=true,with token",
app: "foo",
token: "bar",
strict: true,
hasError: false,
},
{
name: "strict=true,with error token",
app: "foo",
token: "error",
strict: true,
hasError: true,
},
}
store := redistest.CreateRedis(t)
for _, test := range tests {
t.Run(test.name, func(t *testing.T) {
if len(test.app) > 0 {
assert.Nil(t, store.Hset("apps", test.app, test.token))
defer store.Hdel("apps", test.app)
}
authenticator, err := auth.NewAuthenticator(store, "apps", test.strict)
assert.Nil(t, err)
interceptor := StreamAuthorizeInterceptor(authenticator)
md := metadata.New(map[string]string{
"app": "foo",
"token": "bar",
})
ctx := metadata.NewIncomingContext(context.Background(), md)
stream := mockedStream{ctx: ctx}
err = interceptor(nil, stream, nil, func(_ any, _ grpc.ServerStream) error {
return nil
})
if test.hasError {
assert.NotNil(t, err)
} else {
assert.Nil(t, err)
}
})
}
}
func TestUnaryAuthorizeInterceptor(t *testing.T) {
tests := []struct {
name string
app string
token string
strict bool
hasError bool
}{
{
name: "strict=false",
strict: false,
hasError: false,
},
{
name: "strict=true",
strict: true,
hasError: true,
},
{
name: "strict=true,with token",
app: "foo",
token: "bar",
strict: true,
hasError: false,
},
{
name: "strict=true,with error token",
app: "foo",
token: "error",
strict: true,
hasError: true,
},
}
store := redistest.CreateRedis(t)
for _, test := range tests {
t.Run(test.name, func(t *testing.T) {
if len(test.app) > 0 {
assert.Nil(t, store.Hset("apps", test.app, test.token))
defer store.Hdel("apps", test.app)
}
authenticator, err := auth.NewAuthenticator(store, "apps", test.strict)
assert.Nil(t, err)
interceptor := UnaryAuthorizeInterceptor(authenticator)
md := metadata.New(map[string]string{
"app": "foo",
"token": "bar",
})
ctx := metadata.NewIncomingContext(context.Background(), md)
_, err = interceptor(ctx, nil, nil,
func(ctx context.Context, req any) (any, error) {
return nil, nil
})
if test.hasError {
assert.NotNil(t, err)
} else {
assert.Nil(t, err)
}
if test.strict {
_, err = interceptor(context.Background(), nil, nil,
func(ctx context.Context, req any) (any, error) {
return nil, nil
})
assert.NotNil(t, err)
var md metadata.MD
ctx := metadata.NewIncomingContext(context.Background(), md)
_, err = interceptor(ctx, nil, nil,
func(ctx context.Context, req any) (any, error) {
return nil, nil
})
assert.NotNil(t, err)
md = metadata.New(map[string]string{
"app": "",
"token": "",
})
ctx = metadata.NewIncomingContext(context.Background(), md)
_, err = interceptor(ctx, nil, nil,
func(ctx context.Context, req any) (any, error) {
return nil, nil
})
assert.NotNil(t, err)
}
})
}
}
type mockedStream struct {
ctx context.Context
}
func (m mockedStream) SetHeader(_ metadata.MD) error {
return nil
}
func (m mockedStream) SendHeader(_ metadata.MD) error {
return nil
}
func (m mockedStream) SetTrailer(_ metadata.MD) {
}
func (m mockedStream) Context() context.Context {
return m.ctx
}
func (m mockedStream) SendMsg(_ any) error {
return nil
}
func (m mockedStream) RecvMsg(_ any) error {
return nil
}
| go | MIT | 8e7e5695eb2095917864b5d6615dab4c90bde3ac | 2026-01-07T08:36:18.042207Z | false |
zeromicro/go-zero | https://github.com/zeromicro/go-zero/blob/8e7e5695eb2095917864b5d6615dab4c90bde3ac/zrpc/internal/serverinterceptors/recoverinterceptor.go | zrpc/internal/serverinterceptors/recoverinterceptor.go | package serverinterceptors
import (
"context"
"runtime/debug"
"github.com/zeromicro/go-zero/core/logc"
"google.golang.org/grpc"
"google.golang.org/grpc/codes"
"google.golang.org/grpc/status"
)
// StreamRecoverInterceptor catches panics in processing stream requests and recovers.
func StreamRecoverInterceptor(svr any, stream grpc.ServerStream, _ *grpc.StreamServerInfo,
handler grpc.StreamHandler) (err error) {
defer handleCrash(func(r any) {
err = toPanicError(context.Background(), r)
})
return handler(svr, stream)
}
// UnaryRecoverInterceptor catches panics in processing unary requests and recovers.
func UnaryRecoverInterceptor(ctx context.Context, req any, _ *grpc.UnaryServerInfo,
handler grpc.UnaryHandler) (resp any, err error) {
defer handleCrash(func(r any) {
err = toPanicError(ctx, r)
})
return handler(ctx, req)
}
func handleCrash(handler func(any)) {
if r := recover(); r != nil {
handler(r)
}
}
func toPanicError(ctx context.Context, r any) error {
logc.Errorf(ctx, "%+v\n\n%s", r, debug.Stack())
return status.Errorf(codes.Internal, "panic: %v", r)
}
| go | MIT | 8e7e5695eb2095917864b5d6615dab4c90bde3ac | 2026-01-07T08:36:18.042207Z | false |
zeromicro/go-zero | https://github.com/zeromicro/go-zero/blob/8e7e5695eb2095917864b5d6615dab4c90bde3ac/zrpc/internal/serverinterceptors/timeoutinterceptor.go | zrpc/internal/serverinterceptors/timeoutinterceptor.go | package serverinterceptors
import (
"context"
"errors"
"fmt"
"runtime/debug"
"strings"
"sync"
"time"
"google.golang.org/grpc"
"google.golang.org/grpc/codes"
"google.golang.org/grpc/status"
)
type (
// MethodTimeoutConf defines specified timeout for gRPC method.
MethodTimeoutConf struct {
FullMethod string
Timeout time.Duration
}
methodTimeouts map[string]time.Duration
)
// UnaryTimeoutInterceptor returns a func that sets timeout to incoming unary requests.
func UnaryTimeoutInterceptor(timeout time.Duration,
methodTimeouts ...MethodTimeoutConf) grpc.UnaryServerInterceptor {
timeouts := buildMethodTimeouts(methodTimeouts)
return func(ctx context.Context, req any, info *grpc.UnaryServerInfo,
handler grpc.UnaryHandler) (any, error) {
t := getTimeoutByUnaryServerInfo(info.FullMethod, timeouts, timeout)
ctx, cancel := context.WithTimeout(ctx, t)
defer cancel()
var resp any
var err error
var lock sync.Mutex
done := make(chan struct{})
// create channel with buffer size 1 to avoid goroutine leak
panicChan := make(chan any, 1)
go func() {
defer func() {
if p := recover(); p != nil {
// attach call stack to avoid missing in different goroutine
panicChan <- fmt.Sprintf("%+v\n\n%s", p, strings.TrimSpace(string(debug.Stack())))
}
}()
lock.Lock()
defer lock.Unlock()
resp, err = handler(ctx, req)
close(done)
}()
select {
case p := <-panicChan:
panic(p)
case <-done:
lock.Lock()
defer lock.Unlock()
return resp, err
case <-ctx.Done():
err := ctx.Err()
if errors.Is(err, context.Canceled) {
err = status.Error(codes.Canceled, err.Error())
} else if errors.Is(err, context.DeadlineExceeded) {
err = status.Error(codes.DeadlineExceeded, err.Error())
}
return nil, err
}
}
}
func buildMethodTimeouts(timeouts []MethodTimeoutConf) methodTimeouts {
mt := make(methodTimeouts, len(timeouts))
for _, st := range timeouts {
if st.FullMethod != "" {
mt[st.FullMethod] = st.Timeout
}
}
return mt
}
func getTimeoutByUnaryServerInfo(method string, timeouts methodTimeouts,
defaultTimeout time.Duration) time.Duration {
if v, ok := timeouts[method]; ok {
return v
}
return defaultTimeout
}
| go | MIT | 8e7e5695eb2095917864b5d6615dab4c90bde3ac | 2026-01-07T08:36:18.042207Z | false |
zeromicro/go-zero | https://github.com/zeromicro/go-zero/blob/8e7e5695eb2095917864b5d6615dab4c90bde3ac/zrpc/internal/serverinterceptors/prometheusinterceptor.go | zrpc/internal/serverinterceptors/prometheusinterceptor.go | package serverinterceptors
import (
"context"
"strconv"
"github.com/zeromicro/go-zero/core/metric"
"github.com/zeromicro/go-zero/core/timex"
"google.golang.org/grpc"
"google.golang.org/grpc/status"
)
const serverNamespace = "rpc_server"
var (
metricServerReqDur = metric.NewHistogramVec(&metric.HistogramVecOpts{
Namespace: serverNamespace,
Subsystem: "requests",
Name: "duration_ms",
Help: "rpc server requests duration(ms).",
Labels: []string{"method"},
Buckets: []float64{1, 2, 5, 10, 25, 50, 100, 250, 500, 1000, 2000, 5000},
})
metricServerReqCodeTotal = metric.NewCounterVec(&metric.CounterVecOpts{
Namespace: serverNamespace,
Subsystem: "requests",
Name: "code_total",
Help: "rpc server requests code count.",
Labels: []string{"method", "code"},
})
)
// UnaryPrometheusInterceptor reports the statistics to the prometheus server.
func UnaryPrometheusInterceptor(ctx context.Context, req any,
info *grpc.UnaryServerInfo, handler grpc.UnaryHandler) (any, error) {
startTime := timex.Now()
resp, err := handler(ctx, req)
metricServerReqDur.Observe(timex.Since(startTime).Milliseconds(), info.FullMethod)
metricServerReqCodeTotal.Inc(info.FullMethod, strconv.Itoa(int(status.Code(err))))
return resp, err
}
| go | MIT | 8e7e5695eb2095917864b5d6615dab4c90bde3ac | 2026-01-07T08:36:18.042207Z | false |
zeromicro/go-zero | https://github.com/zeromicro/go-zero/blob/8e7e5695eb2095917864b5d6615dab4c90bde3ac/zrpc/internal/serverinterceptors/authinterceptor.go | zrpc/internal/serverinterceptors/authinterceptor.go | package serverinterceptors
import (
"context"
"github.com/zeromicro/go-zero/zrpc/internal/auth"
"google.golang.org/grpc"
)
// StreamAuthorizeInterceptor returns a func that uses given authenticator in processing stream requests.
func StreamAuthorizeInterceptor(authenticator *auth.Authenticator) grpc.StreamServerInterceptor {
return func(svr any, stream grpc.ServerStream, info *grpc.StreamServerInfo,
handler grpc.StreamHandler) error {
if err := authenticator.Authenticate(stream.Context()); err != nil {
return err
}
return handler(svr, stream)
}
}
// UnaryAuthorizeInterceptor returns a func that uses given authenticator in processing unary requests.
func UnaryAuthorizeInterceptor(authenticator *auth.Authenticator) grpc.UnaryServerInterceptor {
return func(ctx context.Context, req any, info *grpc.UnaryServerInfo,
handler grpc.UnaryHandler) (any, error) {
if err := authenticator.Authenticate(ctx); err != nil {
return nil, err
}
return handler(ctx, req)
}
}
| go | MIT | 8e7e5695eb2095917864b5d6615dab4c90bde3ac | 2026-01-07T08:36:18.042207Z | false |
zeromicro/go-zero | https://github.com/zeromicro/go-zero/blob/8e7e5695eb2095917864b5d6615dab4c90bde3ac/zrpc/internal/serverinterceptors/recoverinterceptor_test.go | zrpc/internal/serverinterceptors/recoverinterceptor_test.go | package serverinterceptors
import (
"context"
"testing"
"github.com/stretchr/testify/assert"
"github.com/zeromicro/go-zero/core/logx"
"google.golang.org/grpc"
)
func init() {
logx.Disable()
}
func TestStreamCrashInterceptor(t *testing.T) {
err := StreamRecoverInterceptor(nil, nil, nil, func(
svr any, stream grpc.ServerStream) error {
panic("mock panic")
})
assert.NotNil(t, err)
}
func TestUnaryCrashInterceptor(t *testing.T) {
_, err := UnaryRecoverInterceptor(context.Background(), nil, nil,
func(ctx context.Context, req any) (any, error) {
panic("mock panic")
})
assert.NotNil(t, err)
}
| go | MIT | 8e7e5695eb2095917864b5d6615dab4c90bde3ac | 2026-01-07T08:36:18.042207Z | false |
zeromicro/go-zero | https://github.com/zeromicro/go-zero/blob/8e7e5695eb2095917864b5d6615dab4c90bde3ac/zrpc/internal/serverinterceptors/sheddinginterceptor.go | zrpc/internal/serverinterceptors/sheddinginterceptor.go | package serverinterceptors
import (
"context"
"errors"
"sync"
"github.com/zeromicro/go-zero/core/load"
"github.com/zeromicro/go-zero/core/stat"
"google.golang.org/grpc"
"google.golang.org/grpc/codes"
"google.golang.org/grpc/status"
)
const serviceType = "rpc"
var (
sheddingStat *load.SheddingStat
lock sync.Mutex
)
// UnarySheddingInterceptor returns a func that does load shedding on processing unary requests.
func UnarySheddingInterceptor(shedder load.Shedder, metrics *stat.Metrics) grpc.UnaryServerInterceptor {
ensureSheddingStat()
return func(ctx context.Context, req any, info *grpc.UnaryServerInfo,
handler grpc.UnaryHandler) (val any, err error) {
sheddingStat.IncrementTotal()
var promise load.Promise
promise, err = shedder.Allow()
if err != nil {
metrics.AddDrop()
sheddingStat.IncrementDrop()
err = status.Error(codes.ResourceExhausted, err.Error())
return
}
defer func() {
if errors.Is(err, context.DeadlineExceeded) {
promise.Fail()
} else {
sheddingStat.IncrementPass()
promise.Pass()
}
}()
return handler(ctx, req)
}
}
func ensureSheddingStat() {
lock.Lock()
if sheddingStat == nil {
sheddingStat = load.NewSheddingStat(serviceType)
}
lock.Unlock()
}
| go | MIT | 8e7e5695eb2095917864b5d6615dab4c90bde3ac | 2026-01-07T08:36:18.042207Z | false |
zeromicro/go-zero | https://github.com/zeromicro/go-zero/blob/8e7e5695eb2095917864b5d6615dab4c90bde3ac/zrpc/internal/serverinterceptors/tracinginterceptor_test.go | zrpc/internal/serverinterceptors/tracinginterceptor_test.go | package serverinterceptors
import (
"context"
"errors"
"io"
"sync"
"sync/atomic"
"testing"
"github.com/stretchr/testify/assert"
ztrace "github.com/zeromicro/go-zero/core/trace"
"github.com/zeromicro/go-zero/core/trace/tracetest"
"go.opentelemetry.io/otel/attribute"
tcodes "go.opentelemetry.io/otel/codes"
"go.opentelemetry.io/otel/sdk/trace"
semconv "go.opentelemetry.io/otel/semconv/v1.4.0"
"google.golang.org/grpc"
"google.golang.org/grpc/codes"
"google.golang.org/grpc/metadata"
"google.golang.org/grpc/status"
)
func TestUnaryOpenTracingInterceptor_Disable(t *testing.T) {
_, err := UnaryTracingInterceptor(context.Background(), nil, &grpc.UnaryServerInfo{
FullMethod: "/",
}, func(ctx context.Context, req any) (any, error) {
return nil, nil
})
assert.Nil(t, err)
}
func TestUnaryOpenTracingInterceptor_Enabled(t *testing.T) {
ztrace.StartAgent(ztrace.Config{
Name: "go-zero-test",
Endpoint: "http://localhost:14268",
OtlpHttpPath: "/v1/traces",
Batcher: "otlphttp",
Sampler: 1.0,
})
defer ztrace.StopAgent()
_, err := UnaryTracingInterceptor(context.Background(), nil, &grpc.UnaryServerInfo{
FullMethod: "/package.TestService.GetUser",
}, func(ctx context.Context, req any) (any, error) {
return nil, nil
})
assert.Nil(t, err)
}
func TestUnaryTracingInterceptor(t *testing.T) {
t.Run("normal", func(t *testing.T) {
var run int32
me := tracetest.NewInMemoryExporter(t)
_, err := UnaryTracingInterceptor(context.Background(), nil, &grpc.UnaryServerInfo{
FullMethod: "/proto.Hello/Echo",
}, func(ctx context.Context, req any) (any, error) {
atomic.AddInt32(&run, 1)
return nil, nil
})
assert.Nil(t, err)
assert.Equal(t, int32(1), atomic.LoadInt32(&run))
assert.Equal(t, 1, len(me.GetSpans()))
span := me.GetSpans()[0].Snapshot()
assert.Equal(t, 2, len(span.Events()))
assert.ElementsMatch(t, []attribute.KeyValue{
ztrace.RPCSystemGRPC,
semconv.RPCServiceKey.String("proto.Hello"),
semconv.RPCMethodKey.String("Echo"),
ztrace.StatusCodeAttr(codes.OK),
}, span.Attributes())
})
t.Run("grpc error status", func(t *testing.T) {
me := tracetest.NewInMemoryExporter(t)
_, err := UnaryTracingInterceptor(context.Background(), nil, &grpc.UnaryServerInfo{
FullMethod: "/proto.Hello/Echo",
}, func(ctx context.Context, req any) (any, error) {
return nil, status.Errorf(codes.Unknown, "test")
})
assert.Error(t, err)
assert.Equal(t, 1, len(me.GetSpans()))
span := me.GetSpans()[0].Snapshot()
assert.Equal(t, trace.Status{
Code: tcodes.Error,
Description: "test",
}, span.Status())
assert.Equal(t, 2, len(span.Events()))
assert.ElementsMatch(t, []attribute.KeyValue{
ztrace.RPCSystemGRPC,
semconv.RPCServiceKey.String("proto.Hello"),
semconv.RPCMethodKey.String("Echo"),
ztrace.StatusCodeAttr(codes.Unknown),
}, span.Attributes())
})
t.Run("non grpc status error", func(t *testing.T) {
me := tracetest.NewInMemoryExporter(t)
_, err := UnaryTracingInterceptor(context.Background(), nil, &grpc.UnaryServerInfo{
FullMethod: "/proto.Hello/Echo",
}, func(ctx context.Context, req any) (any, error) {
return nil, errors.New("test")
})
assert.Error(t, err)
assert.Equal(t, 1, len(me.GetSpans()))
span := me.GetSpans()[0].Snapshot()
assert.Equal(t, trace.Status{
Code: tcodes.Error,
Description: "test",
}, span.Status())
assert.Equal(t, 1, len(span.Events()))
assert.ElementsMatch(t, []attribute.KeyValue{
ztrace.RPCSystemGRPC,
semconv.RPCServiceKey.String("proto.Hello"),
semconv.RPCMethodKey.String("Echo"),
}, span.Attributes())
})
}
func TestUnaryTracingInterceptor_WithError(t *testing.T) {
tests := []struct {
name string
err error
}{
{
name: "normal error",
err: errors.New("dummy"),
},
{
name: "grpc error",
err: status.Error(codes.DataLoss, "dummy"),
},
}
for _, test := range tests {
test := test
t.Run(test.name, func(t *testing.T) {
t.Parallel()
var wg sync.WaitGroup
wg.Add(1)
var md metadata.MD
ctx := metadata.NewIncomingContext(context.Background(), md)
_, err := UnaryTracingInterceptor(ctx, nil, &grpc.UnaryServerInfo{
FullMethod: "/",
}, func(ctx context.Context, req any) (any, error) {
defer wg.Done()
return nil, test.err
})
wg.Wait()
assert.Equal(t, test.err, err)
})
}
}
func TestStreamTracingInterceptor_GrpcFormat(t *testing.T) {
var run int32
var wg sync.WaitGroup
wg.Add(1)
var md metadata.MD
ctx := metadata.NewIncomingContext(context.Background(), md)
stream := mockedServerStream{ctx: ctx}
err := StreamTracingInterceptor(nil, &stream, &grpc.StreamServerInfo{
FullMethod: "/foo",
}, func(svr any, stream grpc.ServerStream) error {
defer wg.Done()
atomic.AddInt32(&run, 1)
return nil
})
wg.Wait()
assert.Nil(t, err)
assert.Equal(t, int32(1), atomic.LoadInt32(&run))
}
func TestStreamTracingInterceptor_FinishWithGrpcError(t *testing.T) {
tests := []struct {
name string
err error
}{
{
name: "receive event",
err: status.Error(codes.DataLoss, "dummy"),
},
{
name: "error event",
err: status.Error(codes.DataLoss, "dummy"),
},
}
for _, test := range tests {
test := test
t.Run(test.name, func(t *testing.T) {
t.Parallel()
var wg sync.WaitGroup
wg.Add(1)
var md metadata.MD
ctx := metadata.NewIncomingContext(context.Background(), md)
stream := mockedServerStream{ctx: ctx}
err := StreamTracingInterceptor(nil, &stream, &grpc.StreamServerInfo{
FullMethod: "/foo",
}, func(svr any, stream grpc.ServerStream) error {
defer wg.Done()
return test.err
})
wg.Wait()
assert.Equal(t, test.err, err)
})
}
}
func TestStreamTracingInterceptor_WithError(t *testing.T) {
tests := []struct {
name string
err error
}{
{
name: "normal error",
err: errors.New("dummy"),
},
{
name: "grpc error",
err: status.Error(codes.DataLoss, "dummy"),
},
}
for _, test := range tests {
test := test
t.Run(test.name, func(t *testing.T) {
t.Parallel()
var wg sync.WaitGroup
wg.Add(1)
var md metadata.MD
ctx := metadata.NewIncomingContext(context.Background(), md)
stream := mockedServerStream{ctx: ctx}
err := StreamTracingInterceptor(nil, &stream, &grpc.StreamServerInfo{
FullMethod: "/foo",
}, func(svr any, stream grpc.ServerStream) error {
defer wg.Done()
return test.err
})
wg.Wait()
assert.Equal(t, test.err, err)
})
}
}
func TestClientStream_RecvMsg(t *testing.T) {
tests := []struct {
name string
err error
}{
{
name: "nil error",
},
{
name: "EOF",
err: io.EOF,
},
{
name: "dummy error",
err: errors.New("dummy"),
},
}
for _, test := range tests {
test := test
t.Run(test.name, func(t *testing.T) {
t.Parallel()
stream := wrapServerStream(context.Background(), &mockedServerStream{
ctx: context.Background(),
err: test.err,
})
assert.Equal(t, test.err, stream.RecvMsg(nil))
})
}
}
func TestServerStream_SendMsg(t *testing.T) {
tests := []struct {
name string
err error
}{
{
name: "nil error",
},
{
name: "with error",
err: errors.New("dummy"),
},
}
for _, test := range tests {
test := test
t.Run(test.name, func(t *testing.T) {
t.Parallel()
stream := wrapServerStream(context.Background(), &mockedServerStream{
ctx: context.Background(),
err: test.err,
})
assert.Equal(t, test.err, stream.SendMsg(nil))
})
}
}
type mockedServerStream struct {
ctx context.Context
err error
}
func (m *mockedServerStream) SetHeader(_ metadata.MD) error {
panic("implement me")
}
func (m *mockedServerStream) SendHeader(_ metadata.MD) error {
panic("implement me")
}
func (m *mockedServerStream) SetTrailer(_ metadata.MD) {
panic("implement me")
}
func (m *mockedServerStream) Context() context.Context {
if m.ctx == nil {
return context.Background()
}
return m.ctx
}
func (m *mockedServerStream) SendMsg(_ any) error {
return m.err
}
func (m *mockedServerStream) RecvMsg(_ any) error {
return m.err
}
| go | MIT | 8e7e5695eb2095917864b5d6615dab4c90bde3ac | 2026-01-07T08:36:18.042207Z | false |
zeromicro/go-zero | https://github.com/zeromicro/go-zero/blob/8e7e5695eb2095917864b5d6615dab4c90bde3ac/zrpc/internal/serverinterceptors/breakerinterceptor.go | zrpc/internal/serverinterceptors/breakerinterceptor.go | package serverinterceptors
import (
"context"
"errors"
"github.com/zeromicro/go-zero/core/breaker"
"github.com/zeromicro/go-zero/core/errorx"
"github.com/zeromicro/go-zero/zrpc/internal/codes"
"google.golang.org/grpc"
gcodes "google.golang.org/grpc/codes"
"google.golang.org/grpc/status"
)
// StreamBreakerInterceptor is an interceptor that acts as a circuit breaker.
func StreamBreakerInterceptor(svr any, stream grpc.ServerStream, info *grpc.StreamServerInfo,
handler grpc.StreamHandler) error {
breakerName := info.FullMethod
err := breaker.DoWithAcceptable(breakerName, func() error {
return handler(svr, stream)
}, serverSideAcceptable)
return convertError(err)
}
// UnaryBreakerInterceptor is an interceptor that acts as a circuit breaker.
func UnaryBreakerInterceptor(ctx context.Context, req any, info *grpc.UnaryServerInfo,
handler grpc.UnaryHandler) (resp any, err error) {
breakerName := info.FullMethod
err = breaker.DoWithAcceptableCtx(ctx, breakerName, func() error {
var err error
resp, err = handler(ctx, req)
return err
}, serverSideAcceptable)
return resp, convertError(err)
}
func convertError(err error) error {
if err == nil {
return nil
}
// we don't convert context.DeadlineExceeded to status error,
// because grpc will convert it and return to the client.
if errors.Is(err, breaker.ErrServiceUnavailable) {
return status.Error(gcodes.Unavailable, err.Error())
}
return err
}
func serverSideAcceptable(err error) bool {
if errorx.In(err, context.DeadlineExceeded, breaker.ErrServiceUnavailable) {
return false
}
return codes.Acceptable(err)
}
| go | MIT | 8e7e5695eb2095917864b5d6615dab4c90bde3ac | 2026-01-07T08:36:18.042207Z | false |
zeromicro/go-zero | https://github.com/zeromicro/go-zero/blob/8e7e5695eb2095917864b5d6615dab4c90bde3ac/zrpc/internal/auth/credential.go | zrpc/internal/auth/credential.go | package auth
import (
"context"
"google.golang.org/grpc/metadata"
)
// A Credential is used to authenticate.
type Credential struct {
App string
Token string
}
// GetRequestMetadata gets the request metadata.
func (c *Credential) GetRequestMetadata(context.Context, ...string) (map[string]string, error) {
return map[string]string{
appKey: c.App,
tokenKey: c.Token,
}, nil
}
// RequireTransportSecurity always returns false.
func (c *Credential) RequireTransportSecurity() bool {
return false
}
// ParseCredential parses credential from given ctx.
func ParseCredential(ctx context.Context) Credential {
var credential Credential
md, ok := metadata.FromIncomingContext(ctx)
if !ok {
return credential
}
apps, tokens := md[appKey], md[tokenKey]
if len(apps) == 0 || len(tokens) == 0 {
return credential
}
app, token := apps[0], tokens[0]
if len(app) == 0 || len(token) == 0 {
return credential
}
credential.App = app
credential.Token = token
return credential
}
| go | MIT | 8e7e5695eb2095917864b5d6615dab4c90bde3ac | 2026-01-07T08:36:18.042207Z | false |
zeromicro/go-zero | https://github.com/zeromicro/go-zero/blob/8e7e5695eb2095917864b5d6615dab4c90bde3ac/zrpc/internal/auth/credential_test.go | zrpc/internal/auth/credential_test.go | package auth
import (
"context"
"testing"
"github.com/stretchr/testify/assert"
"google.golang.org/grpc/metadata"
)
func TestParseCredential(t *testing.T) {
tests := []struct {
name string
withNil bool
withEmptyMd bool
app string
token string
}{
{
name: "nil",
withNil: true,
},
{
name: "empty md",
withEmptyMd: true,
},
{
name: "empty",
},
{
name: "valid",
app: "foo",
token: "bar",
},
}
for _, test := range tests {
test := test
t.Run(test.name, func(t *testing.T) {
t.Parallel()
var ctx context.Context
if test.withNil {
ctx = context.Background()
} else if test.withEmptyMd {
ctx = metadata.NewIncomingContext(context.Background(), metadata.MD{})
} else {
md := metadata.New(map[string]string{
"app": test.app,
"token": test.token,
})
ctx = metadata.NewIncomingContext(context.Background(), md)
}
cred := ParseCredential(ctx)
assert.False(t, cred.RequireTransportSecurity())
m, err := cred.GetRequestMetadata(context.Background())
assert.Nil(t, err)
assert.Equal(t, test.app, m[appKey])
assert.Equal(t, test.token, m[tokenKey])
})
}
}
| go | MIT | 8e7e5695eb2095917864b5d6615dab4c90bde3ac | 2026-01-07T08:36:18.042207Z | false |
zeromicro/go-zero | https://github.com/zeromicro/go-zero/blob/8e7e5695eb2095917864b5d6615dab4c90bde3ac/zrpc/internal/auth/vars.go | zrpc/internal/auth/vars.go | package auth
const (
appKey = "app"
tokenKey = "token"
accessDenied = "access denied"
missingMetadata = "app/token required"
)
| go | MIT | 8e7e5695eb2095917864b5d6615dab4c90bde3ac | 2026-01-07T08:36:18.042207Z | false |
zeromicro/go-zero | https://github.com/zeromicro/go-zero/blob/8e7e5695eb2095917864b5d6615dab4c90bde3ac/zrpc/internal/auth/auth.go | zrpc/internal/auth/auth.go | package auth
import (
"context"
"time"
"github.com/zeromicro/go-zero/core/collection"
"github.com/zeromicro/go-zero/core/stores/redis"
"google.golang.org/grpc/codes"
"google.golang.org/grpc/metadata"
"google.golang.org/grpc/status"
)
const defaultExpiration = 5 * time.Minute
// An Authenticator is used to authenticate the rpc requests.
type Authenticator struct {
store *redis.Redis
key string
cache *collection.Cache
strict bool
}
// NewAuthenticator returns an Authenticator.
func NewAuthenticator(store *redis.Redis, key string, strict bool) (*Authenticator, error) {
cache, err := collection.NewCache(defaultExpiration)
if err != nil {
return nil, err
}
return &Authenticator{
store: store,
key: key,
cache: cache,
strict: strict,
}, nil
}
// Authenticate authenticates the given ctx.
func (a *Authenticator) Authenticate(ctx context.Context) error {
md, ok := metadata.FromIncomingContext(ctx)
if !ok {
return status.Error(codes.Unauthenticated, missingMetadata)
}
apps, tokens := md[appKey], md[tokenKey]
if len(apps) == 0 || len(tokens) == 0 {
return status.Error(codes.Unauthenticated, missingMetadata)
}
app, token := apps[0], tokens[0]
if len(app) == 0 || len(token) == 0 {
return status.Error(codes.Unauthenticated, missingMetadata)
}
return a.validate(app, token)
}
func (a *Authenticator) validate(app, token string) error {
expect, err := a.cache.Take(app, func() (any, error) {
return a.store.Hget(a.key, app)
})
if err != nil {
if a.strict {
return status.Error(codes.Internal, err.Error())
}
return nil
}
if token != expect {
return status.Error(codes.Unauthenticated, accessDenied)
}
return nil
}
| go | MIT | 8e7e5695eb2095917864b5d6615dab4c90bde3ac | 2026-01-07T08:36:18.042207Z | false |
zeromicro/go-zero | https://github.com/zeromicro/go-zero/blob/8e7e5695eb2095917864b5d6615dab4c90bde3ac/zrpc/internal/auth/auth_test.go | zrpc/internal/auth/auth_test.go | package auth
import (
"context"
"testing"
"github.com/stretchr/testify/assert"
"github.com/zeromicro/go-zero/core/stores/redis/redistest"
"google.golang.org/grpc/metadata"
)
func TestAuthenticator(t *testing.T) {
tests := []struct {
name string
app string
token string
strict bool
hasError bool
}{
{
name: "strict=false",
strict: false,
hasError: false,
},
{
name: "strict=true",
strict: true,
hasError: true,
},
{
name: "strict=true,with token",
app: "foo",
token: "bar",
strict: true,
hasError: false,
},
{
name: "strict=true,with error token",
app: "foo",
token: "error",
strict: true,
hasError: true,
},
}
store := redistest.CreateRedis(t)
for _, test := range tests {
t.Run(test.name, func(t *testing.T) {
if len(test.app) > 0 {
assert.Nil(t, store.Hset("apps", test.app, test.token))
defer store.Hdel("apps", test.app)
}
authenticator, err := NewAuthenticator(store, "apps", test.strict)
assert.Nil(t, err)
assert.NotNil(t, authenticator.Authenticate(context.Background()))
md := metadata.New(map[string]string{})
ctx := metadata.NewIncomingContext(context.Background(), md)
assert.NotNil(t, authenticator.Authenticate(ctx))
md = metadata.New(map[string]string{
"app": "",
"token": "",
})
ctx = metadata.NewIncomingContext(context.Background(), md)
assert.NotNil(t, authenticator.Authenticate(ctx))
md = metadata.New(map[string]string{
"app": "foo",
"token": "bar",
})
ctx = metadata.NewIncomingContext(context.Background(), md)
err = authenticator.Authenticate(ctx)
if test.hasError {
assert.NotNil(t, err)
} else {
assert.Nil(t, err)
}
})
}
}
| go | MIT | 8e7e5695eb2095917864b5d6615dab4c90bde3ac | 2026-01-07T08:36:18.042207Z | false |
zeromicro/go-zero | https://github.com/zeromicro/go-zero/blob/8e7e5695eb2095917864b5d6615dab4c90bde3ac/zrpc/internal/clientinterceptors/durationinterceptor.go | zrpc/internal/clientinterceptors/durationinterceptor.go | package clientinterceptors
import (
"context"
"path"
"sync"
"time"
"github.com/zeromicro/go-zero/core/lang"
"github.com/zeromicro/go-zero/core/logx"
"github.com/zeromicro/go-zero/core/syncx"
"github.com/zeromicro/go-zero/core/timex"
"google.golang.org/grpc"
)
const defaultSlowThreshold = time.Millisecond * 500
var (
notLoggingContentMethods sync.Map
slowThreshold = syncx.ForAtomicDuration(defaultSlowThreshold)
)
// DurationInterceptor is an interceptor that logs the processing time.
func DurationInterceptor(ctx context.Context, method string, req, reply any,
cc *grpc.ClientConn, invoker grpc.UnaryInvoker, opts ...grpc.CallOption) error {
serverName := path.Join(cc.Target(), method)
start := timex.Now()
err := invoker(ctx, method, req, reply, cc, opts...)
if err != nil {
logger := logx.WithContext(ctx).WithDuration(timex.Since(start))
_, ok := notLoggingContentMethods.Load(method)
if ok {
logger.Errorf("fail - %s - %s", serverName, err.Error())
} else {
logger.Errorf("fail - %s - %v - %s", serverName, req, err.Error())
}
} else {
elapsed := timex.Since(start)
if elapsed > slowThreshold.Load() {
logger := logx.WithContext(ctx).WithDuration(elapsed)
_, ok := notLoggingContentMethods.Load(method)
if ok {
logger.Slowf("[RPC] ok - slowcall - %s", serverName)
} else {
logger.Slowf("[RPC] ok - slowcall - %s - %v - %v", serverName, req, reply)
}
}
}
return err
}
// DontLogContentForMethod disable logging content for given method.
func DontLogContentForMethod(method string) {
notLoggingContentMethods.Store(method, lang.Placeholder)
}
// SetSlowThreshold sets the slow threshold.
func SetSlowThreshold(threshold time.Duration) {
slowThreshold.Set(threshold)
}
| go | MIT | 8e7e5695eb2095917864b5d6615dab4c90bde3ac | 2026-01-07T08:36:18.042207Z | false |
zeromicro/go-zero | https://github.com/zeromicro/go-zero/blob/8e7e5695eb2095917864b5d6615dab4c90bde3ac/zrpc/internal/clientinterceptors/prometheusinterceptor_test.go | zrpc/internal/clientinterceptors/prometheusinterceptor_test.go | package clientinterceptors
import (
"context"
"errors"
"testing"
"github.com/stretchr/testify/assert"
"github.com/zeromicro/go-zero/core/prometheus"
"google.golang.org/grpc"
)
func TestPromMetricInterceptor(t *testing.T) {
tests := []struct {
name string
enable bool
err error
}{
{
name: "nil",
enable: true,
err: nil,
},
{
name: "with error",
enable: true,
err: errors.New("mock"),
},
{
name: "disabled",
},
}
for _, test := range tests {
t.Run(test.name, func(t *testing.T) {
if test.enable {
prometheus.StartAgent(prometheus.Config{
Host: "localhost",
Path: "/",
})
}
cc := new(grpc.ClientConn)
err := PrometheusInterceptor(context.Background(), "/foo", nil, nil, cc,
func(ctx context.Context, method string, req, reply any, cc *grpc.ClientConn,
opts ...grpc.CallOption) error {
return test.err
})
assert.Equal(t, test.err, err)
})
}
}
| go | MIT | 8e7e5695eb2095917864b5d6615dab4c90bde3ac | 2026-01-07T08:36:18.042207Z | false |
zeromicro/go-zero | https://github.com/zeromicro/go-zero/blob/8e7e5695eb2095917864b5d6615dab4c90bde3ac/zrpc/internal/clientinterceptors/tracinginterceptor.go | zrpc/internal/clientinterceptors/tracinginterceptor.go | package clientinterceptors
import (
"context"
"errors"
"io"
ztrace "github.com/zeromicro/go-zero/core/trace"
"go.opentelemetry.io/otel"
"go.opentelemetry.io/otel/codes"
"go.opentelemetry.io/otel/trace"
"google.golang.org/grpc"
gcodes "google.golang.org/grpc/codes"
"google.golang.org/grpc/metadata"
"google.golang.org/grpc/status"
)
const (
receiveEndEvent streamEventType = iota
errorEvent
)
// UnaryTracingInterceptor returns a grpc.UnaryClientInterceptor for opentelemetry.
func UnaryTracingInterceptor(ctx context.Context, method string, req, reply any,
cc *grpc.ClientConn, invoker grpc.UnaryInvoker, opts ...grpc.CallOption) error {
ctx, span := startSpan(ctx, method, cc.Target())
defer span.End()
ztrace.MessageSent.Event(ctx, 1, req)
err := invoker(ctx, method, req, reply, cc, opts...)
ztrace.MessageReceived.Event(ctx, 1, reply)
if err != nil {
s, ok := status.FromError(err)
if ok {
span.SetStatus(codes.Error, s.Message())
span.SetAttributes(ztrace.StatusCodeAttr(s.Code()))
} else {
span.SetStatus(codes.Error, err.Error())
}
return err
}
span.SetAttributes(ztrace.StatusCodeAttr(gcodes.OK))
return nil
}
// StreamTracingInterceptor returns a grpc.StreamClientInterceptor for opentelemetry.
func StreamTracingInterceptor(ctx context.Context, desc *grpc.StreamDesc, cc *grpc.ClientConn,
method string, streamer grpc.Streamer, opts ...grpc.CallOption) (grpc.ClientStream, error) {
ctx, span := startSpan(ctx, method, cc.Target())
s, err := streamer(ctx, desc, cc, method, opts...)
if err != nil {
st, ok := status.FromError(err)
if ok {
span.SetStatus(codes.Error, st.Message())
span.SetAttributes(ztrace.StatusCodeAttr(st.Code()))
} else {
span.SetStatus(codes.Error, err.Error())
}
span.End()
return s, err
}
stream := wrapClientStream(ctx, s, desc)
go func() {
if err := <-stream.Finished; err != nil {
s, ok := status.FromError(err)
if ok {
span.SetStatus(codes.Error, s.Message())
span.SetAttributes(ztrace.StatusCodeAttr(s.Code()))
} else {
span.SetStatus(codes.Error, err.Error())
}
} else {
span.SetAttributes(ztrace.StatusCodeAttr(gcodes.OK))
}
span.End()
}()
return stream, nil
}
type (
streamEventType int
streamEvent struct {
Type streamEventType
Err error
}
clientStream struct {
grpc.ClientStream
Finished chan error
desc *grpc.StreamDesc
events chan streamEvent
eventsDone chan struct{}
receivedMessageID int
sentMessageID int
}
)
func (w *clientStream) CloseSend() error {
err := w.ClientStream.CloseSend()
if err != nil {
w.sendStreamEvent(errorEvent, err)
}
return err
}
func (w *clientStream) Header() (metadata.MD, error) {
md, err := w.ClientStream.Header()
if err != nil {
w.sendStreamEvent(errorEvent, err)
}
return md, err
}
func (w *clientStream) RecvMsg(m any) error {
err := w.ClientStream.RecvMsg(m)
if err == nil && !w.desc.ServerStreams {
w.sendStreamEvent(receiveEndEvent, nil)
} else if errors.Is(err, io.EOF) {
w.sendStreamEvent(receiveEndEvent, nil)
} else if err != nil {
w.sendStreamEvent(errorEvent, err)
} else {
w.receivedMessageID++
ztrace.MessageReceived.Event(w.Context(), w.receivedMessageID, m)
}
return err
}
func (w *clientStream) SendMsg(m any) error {
err := w.ClientStream.SendMsg(m)
w.sentMessageID++
ztrace.MessageSent.Event(w.Context(), w.sentMessageID, m)
if err != nil {
w.sendStreamEvent(errorEvent, err)
}
return err
}
func (w *clientStream) sendStreamEvent(eventType streamEventType, err error) {
select {
case <-w.eventsDone:
case w.events <- streamEvent{Type: eventType, Err: err}:
}
}
func startSpan(ctx context.Context, method, target string) (context.Context, trace.Span) {
md, ok := metadata.FromOutgoingContext(ctx)
if !ok {
md = metadata.MD{}
}
tr := otel.Tracer(ztrace.TraceName)
name, attr := ztrace.SpanInfo(method, target)
ctx, span := tr.Start(ctx, name, trace.WithSpanKind(trace.SpanKindClient),
trace.WithAttributes(attr...))
ztrace.Inject(ctx, otel.GetTextMapPropagator(), &md)
ctx = metadata.NewOutgoingContext(ctx, md)
return ctx, span
}
// wrapClientStream wraps s with given ctx and desc.
func wrapClientStream(ctx context.Context, s grpc.ClientStream, desc *grpc.StreamDesc) *clientStream {
events := make(chan streamEvent)
eventsDone := make(chan struct{})
finished := make(chan error)
go func() {
defer close(eventsDone)
for {
select {
case event := <-events:
switch event.Type {
case receiveEndEvent:
finished <- nil
return
case errorEvent:
finished <- event.Err
return
}
case <-ctx.Done():
finished <- ctx.Err()
return
}
}
}()
return &clientStream{
ClientStream: s,
desc: desc,
events: events,
eventsDone: eventsDone,
Finished: finished,
}
}
| go | MIT | 8e7e5695eb2095917864b5d6615dab4c90bde3ac | 2026-01-07T08:36:18.042207Z | false |
zeromicro/go-zero | https://github.com/zeromicro/go-zero/blob/8e7e5695eb2095917864b5d6615dab4c90bde3ac/zrpc/internal/clientinterceptors/breakerinterceptor_test.go | zrpc/internal/clientinterceptors/breakerinterceptor_test.go | package clientinterceptors
import (
"context"
"errors"
"testing"
"github.com/stretchr/testify/assert"
"github.com/zeromicro/go-zero/core/breaker"
"github.com/zeromicro/go-zero/core/stat"
rcodes "github.com/zeromicro/go-zero/zrpc/internal/codes"
"google.golang.org/grpc"
"google.golang.org/grpc/codes"
"google.golang.org/grpc/status"
)
func init() {
stat.SetReporter(nil)
}
type mockError struct {
st *status.Status
}
func (m mockError) GRPCStatus() *status.Status {
return m.st
}
func (m mockError) Error() string {
return "mocked error"
}
func TestBreakerInterceptorNotFound(t *testing.T) {
err := mockError{st: status.New(codes.NotFound, "any")}
for i := 0; i < 1000; i++ {
assert.Equal(t, err, breaker.DoWithAcceptable("call", func() error {
return err
}, rcodes.Acceptable))
}
}
func TestBreakerInterceptorDeadlineExceeded(t *testing.T) {
err := mockError{st: status.New(codes.DeadlineExceeded, "any")}
errs := make(map[error]int)
for i := 0; i < 1000; i++ {
e := breaker.DoWithAcceptable("call", func() error {
return err
}, rcodes.Acceptable)
errs[e]++
}
assert.Equal(t, 2, len(errs))
assert.True(t, errs[err] > 0)
assert.True(t, errs[breaker.ErrServiceUnavailable] > 0)
}
func TestBreakerInterceptor(t *testing.T) {
tests := []struct {
name string
err error
}{
{
name: "nil",
err: nil,
},
{
name: "with error",
err: errors.New("mock"),
},
}
for _, test := range tests {
t.Run(test.name, func(t *testing.T) {
cc := new(grpc.ClientConn)
err := BreakerInterceptor(context.Background(), "/foo", nil, nil, cc,
func(ctx context.Context, method string, req, reply any, cc *grpc.ClientConn,
opts ...grpc.CallOption) error {
return test.err
})
assert.Equal(t, test.err, err)
})
}
}
| go | MIT | 8e7e5695eb2095917864b5d6615dab4c90bde3ac | 2026-01-07T08:36:18.042207Z | false |
zeromicro/go-zero | https://github.com/zeromicro/go-zero/blob/8e7e5695eb2095917864b5d6615dab4c90bde3ac/zrpc/internal/clientinterceptors/timeoutinterceptor_test.go | zrpc/internal/clientinterceptors/timeoutinterceptor_test.go | package clientinterceptors
import (
"context"
"strconv"
"sync"
"testing"
"time"
"github.com/stretchr/testify/assert"
"google.golang.org/grpc"
)
func TestTimeoutInterceptor(t *testing.T) {
timeouts := []time.Duration{0, time.Millisecond * 10}
for _, timeout := range timeouts {
t.Run(strconv.FormatInt(int64(timeout), 10), func(t *testing.T) {
interceptor := TimeoutInterceptor(timeout)
cc := new(grpc.ClientConn)
err := interceptor(context.Background(), "/foo", nil, nil, cc,
func(ctx context.Context, method string, req, reply any, cc *grpc.ClientConn,
opts ...grpc.CallOption) error {
return nil
},
)
assert.Nil(t, err)
})
}
}
func TestTimeoutInterceptor_timeout(t *testing.T) {
const timeout = time.Millisecond * 10
interceptor := TimeoutInterceptor(timeout)
ctx, cancel := context.WithTimeout(context.Background(), time.Minute)
defer cancel()
var wg sync.WaitGroup
wg.Add(1)
cc := new(grpc.ClientConn)
err := interceptor(ctx, "/foo", nil, nil, cc,
func(ctx context.Context, method string, req, reply any, cc *grpc.ClientConn,
opts ...grpc.CallOption) error {
defer wg.Done()
tm, ok := ctx.Deadline()
assert.True(t, ok)
assert.True(t, tm.Before(time.Now().Add(timeout+time.Millisecond)))
return nil
})
wg.Wait()
assert.Nil(t, err)
}
func TestTimeoutInterceptor_panic(t *testing.T) {
timeouts := []time.Duration{0, time.Millisecond * 10}
for _, timeout := range timeouts {
t.Run(strconv.FormatInt(int64(timeout), 10), func(t *testing.T) {
interceptor := TimeoutInterceptor(timeout)
cc := new(grpc.ClientConn)
assert.Panics(t, func() {
_ = interceptor(context.Background(), "/foo", nil, nil, cc,
func(ctx context.Context, method string, req, reply any, cc *grpc.ClientConn,
opts ...grpc.CallOption) error {
panic("any")
},
)
})
})
}
}
func TestTimeoutInterceptor_TimeoutCallOption(t *testing.T) {
type args struct {
interceptorTimeout time.Duration
callOptionTimeout time.Duration
runTime time.Duration
}
var tests = []struct {
name string
args args
wantErr error
}{
{
name: "do not timeout without call option timeout",
args: args{
interceptorTimeout: time.Second,
runTime: time.Millisecond * 50,
},
wantErr: nil,
},
{
name: "timeout without call option timeout",
args: args{
interceptorTimeout: time.Second,
runTime: time.Second * 2,
},
wantErr: context.DeadlineExceeded,
},
{
name: "do not timeout with call option timeout",
args: args{
interceptorTimeout: time.Second,
callOptionTimeout: time.Second * 3,
runTime: time.Second * 2,
},
wantErr: nil,
},
}
for _, tt := range tests {
tt := tt
t.Run(tt.name, func(t *testing.T) {
t.Parallel()
interceptor := TimeoutInterceptor(tt.args.interceptorTimeout)
cc := new(grpc.ClientConn)
var co []grpc.CallOption
if tt.args.callOptionTimeout > 0 {
co = append(co, WithCallTimeout(tt.args.callOptionTimeout))
}
err := interceptor(context.Background(), "/foo", nil, nil, cc,
func(ctx context.Context, method string, req, reply interface{}, cc *grpc.ClientConn,
opts ...grpc.CallOption) error {
timer := time.NewTimer(tt.args.runTime)
defer timer.Stop()
select {
case <-timer.C:
return nil
case <-ctx.Done():
return ctx.Err()
}
}, co...,
)
t.Logf("error: %+v", err)
assert.EqualValues(t, tt.wantErr, err)
})
}
}
| go | MIT | 8e7e5695eb2095917864b5d6615dab4c90bde3ac | 2026-01-07T08:36:18.042207Z | false |
zeromicro/go-zero | https://github.com/zeromicro/go-zero/blob/8e7e5695eb2095917864b5d6615dab4c90bde3ac/zrpc/internal/clientinterceptors/timeoutinterceptor.go | zrpc/internal/clientinterceptors/timeoutinterceptor.go | package clientinterceptors
import (
"context"
"time"
"google.golang.org/grpc"
)
// TimeoutCallOption is a call option that controls timeout.
type TimeoutCallOption struct {
grpc.EmptyCallOption
timeout time.Duration
}
// TimeoutInterceptor is an interceptor that controls timeout.
func TimeoutInterceptor(timeout time.Duration) grpc.UnaryClientInterceptor {
return func(ctx context.Context, method string, req, reply any, cc *grpc.ClientConn,
invoker grpc.UnaryInvoker, opts ...grpc.CallOption) error {
t := getTimeoutFromCallOptions(opts, timeout)
if t <= 0 {
return invoker(ctx, method, req, reply, cc, opts...)
}
ctx, cancel := context.WithTimeout(ctx, t)
defer cancel()
return invoker(ctx, method, req, reply, cc, opts...)
}
}
// WithCallTimeout returns a call option that controls method call timeout.
func WithCallTimeout(timeout time.Duration) grpc.CallOption {
return TimeoutCallOption{
timeout: timeout,
}
}
func getTimeoutFromCallOptions(opts []grpc.CallOption, defaultTimeout time.Duration) time.Duration {
for _, opt := range opts {
if o, ok := opt.(TimeoutCallOption); ok {
return o.timeout
}
}
return defaultTimeout
}
| go | MIT | 8e7e5695eb2095917864b5d6615dab4c90bde3ac | 2026-01-07T08:36:18.042207Z | false |
zeromicro/go-zero | https://github.com/zeromicro/go-zero/blob/8e7e5695eb2095917864b5d6615dab4c90bde3ac/zrpc/internal/clientinterceptors/prometheusinterceptor.go | zrpc/internal/clientinterceptors/prometheusinterceptor.go | package clientinterceptors
import (
"context"
"strconv"
"github.com/zeromicro/go-zero/core/metric"
"github.com/zeromicro/go-zero/core/timex"
"google.golang.org/grpc"
"google.golang.org/grpc/status"
)
const clientNamespace = "rpc_client"
var (
metricClientReqDur = metric.NewHistogramVec(&metric.HistogramVecOpts{
Namespace: clientNamespace,
Subsystem: "requests",
Name: "duration_ms",
Help: "rpc client requests duration(ms).",
Labels: []string{"method"},
Buckets: []float64{1, 2, 5, 10, 25, 50, 100, 250, 500, 1000, 2000, 5000},
})
metricClientReqCodeTotal = metric.NewCounterVec(&metric.CounterVecOpts{
Namespace: clientNamespace,
Subsystem: "requests",
Name: "code_total",
Help: "rpc client requests code count.",
Labels: []string{"method", "code"},
})
)
// PrometheusInterceptor is an interceptor that reports to prometheus server.
func PrometheusInterceptor(ctx context.Context, method string, req, reply any,
cc *grpc.ClientConn, invoker grpc.UnaryInvoker, opts ...grpc.CallOption) error {
startTime := timex.Now()
err := invoker(ctx, method, req, reply, cc, opts...)
metricClientReqDur.Observe(timex.Since(startTime).Milliseconds(), method)
metricClientReqCodeTotal.Inc(method, strconv.Itoa(int(status.Code(err))))
return err
}
| go | MIT | 8e7e5695eb2095917864b5d6615dab4c90bde3ac | 2026-01-07T08:36:18.042207Z | false |
zeromicro/go-zero | https://github.com/zeromicro/go-zero/blob/8e7e5695eb2095917864b5d6615dab4c90bde3ac/zrpc/internal/clientinterceptors/durationinterceptor_test.go | zrpc/internal/clientinterceptors/durationinterceptor_test.go | package clientinterceptors
import (
"context"
"errors"
"testing"
"time"
"github.com/stretchr/testify/assert"
"google.golang.org/grpc"
)
func TestDurationInterceptor(t *testing.T) {
tests := []struct {
name string
err error
}{
{
name: "nil",
err: nil,
},
{
name: "with error",
err: errors.New("mock"),
},
}
for _, test := range tests {
t.Run(test.name, func(t *testing.T) {
cc := new(grpc.ClientConn)
err := DurationInterceptor(context.Background(), "/foo", nil, nil, cc,
func(ctx context.Context, method string, req, reply any, cc *grpc.ClientConn,
opts ...grpc.CallOption) error {
return test.err
})
assert.Equal(t, test.err, err)
})
}
DontLogContentForMethod("/foo")
t.Cleanup(func() {
notLoggingContentMethods.Delete("/foo")
})
for _, test := range tests {
t.Run(test.name, func(t *testing.T) {
cc := new(grpc.ClientConn)
err := DurationInterceptor(context.Background(), "/foo", nil, nil, cc,
func(ctx context.Context, method string, req, reply any, cc *grpc.ClientConn,
opts ...grpc.CallOption) error {
return test.err
})
assert.Equal(t, test.err, err)
})
}
}
func TestDurationInterceptorWithSlowThreshold(t *testing.T) {
SetSlowThreshold(time.Microsecond)
t.Cleanup(func() {
SetSlowThreshold(defaultSlowThreshold)
})
tests := []struct {
name string
err error
}{
{
name: "nil",
err: nil,
},
{
name: "with error",
err: errors.New("mock"),
},
}
for _, test := range tests {
t.Run(test.name, func(t *testing.T) {
cc := new(grpc.ClientConn)
err := DurationInterceptor(context.Background(), "/foo", nil, nil, cc,
func(ctx context.Context, method string, req, reply any, cc *grpc.ClientConn,
opts ...grpc.CallOption) error {
time.Sleep(time.Millisecond * 10)
return test.err
})
assert.Equal(t, test.err, err)
})
}
DontLogContentForMethod("/foo")
t.Cleanup(func() {
notLoggingContentMethods.Delete("/foo")
})
for _, test := range tests {
t.Run(test.name, func(t *testing.T) {
cc := new(grpc.ClientConn)
err := DurationInterceptor(context.Background(), "/foo", nil, nil, cc,
func(ctx context.Context, method string, req, reply any, cc *grpc.ClientConn,
opts ...grpc.CallOption) error {
time.Sleep(time.Millisecond * 10)
return test.err
})
assert.Equal(t, test.err, err)
})
}
}
func TestSetSlowThreshold(t *testing.T) {
assert.Equal(t, defaultSlowThreshold, slowThreshold.Load())
SetSlowThreshold(time.Second)
assert.Equal(t, time.Second, slowThreshold.Load())
}
| go | MIT | 8e7e5695eb2095917864b5d6615dab4c90bde3ac | 2026-01-07T08:36:18.042207Z | false |
zeromicro/go-zero | https://github.com/zeromicro/go-zero/blob/8e7e5695eb2095917864b5d6615dab4c90bde3ac/zrpc/internal/clientinterceptors/tracinginterceptor_test.go | zrpc/internal/clientinterceptors/tracinginterceptor_test.go | package clientinterceptors
import (
"context"
"errors"
"io"
"sync"
"sync/atomic"
"testing"
"github.com/stretchr/testify/assert"
ztrace "github.com/zeromicro/go-zero/core/trace"
"github.com/zeromicro/go-zero/core/trace/tracetest"
"go.opentelemetry.io/otel/attribute"
tcodes "go.opentelemetry.io/otel/codes"
"go.opentelemetry.io/otel/sdk/trace"
semconv "go.opentelemetry.io/otel/semconv/v1.4.0"
"google.golang.org/grpc"
"google.golang.org/grpc/codes"
"google.golang.org/grpc/metadata"
"google.golang.org/grpc/status"
)
func TestOpenTracingInterceptor(t *testing.T) {
ztrace.StartAgent(ztrace.Config{
Name: "go-zero-test",
Endpoint: "http://localhost:14268",
OtlpHttpPath: "/v1/traces",
Batcher: "otlphttp",
Sampler: 1.0,
})
defer ztrace.StopAgent()
cc := new(grpc.ClientConn)
ctx := metadata.NewOutgoingContext(context.Background(), metadata.MD{})
err := UnaryTracingInterceptor(ctx, "/ListUser", nil, nil, cc,
func(ctx context.Context, method string, req, reply any, cc *grpc.ClientConn,
opts ...grpc.CallOption) error {
return nil
})
assert.Nil(t, err)
}
func TestUnaryTracingInterceptor(t *testing.T) {
t.Run("normal", func(t *testing.T) {
var run int32
cc := new(grpc.ClientConn)
me := tracetest.NewInMemoryExporter(t)
err := UnaryTracingInterceptor(context.Background(), "/proto.Hello/Echo",
nil, nil, cc,
func(ctx context.Context, method string, req, reply any, cc *grpc.ClientConn,
opts ...grpc.CallOption) error {
atomic.AddInt32(&run, 1)
return nil
})
assert.Nil(t, err)
assert.Equal(t, int32(1), atomic.LoadInt32(&run))
assert.Equal(t, 1, len(me.GetSpans()))
span := me.GetSpans()[0].Snapshot()
assert.Equal(t, 2, len(span.Events()))
assert.ElementsMatch(t, []attribute.KeyValue{
ztrace.RPCSystemGRPC,
semconv.RPCServiceKey.String("proto.Hello"),
semconv.RPCMethodKey.String("Echo"),
ztrace.StatusCodeAttr(codes.OK),
}, span.Attributes())
})
t.Run("grpc error status", func(t *testing.T) {
me := tracetest.NewInMemoryExporter(t)
cc := new(grpc.ClientConn)
err := UnaryTracingInterceptor(context.Background(), "/proto.Hello/Echo",
nil, nil, cc,
func(ctx context.Context, method string, req, reply any, cc *grpc.ClientConn,
opts ...grpc.CallOption) error {
return status.Error(codes.Unknown, "test")
})
assert.Error(t, err)
assert.Equal(t, 1, len(me.GetSpans()))
span := me.GetSpans()[0].Snapshot()
assert.Equal(t, trace.Status{
Code: tcodes.Error,
Description: "test",
}, span.Status())
assert.Equal(t, 2, len(span.Events()))
assert.ElementsMatch(t, []attribute.KeyValue{
ztrace.RPCSystemGRPC,
semconv.RPCServiceKey.String("proto.Hello"),
semconv.RPCMethodKey.String("Echo"),
ztrace.StatusCodeAttr(codes.Unknown),
}, span.Attributes())
})
t.Run("non grpc status error", func(t *testing.T) {
me := tracetest.NewInMemoryExporter(t)
cc := new(grpc.ClientConn)
err := UnaryTracingInterceptor(context.Background(), "/proto.Hello/Echo",
nil, nil, cc,
func(ctx context.Context, method string, req, reply any, cc *grpc.ClientConn,
opts ...grpc.CallOption) error {
return errors.New("test")
})
assert.Error(t, err)
assert.Equal(t, 1, len(me.GetSpans()))
span := me.GetSpans()[0].Snapshot()
assert.Equal(t, trace.Status{
Code: tcodes.Error,
Description: "test",
}, span.Status())
assert.Equal(t, 2, len(span.Events()))
assert.ElementsMatch(t, []attribute.KeyValue{
ztrace.RPCSystemGRPC,
semconv.RPCServiceKey.String("proto.Hello"),
semconv.RPCMethodKey.String("Echo"),
}, span.Attributes())
})
}
func TestUnaryTracingInterceptor_WithError(t *testing.T) {
var run int32
var wg sync.WaitGroup
wg.Add(1)
cc := new(grpc.ClientConn)
err := UnaryTracingInterceptor(context.Background(), "/foo", nil, nil, cc,
func(ctx context.Context, method string, req, reply any, cc *grpc.ClientConn,
opts ...grpc.CallOption) error {
defer wg.Done()
atomic.AddInt32(&run, 1)
return errors.New("dummy")
})
wg.Wait()
assert.NotNil(t, err)
assert.Equal(t, int32(1), atomic.LoadInt32(&run))
}
func TestUnaryTracingInterceptor_WithStatusError(t *testing.T) {
var run int32
var wg sync.WaitGroup
wg.Add(1)
cc := new(grpc.ClientConn)
err := UnaryTracingInterceptor(context.Background(), "/foo", nil, nil, cc,
func(ctx context.Context, method string, req, reply any, cc *grpc.ClientConn,
opts ...grpc.CallOption) error {
defer wg.Done()
atomic.AddInt32(&run, 1)
return status.Error(codes.DataLoss, "dummy")
})
wg.Wait()
assert.NotNil(t, err)
assert.Equal(t, int32(1), atomic.LoadInt32(&run))
}
func TestStreamTracingInterceptor(t *testing.T) {
var run int32
var wg sync.WaitGroup
wg.Add(1)
cc := new(grpc.ClientConn)
_, err := StreamTracingInterceptor(context.Background(), nil, cc, "/foo",
func(ctx context.Context, desc *grpc.StreamDesc, cc *grpc.ClientConn, method string,
opts ...grpc.CallOption) (grpc.ClientStream, error) {
defer wg.Done()
atomic.AddInt32(&run, 1)
return nil, nil
})
wg.Wait()
assert.Nil(t, err)
assert.Equal(t, int32(1), atomic.LoadInt32(&run))
}
func TestStreamTracingInterceptor_FinishWithNormalError(t *testing.T) {
var wg sync.WaitGroup
wg.Add(1)
cc := new(grpc.ClientConn)
ctx, cancel := context.WithCancel(context.Background())
stream, err := StreamTracingInterceptor(ctx, nil, cc, "/foo",
func(ctx context.Context, desc *grpc.StreamDesc, cc *grpc.ClientConn, method string,
opts ...grpc.CallOption) (grpc.ClientStream, error) {
defer wg.Done()
return nil, nil
})
wg.Wait()
assert.Nil(t, err)
cancel()
cs := stream.(*clientStream)
<-cs.eventsDone
}
func TestStreamTracingInterceptor_FinishWithGrpcError(t *testing.T) {
tests := []struct {
name string
event streamEventType
err error
}{
{
name: "receive event",
event: receiveEndEvent,
err: status.Error(codes.DataLoss, "dummy"),
},
{
name: "error event",
event: errorEvent,
err: status.Error(codes.DataLoss, "dummy"),
},
}
for _, test := range tests {
test := test
t.Run(test.name, func(t *testing.T) {
t.Parallel()
var wg sync.WaitGroup
wg.Add(1)
cc := new(grpc.ClientConn)
stream, err := StreamTracingInterceptor(context.Background(), nil, cc, "/foo",
func(ctx context.Context, desc *grpc.StreamDesc, cc *grpc.ClientConn, method string,
opts ...grpc.CallOption) (grpc.ClientStream, error) {
defer wg.Done()
return &mockedClientStream{
err: errors.New("dummy"),
}, nil
})
wg.Wait()
assert.Nil(t, err)
cs := stream.(*clientStream)
cs.sendStreamEvent(test.event, status.Error(codes.DataLoss, "dummy"))
<-cs.eventsDone
cs.sendStreamEvent(test.event, test.err)
assert.NotNil(t, cs.CloseSend())
})
}
}
func TestStreamTracingInterceptor_WithError(t *testing.T) {
tests := []struct {
name string
err error
}{
{
name: "normal error",
err: errors.New("dummy"),
},
{
name: "grpc error",
err: status.Error(codes.DataLoss, "dummy"),
},
}
for _, test := range tests {
test := test
t.Run(test.name, func(t *testing.T) {
t.Parallel()
var run int32
var wg sync.WaitGroup
wg.Add(1)
cc := new(grpc.ClientConn)
_, err := StreamTracingInterceptor(context.Background(), nil, cc, "/foo",
func(ctx context.Context, desc *grpc.StreamDesc, cc *grpc.ClientConn, method string,
opts ...grpc.CallOption) (grpc.ClientStream, error) {
defer wg.Done()
atomic.AddInt32(&run, 1)
return new(mockedClientStream), test.err
})
wg.Wait()
assert.NotNil(t, err)
assert.Equal(t, int32(1), atomic.LoadInt32(&run))
})
}
}
func TestUnaryTracingInterceptor_GrpcFormat(t *testing.T) {
var run int32
var wg sync.WaitGroup
wg.Add(1)
cc := new(grpc.ClientConn)
err := UnaryTracingInterceptor(context.Background(), "/foo", nil, nil, cc,
func(ctx context.Context, method string, req, reply any, cc *grpc.ClientConn,
opts ...grpc.CallOption) error {
defer wg.Done()
atomic.AddInt32(&run, 1)
return nil
})
wg.Wait()
assert.Nil(t, err)
assert.Equal(t, int32(1), atomic.LoadInt32(&run))
}
func TestStreamTracingInterceptor_GrpcFormat(t *testing.T) {
var run int32
var wg sync.WaitGroup
wg.Add(1)
cc := new(grpc.ClientConn)
_, err := StreamTracingInterceptor(context.Background(), nil, cc, "/foo",
func(ctx context.Context, desc *grpc.StreamDesc, cc *grpc.ClientConn, method string,
opts ...grpc.CallOption) (grpc.ClientStream, error) {
defer wg.Done()
atomic.AddInt32(&run, 1)
return nil, nil
})
wg.Wait()
assert.Nil(t, err)
assert.Equal(t, int32(1), atomic.LoadInt32(&run))
}
func TestClientStream_RecvMsg(t *testing.T) {
tests := []struct {
name string
serverStreams bool
err error
}{
{
name: "nil error",
},
{
name: "EOF",
err: io.EOF,
},
{
name: "dummy error",
err: errors.New("dummy"),
},
{
name: "server streams",
serverStreams: true,
},
}
for _, test := range tests {
test := test
t.Run(test.name, func(t *testing.T) {
t.Parallel()
desc := new(grpc.StreamDesc)
desc.ServerStreams = test.serverStreams
stream := wrapClientStream(context.Background(), &mockedClientStream{
md: nil,
err: test.err,
}, desc)
assert.Equal(t, test.err, stream.RecvMsg(nil))
})
}
}
func TestClientStream_Header(t *testing.T) {
tests := []struct {
name string
err error
}{
{
name: "nil error",
},
{
name: "with error",
err: errors.New("dummy"),
},
}
for _, test := range tests {
test := test
t.Run(test.name, func(t *testing.T) {
t.Parallel()
desc := new(grpc.StreamDesc)
stream := wrapClientStream(context.Background(), &mockedClientStream{
md: metadata.MD{},
err: test.err,
}, desc)
_, err := stream.Header()
assert.Equal(t, test.err, err)
})
}
}
func TestClientStream_SendMsg(t *testing.T) {
tests := []struct {
name string
err error
}{
{
name: "nil error",
},
{
name: "with error",
err: errors.New("dummy"),
},
}
for _, test := range tests {
test := test
t.Run(test.name, func(t *testing.T) {
t.Parallel()
desc := new(grpc.StreamDesc)
stream := wrapClientStream(context.Background(), &mockedClientStream{
md: metadata.MD{},
err: test.err,
}, desc)
assert.Equal(t, test.err, stream.SendMsg(nil))
})
}
}
type mockedClientStream struct {
md metadata.MD
err error
}
func (m *mockedClientStream) Header() (metadata.MD, error) {
return m.md, m.err
}
func (m *mockedClientStream) Trailer() metadata.MD {
panic("implement me")
}
func (m *mockedClientStream) CloseSend() error {
return m.err
}
func (m *mockedClientStream) Context() context.Context {
return context.Background()
}
func (m *mockedClientStream) SendMsg(_ any) error {
return m.err
}
func (m *mockedClientStream) RecvMsg(_ any) error {
return m.err
}
| go | MIT | 8e7e5695eb2095917864b5d6615dab4c90bde3ac | 2026-01-07T08:36:18.042207Z | false |
zeromicro/go-zero | https://github.com/zeromicro/go-zero/blob/8e7e5695eb2095917864b5d6615dab4c90bde3ac/zrpc/internal/clientinterceptors/breakerinterceptor.go | zrpc/internal/clientinterceptors/breakerinterceptor.go | package clientinterceptors
import (
"context"
"path"
"github.com/zeromicro/go-zero/core/breaker"
"github.com/zeromicro/go-zero/zrpc/internal/codes"
"google.golang.org/grpc"
)
// BreakerInterceptor is an interceptor that acts as a circuit breaker.
func BreakerInterceptor(ctx context.Context, method string, req, reply any,
cc *grpc.ClientConn, invoker grpc.UnaryInvoker, opts ...grpc.CallOption) error {
breakerName := path.Join(cc.Target(), method)
return breaker.DoWithAcceptableCtx(ctx, breakerName, func() error {
return invoker(ctx, method, req, reply, cc, opts...)
}, codes.Acceptable)
}
| go | MIT | 8e7e5695eb2095917864b5d6615dab4c90bde3ac | 2026-01-07T08:36:18.042207Z | false |
zeromicro/go-zero | https://github.com/zeromicro/go-zero/blob/8e7e5695eb2095917864b5d6615dab4c90bde3ac/zrpc/internal/codes/accept_test.go | zrpc/internal/codes/accept_test.go | package codes
import (
"testing"
"github.com/stretchr/testify/assert"
"google.golang.org/grpc/codes"
"google.golang.org/grpc/status"
)
func TestAccept(t *testing.T) {
tests := []struct {
name string
err error
accept bool
}{
{
name: "nil error",
err: nil,
accept: true,
},
{
name: "deadline error",
err: status.Error(codes.DeadlineExceeded, "deadline"),
accept: false,
},
}
for _, test := range tests {
t.Run(test.name, func(t *testing.T) {
assert.Equal(t, test.accept, Acceptable(test.err))
})
}
}
| go | MIT | 8e7e5695eb2095917864b5d6615dab4c90bde3ac | 2026-01-07T08:36:18.042207Z | false |
zeromicro/go-zero | https://github.com/zeromicro/go-zero/blob/8e7e5695eb2095917864b5d6615dab4c90bde3ac/zrpc/internal/codes/accept.go | zrpc/internal/codes/accept.go | package codes
import (
"google.golang.org/grpc/codes"
"google.golang.org/grpc/status"
)
// Acceptable checks if given error is acceptable.
func Acceptable(err error) bool {
switch status.Code(err) {
case codes.DeadlineExceeded, codes.Internal, codes.Unavailable, codes.DataLoss,
codes.Unimplemented, codes.ResourceExhausted:
return false
default:
return true
}
}
| go | MIT | 8e7e5695eb2095917864b5d6615dab4c90bde3ac | 2026-01-07T08:36:18.042207Z | false |
zeromicro/go-zero | https://github.com/zeromicro/go-zero/blob/8e7e5695eb2095917864b5d6615dab4c90bde3ac/zrpc/internal/balancer/consistenthash/consistenthash.go | zrpc/internal/balancer/consistenthash/consistenthash.go | package consistenthash
import (
"context"
"github.com/zeromicro/go-zero/core/hash"
"google.golang.org/grpc/balancer"
"google.golang.org/grpc/balancer/base"
"google.golang.org/grpc/codes"
"google.golang.org/grpc/status"
)
const (
Name = "consistent_hash"
defaultReplicaCount = 100
)
var emptyPickResult balancer.PickResult
func init() {
balancer.Register(newBuilder())
}
type (
// hashKey is the key type for consistent hash in context.
hashKey struct{}
// pickerBuilder is a builder for picker.
pickerBuilder struct{}
// picker is a picker that uses consistent hash to pick a sub connection.
picker struct {
hashRing *hash.ConsistentHash
conns map[string]balancer.SubConn
}
)
func (b *pickerBuilder) Build(info base.PickerBuildInfo) balancer.Picker {
readySCs := info.ReadySCs
if len(readySCs) == 0 {
return base.NewErrPicker(balancer.ErrNoSubConnAvailable)
}
conns := make(map[string]balancer.SubConn, len(readySCs))
hashRing := hash.NewCustomConsistentHash(defaultReplicaCount, hash.Hash)
for conn, connInfo := range readySCs {
addr := connInfo.Address.Addr
conns[addr] = conn
hashRing.Add(addr)
}
return &picker{
hashRing: hashRing,
conns: conns,
}
}
func newBuilder() balancer.Builder {
return base.NewBalancerBuilder(Name, &pickerBuilder{}, base.Config{HealthCheck: true})
}
func (p *picker) Pick(info balancer.PickInfo) (balancer.PickResult, error) {
hashKey := GetHashKey(info.Ctx)
if len(hashKey) == 0 {
return emptyPickResult, status.Error(codes.InvalidArgument,
"[consistent_hash] missing hash key in context")
}
if addrAny, ok := p.hashRing.Get(hashKey); ok {
addr, ok := addrAny.(string)
if !ok {
return emptyPickResult, status.Error(codes.Internal,
"[consistent_hash] invalid addr type in consistent hash")
}
subConn, ok := p.conns[addr]
if !ok {
return emptyPickResult, status.Errorf(codes.Internal,
"[consistent_hash] no subConn for addr: %s", addr)
}
return balancer.PickResult{SubConn: subConn}, nil
}
return emptyPickResult, status.Errorf(codes.Unavailable,
"[consistent_hash] no matching conn for hashKey: %s", hashKey)
}
// SetHashKey sets the hash key into context.
func SetHashKey(ctx context.Context, key string) context.Context {
return context.WithValue(ctx, hashKey{}, key)
}
// GetHashKey gets the hash key from context.
func GetHashKey(ctx context.Context) string {
v, _ := ctx.Value(hashKey{}).(string)
return v
}
| go | MIT | 8e7e5695eb2095917864b5d6615dab4c90bde3ac | 2026-01-07T08:36:18.042207Z | false |
zeromicro/go-zero | https://github.com/zeromicro/go-zero/blob/8e7e5695eb2095917864b5d6615dab4c90bde3ac/zrpc/internal/balancer/consistenthash/consistenthash_test.go | zrpc/internal/balancer/consistenthash/consistenthash_test.go | package consistenthash
import (
"context"
"testing"
"github.com/stretchr/testify/assert"
"github.com/zeromicro/go-zero/core/hash"
"google.golang.org/grpc/balancer"
"google.golang.org/grpc/balancer/base"
"google.golang.org/grpc/resolver"
)
type fakeSubConn struct{ id int }
func (f *fakeSubConn) Connect() {}
func (f *fakeSubConn) UpdateAddresses(_ []resolver.Address) {}
func (f *fakeSubConn) Shutdown() {}
func (f *fakeSubConn) GetOrBuildProducer(b balancer.ProducerBuilder) (balancer.Producer, func()) {
return nil, func() {}
}
func TestPickerBuilder_EmptyReadySCs(t *testing.T) {
b := &pickerBuilder{}
p := b.Build(base.PickerBuildInfo{ReadySCs: map[balancer.SubConn]base.SubConnInfo{}})
_, err := p.Pick(balancer.PickInfo{})
assert.Equal(t, balancer.ErrNoSubConnAvailable, err)
}
func TestPickerBuilder_BuildAndRing(t *testing.T) {
subConn1 := &fakeSubConn{id: 1}
subConn2 := &fakeSubConn{id: 2}
addr1 := "127.0.0.1:8080"
addr2 := "127.0.0.1:8081"
b := &pickerBuilder{}
info := base.PickerBuildInfo{
ReadySCs: map[balancer.SubConn]base.SubConnInfo{
subConn1: {Address: resolver.Address{Addr: addr1}},
subConn2: {Address: resolver.Address{Addr: addr2}},
},
}
p := b.Build(info).(*picker)
assert.NotNil(t, p.hashRing)
assert.Len(t, p.conns, 2)
}
func TestPicker_HashConsistency(t *testing.T) {
subConn1 := &fakeSubConn{id: 1}
subConn2 := &fakeSubConn{id: 2}
pb := &pickerBuilder{}
info := base.PickerBuildInfo{
ReadySCs: map[balancer.SubConn]base.SubConnInfo{
subConn1: {Address: resolver.Address{Addr: "127.0.0.1:8080"}},
subConn2: {Address: resolver.Address{Addr: "127.0.0.1:8081"}},
},
}
p := pb.Build(info).(*picker)
ctx := SetHashKey(context.Background(), "user_123")
res1, err := p.Pick(balancer.PickInfo{Ctx: ctx})
assert.NoError(t, err)
assert.NotNil(t, res1.SubConn)
// Multiple requests with the same key remain consistent
for i := 0; i < 5; i++ {
resN, err := p.Pick(balancer.PickInfo{Ctx: ctx})
assert.NoError(t, err)
assert.Equal(t, res1.SubConn, resN.SubConn)
}
}
func TestPicker_MissingKey(t *testing.T) {
subConn := &fakeSubConn{id: 1}
pb := &pickerBuilder{}
info := base.PickerBuildInfo{
ReadySCs: map[balancer.SubConn]base.SubConnInfo{
subConn: {Address: resolver.Address{Addr: "127.0.0.1:8080"}},
},
}
p := pb.Build(info).(*picker)
// No hash key in context
_, err := p.Pick(balancer.PickInfo{Ctx: context.Background()})
assert.Error(t, err)
assert.Contains(t, err.Error(), "[consistent_hash] missing hash key in context")
}
func TestPicker_NoMatchingConn(t *testing.T) {
emptyRing := newCustomRingForTest()
p := &picker{
hashRing: emptyRing,
conns: map[string]balancer.SubConn{},
}
_, err := p.Pick(balancer.PickInfo{Ctx: SetHashKey(context.Background(), "someone")})
assert.Error(t, err)
assert.Contains(t, err.Error(), "[consistent_hash] no matching conn for hashKey: someone")
}
func TestPicker_InvalidAddrType(t *testing.T) {
ring := newCustomRingForTest()
ring.Add(12345)
subConn := &fakeSubConn{id: 1}
p := &picker{
hashRing: ring,
conns: map[string]balancer.SubConn{
"12345": subConn,
},
}
_, err := p.Pick(balancer.PickInfo{Ctx: SetHashKey(context.Background(), "anykey")})
assert.Error(t, err)
assert.Contains(t, err.Error(), "[consistent_hash] invalid addr type in consistent hash")
}
func TestPicker_NoSubConnForAddr(t *testing.T) {
ring := newCustomRingForTest()
ring.Add("ghost:9999")
exist := &fakeSubConn{id: 1}
p := &picker{
hashRing: ring,
conns: map[string]balancer.SubConn{
"real:8080": exist,
},
}
_, err := p.Pick(balancer.PickInfo{Ctx: SetHashKey(context.Background(), "anykey")})
assert.Error(t, err)
assert.Contains(t, err.Error(), "[consistent_hash] no subConn for addr: ghost:9999")
}
func TestSetAndGetHashKey(t *testing.T) {
ctx := context.Background()
key := "abc123"
ctx = SetHashKey(ctx, key)
got := GetHashKey(ctx)
assert.Equal(t, key, got)
assert.Empty(t, GetHashKey(context.Background()))
}
func BenchmarkPicker_HashConsistency(b *testing.B) {
subConn1 := &fakeSubConn{id: 1}
subConn2 := &fakeSubConn{id: 2}
pb := &pickerBuilder{}
info := base.PickerBuildInfo{
ReadySCs: map[balancer.SubConn]base.SubConnInfo{
subConn1: {Address: resolver.Address{Addr: "127.0.0.1:8080"}},
subConn2: {Address: resolver.Address{Addr: "127.0.0.1:8081"}},
},
}
p := pb.Build(info).(*picker)
ctx := SetHashKey(context.Background(), "hot_user_123")
b.ResetTimer()
for i := 0; i < b.N; i++ {
res, err := p.Pick(balancer.PickInfo{Ctx: ctx})
if err != nil || res.SubConn == nil {
b.Fatalf("unexpected result: res=%v err=%v", res.SubConn, err)
}
}
}
func newCustomRingForTest() *hash.ConsistentHash {
return hash.NewCustomConsistentHash(defaultReplicaCount, hash.Hash)
}
| go | MIT | 8e7e5695eb2095917864b5d6615dab4c90bde3ac | 2026-01-07T08:36:18.042207Z | false |
zeromicro/go-zero | https://github.com/zeromicro/go-zero/blob/8e7e5695eb2095917864b5d6615dab4c90bde3ac/zrpc/internal/balancer/p2c/p2c.go | zrpc/internal/balancer/p2c/p2c.go | package p2c
import (
"fmt"
"math"
"math/rand"
"strings"
"sync"
"sync/atomic"
"time"
"github.com/zeromicro/go-zero/core/logx"
"github.com/zeromicro/go-zero/core/syncx"
"github.com/zeromicro/go-zero/core/timex"
"github.com/zeromicro/go-zero/zrpc/internal/codes"
"google.golang.org/grpc/balancer"
"google.golang.org/grpc/balancer/base"
"google.golang.org/grpc/resolver"
)
const (
// Name is the name of p2c balancer.
Name = "p2c_ewma"
// default value from finagle
decayTime = int64(time.Second * 10)
// if a node is not selected for a period of time, it is forcibly selected.
forcePick = int64(time.Second)
// initial success count
initSuccess = 1000
// success count to trigger throttling
throttleSuccess = initSuccess / 2
// penalty value for load calculation
penalty = int64(math.MaxInt32)
// number of pick attempts
pickTimes = 3
// log interval for statistics
logInterval = time.Minute
)
var emptyPickResult balancer.PickResult
func init() {
balancer.Register(newBuilder())
}
type p2cPickerBuilder struct{}
func (b *p2cPickerBuilder) Build(info base.PickerBuildInfo) balancer.Picker {
readySCs := info.ReadySCs
if len(readySCs) == 0 {
return base.NewErrPicker(balancer.ErrNoSubConnAvailable)
}
conns := make([]*subConn, 0, len(readySCs))
for conn, connInfo := range readySCs {
conns = append(conns, &subConn{
addr: connInfo.Address,
conn: conn,
success: initSuccess,
})
}
return &p2cPicker{
conns: conns,
r: rand.New(rand.NewSource(time.Now().UnixNano())),
stamp: syncx.NewAtomicDuration(),
}
}
func newBuilder() balancer.Builder {
return base.NewBalancerBuilder(Name, new(p2cPickerBuilder), base.Config{HealthCheck: true})
}
type p2cPicker struct {
conns []*subConn
r *rand.Rand
stamp *syncx.AtomicDuration
lock sync.Mutex
}
func (p *p2cPicker) Pick(_ balancer.PickInfo) (balancer.PickResult, error) {
p.lock.Lock()
defer p.lock.Unlock()
var chosen *subConn
switch len(p.conns) {
case 0:
return emptyPickResult, balancer.ErrNoSubConnAvailable
case 1:
chosen = p.choose(p.conns[0], nil)
case 2:
chosen = p.choose(p.conns[0], p.conns[1])
default:
var node1, node2 *subConn
for i := 0; i < pickTimes; i++ {
a := p.r.Intn(len(p.conns))
b := p.r.Intn(len(p.conns) - 1)
if b >= a {
b++
}
node1 = p.conns[a]
node2 = p.conns[b]
if node1.healthy() && node2.healthy() {
break
}
}
chosen = p.choose(node1, node2)
}
atomic.AddInt64(&chosen.inflight, 1)
atomic.AddInt64(&chosen.requests, 1)
return balancer.PickResult{
SubConn: chosen.conn,
Done: p.buildDoneFunc(chosen),
}, nil
}
func (p *p2cPicker) buildDoneFunc(c *subConn) func(info balancer.DoneInfo) {
start := int64(timex.Now())
return func(info balancer.DoneInfo) {
atomic.AddInt64(&c.inflight, -1)
now := timex.Now()
last := atomic.SwapInt64(&c.last, int64(now))
td := int64(now) - last
if td < 0 {
td = 0
}
// As the td/decayTime value increases, indicating an increase in delay,
// the value of w (y-axis) will decrease, inversely proportional.
// The function curve of y = x^(-x) is as follows:
// https://github.com/zeromicro/zero-doc/blob/main/doc/images/y_e_x.png?raw=true
w := math.Exp(float64(-td) / float64(decayTime))
lag := int64(now) - start
if lag < 0 {
lag = 0
}
olag := atomic.LoadUint64(&c.lag)
if olag == 0 {
w = 0
}
// The smaller the value of w, the lower the impact of historical data.
atomic.StoreUint64(&c.lag, uint64(float64(olag)*w+float64(lag)*(1-w)))
success := initSuccess
if info.Err != nil && !codes.Acceptable(info.Err) {
success = 0
}
osucc := atomic.LoadUint64(&c.success)
atomic.StoreUint64(&c.success, uint64(float64(osucc)*w+float64(success)*(1-w)))
stamp := p.stamp.Load()
if now-stamp >= logInterval {
if p.stamp.CompareAndSwap(stamp, now) {
p.logStats()
}
}
}
}
func (p *p2cPicker) choose(c1, c2 *subConn) *subConn {
start := int64(timex.Now())
if c2 == nil {
atomic.StoreInt64(&c1.pick, start)
return c1
}
if c1.load() > c2.load() {
c1, c2 = c2, c1
}
pick := atomic.LoadInt64(&c2.pick)
if start-pick > forcePick && atomic.CompareAndSwapInt64(&c2.pick, pick, start) {
return c2
}
atomic.StoreInt64(&c1.pick, start)
return c1
}
func (p *p2cPicker) logStats() {
stats := make([]string, 0, len(p.conns))
p.lock.Lock()
defer p.lock.Unlock()
for _, conn := range p.conns {
stats = append(stats, fmt.Sprintf("conn: %s, load: %d, reqs: %d",
conn.addr.Addr, conn.load(), atomic.SwapInt64(&conn.requests, 0)))
}
logx.Statf("p2c - %s", strings.Join(stats, "; "))
}
type subConn struct {
// The request latency measured by the weighted moving average algorithm.
lag uint64
// The value represents the number of requests that are either pending or just
// starting at the current node, and it is obtained through atomic addition.
inflight int64
success uint64
requests int64
last int64
pick int64
addr resolver.Address
conn balancer.SubConn
}
func (c *subConn) healthy() bool {
return atomic.LoadUint64(&c.success) > throttleSuccess
}
func (c *subConn) load() int64 {
// plus one to avoid multiply zero
lag := int64(math.Sqrt(float64(atomic.LoadUint64(&c.lag) + 1)))
load := lag * (atomic.LoadInt64(&c.inflight) + 1)
if load == 0 {
return penalty
}
return load
}
| go | MIT | 8e7e5695eb2095917864b5d6615dab4c90bde3ac | 2026-01-07T08:36:18.042207Z | false |
zeromicro/go-zero | https://github.com/zeromicro/go-zero/blob/8e7e5695eb2095917864b5d6615dab4c90bde3ac/zrpc/internal/balancer/p2c/p2c_test.go | zrpc/internal/balancer/p2c/p2c_test.go | package p2c
import (
"context"
"fmt"
"runtime"
"strconv"
"sync"
"testing"
"github.com/stretchr/testify/assert"
"github.com/zeromicro/go-zero/core/logx"
"github.com/zeromicro/go-zero/core/mathx"
"github.com/zeromicro/go-zero/core/stringx"
"google.golang.org/grpc/balancer"
"google.golang.org/grpc/balancer/base"
"google.golang.org/grpc/codes"
"google.golang.org/grpc/resolver"
"google.golang.org/grpc/status"
)
func init() {
logx.Disable()
}
func TestP2cPicker_PickNil(t *testing.T) {
builder := new(p2cPickerBuilder)
picker := builder.Build(base.PickerBuildInfo{})
_, err := picker.Pick(balancer.PickInfo{
FullMethodName: "/",
Ctx: context.Background(),
})
assert.NotNil(t, err)
}
func TestP2cPicker_Pick(t *testing.T) {
tests := []struct {
name string
candidates int
err error
threshold float64
}{
{
name: "empty",
candidates: 0,
err: balancer.ErrNoSubConnAvailable,
},
{
name: "single",
candidates: 1,
threshold: 0.9,
},
{
name: "two",
candidates: 2,
threshold: 0.5,
},
{
name: "multiple",
candidates: 100,
threshold: 0.95,
},
}
for _, test := range tests {
test := test
t.Run(test.name, func(t *testing.T) {
t.Parallel()
const total = 10000
builder := new(p2cPickerBuilder)
ready := make(map[balancer.SubConn]base.SubConnInfo)
for i := 0; i < test.candidates; i++ {
ready[mockClientConn{
id: stringx.Rand(),
}] = base.SubConnInfo{
Address: resolver.Address{
Addr: strconv.Itoa(i),
},
}
}
picker := builder.Build(base.PickerBuildInfo{
ReadySCs: ready,
})
var wg sync.WaitGroup
wg.Add(total)
for i := 0; i < total; i++ {
result, err := picker.Pick(balancer.PickInfo{
FullMethodName: "/",
Ctx: context.Background(),
})
assert.Equal(t, test.err, err)
if test.err != nil {
return
}
if i%100 == 0 {
err = status.Error(codes.DeadlineExceeded, "deadline")
}
go func() {
runtime.Gosched()
result.Done(balancer.DoneInfo{
Err: err,
})
wg.Done()
}()
}
wg.Wait()
dist := make(map[any]int)
conns := picker.(*p2cPicker).conns
for _, conn := range conns {
dist[conn.addr.Addr] = int(conn.requests)
}
entropy := mathx.CalcEntropy(dist)
assert.True(t, entropy > test.threshold, fmt.Sprintf("entropy is %f, less than %f",
entropy, test.threshold))
})
}
}
func TestPickerWithEmptyConns(t *testing.T) {
var picker p2cPicker
_, err := picker.Pick(balancer.PickInfo{
FullMethodName: "/",
Ctx: context.Background(),
})
assert.ErrorIs(t, err, balancer.ErrNoSubConnAvailable)
}
type mockClientConn struct {
// add random string member to avoid map key equality.
id string
}
func (m mockClientConn) GetOrBuildProducer(builder balancer.ProducerBuilder) (
p balancer.Producer, close func()) {
return builder.Build(m)
}
func (m mockClientConn) UpdateAddresses(_ []resolver.Address) {
}
func (m mockClientConn) Connect() {
}
func (m mockClientConn) Shutdown() {
}
| go | MIT | 8e7e5695eb2095917864b5d6615dab4c90bde3ac | 2026-01-07T08:36:18.042207Z | false |
zeromicro/go-zero | https://github.com/zeromicro/go-zero/blob/8e7e5695eb2095917864b5d6615dab4c90bde3ac/tools/goctl/goctl.go | tools/goctl/goctl.go | package main
import (
"github.com/zeromicro/go-zero/core/load"
"github.com/zeromicro/go-zero/core/logx"
"github.com/zeromicro/go-zero/tools/goctl/cmd"
)
func main() {
logx.Disable()
load.Disable()
cmd.Execute()
}
| go | MIT | 8e7e5695eb2095917864b5d6615dab4c90bde3ac | 2026-01-07T08:36:18.042207Z | false |
zeromicro/go-zero | https://github.com/zeromicro/go-zero/blob/8e7e5695eb2095917864b5d6615dab4c90bde3ac/tools/goctl/pkg/env/env.go | tools/goctl/pkg/env/env.go | package env
import (
"fmt"
"log"
"os"
"path/filepath"
"runtime"
"strings"
"testing"
"github.com/zeromicro/go-zero/tools/goctl/internal/version"
sortedmap "github.com/zeromicro/go-zero/tools/goctl/pkg/collection"
"github.com/zeromicro/go-zero/tools/goctl/pkg/protoc"
"github.com/zeromicro/go-zero/tools/goctl/pkg/protocgengo"
"github.com/zeromicro/go-zero/tools/goctl/pkg/protocgengogrpc"
"github.com/zeromicro/go-zero/tools/goctl/util/pathx"
)
var goctlEnv *sortedmap.SortedMap
const (
GoctlOS = "GOCTL_OS"
GoctlArch = "GOCTL_ARCH"
GoctlHome = "GOCTL_HOME"
GoctlDebug = "GOCTL_DEBUG"
GoctlCache = "GOCTL_CACHE"
GoctlVersion = "GOCTL_VERSION"
GoctlExperimental = "GOCTL_EXPERIMENTAL"
ProtocVersion = "PROTOC_VERSION"
ProtocGenGoVersion = "PROTOC_GEN_GO_VERSION"
ProtocGenGoGRPCVersion = "PROTO_GEN_GO_GRPC_VERSION"
envFileDir = "env"
ExperimentalOn = "on"
ExperimentalOff = "off"
)
// init initializes the goctl environment variables, the environment variables of the function are set in order,
// please do not change the logic order of the code.
func init() {
defaultGoctlHome, err := pathx.GetDefaultGoctlHome()
if err != nil {
log.Fatalln(err)
}
goctlEnv = sortedmap.New()
goctlEnv.SetKV(GoctlOS, runtime.GOOS)
goctlEnv.SetKV(GoctlArch, runtime.GOARCH)
existsEnv := readEnv(defaultGoctlHome)
if existsEnv != nil {
goctlHome, ok := existsEnv.GetString(GoctlHome)
if ok && len(goctlHome) > 0 {
goctlEnv.SetKV(GoctlHome, goctlHome)
}
if debug := existsEnv.GetOr(GoctlDebug, "").(string); debug != "" {
if strings.EqualFold(debug, "true") || strings.EqualFold(debug, "false") {
goctlEnv.SetKV(GoctlDebug, debug)
}
}
if value := existsEnv.GetStringOr(GoctlCache, ""); value != "" {
goctlEnv.SetKV(GoctlCache, value)
}
experimental := existsEnv.GetOr(GoctlExperimental, ExperimentalOn)
goctlEnv.SetKV(GoctlExperimental, experimental)
}
if !goctlEnv.HasKey(GoctlHome) {
goctlEnv.SetKV(GoctlHome, defaultGoctlHome)
}
if !goctlEnv.HasKey(GoctlDebug) {
goctlEnv.SetKV(GoctlDebug, "False")
}
if !goctlEnv.HasKey(GoctlCache) {
cacheDir, _ := pathx.GetCacheDir()
goctlEnv.SetKV(GoctlCache, cacheDir)
}
if !goctlEnv.HasKey(GoctlExperimental) {
goctlEnv.SetKV(GoctlExperimental, ExperimentalOn)
}
goctlEnv.SetKV(GoctlVersion, version.BuildVersion)
protocVer, _ := protoc.Version()
goctlEnv.SetKV(ProtocVersion, protocVer)
protocGenGoVer, _ := protocgengo.Version()
goctlEnv.SetKV(ProtocGenGoVersion, protocGenGoVer)
protocGenGoGrpcVer, _ := protocgengogrpc.Version()
goctlEnv.SetKV(ProtocGenGoGRPCVersion, protocGenGoGrpcVer)
}
func Print(args ...string) string {
if len(args) == 0 {
return strings.Join(goctlEnv.Format(), "\n")
}
var values []string
for _, key := range args {
value, ok := goctlEnv.GetString(key)
if !ok {
value = fmt.Sprintf("%s=%%not found%%", key)
}
values = append(values, fmt.Sprintf("%s=%s", key, value))
}
return strings.Join(values, "\n")
}
func Get(key string) string {
return GetOr(key, "")
}
// Set sets the environment variable for testing
func Set(t *testing.T, key, value string) {
goctlEnv.SetKV(key, value)
t.Cleanup(func() {
goctlEnv.Remove(key)
})
}
func GetOr(key, def string) string {
return goctlEnv.GetStringOr(key, def)
}
func UseExperimental() bool {
return GetOr(GoctlExperimental, ExperimentalOff) == ExperimentalOn
}
func readEnv(goctlHome string) *sortedmap.SortedMap {
envFile := filepath.Join(goctlHome, envFileDir)
data, err := os.ReadFile(envFile)
if err != nil {
return nil
}
dataStr := string(data)
lines := strings.Split(dataStr, "\n")
sm := sortedmap.New()
for _, line := range lines {
_, _, err = sm.SetExpression(line)
if err != nil {
continue
}
}
return sm
}
func WriteEnv(kv []string) error {
defaultGoctlHome, err := pathx.GetDefaultGoctlHome()
if err != nil {
log.Fatalln(err)
}
data := sortedmap.New()
for _, e := range kv {
_, _, err := data.SetExpression(e)
if err != nil {
return err
}
}
data.RangeIf(func(key, value any) bool {
switch key.(string) {
case GoctlHome, GoctlCache:
path := value.(string)
if !pathx.FileExists(path) {
err = fmt.Errorf("[writeEnv]: path %q is not exists", path)
return false
}
}
if goctlEnv.HasKey(key) {
goctlEnv.SetKV(key, value)
return true
} else {
err = fmt.Errorf("[writeEnv]: invalid key: %v", key)
return false
}
})
if err != nil {
return err
}
envFile := filepath.Join(defaultGoctlHome, envFileDir)
return os.WriteFile(envFile, []byte(strings.Join(goctlEnv.Format(), "\n")), 0o777)
}
| go | MIT | 8e7e5695eb2095917864b5d6615dab4c90bde3ac | 2026-01-07T08:36:18.042207Z | false |
zeromicro/go-zero | https://github.com/zeromicro/go-zero/blob/8e7e5695eb2095917864b5d6615dab4c90bde3ac/tools/goctl/pkg/golang/install.go | tools/goctl/pkg/golang/install.go | package golang
import (
"os"
"os/exec"
)
func Install(git string) error {
cmd := exec.Command("go", "install", git)
env := os.Environ()
env = append(env, "GO111MODULE=on")
cmd.Env = env
cmd.Stdout = os.Stdout
cmd.Stderr = os.Stderr
err := cmd.Run()
return err
}
| go | MIT | 8e7e5695eb2095917864b5d6615dab4c90bde3ac | 2026-01-07T08:36:18.042207Z | false |
zeromicro/go-zero | https://github.com/zeromicro/go-zero/blob/8e7e5695eb2095917864b5d6615dab4c90bde3ac/tools/goctl/pkg/golang/path.go | tools/goctl/pkg/golang/path.go | package golang
import (
"path/filepath"
"strings"
"github.com/zeromicro/go-zero/tools/goctl/util/ctx"
"github.com/zeromicro/go-zero/tools/goctl/util/pathx"
)
func GetParentPackage(dir string) (string, string, error) {
return GetParentPackageWithModule(dir, "")
}
func GetParentPackageWithModule(dir, moduleName string) (string, string, error) {
abs, err := filepath.Abs(dir)
if err != nil {
return "", "", err
}
var projectCtx *ctx.ProjectContext
if len(moduleName) > 0 {
projectCtx, err = ctx.PrepareWithModule(abs, moduleName)
} else {
projectCtx, err = ctx.Prepare(abs)
}
if err != nil {
return "", "", err
}
return buildParentPackage(projectCtx)
}
// buildParentPackage extracts the common logic for building parent package paths
func buildParentPackage(projectCtx *ctx.ProjectContext) (string, string, error) {
wd := projectCtx.WorkDir
d := projectCtx.Dir
same, err := pathx.SameFile(wd, d)
if err != nil {
return "", "", err
}
trim := strings.TrimPrefix(projectCtx.WorkDir, projectCtx.Dir)
if same {
trim = strings.TrimPrefix(strings.ToLower(projectCtx.WorkDir), strings.ToLower(projectCtx.Dir))
}
return filepath.ToSlash(filepath.Join(projectCtx.Path, trim)), projectCtx.Path, nil
}
| go | MIT | 8e7e5695eb2095917864b5d6615dab4c90bde3ac | 2026-01-07T08:36:18.042207Z | false |
zeromicro/go-zero | https://github.com/zeromicro/go-zero/blob/8e7e5695eb2095917864b5d6615dab4c90bde3ac/tools/goctl/pkg/golang/path_test.go | tools/goctl/pkg/golang/path_test.go | package golang
import (
"os"
"path/filepath"
"testing"
"github.com/stretchr/testify/assert"
"github.com/stretchr/testify/require"
)
func TestGetParentPackage(t *testing.T) {
// Create a temporary directory for testing
tempDir, err := os.MkdirTemp("", "goctl-test-*")
require.NoError(t, err)
defer os.RemoveAll(tempDir)
// Test with a directory (should create go.mod with directory name)
testDir := filepath.Join(tempDir, "testproject")
err = os.MkdirAll(testDir, 0755)
require.NoError(t, err)
parentPkg, rootPkg, err := GetParentPackage(testDir)
assert.NoError(t, err)
assert.Equal(t, "testproject", parentPkg)
assert.Equal(t, "testproject", rootPkg)
// Verify go.mod was created with directory name
goModPath := filepath.Join(testDir, "go.mod")
assert.FileExists(t, goModPath)
content, err := os.ReadFile(goModPath)
require.NoError(t, err)
assert.Contains(t, string(content), "module testproject")
}
func TestGetParentPackageWithModule(t *testing.T) {
tests := []struct {
name string
moduleName string
expectedModule string
expectedPkg string
}{
{
name: "custom module name",
moduleName: "github.com/example/myproject",
expectedModule: "github.com/example/myproject",
expectedPkg: "github.com/example/myproject",
},
{
name: "simple module name",
moduleName: "myservice",
expectedModule: "myservice",
expectedPkg: "myservice",
},
{
name: "empty module name falls back to directory",
moduleName: "",
expectedModule: "fallback",
expectedPkg: "fallback",
},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
// Create a temporary directory for testing
tempDir, err := os.MkdirTemp("", "goctl-test-*")
require.NoError(t, err)
defer os.RemoveAll(tempDir)
// Create test directory - use "fallback" name for empty module test
testDirName := "fallback"
if tt.name != "empty module name falls back to directory" {
testDirName = "testdir"
}
testDir := filepath.Join(tempDir, testDirName)
err = os.MkdirAll(testDir, 0755)
require.NoError(t, err)
parentPkg, rootPkg, err := GetParentPackageWithModule(testDir, tt.moduleName)
assert.NoError(t, err)
assert.Equal(t, tt.expectedPkg, parentPkg)
assert.Equal(t, tt.expectedModule, rootPkg)
// Verify go.mod was created with correct module name
goModPath := filepath.Join(testDir, "go.mod")
assert.FileExists(t, goModPath)
content, err := os.ReadFile(goModPath)
require.NoError(t, err)
assert.Contains(t, string(content), "module "+tt.expectedModule)
})
}
}
func TestGetParentPackageWithModule_InvalidDir(t *testing.T) {
// Test with non-existent directory
_, _, err := GetParentPackageWithModule("/non/existent/path", "github.com/example/test")
assert.Error(t, err)
}
func TestGetParentPackage_InvalidDir(t *testing.T) {
// Test with non-existent directory
_, _, err := GetParentPackage("/non/existent/path")
assert.Error(t, err)
}
func TestGetParentPackage_UsesGetParentPackageWithModule(t *testing.T) {
// Create a temporary directory for testing
tempDir, err := os.MkdirTemp("", "goctl-test-*")
require.NoError(t, err)
defer os.RemoveAll(tempDir)
testDir := filepath.Join(tempDir, "testproject")
err = os.MkdirAll(testDir, 0755)
require.NoError(t, err)
// Test that GetParentPackage calls GetParentPackageWithModule with empty string
parentPkg1, rootPkg1, err1 := GetParentPackage(testDir)
require.NoError(t, err1)
// Clean up go.mod to test again
os.Remove(filepath.Join(testDir, "go.mod"))
parentPkg2, rootPkg2, err2 := GetParentPackageWithModule(testDir, "")
require.NoError(t, err2)
// Should produce identical results
assert.Equal(t, parentPkg1, parentPkg2)
assert.Equal(t, rootPkg1, rootPkg2)
}
func TestBuildParentPackage(t *testing.T) {
// This tests the internal buildParentPackage function indirectly
// through the public API, as it's a private function
// Create a temporary directory with subdirectory structure
tempDir, err := os.MkdirTemp("", "goctl-test-*")
require.NoError(t, err)
defer os.RemoveAll(tempDir)
// Create a nested directory structure
projectDir := filepath.Join(tempDir, "myproject")
subDir := filepath.Join(projectDir, "internal", "logic")
err = os.MkdirAll(subDir, 0755)
require.NoError(t, err)
// Test from root directory
parentPkg, rootPkg, err := GetParentPackageWithModule(projectDir, "github.com/example/myproject")
assert.NoError(t, err)
assert.Equal(t, "github.com/example/myproject", parentPkg)
assert.Equal(t, "github.com/example/myproject", rootPkg)
// Test from subdirectory
parentPkg2, rootPkg2, err := GetParentPackageWithModule(subDir, "github.com/example/myproject")
assert.NoError(t, err)
assert.Equal(t, "github.com/example/myproject/internal/logic", parentPkg2)
assert.Equal(t, "github.com/example/myproject", rootPkg2)
}
func TestGetParentPackageWithModule_SpecialCharacters(t *testing.T) {
tests := []struct {
name string
moduleName string
valid bool
}{
{
name: "domain with path",
moduleName: "github.com/user/repo",
valid: true,
},
{
name: "domain with version",
moduleName: "github.com/user/repo/v2",
valid: true,
},
{
name: "private repo",
moduleName: "private.example.com/team/project",
valid: true,
},
{
name: "simple name with underscore",
moduleName: "my_project",
valid: true,
},
{
name: "simple name with hyphen",
moduleName: "my-project",
valid: true,
},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
// Create a temporary directory for testing
tempDir, err := os.MkdirTemp("", "goctl-test-*")
require.NoError(t, err)
defer os.RemoveAll(tempDir)
testDir := filepath.Join(tempDir, "testdir")
err = os.MkdirAll(testDir, 0755)
require.NoError(t, err)
parentPkg, rootPkg, err := GetParentPackageWithModule(testDir, tt.moduleName)
if tt.valid {
assert.NoError(t, err)
assert.Equal(t, tt.moduleName, parentPkg)
assert.Equal(t, tt.moduleName, rootPkg)
// Verify go.mod contains the module name
goModPath := filepath.Join(testDir, "go.mod")
content, err := os.ReadFile(goModPath)
require.NoError(t, err)
assert.Contains(t, string(content), "module "+tt.moduleName)
} else {
assert.Error(t, err)
}
})
}
}
| go | MIT | 8e7e5695eb2095917864b5d6615dab4c90bde3ac | 2026-01-07T08:36:18.042207Z | false |
zeromicro/go-zero | https://github.com/zeromicro/go-zero/blob/8e7e5695eb2095917864b5d6615dab4c90bde3ac/tools/goctl/pkg/golang/format.go | tools/goctl/pkg/golang/format.go | package golang
import goformat "go/format"
func FormatCode(code string) string {
ret, err := goformat.Source([]byte(code))
if err != nil {
return code
}
return string(ret)
}
| go | MIT | 8e7e5695eb2095917864b5d6615dab4c90bde3ac | 2026-01-07T08:36:18.042207Z | false |
zeromicro/go-zero | https://github.com/zeromicro/go-zero/blob/8e7e5695eb2095917864b5d6615dab4c90bde3ac/tools/goctl/pkg/golang/bin.go | tools/goctl/pkg/golang/bin.go | package golang
import (
"go/build"
"os"
"path/filepath"
"github.com/zeromicro/go-zero/tools/goctl/util/pathx"
)
// GoBin returns a path of GOBIN.
func GoBin() string {
def := build.Default
goroot := os.Getenv("GOPATH")
bin := filepath.Join(goroot, "bin")
if !pathx.FileExists(bin) {
gopath := os.Getenv("GOROOT")
bin = filepath.Join(gopath, "bin")
}
if !pathx.FileExists(bin) {
bin = os.Getenv("GOBIN")
}
if !pathx.FileExists(bin) {
bin = filepath.Join(def.GOPATH, "bin")
}
return bin
}
| go | MIT | 8e7e5695eb2095917864b5d6615dab4c90bde3ac | 2026-01-07T08:36:18.042207Z | false |
zeromicro/go-zero | https://github.com/zeromicro/go-zero/blob/8e7e5695eb2095917864b5d6615dab4c90bde3ac/tools/goctl/pkg/collection/sortedmap.go | tools/goctl/pkg/collection/sortedmap.go | package sortedmap
import (
"container/list"
"errors"
"fmt"
"strings"
"github.com/zeromicro/go-zero/tools/goctl/util/stringx"
)
var (
ErrInvalidKVExpression = errors.New(`invalid key-value expression`)
ErrInvalidKVS = errors.New("the length of kv must be an even number")
)
type KV []any
type SortedMap struct {
kv *list.List
keys map[any]*list.Element
}
func New() *SortedMap {
return &SortedMap{
kv: list.New(),
keys: make(map[any]*list.Element),
}
}
func (m *SortedMap) SetExpression(expression string) (key, value any, err error) {
idx := strings.Index(expression, "=")
if idx == -1 {
return "", "", ErrInvalidKVExpression
}
key = expression[:idx]
if len(expression) == idx {
value = ""
} else {
value = expression[idx+1:]
}
if keys, ok := key.(string); ok && stringx.ContainsWhiteSpace(keys) {
return "", "", ErrInvalidKVExpression
}
if values, ok := value.(string); ok && stringx.ContainsWhiteSpace(values) {
return "", "", ErrInvalidKVExpression
}
if len(key.(string)) == 0 {
return "", "", ErrInvalidKVExpression
}
m.SetKV(key, value)
return
}
func (m *SortedMap) SetKV(key, value any) {
e, ok := m.keys[key]
if !ok {
e = m.kv.PushBack(KV{
key, value,
})
} else {
e.Value.(KV)[1] = value
}
m.keys[key] = e
}
func (m *SortedMap) Set(kv KV) error {
if len(kv) == 0 {
return nil
}
if len(kv)%2 != 0 {
return ErrInvalidKVS
}
for idx := 0; idx < len(kv); idx += 2 {
m.SetKV(kv[idx], kv[idx+1])
}
return nil
}
func (m *SortedMap) Get(key any) (any, bool) {
e, ok := m.keys[key]
if !ok {
return nil, false
}
return e.Value.(KV)[1], true
}
func (m *SortedMap) GetOr(key, dft any) any {
e, ok := m.keys[key]
if !ok {
return dft
}
return e.Value.(KV)[1]
}
func (m *SortedMap) GetString(key any) (string, bool) {
value, ok := m.Get(key)
if !ok {
return "", false
}
vs, ok := value.(string)
return vs, ok
}
func (m *SortedMap) GetStringOr(key any, dft string) string {
value, ok := m.GetString(key)
if !ok {
return dft
}
return value
}
func (m *SortedMap) HasKey(key any) bool {
_, ok := m.keys[key]
return ok
}
func (m *SortedMap) HasValue(value any) bool {
var contains bool
m.RangeIf(func(key, v any) bool {
if value == v {
contains = true
return false
}
return true
})
return contains
}
func (m *SortedMap) Keys() []any {
keys := make([]any, 0)
next := m.kv.Front()
for next != nil {
keys = append(keys, next.Value.(KV)[0])
next = next.Next()
}
return keys
}
func (m *SortedMap) Values() []any {
keys := m.Keys()
values := make([]any, len(keys))
for idx, key := range keys {
values[idx] = m.keys[key].Value.(KV)[1]
}
return values
}
func (m *SortedMap) Range(iterator func(key, value any)) {
next := m.kv.Front()
for next != nil {
value := next.Value.(KV)
iterator(value[0], value[1])
next = next.Next()
}
}
func (m *SortedMap) RangeIf(iterator func(key, value any) bool) {
next := m.kv.Front()
for next != nil {
value := next.Value.(KV)
loop := iterator(value[0], value[1])
if !loop {
return
}
next = next.Next()
}
}
func (m *SortedMap) Remove(key any) (value any, ok bool) {
v, ok := m.keys[key]
if !ok {
return nil, false
}
value = v.Value.(KV)[1]
ok = true
m.kv.Remove(v)
delete(m.keys, key)
return
}
func (m *SortedMap) Insert(sm *SortedMap) {
sm.Range(func(key, value any) {
m.SetKV(key, value)
})
}
func (m *SortedMap) Copy() *SortedMap {
sm := New()
m.Range(func(key, value any) {
sm.SetKV(key, value)
})
return sm
}
func (m *SortedMap) Format() []string {
format := make([]string, 0)
m.Range(func(key, value any) {
format = append(format, fmt.Sprintf("%s=%s", key, value))
})
return format
}
func (m *SortedMap) Reset() {
m.kv.Init()
for key := range m.keys {
delete(m.keys, key)
}
}
| go | MIT | 8e7e5695eb2095917864b5d6615dab4c90bde3ac | 2026-01-07T08:36:18.042207Z | false |
zeromicro/go-zero | https://github.com/zeromicro/go-zero/blob/8e7e5695eb2095917864b5d6615dab4c90bde3ac/tools/goctl/pkg/collection/sortedmap_test.go | tools/goctl/pkg/collection/sortedmap_test.go | package sortedmap
import (
"testing"
"github.com/stretchr/testify/assert"
)
func Test_SortedMap(t *testing.T) {
sm := New()
t.Run("SetExpression", func(t *testing.T) {
_, _, err := sm.SetExpression("")
assert.ErrorIs(t, err, ErrInvalidKVExpression)
_, _, err = sm.SetExpression("foo")
assert.ErrorIs(t, err, ErrInvalidKVExpression)
_, _, err = sm.SetExpression("foo= ")
assert.ErrorIs(t, err, ErrInvalidKVExpression)
_, _, err = sm.SetExpression(" foo=")
assert.ErrorIs(t, err, ErrInvalidKVExpression)
_, _, err = sm.SetExpression("foo =")
assert.ErrorIs(t, err, ErrInvalidKVExpression)
_, _, err = sm.SetExpression("=")
assert.ErrorIs(t, err, ErrInvalidKVExpression)
_, _, err = sm.SetExpression("=bar")
assert.ErrorIs(t, err, ErrInvalidKVExpression)
key, value, err := sm.SetExpression("foo=bar")
assert.Nil(t, err)
assert.Equal(t, "foo", key)
assert.Equal(t, "bar", value)
key, value, err = sm.SetExpression("foo=")
assert.Nil(t, err)
assert.Equal(t, value, sm.GetOr(key, ""))
sm.Reset()
})
t.Run("SetKV", func(t *testing.T) {
sm.SetKV("foo", "bar")
assert.Equal(t, "bar", sm.GetOr("foo", ""))
sm.SetKV("foo", "bar-changed")
assert.Equal(t, "bar-changed", sm.GetOr("foo", ""))
sm.Reset()
})
t.Run("Set", func(t *testing.T) {
err := sm.Set(KV{})
assert.Nil(t, err)
err = sm.Set(KV{"foo"})
assert.ErrorIs(t, ErrInvalidKVS, err)
err = sm.Set(KV{"foo", "bar", "bar", "foo"})
assert.Nil(t, err)
assert.Equal(t, "bar", sm.GetOr("foo", ""))
assert.Equal(t, "foo", sm.GetOr("bar", ""))
sm.Reset()
})
t.Run("Get", func(t *testing.T) {
_, ok := sm.Get("foo")
assert.False(t, ok)
sm.SetKV("foo", "bar")
value, ok := sm.Get("foo")
assert.True(t, ok)
assert.Equal(t, "bar", value)
sm.Reset()
})
t.Run("GetString", func(t *testing.T) {
_, ok := sm.GetString("foo")
assert.False(t, ok)
sm.SetKV("foo", "bar")
value, ok := sm.GetString("foo")
assert.True(t, ok)
assert.Equal(t, "bar", value)
sm.Reset()
})
t.Run("GetStringOr", func(t *testing.T) {
value := sm.GetStringOr("foo", "bar")
assert.Equal(t, "bar", value)
sm.SetKV("foo", "foo")
value = sm.GetStringOr("foo", "bar")
assert.Equal(t, "foo", value)
sm.Reset()
})
t.Run("GetOr", func(t *testing.T) {
value := sm.GetOr("foo", "bar")
assert.Equal(t, "bar", value)
sm.SetKV("foo", "foo")
value = sm.GetOr("foo", "bar")
assert.Equal(t, "foo", value)
sm.Reset()
})
t.Run("HasKey", func(t *testing.T) {
ok := sm.HasKey("foo")
assert.False(t, ok)
sm.SetKV("foo", "")
assert.True(t, sm.HasKey("foo"))
sm.Reset()
})
t.Run("HasValue", func(t *testing.T) {
assert.False(t, sm.HasValue("bar"))
sm.SetKV("foo", "bar")
assert.True(t, sm.HasValue("bar"))
sm.Reset()
})
t.Run("Keys", func(t *testing.T) {
keys := sm.Keys()
assert.Equal(t, 0, len(keys))
expected := []string{"foo1", "foo2", "foo3"}
for _, key := range expected {
sm.SetKV(key, "")
}
keys = sm.Keys()
var actual []string
for _, key := range keys {
actual = append(actual, key.(string))
}
assert.Equal(t, expected, actual)
sm.Reset()
})
t.Run("Values", func(t *testing.T) {
values := sm.Values()
assert.Equal(t, 0, len(values))
expected := []string{"foo1", "foo2", "foo3"}
for _, key := range expected {
sm.SetKV(key, key)
}
values = sm.Values()
var actual []string
for _, value := range values {
actual = append(actual, value.(string))
}
assert.Equal(t, expected, actual)
sm.Reset()
})
t.Run("Range", func(t *testing.T) {
var keys, values []string
sm.Range(func(key, value any) {
keys = append(keys, key.(string))
values = append(values, value.(string))
})
assert.Len(t, keys, 0)
assert.Len(t, values, 0)
expected := []string{"foo1", "foo2", "foo3"}
for _, key := range expected {
sm.SetKV(key, key)
}
sm.Range(func(key, value any) {
keys = append(keys, key.(string))
values = append(values, value.(string))
})
assert.Equal(t, expected, keys)
assert.Equal(t, expected, values)
sm.Reset()
})
t.Run("RangeIf", func(t *testing.T) {
var keys, values []string
sm.RangeIf(func(key, value any) bool {
keys = append(keys, key.(string))
values = append(values, value.(string))
return true
})
assert.Len(t, keys, 0)
assert.Len(t, values, 0)
expected := []string{"foo1", "foo2", "foo3"}
for _, key := range expected {
sm.SetKV(key, key)
}
sm.RangeIf(func(key, value any) bool {
keys = append(keys, key.(string))
values = append(values, value.(string))
if key.(string) == "foo1" {
return false
}
return true
})
assert.Equal(t, []string{"foo1"}, keys)
assert.Equal(t, []string{"foo1"}, values)
sm.Reset()
})
t.Run("Remove", func(t *testing.T) {
_, ok := sm.Remove("foo")
assert.False(t, ok)
sm.SetKV("foo", "bar")
value, ok := sm.Remove("foo")
assert.True(t, ok)
assert.Equal(t, "bar", value)
assert.False(t, sm.HasKey("foo"))
assert.False(t, sm.HasValue("bar"))
sm.Reset()
})
t.Run("Insert", func(t *testing.T) {
data := New()
data.SetKV("foo", "bar")
sm.SetKV("foo1", "bar1")
sm.Insert(data)
assert.True(t, sm.HasKey("foo"))
assert.True(t, sm.HasValue("bar"))
sm.Reset()
})
t.Run("Copy", func(t *testing.T) {
sm.SetKV("foo", "bar")
data := sm.Copy()
assert.True(t, data.HasKey("foo"))
assert.True(t, data.HasValue("bar"))
sm.SetKV("foo", "bar1")
assert.True(t, data.HasKey("foo"))
assert.True(t, data.HasValue("bar"))
sm.Reset()
})
t.Run("Format", func(t *testing.T) {
format := sm.Format()
assert.Equal(t, []string{}, format)
sm.SetKV("foo1", "bar1")
sm.SetKV("foo2", "bar2")
sm.SetKV("foo3", "")
format = sm.Format()
assert.Equal(t, []string{"foo1=bar1", "foo2=bar2", "foo3="}, format)
sm.Reset()
})
}
| go | MIT | 8e7e5695eb2095917864b5d6615dab4c90bde3ac | 2026-01-07T08:36:18.042207Z | false |
zeromicro/go-zero | https://github.com/zeromicro/go-zero/blob/8e7e5695eb2095917864b5d6615dab4c90bde3ac/tools/goctl/pkg/protoc/protoc.go | tools/goctl/pkg/protoc/protoc.go | package protoc
import (
"archive/zip"
"fmt"
"os"
"path/filepath"
"runtime"
"strings"
"github.com/zeromicro/go-zero/tools/goctl/pkg/downloader"
"github.com/zeromicro/go-zero/tools/goctl/pkg/goctl"
"github.com/zeromicro/go-zero/tools/goctl/rpc/execx"
"github.com/zeromicro/go-zero/tools/goctl/util/env"
"github.com/zeromicro/go-zero/tools/goctl/util/zipx"
"github.com/zeromicro/go-zero/tools/goctl/vars"
)
var url = map[string]string{
"linux_32": "https://github.com/protocolbuffers/protobuf/releases/download/v3.19.4/protoc-3.19.4-linux-x86_32.zip",
"linux_64": "https://github.com/protocolbuffers/protobuf/releases/download/v3.19.4/protoc-3.19.4-linux-x86_64.zip",
"darwin": "https://github.com/protocolbuffers/protobuf/releases/download/v3.19.4/protoc-3.19.4-osx-x86_64.zip",
"windows_32": "https://github.com/protocolbuffers/protobuf/releases/download/v3.19.4/protoc-3.19.4-win32.zip",
"windows_64": "https://github.com/protocolbuffers/protobuf/releases/download/v3.19.4/protoc-3.19.4-win64.zip",
}
const (
Name = "protoc"
ZipFileName = Name + ".zip"
)
func Install(cacheDir string) (string, error) {
return goctl.Install(cacheDir, Name, func(dest string) (string, error) {
goos := runtime.GOOS
tempFile := filepath.Join(os.TempDir(), ZipFileName)
bit := 32 << (^uint(0) >> 63)
var downloadUrl string
switch goos {
case vars.OsMac:
downloadUrl = url[vars.OsMac]
case vars.OsWindows:
downloadUrl = url[fmt.Sprintf("%s_%d", vars.OsWindows, bit)]
case vars.OsLinux:
downloadUrl = url[fmt.Sprintf("%s_%d", vars.OsLinux, bit)]
default:
return "", fmt.Errorf("unsupported OS: %q", goos)
}
err := downloader.Download(downloadUrl, tempFile)
if err != nil {
return "", err
}
return dest, zipx.Unpacking(tempFile, filepath.Dir(dest), func(f *zip.File) bool {
return filepath.Base(f.Name) == filepath.Base(dest)
})
})
}
func Exists() bool {
_, err := env.LookUpProtoc()
return err == nil
}
func Version() (string, error) {
path, err := env.LookUpProtoc()
if err != nil {
return "", err
}
version, err := execx.Run(path+" --version", "")
if err != nil {
return "", err
}
fields := strings.Fields(version)
if len(fields) > 1 {
return fields[1], nil
}
return "", nil
}
| go | MIT | 8e7e5695eb2095917864b5d6615dab4c90bde3ac | 2026-01-07T08:36:18.042207Z | false |
zeromicro/go-zero | https://github.com/zeromicro/go-zero/blob/8e7e5695eb2095917864b5d6615dab4c90bde3ac/tools/goctl/pkg/protocgengo/protocgengo.go | tools/goctl/pkg/protocgengo/protocgengo.go | package protocgengo
import (
"strings"
"time"
"github.com/zeromicro/go-zero/tools/goctl/pkg/goctl"
"github.com/zeromicro/go-zero/tools/goctl/pkg/golang"
"github.com/zeromicro/go-zero/tools/goctl/rpc/execx"
"github.com/zeromicro/go-zero/tools/goctl/util/env"
)
const (
Name = "protoc-gen-go"
url = "google.golang.org/protobuf/cmd/protoc-gen-go@latest"
)
func Install(cacheDir string) (string, error) {
return goctl.Install(cacheDir, Name, func(dest string) (string, error) {
err := golang.Install(url)
return dest, err
})
}
func Exists() bool {
ver, err := Version()
if err != nil {
return false
}
return len(ver) > 0
}
// Version is used to get the version of the protoc-gen-go plugin. For older versions, protoc-gen-go does not support
// version fetching, so if protoc-gen-go --version is executed, it will cause the process to block, so it is controlled
// by a timer to prevent the older version process from blocking.
func Version() (string, error) {
path, err := env.LookUpProtocGenGo()
if err != nil {
return "", err
}
versionC := make(chan string)
go func(c chan string) {
version, _ := execx.Run(path+" --version", "")
fields := strings.Fields(version)
if len(fields) > 1 {
c <- fields[1]
}
}(versionC)
t := time.NewTimer(time.Second)
select {
case <-t.C:
return "", nil
case version := <-versionC:
return version, nil
}
}
| go | MIT | 8e7e5695eb2095917864b5d6615dab4c90bde3ac | 2026-01-07T08:36:18.042207Z | false |
zeromicro/go-zero | https://github.com/zeromicro/go-zero/blob/8e7e5695eb2095917864b5d6615dab4c90bde3ac/tools/goctl/pkg/downloader/downloader.go | tools/goctl/pkg/downloader/downloader.go | package downloader
import (
"io"
"net/http"
"os"
)
func Download(url, filename string) error {
resp, err := http.Get(url)
if err != nil {
return err
}
defer resp.Body.Close()
f, err := os.Create(filename)
if err != nil {
return err
}
defer f.Close()
_, err = io.Copy(f, resp.Body)
return err
}
| go | MIT | 8e7e5695eb2095917864b5d6615dab4c90bde3ac | 2026-01-07T08:36:18.042207Z | false |
zeromicro/go-zero | https://github.com/zeromicro/go-zero/blob/8e7e5695eb2095917864b5d6615dab4c90bde3ac/tools/goctl/pkg/goctl/goctl.go | tools/goctl/pkg/goctl/goctl.go | package goctl
import (
"path/filepath"
"runtime"
"github.com/zeromicro/go-zero/tools/goctl/pkg/golang"
"github.com/zeromicro/go-zero/tools/goctl/util/console"
"github.com/zeromicro/go-zero/tools/goctl/util/pathx"
"github.com/zeromicro/go-zero/tools/goctl/vars"
)
func Install(cacheDir, name string, installFn func(dest string) (string, error)) (string, error) {
goBin := golang.GoBin()
cacheFile := filepath.Join(cacheDir, name)
binFile := filepath.Join(goBin, name)
goos := runtime.GOOS
if goos == vars.OsWindows {
cacheFile = cacheFile + ".exe"
binFile = binFile + ".exe"
}
// read cache.
err := pathx.Copy(cacheFile, binFile)
if err == nil {
console.Info("%q installed from cache", name)
return binFile, nil
}
binFile, err = installFn(binFile)
if err != nil {
return "", err
}
// write cache.
err = pathx.Copy(binFile, cacheFile)
if err != nil {
console.Warning("write cache error: %+v", err)
}
return binFile, nil
}
| go | MIT | 8e7e5695eb2095917864b5d6615dab4c90bde3ac | 2026-01-07T08:36:18.042207Z | false |
zeromicro/go-zero | https://github.com/zeromicro/go-zero/blob/8e7e5695eb2095917864b5d6615dab4c90bde3ac/tools/goctl/pkg/protocgengogrpc/protocgengogrpc.go | tools/goctl/pkg/protocgengogrpc/protocgengogrpc.go | package protocgengogrpc
import (
"strings"
"github.com/zeromicro/go-zero/tools/goctl/pkg/goctl"
"github.com/zeromicro/go-zero/tools/goctl/pkg/golang"
"github.com/zeromicro/go-zero/tools/goctl/rpc/execx"
"github.com/zeromicro/go-zero/tools/goctl/util/env"
)
const (
Name = "protoc-gen-go-grpc"
url = "google.golang.org/grpc/cmd/protoc-gen-go-grpc@latest"
)
func Install(cacheDir string) (string, error) {
return goctl.Install(cacheDir, Name, func(dest string) (string, error) {
err := golang.Install(url)
return dest, err
})
}
func Exists() bool {
_, err := env.LookUpProtocGenGoGrpc()
return err == nil
}
// Version is used to get the version of the protoc-gen-go-grpc plugin.
func Version() (string, error) {
path, err := env.LookUpProtocGenGoGrpc()
if err != nil {
return "", err
}
version, err := execx.Run(path+" --version", "")
if err != nil {
return "", err
}
fields := strings.Fields(version)
if len(fields) > 1 {
return fields[1], nil
}
return "", nil
}
| go | MIT | 8e7e5695eb2095917864b5d6615dab4c90bde3ac | 2026-01-07T08:36:18.042207Z | false |
zeromicro/go-zero | https://github.com/zeromicro/go-zero/blob/8e7e5695eb2095917864b5d6615dab4c90bde3ac/tools/goctl/pkg/parser/api/importstack/importstack.go | tools/goctl/pkg/parser/api/importstack/importstack.go | package importstack
import "errors"
// ErrImportCycleNotAllowed defines an error for circular importing
var ErrImportCycleNotAllowed = errors.New("import cycle not allowed")
// ImportStack a stack of import paths
type ImportStack []string
func New() *ImportStack {
return &ImportStack{}
}
func (s *ImportStack) Push(p string) error {
for _, x := range *s {
if x == p {
return ErrImportCycleNotAllowed
}
}
*s = append(*s, p)
return nil
}
func (s *ImportStack) Pop() {
*s = (*s)[0 : len(*s)-1]
}
func (s *ImportStack) List() []string {
return *s
}
| go | MIT | 8e7e5695eb2095917864b5d6615dab4c90bde3ac | 2026-01-07T08:36:18.042207Z | false |
zeromicro/go-zero | https://github.com/zeromicro/go-zero/blob/8e7e5695eb2095917864b5d6615dab4c90bde3ac/tools/goctl/pkg/parser/api/assertx/error.go | tools/goctl/pkg/parser/api/assertx/error.go | package assertx
import (
"fmt"
"testing"
"github.com/stretchr/testify/assert"
)
// ErrorOrigin is used to assert error and print source and error.
func ErrorOrigin(t *testing.T, source string, err ...error) {
if len(err) == 0 {
t.Fatalf("expected errors, got 0 error")
return
}
for _, e := range err {
fmt.Printf("<%s>: %v\n", source, e)
assert.Error(t, e)
}
}
// Error is used to assert error.
func Error(t *testing.T, err ...error) {
if len(err) == 0 {
t.Fatalf("expected errors, got 0 error")
return
}
for _, e := range err {
fmt.Println(e)
assert.Error(t, e)
}
}
| go | MIT | 8e7e5695eb2095917864b5d6615dab4c90bde3ac | 2026-01-07T08:36:18.042207Z | false |
zeromicro/go-zero | https://github.com/zeromicro/go-zero/blob/8e7e5695eb2095917864b5d6615dab4c90bde3ac/tools/goctl/pkg/parser/api/scanner/scanner_test.go | tools/goctl/pkg/parser/api/scanner/scanner_test.go | package scanner
import (
"bytes"
_ "embed"
"fmt"
"strings"
"testing"
"github.com/stretchr/testify/assert"
"github.com/zeromicro/go-zero/tools/goctl/pkg/parser/api/assertx"
"github.com/zeromicro/go-zero/tools/goctl/pkg/parser/api/token"
)
func Test_readData(t *testing.T) {
testData := []struct {
input interface{}
expected interface{}
}{
{
input: []byte("foo"),
expected: []byte("foo"),
},
{
input: bytes.NewBufferString("foo"),
expected: []byte("foo"),
},
{
input: "foo",
expected: []byte("foo"),
},
{
input: "",
expected: []byte{},
},
{
input: strings.NewReader("foo"),
expected: fmt.Errorf("unsupported type: *strings.Reader"),
},
}
for _, v := range testData {
actual, err := readData("", v.input)
if err != nil {
assert.Equal(t, v.expected.(error).Error(), err.Error())
} else {
assert.Equal(t, v.expected, actual)
}
}
}
func TestNewScanner(t *testing.T) {
testData := []struct {
filename string
src interface{}
expected interface{}
}{
{
filename: "foo",
src: "foo",
expected: "foo",
},
{
filename: "foo",
src: "",
expected: "missing input",
},
}
for _, v := range testData {
s, err := NewScanner(v.filename, v.src)
if err != nil {
assert.Contains(t, err.Error(), v.expected)
} else {
assert.Equal(t, v.expected, s.filename)
}
}
}
func TestScanner_NextToken_lineComment(t *testing.T) {
var testData = []token.Token{
{
Type: token.COMMENT,
Text: "//",
Position: token.Position{
Filename: "foo.api",
Line: 1,
Column: 1,
},
},
{
Type: token.COMMENT,
Text: "//foo",
Position: token.Position{
Filename: "foo.api",
Line: 2,
Column: 1,
},
},
{
Type: token.COMMENT,
Text: "//bar",
Position: token.Position{
Filename: "foo.api",
Line: 3,
Column: 1,
},
},
{
Type: token.COMMENT,
Text: "///",
Position: token.Position{
Filename: "foo.api",
Line: 4,
Column: 1,
},
},
{
Type: token.COMMENT,
Text: "////",
Position: token.Position{
Filename: "foo.api",
Line: 5,
Column: 1,
},
},
{
Type: token.QUO,
Text: "/",
Position: token.Position{
Filename: "foo.api",
Line: 6,
Column: 1,
},
},
token.EofToken,
}
var input = "//\n//foo\n//bar\n///\n////\n/"
s, err := NewScanner("foo.api", input)
assert.NoError(t, err)
for _, expected := range testData {
actual, err := s.NextToken()
assert.NoError(t, err)
assert.Equal(t, expected, actual)
}
}
func TestScanner_NextToken_document(t *testing.T) {
var testData = []token.Token{
{
Type: token.DOCUMENT,
Text: "/**/",
Position: token.Position{
Filename: "foo.api",
Line: 1,
Column: 1,
},
},
{
Type: token.DOCUMENT,
Text: "/***/",
Position: token.Position{
Filename: "foo.api",
Line: 1,
Column: 6,
},
},
{
Type: token.DOCUMENT,
Text: "/*-*/",
Position: token.Position{
Filename: "foo.api",
Line: 1,
Column: 12,
},
},
{
Type: token.DOCUMENT,
Text: "/*/*/",
Position: token.Position{
Filename: "foo.api",
Line: 1,
Column: 18,
},
},
{
Type: token.DOCUMENT,
Text: "/*////*/",
Position: token.Position{
Filename: "foo.api",
Line: 1,
Column: 24,
},
},
{
Type: token.DOCUMENT,
Text: "/*foo*/",
Position: token.Position{
Filename: "foo.api",
Line: 2,
Column: 1,
},
},
{
Type: token.DOCUMENT,
Text: "/*---*/",
Position: token.Position{
Filename: "foo.api",
Line: 3,
Column: 1,
},
},
{
Type: token.DOCUMENT,
Text: "/*\n*/",
Position: token.Position{
Filename: "foo.api",
Line: 4,
Column: 1,
},
},
{
Type: token.QUO,
Text: "/",
Position: token.Position{
Filename: "foo.api",
Line: 5,
Column: 1,
},
},
token.EofToken,
}
var input = "/**/ /***/ /*-*/ /*/*/ /*////*/ \n/*foo*/\n/*---*/\n/*\n*/\n/"
s, err := NewScanner("foo.api", input)
assert.NoError(t, err)
for _, expected := range testData {
actual, err := s.NextToken()
assert.NoError(t, err)
assert.Equal(t, expected, actual)
}
}
func TestScanner_NextToken_invalid_document(t *testing.T) {
var testData = []string{
"/*",
"/**",
"/***",
"/*/",
"/*/*",
"/*/**",
}
for _, v := range testData {
s, err := NewScanner("foo.api", v)
assert.NoError(t, err)
_, err = s.NextToken()
assertx.Error(t, err)
}
}
func TestScanner_NextToken_operator(t *testing.T) {
var testData = []token.Token{
{
Type: token.SUB,
Text: "-",
Position: token.Position{
Filename: "foo.api",
Line: 1,
Column: 1,
},
},
{
Type: token.MUL,
Text: "*",
Position: token.Position{
Filename: "foo.api",
Line: 1,
Column: 2,
},
},
{
Type: token.LPAREN,
Text: "(",
Position: token.Position{
Filename: "foo.api",
Line: 1,
Column: 3,
},
},
{
Type: token.LBRACE,
Text: "{",
Position: token.Position{
Filename: "foo.api",
Line: 1,
Column: 4,
},
},
{
Type: token.COMMA,
Text: ",",
Position: token.Position{
Filename: "foo.api",
Line: 1,
Column: 5,
},
},
{
Type: token.DOT,
Text: ".",
Position: token.Position{
Filename: "foo.api",
Line: 1,
Column: 6,
},
},
{
Type: token.RPAREN,
Text: ")",
Position: token.Position{
Filename: "foo.api",
Line: 1,
Column: 7,
},
},
{
Type: token.RBRACE,
Text: "}",
Position: token.Position{
Filename: "foo.api",
Line: 1,
Column: 8,
},
},
{
Type: token.SEMICOLON,
Text: ";",
Position: token.Position{
Filename: "foo.api",
Line: 1,
Column: 9,
},
},
{
Type: token.COLON,
Text: ":",
Position: token.Position{
Filename: "foo.api",
Line: 1,
Column: 10,
},
},
{
Type: token.ASSIGN,
Text: "=",
Position: token.Position{
Filename: "foo.api",
Line: 1,
Column: 11,
},
},
{
Type: token.ELLIPSIS,
Text: "...",
Position: token.Position{
Filename: "foo.api",
Line: 1,
Column: 12,
},
},
}
s, err := NewScanner("foo.api", "-*({,.)};:=...")
assert.NoError(t, err)
for _, expected := range testData {
actual, err := s.NextToken()
assert.NoError(t, err)
assert.Equal(t, expected, actual)
}
}
func TestScanner_NextToken_at(t *testing.T) {
t.Run("valid", func(t *testing.T) {
var testData = []token.Token{
{
Type: token.AT_DOC,
Text: "@doc",
Position: token.Position{
Filename: "foo.api",
Line: 1,
Column: 1,
},
},
{
Type: token.AT_HANDLER,
Text: "@handler",
Position: token.Position{
Filename: "foo.api",
Line: 1,
Column: 5,
},
},
{
Type: token.AT_SERVER,
Text: "@server",
Position: token.Position{
Filename: "foo.api",
Line: 1,
Column: 13,
},
},
{
Type: token.AT_HANDLER,
Text: "@handler",
Position: token.Position{
Filename: "foo.api",
Line: 2,
Column: 1,
},
},
{
Type: token.AT_SERVER,
Text: "@server",
Position: token.Position{
Filename: "foo.api",
Line: 3,
Column: 1,
},
},
}
s, err := NewScanner("foo.api", "@doc@handler@server\n@handler\n@server")
assert.NoError(t, err)
for _, expected := range testData {
actual, err := s.NextToken()
assert.NoError(t, err)
assert.Equal(t, expected, actual)
}
})
t.Run("invalid", func(t *testing.T) {
var testData = []string{
"@h",
"@ha",
"@han",
"@hand",
"@handl",
"@handle",
"@handlerr",
"@hhandler",
"@foo",
"@sserver",
"@serverr",
"@d",
"@do",
"@docc",
}
for _, v := range testData {
s, err := NewScanner("foo.api", v)
assert.NoError(t, err)
_, err = s.NextToken()
assertx.Error(t, err)
}
})
}
func TestScanner_NextToken_ident(t *testing.T) {
var testData = []token.Token{
{
Type: token.IDENT,
Text: "foo",
Position: token.Position{
Filename: "foo.api",
Line: 1,
Column: 1,
},
},
{
Type: token.IDENT,
Text: "bar",
Position: token.Position{
Filename: "foo.api",
Line: 1,
Column: 5,
},
},
{
Type: token.IDENT,
Text: "go",
Position: token.Position{
Filename: "foo.api",
Line: 2,
Column: 1,
},
},
{
Type: token.IDENT,
Text: "func",
Position: token.Position{
Filename: "foo.api",
Line: 2,
Column: 4,
},
},
{
Type: token.IDENT,
Text: "_",
Position: token.Position{
Filename: "foo.api",
Line: 3,
Column: 1,
},
},
{
Type: token.IDENT,
Text: "_go",
Position: token.Position{
Filename: "foo.api",
Line: 4,
Column: 1,
},
},
{
Type: token.IDENT,
Text: "info",
Position: token.Position{
Filename: "foo.api",
Line: 5,
Column: 1,
},
},
{
Type: token.IDENT,
Text: "goo",
Position: token.Position{
Filename: "foo.api",
Line: 6,
Column: 1,
},
},
{
Type: token.IDENT,
Text: "vvar",
Position: token.Position{
Filename: "foo.api",
Line: 6,
Column: 5,
},
},
{
Type: token.IDENT,
Text: "imports",
Position: token.Position{
Filename: "foo.api",
Line: 6,
Column: 10,
},
},
{
Type: token.IDENT,
Text: "go1",
Position: token.Position{
Filename: "foo.api",
Line: 7,
Column: 1,
},
},
}
s, err := NewScanner("foo.api", "foo bar\ngo func\n_\n_go\ninfo\ngoo vvar imports\ngo1")
assert.NoError(t, err)
for _, expected := range testData {
actual, err := s.NextToken()
assert.NoError(t, err)
assert.Equal(t, expected, actual)
}
}
func TestScanner_NextToken_Key(t *testing.T) {
var testData = []token.Token{
{
Type: token.IDENT,
Text: "foo",
Position: token.Position{
Filename: "foo.api",
Line: 1,
Column: 1,
},
},
{
Type: token.IDENT,
Text: "foo",
Position: token.Position{
Filename: "foo.api",
Line: 2,
Column: 1,
},
},
{
Type: token.COLON,
Text: ":",
Position: token.Position{
Filename: "foo.api",
Line: 2,
Column: 4,
},
},
{
Type: token.IDENT,
Text: "bar",
Position: token.Position{
Filename: "foo.api",
Line: 3,
Column: 1,
},
},
{
Type: token.COLON,
Text: ":",
Position: token.Position{
Filename: "foo.api",
Line: 3,
Column: 4,
},
},
{
Type: token.COLON,
Text: ":",
Position: token.Position{
Filename: "foo.api",
Line: 3,
Column: 5,
},
},
{
Type: token.IDENT,
Text: "interface",
Position: token.Position{
Filename: "foo.api",
Line: 4,
Column: 1,
},
},
{
Type: token.ANY,
Text: "interface{}",
Position: token.Position{
Filename: "foo.api",
Line: 5,
Column: 1,
},
},
{
Type: token.LBRACE,
Text: "{",
Position: token.Position{
Filename: "foo.api",
Line: 5,
Column: 12,
},
},
}
s, err := NewScanner("foo.api", "foo\nfoo:\nbar::\ninterface\ninterface{}{")
assert.NoError(t, err)
for _, expected := range testData {
actual, err := s.NextToken()
assert.NoError(t, err)
assert.Equal(t, expected, actual)
}
}
func TestScanner_NextToken_int(t *testing.T) {
var testData = []token.Token{
{
Type: token.INT,
Text: `123`,
Position: token.Position{
Filename: "foo.api",
Line: 1,
Column: 1,
},
},
{
Type: token.INT,
Text: `234`,
Position: token.Position{
Filename: "foo.api",
Line: 1,
Column: 5,
},
},
{
Type: token.INT,
Text: `123`,
Position: token.Position{
Filename: "foo.api",
Line: 2,
Column: 1,
},
},
{
Type: token.INT,
Text: `234`,
Position: token.Position{
Filename: "foo.api",
Line: 3,
Column: 1,
},
},
}
s, err := NewScanner("foo.api", "123 234\n123\n234a")
assert.NoError(t, err)
for _, expected := range testData {
actual, err := s.NextToken()
assert.NoError(t, err)
assert.Equal(t, expected, actual)
}
}
func TestScanner_NextToken_duration(t *testing.T) {
t.Run("ns", func(t *testing.T) {
var testData = []token.Token{
{
Type: token.DURATION,
Text: `1ns`,
Position: token.Position{
Filename: "foo.api",
Line: 1,
Column: 1,
},
},
{
Type: token.DURATION,
Text: `10ns`,
Position: token.Position{
Filename: "foo.api",
Line: 2,
Column: 1,
},
},
{
Type: token.DURATION,
Text: `100ns`,
Position: token.Position{
Filename: "foo.api",
Line: 3,
Column: 1,
},
},
}
s, err := NewScanner("foo.api", "1ns\n10ns\n100ns")
assert.NoError(t, err)
for _, expected := range testData {
actual, err := s.NextToken()
assert.NoError(t, err)
assert.Equal(t, expected, actual)
}
})
t.Run("µs", func(t *testing.T) {
var testData = []token.Token{
{
Type: token.DURATION,
Text: `1µs`,
Position: token.Position{
Filename: "foo.api",
Line: 1,
Column: 1,
},
},
{
Type: token.DURATION,
Text: `10µs`,
Position: token.Position{
Filename: "foo.api",
Line: 2,
Column: 1,
},
},
{
Type: token.DURATION,
Text: `100µs`,
Position: token.Position{
Filename: "foo.api",
Line: 3,
Column: 1,
},
},
{
Type: token.DURATION,
Text: `1µs1ns`,
Position: token.Position{
Filename: "foo.api",
Line: 4,
Column: 1,
},
},
{
Type: token.DURATION,
Text: `1µs10ns`,
Position: token.Position{
Filename: "foo.api",
Line: 5,
Column: 1,
},
},
}
s, err := NewScanner("foo.api", "1µs\n10µs\n100µs\n1µs1ns\n1µs10ns")
assert.NoError(t, err)
for _, expected := range testData {
actual, err := s.NextToken()
assert.NoError(t, err)
assert.Equal(t, expected, actual)
}
})
t.Run("ms", func(t *testing.T) {
var testData []token.Token
var source interface{} = "1ms\n10ms\n100ms\n1ms1µs\n1ms10µs\n1ms1ns\n1ms10ns\n1ms1µs1ns\n1ms1µs10ns\n1ms10µs1ns\n1ms10µs10ns"
for idx, seg := range strings.FieldsFunc(source.(string), func(r rune) bool {
return r == '\n'
}) {
testData = append(testData, token.Token{
Type: token.DURATION,
Text: seg,
Position: token.Position{
Filename: "foo.api",
Line: idx + 1,
Column: 1,
},
})
}
s, err := NewScanner("foo.api", source)
assert.NoError(t, err)
for _, expected := range testData {
actual, err := s.NextToken()
assert.NoError(t, err)
assert.Equal(t, expected, actual)
}
})
t.Run("s", func(t *testing.T) {
var testData []token.Token
var source interface{} = "1s\n10s\n100s\n1s1ms\n1s10ms\n1s100ms\n1s1ms1µs\n1s10ms10µs\n1s100ms100µs\n" +
"1s100ms100µs1ns\n1s100ms100µs10ns\n1s100ms100µs100ns\n1s1µs\n1s10µs\n1s100µs\n1s1µs1ns\n1s10µs10ns\n" +
"1s100µs100ns\n1s1ms1µs1ns\n1s10ms10µs10ns\n1s100ms100µs100ns\n1s1ns\n1s10ns\n1s100ns"
for idx, seg := range strings.FieldsFunc(source.(string), func(r rune) bool {
return r == '\n'
}) {
testData = append(testData, token.Token{
Type: token.DURATION,
Text: seg,
Position: token.Position{
Filename: "foo.api",
Line: idx + 1,
Column: 1,
},
})
}
s, err := NewScanner("foo.api", source)
assert.NoError(t, err)
for _, expected := range testData {
actual, err := s.NextToken()
assert.NoError(t, err)
assert.Equal(t, expected, actual)
}
})
t.Run("m", func(t *testing.T) {
var testData []token.Token
var source interface{} = "1m\n10m\n100m\n1m1s\n1m10s\n1m100s\n1m1s1ms\n1m10s10ms\n1m100s100ms\n" +
"1m1s1ms1µs\n1m10s10ms10µs\n1m100s100ms100µs\n1m1s1ms1µs1ns\n1m1s1ms1µs10ns\n1m1s1ms1µs100ns\n" +
"1m1s1µs\n1m1ns\n1m10ms10µs100ns"
list := strings.FieldsFunc(source.(string), func(r rune) bool {
return r == '\n'
})
for idx, seg := range list {
testData = append(testData, token.Token{
Type: token.DURATION,
Text: seg,
Position: token.Position{
Filename: "foo.api",
Line: idx + 1,
Column: 1,
},
})
}
s, err := NewScanner("foo.api", source)
assert.NoError(t, err)
for _, expected := range testData {
actual, err := s.NextToken()
assert.NoError(t, err)
assert.Equal(t, expected, actual)
}
})
t.Run("h", func(t *testing.T) {
var testData []token.Token
var source interface{} = "1h\n10h\n100h\n" +
"1h1m\n10h10m\n100h100m\n" +
"1h1m1s\n10h10m10s\n100h100m100s\n" +
"1h1m1s1ms\n10h10m10s10ms\n100h100m100s100ms\n" +
"1h1m1s1ms1µs\n10h10m10s10ms10µs\n100h100m100s100ms100µs\n" +
"1h1m1s1ms1µs1ns\n10h10m10s10ms10µs10ns\n100h100m100s100ms100µs100ns\n" +
"1h10ns\n1h100µs\n10h10s\n10h10ms\n10h10m10µs"
list := strings.FieldsFunc(source.(string), func(r rune) bool {
return r == '\n'
})
for idx, seg := range list {
testData = append(testData, token.Token{
Type: token.DURATION,
Text: seg,
Position: token.Position{
Filename: "foo.api",
Line: idx + 1,
Column: 1,
},
})
}
s, err := NewScanner("foo.api", source)
assert.NoError(t, err)
for _, expected := range testData {
actual, err := s.NextToken()
assert.NoError(t, err)
assert.Equal(t, expected, actual)
}
})
}
func TestScanner_NextToken_string(t *testing.T) {
t.Run("valid", func(t *testing.T) {
var testData = []token.Token{
{
Type: token.STRING,
Text: `""`,
Position: token.Position{
Filename: "foo.api",
Line: 1,
Column: 1,
},
},
{
Type: token.STRING,
Text: `"foo"`,
Position: token.Position{
Filename: "foo.api",
Line: 1,
Column: 3,
},
},
{
Type: token.STRING,
Text: `"foo\nbar"`,
Position: token.Position{
Filename: "foo.api",
Line: 1,
Column: 8,
},
},
}
s, err := NewScanner("foo.api", `"""foo""foo\nbar"`)
assert.NoError(t, err)
for _, expected := range testData {
actual, err := s.NextToken()
assert.NoError(t, err)
assert.Equal(t, expected, actual)
}
})
t.Run("invalid", func(t *testing.T) {
var testData = []string{
`"`,
`"foo`,
`"
`,
}
for _, v := range testData {
s, err := NewScanner("foo.api", v)
assert.NoError(t, err)
_, err = s.NextToken()
assertx.Error(t, err)
}
})
}
func TestScanner_NextToken_rawString(t *testing.T) {
t.Run("valid", func(t *testing.T) {
var testData = []token.Token{
{
Type: token.RAW_STRING,
Text: "``",
Position: token.Position{
Filename: "foo.api",
Line: 1,
Column: 1,
},
},
{
Type: token.RAW_STRING,
Text: "`foo`",
Position: token.Position{
Filename: "foo.api",
Line: 1,
Column: 3,
},
},
{
Type: token.RAW_STRING,
Text: "`foo bar`",
Position: token.Position{
Filename: "foo.api",
Line: 1,
Column: 8,
},
},
}
s, err := NewScanner("foo.api", "```foo``foo bar`")
assert.NoError(t, err)
for _, expected := range testData {
actual, err := s.NextToken()
assert.NoError(t, err)
assert.Equal(t, expected, actual)
}
})
t.Run("invalid", func(t *testing.T) {
var testData = []string{
"`",
"`foo",
"` ",
}
for _, v := range testData {
s, err := NewScanner("foo.api", v)
assert.NoError(t, err)
_, err = s.NextToken()
assertx.Error(t, err)
}
})
}
func TestScanner_NextToken_anyCase(t *testing.T) {
t.Run("case1", func(t *testing.T) {
var testData = []string{
"#",
"$",
"^",
"好",
"|",
}
for _, v := range testData {
s, err := NewScanner("foo.api", v)
assert.NoError(t, err)
tok, err := s.NextToken()
assert.NoError(t, err)
fmt.Println(tok.String())
assert.Equal(t, token.ILLEGAL, tok.Type)
}
})
t.Run("case2", func(t *testing.T) {
s, err := NewScanner("foo.api", `好の`)
assert.NoError(t, err)
for {
tok, err := s.NextToken()
if tok.Type == token.EOF {
break
}
assert.NoError(t, err)
fmt.Println(tok)
}
})
t.Run("case3", func(t *testing.T) {
s, err := NewScanner("foo.api", `foo`)
assert.NoError(t, err)
for {
tok, err := s.NextToken()
if tok.Type == token.EOF {
break
}
assert.NoError(t, err)
fmt.Println(tok)
}
})
}
//go:embed test.api
var testInput string
func TestScanner_NextToken(t *testing.T) {
position := func(line, column int) token.Position {
return token.Position{
Filename: "test.api",
Line: line,
Column: column,
}
}
var testData = []token.Token{
{
Type: token.IDENT,
Text: "syntax",
Position: position(1, 1),
},
{
Type: token.ASSIGN,
Text: "=",
Position: position(1, 8),
},
{
Type: token.STRING,
Text: `"v1"`,
Position: position(1, 10),
},
{
Type: token.IDENT,
Text: `info`,
Position: position(3, 1),
},
{
Type: token.LPAREN,
Text: `(`,
Position: position(3, 5),
},
{
Type: token.IDENT,
Text: `title`,
Position: position(4, 5),
},
{
Type: token.COLON,
Text: `:`,
Position: position(4, 10),
},
{
Type: token.STRING,
Text: `"type title here"`,
Position: position(4, 12),
},
{
Type: token.IDENT,
Text: `desc`,
Position: position(5, 5),
},
{
Type: token.COLON,
Text: `:`,
Position: position(5, 9),
},
{
Type: token.STRING,
Text: `"type desc here"`,
Position: position(5, 11),
},
{
Type: token.IDENT,
Text: `author`,
Position: position(6, 5),
},
{
Type: token.COLON,
Text: `:`,
Position: position(6, 11),
},
{
Type: token.STRING,
Text: `"type author here"`,
Position: position(6, 13),
},
{
Type: token.IDENT,
Text: `email`,
Position: position(7, 5),
},
{
Type: token.COLON,
Text: `:`,
Position: position(7, 10),
},
{
Type: token.STRING,
Text: `"type email here"`,
Position: position(7, 12),
},
{
Type: token.IDENT,
Text: `version`,
Position: position(8, 5),
},
{
Type: token.COLON,
Text: `:`,
Position: position(8, 12),
},
{
Type: token.STRING,
Text: `"type version here"`,
Position: position(8, 14),
},
{
Type: token.RPAREN,
Text: `)`,
Position: position(9, 1),
},
{
Type: token.IDENT,
Text: `type`,
Position: position(12, 1),
},
{
Type: token.IDENT,
Text: `request`,
Position: position(12, 6),
},
{
Type: token.LBRACE,
Text: `{`,
Position: position(12, 14),
},
{
Type: token.COMMENT,
Text: `// TODO: add members here and delete this comment`,
Position: position(13, 5),
},
{
Type: token.RBRACE,
Text: `}`,
Position: position(14, 1),
},
{
Type: token.IDENT,
Text: `type`,
Position: position(16, 1),
},
{
Type: token.IDENT,
Text: `response`,
Position: position(16, 6),
},
{
Type: token.LBRACE,
Text: `{`,
Position: position(16, 15),
},
{
Type: token.COMMENT,
Text: `// TODO: add members here and delete this comment`,
Position: position(17, 5),
},
{
Type: token.RBRACE,
Text: `}`,
Position: position(18, 1),
},
{
Type: token.AT_SERVER,
Text: `@server`,
Position: position(20, 1),
},
{
Type: token.LPAREN,
Text: `(`,
Position: position(20, 8),
},
{
Type: token.IDENT,
Text: `jwt`,
Position: position(21, 5),
},
{
Type: token.COLON,
Text: `:`,
Position: position(21, 8),
},
{
Type: token.IDENT,
Text: `Auth`,
Position: position(21, 10),
},
{
Type: token.IDENT,
Text: `group`,
Position: position(22, 5),
},
{
Type: token.COLON,
Text: `:`,
Position: position(22, 10),
},
{
Type: token.IDENT,
Text: `template`,
Position: position(22, 12),
},
{
Type: token.RPAREN,
Text: `)`,
Position: position(23, 1),
},
{
Type: token.IDENT,
Text: `service`,
Position: position(24, 1),
},
{
Type: token.IDENT,
Text: `template`,
Position: position(24, 9),
},
{
Type: token.LBRACE,
Text: `{`,
Position: position(24, 18),
},
{
Type: token.AT_DOC,
Text: `@doc`,
Position: position(25, 5),
},
{
Type: token.STRING,
Text: `"foo"`,
Position: position(25, 10),
},
{
Type: token.DOCUMENT,
Text: `/*foo*/`,
Position: position(25, 16),
},
{
Type: token.AT_HANDLER,
Text: `@handler`,
Position: position(26, 5),
},
{
Type: token.IDENT,
Text: `handlerName`,
Position: position(26, 14),
},
{
Type: token.COMMENT,
Text: `// TODO: replace handler name and delete this comment`,
Position: position(26, 26),
},
{
Type: token.IDENT,
Text: `get`,
Position: position(27, 5),
},
{
Type: token.QUO,
Text: `/`,
Position: position(27, 9),
},
{
Type: token.IDENT,
Text: `users`,
Position: position(27, 10),
},
{
Type: token.QUO,
Text: `/`,
Position: position(27, 15),
},
{
Type: token.IDENT,
Text: `id`,
Position: position(27, 16),
},
{
Type: token.QUO,
Text: `/`,
Position: position(27, 18),
},
{
Type: token.COLON,
Text: `:`,
Position: position(27, 19),
},
{
Type: token.IDENT,
Text: `userId`,
Position: position(27, 20),
},
{
Type: token.LPAREN,
Text: `(`,
Position: position(27, 27),
},
{
Type: token.IDENT,
Text: `request`,
Position: position(27, 28),
},
{
Type: token.RPAREN,
Text: `)`,
Position: position(27, 35),
},
{
Type: token.IDENT,
Text: `returns`,
Position: position(27, 37),
},
{
Type: token.LPAREN,
Text: `(`,
Position: position(27, 45),
},
{
Type: token.IDENT,
Text: `response`,
Position: position(27, 46),
},
{
Type: token.RPAREN,
Text: `)`,
Position: position(27, 54),
},
}
scanner, err := NewScanner("test.api", testInput)
assert.NoError(t, err)
for _, v := range testData {
actual, err := scanner.NextToken()
assert.NoError(t, err)
assert.Equal(t, v, actual)
}
}
func TestScanner_NextToken_type(t *testing.T) {
var testData = []token.Token{
{
Type: token.IDENT,
Text: "foo",
Position: token.Position{
Filename: "foo.api",
Line: 1,
Column: 1,
},
},
{
Type: token.IDENT,
Text: "string",
Position: token.Position{
Filename: "foo.api",
Line: 1,
Column: 5,
},
},
{
Type: token.RAW_STRING,
Text: "`json:\"foo\"`",
Position: token.Position{
Filename: "foo.api",
Line: 1,
Column: 12,
},
},
{
Type: token.IDENT,
Text: "bar",
Position: token.Position{
Filename: "foo.api",
Line: 2,
Column: 1,
},
},
{
Type: token.LBRACK,
Text: "[",
Position: token.Position{
Filename: "foo.api",
Line: 2,
Column: 5,
},
},
{
Type: token.RBRACK,
Text: "]",
Position: token.Position{
Filename: "foo.api",
Line: 2,
Column: 6,
},
},
{
Type: token.IDENT,
Text: "int",
Position: token.Position{
Filename: "foo.api",
Line: 2,
Column: 7,
},
},
{
Type: token.IDENT,
Text: "baz",
Position: token.Position{
Filename: "foo.api",
Line: 3,
Column: 1,
},
},
{
Type: token.IDENT,
Text: "map",
Position: token.Position{
Filename: "foo.api",
Line: 3,
Column: 5,
},
},
{
Type: token.LBRACK,
Text: "[",
Position: token.Position{
Filename: "foo.api",
Line: 3,
Column: 8,
},
},
{
Type: token.IDENT,
Text: "string",
Position: token.Position{
Filename: "foo.api",
Line: 3,
Column: 9,
},
},
{
Type: token.RBRACK,
Text: "]",
Position: token.Position{
Filename: "foo.api",
Line: 3,
Column: 15,
},
},
{
Type: token.IDENT,
Text: "int",
Position: token.Position{
Filename: "foo.api",
Line: 3,
Column: 16,
},
},
}
var input = "foo string `json:\"foo\"`\nbar []int\nbaz map[string]int"
scanner, err := NewScanner("foo.api", input)
assert.NoError(t, err)
for _, v := range testData {
actual, err := scanner.NextToken()
assert.NoError(t, err)
assert.Equal(t, v, actual)
}
}
| go | MIT | 8e7e5695eb2095917864b5d6615dab4c90bde3ac | 2026-01-07T08:36:18.042207Z | false |
zeromicro/go-zero | https://github.com/zeromicro/go-zero/blob/8e7e5695eb2095917864b5d6615dab4c90bde3ac/tools/goctl/pkg/parser/api/scanner/scanner.go | tools/goctl/pkg/parser/api/scanner/scanner.go | package scanner
import (
"bytes"
"errors"
"fmt"
"log"
"os"
"path/filepath"
"strings"
"github.com/zeromicro/go-zero/tools/goctl/pkg/parser/api/token"
"github.com/zeromicro/go-zero/tools/goctl/util/pathx"
)
const (
initMode mode = iota
// document mode bg
documentHalfOpen
documentOpen
documentHalfClose
documentClose
// document mode end
// string mode bg
stringOpen
stringClose
// string mode end
)
type mode int
// Scanner is a lexical scanner.
type Scanner struct {
filename string
size int
data []rune
position int // current position in input (points to current char)
readPosition int // current reading position in input (after current char)
ch rune
lines []int
}
// NextToken returns the next token.
func (s *Scanner) NextToken() (token.Token, error) {
s.skipWhiteSpace()
switch s.ch {
case '/':
peekOne := s.peekRune()
switch peekOne {
case '/':
return s.scanLineComment(), nil
case '*':
return s.scanDocument()
default:
return s.newToken(token.QUO), nil
}
case '-':
return s.newToken(token.SUB), nil
case '*':
return s.newToken(token.MUL), nil
case '(':
return s.newToken(token.LPAREN), nil
case '[':
return s.newToken(token.LBRACK), nil
case '{':
return s.newToken(token.LBRACE), nil
case ',':
return s.newToken(token.COMMA), nil
case '.':
position := s.position
peekOne := s.peekRune()
if peekOne != '.' {
return s.newToken(token.DOT), nil
}
s.readRune()
peekOne = s.peekRune()
if peekOne != '.' {
return s.newToken(token.DOT), nil
}
s.readRune()
s.readRune()
return token.Token{
Type: token.ELLIPSIS,
Text: "...",
Position: s.newPosition(position),
}, nil
case ')':
return s.newToken(token.RPAREN), nil
case ']':
return s.newToken(token.RBRACK), nil
case '}':
return s.newToken(token.RBRACE), nil
case ';':
return s.newToken(token.SEMICOLON), nil
case ':':
return s.newToken(token.COLON), nil
case '=':
return s.newToken(token.ASSIGN), nil
case '@':
return s.scanAt()
case '"':
return s.scanString('"', token.STRING)
case '`':
return s.scanString('`', token.RAW_STRING)
case 0:
return token.EofToken, nil
default:
if s.isIdentifierLetter(s.ch) {
return s.scanIdent(), nil
}
if s.isDigit(s.ch) {
return s.scanIntOrDuration(), nil
}
tok := token.NewIllegalToken(s.ch, s.newPosition(s.position))
s.readRune()
return tok, nil
}
}
func (s *Scanner) newToken(tp token.Type) token.Token {
tok := token.Token{
Type: tp,
Text: string(s.ch),
Position: s.positionAt(),
}
s.readRune()
return tok
}
func (s *Scanner) readRune() {
if s.readPosition >= s.size {
s.ch = 0
} else {
s.ch = s.data[s.readPosition]
}
s.position = s.readPosition
s.readPosition += 1
}
func (s *Scanner) peekRune() rune {
if s.readPosition >= s.size {
return 0
}
return s.data[s.readPosition]
}
func (s *Scanner) scanString(delim rune, tp token.Type) (token.Token, error) {
position := s.position
var stringMode = initMode
for {
switch s.ch {
case delim:
switch stringMode {
case initMode:
stringMode = stringOpen
case stringOpen:
stringMode = stringClose
s.readRune()
return token.Token{
Type: tp,
Text: string(s.data[position:s.position]),
Position: s.newPosition(position),
}, nil
}
case 0:
switch stringMode {
case initMode: // assert: dead code
return token.ErrorToken, s.assertExpected(token.EOF, tp)
case stringOpen:
return token.ErrorToken, s.assertExpectedString(token.EOF.String(), string(delim))
case stringClose: // assert: dead code
return token.Token{
Type: tp,
Text: string(s.data[position:s.position]),
Position: s.newPosition(position),
}, nil
}
}
s.readRune()
}
}
func (s *Scanner) scanAt() (token.Token, error) {
position := s.position
peek := s.peekRune()
if !s.isLetter(peek) {
if peek == 0 {
return token.NewIllegalToken(s.ch, s.positionAt()), nil
}
return token.ErrorToken, s.assertExpectedString(string(peek), token.IDENT.String())
}
s.readRune()
letters := s.scanLetterSet()
switch letters {
case "handler":
return token.Token{
Type: token.AT_HANDLER,
Text: "@handler",
Position: s.newPosition(position),
}, nil
case "server":
return token.Token{
Type: token.AT_SERVER,
Text: "@server",
Position: s.newPosition(position),
}, nil
case "doc":
return token.Token{
Type: token.AT_DOC,
Text: "@doc",
Position: s.newPosition(position),
}, nil
default:
return token.ErrorToken, s.assertExpectedString(
"@"+letters,
token.AT_DOC.String(),
token.AT_HANDLER.String(),
token.AT_SERVER.String())
}
}
func (s *Scanner) scanIntOrDuration() token.Token {
position := s.position
for s.isDigit(s.ch) {
s.readRune()
}
switch s.ch {
case 'n', 'µ', 'm', 's', 'h':
return s.scanDuration(position)
default:
return token.Token{
Type: token.INT,
Text: string(s.data[position:s.position]),
Position: s.newPosition(position),
}
}
}
// scanDuration scans a duration literal, for example "1ns", "1µs", "1ms", "1s", "1m", "1h".
func (s *Scanner) scanDuration(bgPos int) token.Token {
switch s.ch {
case 'n':
return s.scanNanosecond(bgPos)
case 'µ':
return s.scanMicrosecond(bgPos)
case 'm':
return s.scanMillisecondOrMinute(bgPos)
case 's':
return s.scanSecond(bgPos)
case 'h':
return s.scanHour(bgPos)
default:
return s.illegalToken()
}
}
func (s *Scanner) scanNanosecond(bgPos int) token.Token {
s.readRune()
if s.ch != 's' {
return s.illegalToken()
}
s.readRune()
return token.Token{
Type: token.DURATION,
Text: string(s.data[bgPos:s.position]),
Position: s.newPosition(bgPos),
}
}
func (s *Scanner) scanMicrosecond(bgPos int) token.Token {
s.readRune()
if s.ch != 's' {
return s.illegalToken()
}
s.readRune()
if !s.isDigit(s.ch) {
return token.Token{
Type: token.DURATION,
Text: string(s.data[bgPos:s.position]),
Position: s.newPosition(bgPos),
}
}
for s.isDigit(s.ch) {
s.readRune()
}
if s.ch != 'n' {
return s.illegalToken()
}
return s.scanNanosecond(bgPos)
}
func (s *Scanner) scanMillisecondOrMinute(bgPos int) token.Token {
s.readRune()
if s.ch != 's' { // minute
if s.ch == 0 || !s.isDigit(s.ch) {
return token.Token{
Type: token.DURATION,
Text: string(s.data[bgPos:s.position]),
Position: s.newPosition(bgPos),
}
}
return s.scanMinute(bgPos)
}
return s.scanMillisecond(bgPos)
}
func (s *Scanner) scanMillisecond(bgPos int) token.Token {
s.readRune()
if !s.isDigit(s.ch) {
return token.Token{
Type: token.DURATION,
Text: string(s.data[bgPos:s.position]),
Position: s.newPosition(bgPos),
}
}
for s.isDigit(s.ch) {
s.readRune()
}
switch s.ch {
case 'n':
return s.scanNanosecond(bgPos)
case 'µ':
return s.scanMicrosecond(bgPos)
default:
return s.illegalToken()
}
}
func (s *Scanner) scanSecond(bgPos int) token.Token {
s.readRune()
if !s.isDigit(s.ch) {
return token.Token{
Type: token.DURATION,
Text: string(s.data[bgPos:s.position]),
Position: s.newPosition(bgPos),
}
}
for s.isDigit(s.ch) {
s.readRune()
}
switch s.ch {
case 'n':
return s.scanNanosecond(bgPos)
case 'µ':
return s.scanMicrosecond(bgPos)
case 'm':
s.readRune()
if s.ch != 's' {
return s.illegalToken()
}
return s.scanMillisecond(bgPos)
default:
return s.illegalToken()
}
}
func (s *Scanner) scanMinute(bgPos int) token.Token {
if !s.isDigit(s.ch) {
return token.Token{
Type: token.DURATION,
Text: string(s.data[bgPos:s.position]),
Position: s.newPosition(bgPos),
}
}
for s.isDigit(s.ch) {
s.readRune()
}
switch s.ch {
case 'n':
return s.scanNanosecond(bgPos)
case 'µ':
return s.scanMicrosecond(bgPos)
case 'm':
s.readRune()
if s.ch != 's' {
return s.illegalToken()
}
return s.scanMillisecond(bgPos)
case 's':
return s.scanSecond(bgPos)
default:
return s.illegalToken()
}
}
func (s *Scanner) scanHour(bgPos int) token.Token {
s.readRune()
if !s.isDigit(s.ch) {
return token.Token{
Type: token.DURATION,
Text: string(s.data[bgPos:s.position]),
Position: s.newPosition(bgPos),
}
}
for s.isDigit(s.ch) {
s.readRune()
}
switch s.ch {
case 'n':
return s.scanNanosecond(bgPos)
case 'µ':
return s.scanMicrosecond(bgPos)
case 'm':
return s.scanMillisecondOrMinute(bgPos)
case 's':
return s.scanSecond(bgPos)
default:
return s.illegalToken()
}
}
func (s *Scanner) illegalToken() token.Token {
tok := token.NewIllegalToken(s.ch, s.newPosition(s.position))
s.readRune()
return tok
}
func (s *Scanner) scanIdent() token.Token {
position := s.position
for s.isIdentifierLetter(s.ch) || s.isDigit(s.ch) {
s.readRune()
}
ident := string(s.data[position:s.position])
if ident == "interface" && s.ch == '{' && s.peekRune() == '}' {
s.readRune()
s.readRune()
return token.Token{
Type: token.ANY,
Text: string(s.data[position:s.position]),
Position: s.newPosition(position),
}
}
return token.Token{
Type: token.IDENT,
Text: ident,
Position: s.newPosition(position),
}
}
func (s *Scanner) scanLetterSet() string {
position := s.position
for s.isLetter(s.ch) {
s.readRune()
}
return string(s.data[position:s.position])
}
func (s *Scanner) scanLineComment() token.Token {
position := s.position
for s.ch != '\n' && s.ch != 0 {
s.readRune()
}
return token.Token{
Type: token.COMMENT,
Text: string(s.data[position:s.position]),
Position: s.newPosition(position),
}
}
func (s *Scanner) scanDocument() (token.Token, error) {
position := s.position
var documentMode = initMode
for {
switch s.ch {
case '*':
switch documentMode {
case documentHalfOpen:
documentMode = documentOpen // /*
case documentOpen, documentHalfClose:
documentMode = documentHalfClose // (?m)\/\*\*+
}
case 0:
switch documentMode {
case initMode, documentHalfOpen: // assert: dead code
return token.ErrorToken, s.assertExpected(token.EOF, token.MUL)
case documentOpen:
return token.ErrorToken, s.assertExpected(token.EOF, token.MUL)
case documentHalfClose:
return token.ErrorToken, s.assertExpected(token.EOF, token.QUO)
}
case '/':
switch documentMode {
case initMode: // /
documentMode = documentHalfOpen
case documentHalfOpen: // assert: dead code
return token.ErrorToken, s.assertExpected(token.QUO, token.MUL)
case documentHalfClose:
documentMode = documentClose // /*\*+*/
s.readRune()
tok := token.Token{
Type: token.DOCUMENT,
Text: string(s.data[position:s.position]),
Position: s.newPosition(position),
}
return tok, nil
}
}
s.readRune()
}
}
func (s *Scanner) assertExpected(actual token.Type, expected ...token.Type) error {
var expects []string
for _, v := range expected {
expects = append(expects, fmt.Sprintf("'%s'", v.String()))
}
text := fmt.Sprint(s.positionAt().String(), " ", fmt.Sprintf(
"expected %s, got '%s'",
strings.Join(expects, " | "),
actual.String(),
))
return errors.New(text)
}
func (s *Scanner) assertExpectedString(actual string, expected ...string) error {
var expects []string
for _, v := range expected {
expects = append(expects, fmt.Sprintf("'%s'", v))
}
text := fmt.Sprint(s.positionAt().String(), " ", fmt.Sprintf(
"expected %s, got '%s'",
strings.Join(expects, " | "),
actual,
))
return errors.New(text)
}
func (s *Scanner) positionAt() token.Position {
return s.newPosition(s.position)
}
func (s *Scanner) newPosition(position int) token.Position {
line := s.lineCount()
return token.Position{
Filename: s.filename,
Line: line,
Column: position - s.lines[line-1],
}
}
func (s *Scanner) lineCount() int {
return len(s.lines)
}
func (s *Scanner) skipWhiteSpace() {
for s.isWhiteSpace(s.ch) {
s.readRune()
}
}
func (s *Scanner) isDigit(b rune) bool {
return b >= '0' && b <= '9'
}
func (s *Scanner) isLetter(b rune) bool {
return (b >= 'a' && b <= 'z') || (b >= 'A' && b <= 'Z')
}
func (s *Scanner) isIdentifierLetter(b rune) bool {
if s.isLetter(b) {
return true
}
return b == '_'
}
func (s *Scanner) isWhiteSpace(b rune) bool {
if b == '\n' {
s.lines = append(s.lines, s.position)
}
return b == ' ' || b == '\t' || b == '\r' || b == '\f' || b == '\v' || b == '\n'
}
// MustNewScanner returns a new scanner for the given filename and data.
func MustNewScanner(filename string, src interface{}) *Scanner {
sc, err := NewScanner(filename, src)
if err != nil {
log.Fatalln(err)
}
return sc
}
// NewScanner returns a new scanner for the given filename and data.
func NewScanner(filename string, src interface{}) (*Scanner, error) {
data, err := readData(filename, src)
if err != nil {
return nil, err
}
if len(data) == 0 {
return nil, fmt.Errorf("filename: %s, missing input", filename)
}
var runeList []rune
for _, r := range string(data) {
runeList = append(runeList, r)
}
filename = filepath.Base(filename)
s := &Scanner{
filename: filename,
size: len(runeList),
data: runeList,
lines: []int{-1},
readPosition: 0,
}
s.readRune()
return s, nil
}
func readData(filename string, src interface{}) ([]byte, error) {
if strings.HasSuffix(filename, ".api") && pathx.FileExists(filename) {
data, err := os.ReadFile(filename)
if err != nil {
return nil, err
}
return data, nil
}
switch v := src.(type) {
case []byte:
return v, nil
case *bytes.Buffer:
return v.Bytes(), nil
case string:
return []byte(v), nil
default:
return nil, fmt.Errorf("unsupported type: %T", src)
}
}
| go | MIT | 8e7e5695eb2095917864b5d6615dab4c90bde3ac | 2026-01-07T08:36:18.042207Z | false |
zeromicro/go-zero | https://github.com/zeromicro/go-zero/blob/8e7e5695eb2095917864b5d6615dab4c90bde3ac/tools/goctl/pkg/parser/api/placeholder/placeholder.go | tools/goctl/pkg/parser/api/placeholder/placeholder.go | package placeholder
// Type is the placeholder type.
type Type struct{}
// PlaceHolder is the placeholder.
var PlaceHolder Type
| go | MIT | 8e7e5695eb2095917864b5d6615dab4c90bde3ac | 2026-01-07T08:36:18.042207Z | false |
zeromicro/go-zero | https://github.com/zeromicro/go-zero/blob/8e7e5695eb2095917864b5d6615dab4c90bde3ac/tools/goctl/pkg/parser/api/token/token.go | tools/goctl/pkg/parser/api/token/token.go | package token
import (
"fmt"
"github.com/zeromicro/go-zero/tools/goctl/pkg/parser/api/placeholder"
"github.com/zeromicro/go-zero/tools/goctl/util"
)
const (
Syntax = "syntax"
Info = "info"
Service = "service"
Returns = "returns"
Any = "any"
TypeKeyword = "type"
MapKeyword = "map"
ImportKeyword = "import"
)
// Type is the type of token.
type Type int
// EofToken is the end of file token.
var EofToken = Token{Type: EOF}
// ErrorToken is the error token.
var ErrorToken = Token{Type: error}
// Token is the token of a rune.
type Token struct {
Type Type
Text string
Position Position
}
// Fork forks token for a given Type.
func (t Token) Fork(tp Type) Token {
return Token{
Type: tp,
Text: t.Text,
Position: t.Position,
}
}
// IsEmptyString returns true if the token is empty string.
func (t Token) IsEmptyString() bool {
if t.Type != STRING && t.Type != RAW_STRING {
return false
}
text := util.TrimWhiteSpace(t.Text)
return text == `""` || text == "``"
}
// IsComment returns true if the token is comment.
func (t Token) IsComment() bool {
return t.IsType(COMMENT)
}
// IsDocument returns true if the token is document.
func (t Token) IsDocument() bool {
return t.IsType(DOCUMENT)
}
// IsType returns true if the token is the given type.
func (t Token) IsType(tp Type) bool {
return t.Type == tp
}
// Line returns the line number of the token.
func (t Token) Line() int {
return t.Position.Line
}
// String returns the string of the token.
func (t Token) String() string {
if t == ErrorToken {
return t.Type.String()
}
return fmt.Sprintf("%s %s %s", t.Position.String(), t.Type.String(), t.Text)
}
// Valid returns true if the token is valid.
func (t Token) Valid() bool {
return t.Type != token_bg
}
// IsKeyword returns true if the token is keyword.
func (t Token) IsKeyword() bool {
return golang_keyword_beg < t.Type && t.Type < golang_keyword_end
}
// IsBaseType returns true if the token is base type.
func (t Token) IsBaseType() bool {
_, ok := baseDataType[t.Text]
return ok
}
// IsHttpMethod returns true if the token is http method.
func (t Token) IsHttpMethod() bool {
_, ok := httpMethod[t.Text]
return ok
}
// Is returns true if the token text is one of the given list.
func (t Token) Is(text ...string) bool {
for _, v := range text {
if t.Text == v {
return true
}
}
return false
}
const (
token_bg Type = iota
error
ILLEGAL
EOF
COMMENT
DOCUMENT
literal_beg
IDENT // main
INT // 123
DURATION // 3s,3ms
STRING // "abc"
RAW_STRING // `abc`
PATH // `abc`
literal_end
operator_beg
SUB // -
MUL // *
QUO // /
ASSIGN // =
LPAREN // (
LBRACK // [
LBRACE // {
COMMA // ,
DOT // .
RPAREN // )
RBRACE // }
RBRACK // ]
SEMICOLON // ;
COLON // :
ELLIPSIS
operator_end
golang_keyword_beg
BREAK
CASE
CHAN
CONST
CONTINUE
DEFAULT
DEFER
ELSE
FALLTHROUGH
FOR
FUNC
GO
GOTO
IF
IMPORT
INTERFACE
MAP
PACKAGE
RANGE
RETURN
SELECT
STRUCT
SWITCH
TYPE
VAR
golang_keyword_end
api_keyword_bg
AT_DOC
AT_HANDLER
AT_SERVER
ANY
api_keyword_end
token_end
)
// String returns the string of the token type.
func (t Type) String() string {
if t >= token_bg && t < token_end {
return tokens[t]
}
return ""
}
var tokens = [...]string{
ILLEGAL: "ILLEGAL",
EOF: "EOF",
COMMENT: "COMMENT",
DOCUMENT: "DOCUMENT",
IDENT: "IDENT",
INT: "INT",
DURATION: "DURATION",
STRING: "STRING",
RAW_STRING: "RAW_STRING",
PATH: "PATH",
SUB: "-",
MUL: "*",
QUO: "/",
ASSIGN: "=",
LPAREN: "(",
LBRACK: "[",
LBRACE: "{",
COMMA: ",",
DOT: ".",
RPAREN: ")",
RBRACK: "]",
RBRACE: "}",
SEMICOLON: ";",
COLON: ":",
ELLIPSIS: "...",
BREAK: "break",
CASE: "case",
CHAN: "chan",
CONST: "const",
CONTINUE: "continue",
DEFAULT: "default",
DEFER: "defer",
ELSE: "else",
FALLTHROUGH: "fallthrough",
FOR: "for",
FUNC: "func",
GO: "go",
GOTO: "goto",
IF: "if",
IMPORT: "import",
INTERFACE: "interface",
MAP: "map",
PACKAGE: "package",
RANGE: "range",
RETURN: "return",
SELECT: "select",
STRUCT: "struct",
SWITCH: "switch",
TYPE: "type",
VAR: "var",
AT_DOC: "@doc",
AT_HANDLER: "@handler",
AT_SERVER: "@server",
ANY: "interface{}",
}
// HttpMethods returns the http methods.
var HttpMethods = []interface{}{"get", "head", "post", "put", "patch", "delete", "connect", "options", "trace"}
var httpMethod = map[string]placeholder.Type{
"get": placeholder.PlaceHolder,
"head": placeholder.PlaceHolder,
"post": placeholder.PlaceHolder,
"put": placeholder.PlaceHolder,
"patch": placeholder.PlaceHolder,
"delete": placeholder.PlaceHolder,
"connect": placeholder.PlaceHolder,
"options": placeholder.PlaceHolder,
"trace": placeholder.PlaceHolder,
}
var keywords = map[string]Type{
// golang_keyword_bg
"break": BREAK,
"case": CASE,
"chan": CHAN,
"const": CONST,
"continue": CONTINUE,
"default": DEFAULT,
"defer": DEFER,
"else": ELSE,
"fallthrough": FALLTHROUGH,
"for": FOR,
"func": FUNC,
"go": GO,
"goto": GOTO,
"if": IF,
"import": IMPORT,
"interface": INTERFACE,
"map": MAP,
"package": PACKAGE,
"range": RANGE,
"return": RETURN,
"select": SELECT,
"struct": STRUCT,
"switch": SWITCH,
"type": TYPE,
"var": VAR,
// golang_keyword_end
}
var baseDataType = map[string]placeholder.Type{
"bool": placeholder.PlaceHolder,
"uint8": placeholder.PlaceHolder,
"uint16": placeholder.PlaceHolder,
"uint32": placeholder.PlaceHolder,
"uint64": placeholder.PlaceHolder,
"int8": placeholder.PlaceHolder,
"int16": placeholder.PlaceHolder,
"int32": placeholder.PlaceHolder,
"int64": placeholder.PlaceHolder,
"float32": placeholder.PlaceHolder,
"float64": placeholder.PlaceHolder,
"complex64": placeholder.PlaceHolder,
"complex128": placeholder.PlaceHolder,
"string": placeholder.PlaceHolder,
"int": placeholder.PlaceHolder,
"uint": placeholder.PlaceHolder,
"uintptr": placeholder.PlaceHolder,
"byte": placeholder.PlaceHolder,
"rune": placeholder.PlaceHolder,
"any": placeholder.PlaceHolder,
}
// LookupKeyword returns the keyword type if the given ident is keyword.
func LookupKeyword(ident string) (Type, bool) {
tp, ok := keywords[ident]
return tp, ok
}
// NewIllegalToken returns a new illegal token.
func NewIllegalToken(b rune, pos Position) Token {
return Token{
Type: ILLEGAL,
Text: string(b),
Position: pos,
}
}
| go | MIT | 8e7e5695eb2095917864b5d6615dab4c90bde3ac | 2026-01-07T08:36:18.042207Z | false |
zeromicro/go-zero | https://github.com/zeromicro/go-zero/blob/8e7e5695eb2095917864b5d6615dab4c90bde3ac/tools/goctl/pkg/parser/api/token/position.go | tools/goctl/pkg/parser/api/token/position.go | package token
import "fmt"
// IllegalPosition is a position that is not valid.
var IllegalPosition = Position{}
// Position represents a rune position in the source code.
type Position struct {
Filename string
Line int
Column int
}
// String returns a string representation of the position.
func (p Position) String() string {
if len(p.Filename) == 0 {
return fmt.Sprint(p.Line, ":", p.Column)
}
return fmt.Sprint(p.Filename, " ", p.Line, ":", p.Column)
}
| go | MIT | 8e7e5695eb2095917864b5d6615dab4c90bde3ac | 2026-01-07T08:36:18.042207Z | false |
zeromicro/go-zero | https://github.com/zeromicro/go-zero/blob/8e7e5695eb2095917864b5d6615dab4c90bde3ac/tools/goctl/pkg/parser/api/format/format.go | tools/goctl/pkg/parser/api/format/format.go | package format
import (
"bytes"
"io"
"os"
"github.com/zeromicro/go-zero/tools/goctl/pkg/parser/api/parser"
)
// File formats the api file.
func File(filename string) error {
data, err := os.ReadFile(filename)
if err != nil {
return err
}
buffer := bytes.NewBuffer(nil)
if err := Source(data, buffer); err != nil {
return err
}
return os.WriteFile(filename, buffer.Bytes(), 0666)
}
// Source formats the api source.
func Source(source []byte, w io.Writer) error {
p := parser.New("", source)
result := p.Parse()
if err := p.CheckErrors(); err != nil {
return err
}
result.Format(w)
return nil
}
func formatForUnitTest(source []byte, w io.Writer) error {
p := parser.New("", source)
result := p.Parse()
if err := p.CheckErrors(); err != nil {
return err
}
result.FormatForUnitTest(w)
return nil
}
| go | MIT | 8e7e5695eb2095917864b5d6615dab4c90bde3ac | 2026-01-07T08:36:18.042207Z | false |
zeromicro/go-zero | https://github.com/zeromicro/go-zero/blob/8e7e5695eb2095917864b5d6615dab4c90bde3ac/tools/goctl/pkg/parser/api/format/format_test.go | tools/goctl/pkg/parser/api/format/format_test.go | package format
import (
"bytes"
_ "embed"
"os"
"strings"
"testing"
"github.com/stretchr/testify/assert"
"github.com/zeromicro/go-zero/tools/goctl/pkg/parser/api/assertx"
"github.com/zeromicro/go-zero/tools/goctl/pkg/parser/api/parser"
)
type formatData struct {
input string
expected string
converter formatResultConvert
}
type formatResultConvert func(s string) string
// EXPERIMENTAL: just for view format code.
func TestFormat(t *testing.T) {
assert.NoError(t, File("testdata/test_format.api"))
}
//go:embed testdata/test_type_struct_lit.api
var testStructLitData string
//go:embed testdata/expected_type_struct_lit.api
var expectedStructLitData string
func TestFormat_ImportLiteralStmt(t *testing.T) {
testRun(t, []formatData{
{
input: `import ""`,
expected: ``,
},
{
input: `import"aa"`,
expected: `import "aa"`,
},
{
input: `/*aa*/import "aa"`,
expected: `/*aa*/
import "aa"`,
},
{
input: `/*aa*/import /*bb*/"aa"`,
expected: `/*aa*/
import "aa"`,
},
{
input: `/*aa*/import /*bb*/"aa"// cc`,
expected: `/*aa*/
import "aa" // cc`,
},
})
}
func TestFormat_ImportGroupStmt(t *testing.T) {
testRun(t, []formatData{
{
input: `import()`,
expected: ``,
},
{
input: `import("aa")`,
expected: `import (
"aa"
)`,
},
{
input: `import(
"aa")`,
expected: `import (
"aa"
)`,
},
{
input: `import(
"aa"
)`,
expected: `import (
"aa"
)`,
},
{
input: `import("aa""bb")`,
expected: `import (
"aa"
"bb"
)`,
},
{
input: `/*aa*/import("aa""bb")`,
expected: `/*aa*/
import (
"aa"
"bb"
)`,
},
{
input: `/*aa*/import("aa""bb")// bb`,
expected: `/*aa*/
import (
"aa"
"bb"
) // bb`,
},
{
input: `/*aa*/import(// bb
"aa""bb")// cc`,
expected: `/*aa*/
import ( // bb
"aa"
"bb"
) // cc`,
},
{
input: `import(// aa
"aa" // bb
"bb" // cc
)// dd`,
expected: `import ( // aa
"aa" // bb
"bb" // cc
) // dd`,
},
{
input: `import (// aa
/*bb*/
"aa" // cc
/*dd*/
"bb" // ee
) // ff`,
expected: `import ( // aa
/*bb*/
"aa" // cc
/*dd*/
"bb" // ee
) // ff`,
},
})
}
func TestFormat_InfoStmt(t *testing.T) {
testRun(t, []formatData{
{
input: `info()`,
expected: ``,
},
{
input: `info(foo:"foo")`,
expected: `info (
foo: "foo"
)`,
},
{
input: `info(foo:"foo" bar:"bar")`,
expected: `info (
foo: "foo"
bar: "bar"
)`,
},
{
input: `info(foo:"foo" bar:"bar" quux:"quux")`,
expected: `info (
foo: "foo"
bar: "bar"
quux: "quux"
)`,
},
{
input: `info(foo:"foo"
bar: "bar")`,
expected: `info (
foo: "foo"
bar: "bar"
)`,
},
{
input: `info(foo:"foo"// aa
bar: "bar"// bb
)`,
expected: `info (
foo: "foo" // aa
bar: "bar" // bb
)`,
},
{
input: `info(// aa
foo:"foo"// bb
bar: "bar"// cc
)`,
expected: `info ( // aa
foo: "foo" // bb
bar: "bar" // cc
)`,
},
{
input: `/*aa*/info(// bb
foo:"foo"// cc
bar: "bar"// dd
)`,
expected: `/*aa*/
info ( // bb
foo: "foo" // cc
bar: "bar" // dd
)`,
},
{
input: `/*aa*/
info(// bb
foo:"foo"// cc
bar: "bar"// dd
)// ee`,
expected: `/*aa*/
info ( // bb
foo: "foo" // cc
bar: "bar" // dd
) // ee`,
},
{
input: `/*aa*/
info ( // bb
/*cc*/foo: "foo" // dd
/*ee*/bar: "bar" // ff
) // gg`,
expected: `/*aa*/
info ( // bb
/*cc*/
foo: "foo" // dd
/*ee*/
bar: "bar" // ff
) // gg`,
},
{
input: `/*aa*/
info/*xx*/( // bb
/*cc*/foo:/*xx*/ "foo" // dd
/*ee*/bar:/*xx*/ "bar" // ff
) // gg`,
expected: `/*aa*/
info ( // bb
/*cc*/
foo: "foo" // dd
/*ee*/
bar: "bar" // ff
) // gg`,
},
})
}
func TestFormat_SyntaxStmt(t *testing.T) {
testRun(t, []formatData{
{
input: `syntax="v1"`,
expected: `syntax = "v1"`,
},
{
input: `syntax="v1"// aa`,
expected: `syntax = "v1" // aa`,
},
{
input: `syntax
="v1"// aa`,
expected: `syntax = "v1" // aa`,
},
{
input: `syntax=
"v1"// aa`,
expected: `syntax = "v1" // aa`,
},
{
input: `/*aa*/syntax="v1"// bb`,
expected: `/*aa*/
syntax = "v1" // bb`,
},
{
input: `/*aa*/
syntax="v1"// bb`,
expected: `/*aa*/
syntax = "v1" // bb`,
},
{
input: `syntax/*xx*/=/*xx*/"v1"// bb`,
expected: `syntax = "v1" // bb`,
},
})
}
func TestFormat_TypeLiteralStmt(t *testing.T) {
t.Run("any", func(t *testing.T) {
testRun(t, []formatData{
{
input: `type Any any`,
expected: `type Any any`,
},
{
input: `type
Any
any
`,
expected: `type Any any`,
},
{
input: `type Any=any`,
expected: `type Any = any`,
},
{
input: `
type
Any
=
any
`,
expected: `type Any = any`,
},
{
input: `type // aa
Any // bb
any // cc
`,
expected: `type // aa
Any // bb
any // cc`,
},
{
input: `
type
Any
=
any`,
expected: `type Any = any`,
},
{
input: `
type
Any
=
any
`,
expected: `type Any = any`,
},
{
input: `type Any any// aa`,
expected: `type Any any // aa`,
},
{
input: `type Any=any// aa`,
expected: `type Any = any // aa`,
},
{
input: `type Any any/*aa*/// bb`,
expected: `type Any any /*aa*/ // bb`,
},
{
input: `type Any = any/*aa*/// bb`,
expected: `type Any = any /*aa*/ // bb`,
},
{
input: `type Any/*aa*/ =/*bb*/ any/*cc*/// dd`,
expected: `type Any /*aa*/ = /*bb*/ any /*cc*/ // dd`,
},
{
input: `/*aa*/type Any any/*bb*/// cc`,
expected: `/*aa*/
type Any any /*bb*/ // cc`,
},
{
input: `/*aa*/
type
/*bb*/
Any
/*cc*/
any/*dd*/// ee`,
expected: `/*aa*/
type
/*bb*/
Any
/*cc*/
any /*dd*/ // ee`,
},
})
})
t.Run("array", func(t *testing.T) {
testRun(t, []formatData{
{
input: `type A [2]int`,
expected: `type A [2]int`,
},
{
input: `type
A
[2]int
`,
expected: `type A [2]int`,
},
{
input: `type A=[2]int`,
expected: `type A = [2]int`,
},
{
input: `type
A
=
[2]int
`,
expected: `type A = [2]int`,
},
{
input: `type A [/*xx*/2/*xx*/]/*xx*/int// aa`,
expected: `type A [2]int // aa`,
},
{
input: `/*aa*/type/*bb*/A/*cc*/[/*xx*/2/*xx*/]/*xx*/int// dd`,
expected: `/*aa*/
type /*bb*/ A /*cc*/ [2]int // dd`,
},
{
input: `/*aa*/type
/*bb*/A
/*cc*/[/*xx*/2/*xx*/]/*xx*/int// dd`,
expected: `/*aa*/
type
/*bb*/
A
/*cc*/
[2]int // dd`,
},
{
input: `type A [ 2 ] int`,
expected: `type A [2]int`,
},
{
input: `type A [
2
]
int`,
expected: `type A [2]int`,
},
{
input: `type A [// aa
2 // bb
] // cc
int`,
expected: `type A [2]int`,
},
{
input: `type A [// aa
/*xx*/
2 // bb
/*xx*/
] // cc
/*xx*/
int`,
expected: `type A [2]int`,
},
{
input: `type A [...]int`,
expected: `type A [...]int`,
},
{
input: `type A=[...]int`,
expected: `type A = [...]int`,
},
{
input: `type A/*aa*/[/*xx*/.../*xx*/]/*xx*/int// bb`,
expected: `type A /*aa*/ [...]int // bb`,
},
{
input: `/*aa*/
// bb
type /*cc*/
// dd
A /*ee*/
// ff
[/*xx*/.../*xx*/]/*xx*/int// bb`,
expected: `/*aa*/
// bb
type /*cc*/
// dd
A /*ee*/
// ff
[...]int // bb`,
},
{
input: `type A [2][2]int`,
expected: `type A [2][2]int`,
},
{
input: `type A=[2][2]int`,
expected: `type A = [2][2]int`,
},
{
input: `type A [2][]int`,
expected: `type A [2][]int`,
},
{
input: `type A=[2][]int`,
expected: `type A = [2][]int`,
},
})
})
t.Run("base", func(t *testing.T) {
testRun(t, []formatData{
// base
{
input: `type A int`,
expected: `type A int`,
},
{
input: `type A =int`,
expected: `type A = int`,
},
{
input: `type/*aa*/A/*bb*/ int// cc`,
expected: `type /*aa*/ A /*bb*/ int // cc`,
},
{
input: `type/*aa*/A/*bb*/ =int// cc`,
expected: `type /*aa*/ A /*bb*/ = int // cc`,
},
{
input: `type A int// aa`,
expected: `type A int // aa`,
},
{
input: `type A=int// aa`,
expected: `type A = int // aa`,
},
{
input: `/*aa*/type A int`,
expected: `/*aa*/
type A int`,
},
{
input: `/*aa*/type A = int`,
expected: `/*aa*/
type A = int`,
},
{
input: `/*aa*/type/*bb*/ A/*cc*/ int// dd`,
expected: `/*aa*/
type /*bb*/ A /*cc*/ int // dd`,
},
{
input: `/*aa*/type/*bb*/ A/*cc*/ = /*dd*/int// ee`,
expected: `/*aa*/
type /*bb*/ A /*cc*/ = /*dd*/ int // ee`,
},
{
input: `/*aa*/
type
/*bb*/
A
/*cc*/
int`,
expected: `/*aa*/
type
/*bb*/
A
/*cc*/
int`,
},
})
})
t.Run("interface", func(t *testing.T) {
testRun(t, []formatData{
{
input: `type any interface{}`,
expected: `type any interface{}`,
},
{
input: `type any=interface{}`,
expected: `type any = interface{}`,
},
{
input: `type
any
interface{}
`,
expected: `type any interface{}`,
},
{
input: `/*aa*/type /*bb*/any /*cc*/interface{} // dd`,
expected: `/*aa*/
type /*bb*/ any /*cc*/ interface{} // dd`,
},
{
input: `/*aa*/type
/*bb*/any
/*cc*/interface{} // dd`,
expected: `/*aa*/
type
/*bb*/
any
/*cc*/
interface{} // dd`,
},
{
input: `/*aa*/type
// bb
any
// cc
interface{} // dd`,
expected: `/*aa*/
type
// bb
any
// cc
interface{} // dd`,
},
})
})
t.Run("map", func(t *testing.T) {
testRun(t, []formatData{
{
input: `type M map[int]int`,
expected: `type M map[int]int`,
},
{
input: `type M map [ int ] int`,
expected: `type M map[int]int`,
},
{
input: `type M map [/*xx*/int/*xx*/]/*xx*/int // aa`,
expected: `type M map[int]int // aa`,
},
{
input: `/*aa*/type /*bb*/ M/*cc*/map[int]int // dd`,
expected: `/*aa*/
type /*bb*/ M /*cc*/ map[int]int // dd`,
},
{
input: `/*aa*/type// bb
// cc
M // dd
// ee
map // ff
[int]// gg
// hh
int // dd`,
expected: `/*aa*/
type // bb
// cc
M // dd
// ee
map[int]int // dd`,
},
{
input: `type M map[string][2]int // aa`,
expected: `type M map[string][2]int // aa`,
},
{
input: `type M map[string]any`,
expected: `type M map[string]any`,
},
{
input: `type M /*aa*/map/*xx*/[/*xx*/string/*xx*/]/*xx*/[/*xx*/2/*xx*/]/*xx*/int// bb`,
expected: `type M /*aa*/ map[string][2]int // bb`,
},
{
input: `type M /*aa*/
// bb
map/*xx*/
//
[/*xx*/
//
string/*xx*/
//
]/*xx*/
//
[/*xx*/
//
2/*xx*/
//
]/*xx*/
//
int// bb`,
expected: `type M /*aa*/
// bb
map[string][2]int // bb`,
},
{
input: `type M map[int]map[string]int`,
expected: `type M map[int]map[string]int`,
},
{
input: `type M map/*xx*/[/*xx*/int/*xx*/]/*xx*/map/*xx*/[/*xx*/string/*xx*/]/*xx*/int// aa`,
expected: `type M map[int]map[string]int // aa`,
},
{
input: `type M map/*xx*/[/*xx*/map/*xx*/[/*xx*/string/*xx*/]/*xx*/int/*xx*/]/*xx*/string // aa`,
expected: `type M map[map[string]int]string // aa`,
},
{
input: `type M map[[2]int]int`,
expected: `type M map[[2]int]int`,
},
{
input: `type M map/*xx*/[/*xx*/[/*xx*/2/*xx*/]/*xx*/int/*xx*/]/*xx*/int// aa`,
expected: `type M map[[2]int]int // aa`,
},
})
})
t.Run("pointer", func(t *testing.T) {
testRun(t, []formatData{
{
input: `type P *int`,
expected: `type P *int`,
},
{
input: `type P=*int`,
expected: `type P = *int`,
},
{
input: `type
P
*int
`,
expected: `type P *int`,
},
{
input: `/*aa*/type // bb
/*cc*/
P // dd
/*ee*/
*/*ff*/int // gg
`,
expected: `/*aa*/
type // bb
/*cc*/
P // dd
/*ee*/
*int // gg`,
},
{
input: `type P *bool`,
expected: `type P *bool`,
},
{
input: `type P *[2]int`,
expected: `type P *[2]int`,
},
{
input: `type P=*[2]int`,
expected: `type P = *[2]int`,
},
{
input: `/*aa*/type /*bb*/P /*cc*/*/*xx*/[/*xx*/2/*xx*/]/*xx*/int // dd`,
expected: `/*aa*/
type /*bb*/ P /*cc*/ *[2]int // dd`,
},
{
input: `type P *[...]int`,
expected: `type P *[...]int`,
},
{
input: `type P=*[...]int`,
expected: `type P = *[...]int`,
},
{
input: `/*aa*/type /*bb*/P /*cc*/*/*xx*/[/*xx*/.../*xx*/]/*xx*/int // dd`,
expected: `/*aa*/
type /*bb*/ P /*cc*/ *[...]int // dd`,
},
{
input: `type P *map[string]int`,
expected: `type P *map[string]int`,
},
{
input: `type P=*map[string]int`,
expected: `type P = *map[string]int`,
},
{
input: `type P /*aa*/*/*xx*/map/*xx*/[/*xx*/string/*xx*/]/*xx*/int// bb`,
expected: `type P /*aa*/ *map[string]int // bb`,
},
{
input: `type P *interface{}`,
expected: `type P *interface{}`,
},
{
input: `type P=*interface{}`,
expected: `type P = *interface{}`,
},
{
input: `type P /*aa*/*/*xx*/interface{}// bb`,
expected: `type P /*aa*/ *interface{} // bb`,
},
{
input: `type P *any`,
expected: `type P *any`,
},
{
input: `type P=*any`,
expected: `type P = *any`,
},
{
input: `type P *map[int][2]int`,
expected: `type P *map[int][2]int`,
},
{
input: `type P=*map[int][2]int`,
expected: `type P = *map[int][2]int`,
},
{
input: `type P /*aa*/*/*xx*/map/*xx*/[/*xx*/int/*xx*/]/*xx*/[/*xx*/2/*xx*/]/*xx*/int// bb`,
expected: `type P /*aa*/ *map[int][2]int // bb`,
},
{
input: `type P *map[[2]int]int`,
expected: `type P *map[[2]int]int`,
},
{
input: `type P=*map[[2]int]int`,
expected: `type P = *map[[2]int]int`,
},
{
input: `type P /*aa*/*/*xx*/map/*xx*/[/*xx*/[/*xx*/2/*xx*/]/*xx*/int/*xx*/]/*xx*/int// bb`,
expected: `type P /*aa*/ *map[[2]int]int // bb`,
},
})
})
t.Run("slice", func(t *testing.T) {
testRun(t, []formatData{
{
input: `type S []int`,
expected: `type S []int`,
},
{
input: `type S=[]int`,
expected: `type S = []int`,
},
{
input: `type S [ ] int `,
expected: `type S []int`,
},
{
input: `type S [ /*xx*/ ] /*xx*/ int `,
expected: `type S []int`,
},
{
input: `type S [][]int`,
expected: `type S [][]int`,
},
{
input: `type S=[][]int`,
expected: `type S = [][]int`,
},
{
input: `type S [ ] [ ] int`,
expected: `type S [][]int`,
},
{
input: `type S [/*xx*/]/*xx*/[/*xx*/]/*xx*/int`,
expected: `type S [][]int`,
},
{
input: `type S [//
]//
[//
]//
int`,
expected: `type S [][]int`,
},
{
input: `type S []map[string]int`,
expected: `type S []map[string]int`,
},
{
input: `type S=[]map[string]int`,
expected: `type S = []map[string]int`,
},
{
input: `type S [ ]
map [ string ]
int`,
expected: `type S []map[string]int`,
},
{
input: `type S [/*xx*/]/*xx*/map/*xx*/[/*xx*/string/*xx*/]/*xx*/int`,
expected: `type S []map[string]int`,
},
{
input: `/*aa*/type// bb
// cc
S// dd
// ff
/*gg*/[ // hh
/*xx*/] // ii
/*xx*/map// jj
/*xx*/[/*xx*/string/*xx*/]/*xx*/int// mm`,
expected: `/*aa*/
type // bb
// cc
S // dd
// ff
/*gg*/
[]map[string]int // mm`,
},
{
input: `type S []map[[2]int]int`,
expected: `type S []map[[2]int]int`,
},
{
input: `type S=[]map[[2]int]int`,
expected: `type S = []map[[2]int]int`,
},
{
input: `type S [/*xx*/]/*xx*/map/*xx*/[/*xx*/[/*xx*/2/*xx*/]/*xx*/int/*xx*/]/*xx*/int`,
expected: `type S []map[[2]int]int`,
},
{
input: `/*aa*/type// bb
// cc
/*dd*/S// ee
// ff
/*gg*/[//
/*xx*/]//
/*xx*/map//
/*xx*/[//
/*xx*/[//
/*xx*/2//
/*xx*/]//
/*xx*/int//
/*xx*/]//
/*xx*/int // hh`,
expected: `/*aa*/
type // bb
// cc
/*dd*/
S // ee
// ff
/*gg*/
[]map[[2]int]int // hh`,
},
{
input: `type S []map[[2]int]map[int]string`,
expected: `type S []map[[2]int]map[int]string`,
},
{
input: `type S=[]map[[2]int]map[int]string`,
expected: `type S = []map[[2]int]map[int]string`,
},
{
input: `type S [/*xx*/]/*xx*/map/*xx*/[/*xx*/[/*xx*/2/*xx*/]/*xx*/int/*xx*/]/*xx*/map/*xx*/[/*xx*/int/*xx*/]/*xx*/string`,
expected: `type S []map[[2]int]map[int]string`,
},
{
input: `/*aa*/type// bb
// cc
/*dd*/S// ee
/*ff*/[//
/*xx*/]//
/*xx*/map
/*xx*/[//
/*xx*/[//
/*xx*/2//
/*xx*/]//
/*xx*/int//
/*xx*/]//
/*xx*/map//
/*xx*/[//
/*xx*/int//
/*xx*/]//
/*xx*/string// gg`,
expected: `/*aa*/
type // bb
// cc
/*dd*/
S // ee
/*ff*/
[]map[[2]int]map[int]string // gg`,
},
{
input: `type S []*P`,
expected: `type S []*P`,
},
{
input: `type S=[]*P`,
expected: `type S = []*P`,
},
{
input: `type S [/*xx*/]/*xx*/*/*xx*/P`,
expected: `type S []*P`,
},
{
input: `/*aa*/type// bb
// cc
/*dd*/S// ee
/*ff*/[//
/*xx*/]//
/*xx*/*//
/*xx*/P // gg`,
expected: `/*aa*/
type // bb
// cc
/*dd*/
S // ee
/*ff*/
[]*P // gg`,
},
{
input: `type S []*[]int`,
expected: `type S []*[]int`,
},
{
input: `type S=[]*[]int`,
expected: `type S = []*[]int`,
},
{
input: `type S [/*xx*/]/*xx*/*/*xx*/[/*xx*/]/*xx*/int`,
expected: `type S []*[]int`,
},
{
input: `/*aa*/
type // bb
// cc
/*dd*/S// ee
/*ff*/[//
/*xx*/]//
/*xx*/*//
/*xx*/[//
/*xx*/]//
/*xx*/int // gg`,
expected: `/*aa*/
type // bb
// cc
/*dd*/
S // ee
/*ff*/
[]*[]int // gg`,
},
})
})
t.Run("struct", func(t *testing.T) {
testRun(t, []formatData{
{
input: `type T {}`,
expected: `type T {}`,
},
{
input: `type T {
} `,
expected: `type T {}`,
},
{
input: `type T={}`,
expected: `type T = {}`,
},
{
input: `type T /*aa*/{/*xx*/}// cc`,
expected: `type T /*aa*/ {} // cc`,
},
{
input: `/*aa*/type// bb
// cc
/*dd*/T // ee
/*ff*/{//
/*xx*/}// cc`,
expected: `/*aa*/
type // bb
// cc
/*dd*/
T // ee
/*ff*/
{} // cc`,
},
{
input: `type T {
Name string
}`,
expected: `type T {
Name string
}`,
},
{
input: `type T {
Foo
}`,
expected: `type T {
Foo
}`,
},
{
input: `type T {
*Foo
}`,
expected: `type T {
*Foo
}`,
},
{
input: testStructLitData,
expected: expectedStructLitData,
converter: func(s string) string {
return strings.ReplaceAll(s, "\t", " ")
},
},
})
})
}
//go:embed testdata/test_type_struct_group.api
var testStructGroupData string
//go:embed testdata/expected_type_struct_group.api
var expectedStructgroupData string
func TestFormat_TypeGroupStmt(t *testing.T) {
testRun(t, []formatData{
{
input: testStructGroupData,
expected: expectedStructgroupData,
converter: func(s string) string {
return strings.ReplaceAll(s, "\t", " ")
},
},
})
}
func TestFormat_AtServerStmt(t *testing.T) {
testRunStmt(t, []formatData{
{
input: `@server()`,
expected: ``,
},
{
input: `@server(foo:foo)`,
expected: `@server (
foo: foo
)`,
},
{
input: `@server(foo:foo quux:quux)`,
expected: `@server (
foo: foo
quux: quux
)`,
},
{
input: `@server(
foo:
foo
quux:
quux
)`,
expected: `@server (
foo: foo
quux: quux
)`,
},
{
input: `/*aa*/@server/*bb*/(/*cc*/foo:/**/foo /*dd*/quux:/**/quux/*ee*/)`,
expected: `/*aa*/
@server ( /*cc*/
foo: foo /*dd*/
quux: quux /*ee*/
)`,
},
{
input: `/*aa*/
@server
/*bb*/(// cc
/*dd*/foo:/**/foo// ee
/*ff*/quux:/**/quux// gg
)`,
expected: `/*aa*/
@server
/*bb*/
( // cc
/*dd*/
foo: foo // ee
/*ff*/
quux: quux // gg
)`,
},
})
}
func TestFormat_AtDocStmt(t *testing.T) {
t.Run("AtDocLiteralStmt", func(t *testing.T) {
testRunStmt(t, []formatData{
{
input: `@doc ""`,
expected: ``,
},
{
input: `@doc "foo"`,
expected: `@doc "foo"`,
},
{
input: `@doc "foo"`,
expected: `@doc "foo"`,
},
{
input: `@doc"foo"`,
expected: `@doc "foo"`,
},
{
input: `/*aa*/@doc/**/"foo"// bb`,
expected: `/*aa*/
@doc "foo" // bb`,
},
{
input: `/*aa*/
/*bb*/@doc // cc
"foo"// ee`,
expected: `/*aa*/
/*bb*/
@doc "foo" // ee`,
},
})
})
t.Run("AtDocGroupStmt", func(t *testing.T) {
testRunStmt(t, []formatData{
{
input: `@doc()`,
expected: ``,
},
{
input: `@doc(foo:"foo")`,
expected: `@doc (
foo: "foo"
)`,
},
{
input: `@doc(foo:"foo" bar:"bar")`,
expected: `@doc (
foo: "foo"
bar: "bar"
)`,
},
{
input: `@doc(foo:"foo" bar:"bar" quux:"quux")`,
expected: `@doc (
foo: "foo"
bar: "bar"
quux: "quux"
)`,
},
{
input: `@doc(foo:"foo"
bar: "bar")`,
expected: `@doc (
foo: "foo"
bar: "bar"
)`,
},
{
input: `@doc(foo:"foo"// aa
bar: "bar"// bb
)`,
expected: `@doc (
foo: "foo" // aa
bar: "bar" // bb
)`,
},
{
input: `@doc(// aa
foo:"foo"// bb
bar: "bar"// cc
)`,
expected: `@doc ( // aa
foo: "foo" // bb
bar: "bar" // cc
)`,
},
{
input: `/*aa*/@doc(// bb
foo:"foo"// cc
bar: "bar"// dd
)`,
expected: `/*aa*/
@doc ( // bb
foo: "foo" // cc
bar: "bar" // dd
)`,
},
{
input: `/*aa*/
@doc(// bb
foo:"foo"// cc
bar: "bar"// dd
)// ee`,
expected: `/*aa*/
@doc ( // bb
foo: "foo" // cc
bar: "bar" // dd
) // ee`,
},
{
input: `/*aa*/
@doc ( // bb
/*cc*/foo: "foo" // dd
/*ee*/bar: "bar" // ff
) // gg`,
expected: `/*aa*/
@doc ( // bb
/*cc*/
foo: "foo" // dd
/*ee*/
bar: "bar" // ff
) // gg`,
},
{
input: `/*aa*/
@doc/*xx*/( // bb
/*cc*/foo:/*xx*/ "foo" // dd
/*ee*/bar:/*xx*/ "bar" // ff
) // gg`,
expected: `/*aa*/
@doc ( // bb
/*cc*/
foo: "foo" // dd
/*ee*/
bar: "bar" // ff
) // gg`,
},
})
})
}
func TestFormat_AtHandlerStmt(t *testing.T) {
testRunStmt(t, []formatData{
{
input: `@handler foo`,
expected: `@handler foo`,
},
{
input: `@handler foo`,
expected: `@handler foo`,
},
{
input: `/*aa*/@handler/**/foo// bb`,
expected: `/*aa*/
@handler foo // bb`,
},
{
input: `/*aa*/
/*bb*/@handler // cc
foo// ee`,
expected: `/*aa*/
/*bb*/
@handler foo // ee`,
},
})
}
//go:embed testdata/test_service.api
var testServiceData string
//go:embed testdata/expected_service.api
var expectedServiceData string
func TestFormat_ServiceStmt(t *testing.T) {
testRun(t, []formatData{
{
input: `service foo{}`,
expected: `service foo {}`,
},
{
input: `service foo { }`,
expected: `service foo {}`,
},
{
input: `@server()service foo { }`,
expected: `service foo {}`,
},
{
input: `@server(foo:foo quux:quux)service foo { }`,
expected: `@server (
foo: foo
quux: quux
)
service foo {}`,
},
{
input: `service foo-api { }`,
expected: `service foo-api {}`,
},
{
input: `service foo-api {
@doc "foo"
@handler foo
post /ping
}`,
expected: `service foo-api {
@doc "foo"
@handler foo
post /ping
}`,
},
{
input: `service foo-api {
@doc(foo: "foo" bar: "bar")
@handler foo
post /ping
}`,
expected: `service foo-api {
@doc (
foo: "foo"
bar: "bar"
)
@handler foo
post /ping
}`,
},
{
input: `service foo-api {
@doc(foo: "foo" bar: "bar"
quux: "quux"
)
@handler foo
post /ping
}`,
expected: `service foo-api {
@doc (
foo: "foo"
bar: "bar"
quux: "quux"
)
@handler foo
post /ping
}`,
},
{
input: `service
foo-api
{
@doc
(foo: "foo" bar: "bar"
quux: "quux"
)
@handler
foo
post
/aa/:bb/cc-dd/ee
@handler bar
get /bar () returns (Bar);
@handler baz
get /bar (Baz) returns ();
}`,
expected: `service foo-api {
@doc (
foo: "foo"
bar: "bar"
quux: "quux"
)
@handler foo
post /aa/:bb/cc-dd/ee
@handler bar
get /bar returns (Bar)
@handler baz
get /bar (Baz)
}`,
},
{
input: testServiceData,
expected: expectedServiceData,
converter: func(s string) string {
return strings.ReplaceAll(s, "\t", " ")
},
},
})
}
func TestFormat_error(t *testing.T) {
err := Source([]byte("aaa"), os.Stdout)
assertx.Error(t, err)
}
func testRun(t *testing.T, testData []formatData) {
for _, v := range testData {
buffer := bytes.NewBuffer(nil)
err := formatForUnitTest([]byte(v.input), buffer)
assert.NoError(t, err)
var result = buffer.String()
if v.converter != nil {
result = v.converter(result)
}
assert.Equal(t, v.expected, result)
}
}
func testRunStmt(t *testing.T, testData []formatData) {
for _, v := range testData {
p := parser.New("foo.api", v.input)
ast := p.ParseForUintTest()
assert.NoError(t, p.CheckErrors())
assert.True(t, len(ast.Stmts) > 0)
one := ast.Stmts[0]
actual := one.Format()
if v.converter != nil {
actual = v.converter(actual)
}
assert.Equal(t, v.expected, actual)
}
}
| go | MIT | 8e7e5695eb2095917864b5d6615dab4c90bde3ac | 2026-01-07T08:36:18.042207Z | false |
zeromicro/go-zero | https://github.com/zeromicro/go-zero/blob/8e7e5695eb2095917864b5d6615dab4c90bde3ac/tools/goctl/pkg/parser/api/ast/kvexpression.go | tools/goctl/pkg/parser/api/ast/kvexpression.go | package ast
import "github.com/zeromicro/go-zero/tools/goctl/pkg/parser/api/token"
// KVExpr is a key value expression.
type KVExpr struct {
// Key is the key of the key value expression.
Key *TokenNode
// Colon is the colon of the key value expression.
Colon *TokenNode
// Value is the value of the key value expression.
Value *TokenNode
}
func (i *KVExpr) HasHeadCommentGroup() bool {
return i.Key.HasHeadCommentGroup()
}
func (i *KVExpr) HasLeadingCommentGroup() bool {
return i.Value.HasLeadingCommentGroup()
}
func (i *KVExpr) CommentGroup() (head, leading CommentGroup) {
return i.Key.HeadCommentGroup, i.Value.LeadingCommentGroup
}
func (i *KVExpr) Format(prefix ...string) string {
w := NewBufferWriter()
node := transferNilInfixNode([]*TokenNode{i.Key, i.Colon})
w.Write(withNode(node, i.Value), withPrefix(prefix...), withInfix(Indent), withRawText())
return w.String()
}
func (i *KVExpr) End() token.Position {
return i.Value.End()
}
func (i *KVExpr) Pos() token.Position {
return i.Key.Pos()
}
func (i *KVExpr) exprNode() {}
| go | MIT | 8e7e5695eb2095917864b5d6615dab4c90bde3ac | 2026-01-07T08:36:18.042207Z | false |
zeromicro/go-zero | https://github.com/zeromicro/go-zero/blob/8e7e5695eb2095917864b5d6615dab4c90bde3ac/tools/goctl/pkg/parser/api/ast/comment.go | tools/goctl/pkg/parser/api/ast/comment.go | package ast
import (
"strings"
"github.com/zeromicro/go-zero/tools/goctl/pkg/parser/api/token"
"github.com/zeromicro/go-zero/tools/goctl/util"
)
// CommentGroup represents a list of comments.
type CommentGroup []*CommentStmt
// List returns the list of comments.
func (cg CommentGroup) List() []string {
var list = make([]string, 0, len(cg))
for _, v := range cg {
comment := v.Comment.Text
if util.IsEmptyStringOrWhiteSpace(comment) {
continue
}
list = append(list, comment)
}
return list
}
// String joins and returns the comment text.
func (cg CommentGroup) String() string {
return cg.Join(" ")
}
// Join joins the comments with the given separator.
func (cg CommentGroup) Join(sep string) string {
if !cg.Valid() {
return ""
}
list := cg.List()
return strings.Join(list, sep)
}
// Valid returns true if the comment is valid.
func (cg CommentGroup) Valid() bool {
return len(cg) > 0
}
// CommentStmt represents a comment statement.
type CommentStmt struct {
// Comment is the comment token.
Comment token.Token
}
func (c *CommentStmt) HasHeadCommentGroup() bool {
return false
}
func (c *CommentStmt) HasLeadingCommentGroup() bool {
return false
}
func (c *CommentStmt) CommentGroup() (head, leading CommentGroup) {
return
}
func (c *CommentStmt) stmtNode() {}
func (c *CommentStmt) Pos() token.Position {
return c.Comment.Position
}
func (c *CommentStmt) End() token.Position {
return c.Comment.Position
}
func (c *CommentStmt) Format(prefix ...string) string {
return peekOne(prefix) + c.Comment.Text
}
| go | MIT | 8e7e5695eb2095917864b5d6615dab4c90bde3ac | 2026-01-07T08:36:18.042207Z | false |
zeromicro/go-zero | https://github.com/zeromicro/go-zero/blob/8e7e5695eb2095917864b5d6615dab4c90bde3ac/tools/goctl/pkg/parser/api/ast/print.go | tools/goctl/pkg/parser/api/ast/print.go | package ast
import (
"fmt"
"go/token"
"io"
"os"
"reflect"
apitoken "github.com/zeromicro/go-zero/tools/goctl/pkg/parser/api/token"
)
// A FieldFilter may be provided to Fprint to control the output.
type FieldFilter func(name string, value reflect.Value) bool
// NotNilFilter returns true for field values that are not nil,
// it returns false otherwise.
func NotNilFilter(_ string, v reflect.Value) bool {
switch v.Kind() {
case reflect.Chan, reflect.Func, reflect.Interface, reflect.Map, reflect.Pointer, reflect.Slice:
return !v.IsNil()
}
return true
}
// Fprint prints the value of x to the writer w.
func Fprint(w io.Writer, x interface{}, f FieldFilter) error {
return fprint(w, x, f)
}
func fprint(w io.Writer, x interface{}, f FieldFilter) (err error) {
// setup printer
p := printer{
output: w,
filter: f,
ptrmap: make(map[interface{}]int),
last: '\n', // force printing of line number on first line
}
// install error handler
defer func() {
if e := recover(); e != nil {
err = e.(localError).err // re-panics if it's not a localError
}
}()
// print x
if x == nil {
p.printf("nil\n")
return
}
p.print(reflect.ValueOf(x))
p.printf("\n")
return
}
func Print(x interface{}) error {
return Fprint(os.Stdout, x, NotNilFilter)
}
type printer struct {
output io.Writer
filter FieldFilter
ptrmap map[interface{}]int // *T -> line number
prefixIndent int // current indentation level
last byte // the last byte processed by Write
line int // current line number
}
var prefixIndent = []byte(". ")
// Write implements io.Writer.
func (p *printer) Write(data []byte) (n int, err error) {
var m int
for i, b := range data {
// invariant: data[0:n] has been written
if b == '\n' {
m, err = p.output.Write(data[n : i+1])
n += m
if err != nil {
return
}
p.line++
} else if p.last == '\n' {
_, err = fmt.Fprintf(p.output, "%6d ", p.line)
if err != nil {
return
}
for j := p.prefixIndent; j > 0; j-- {
_, err = p.output.Write(prefixIndent)
if err != nil {
return
}
}
}
p.last = b
}
if len(data) > n {
m, err = p.output.Write(data[n:])
n += m
}
return
}
// localError wraps locally caught errors so we can distinguish
// them from genuine panics which we don't want to return as errors.
type localError struct {
err error
}
// printf is a convenience wrapper that takes care of print errors.
func (p *printer) printf(format string, args ...interface{}) {
if _, err := fmt.Fprintf(p, format, args...); err != nil {
panic(localError{err})
}
}
// Implementation note: Print is written for AST nodes but could be
// used to print arbitrary data structures; such a version should
// probably be in a different package.
//
// Note: This code detects (some) cycles created via pointers but
// not cycles that are created via slices or maps containing the
// same slice or map. Code for general data structures probably
// should catch those as well.
func (p *printer) print(x reflect.Value) {
if !NotNilFilter("", x) {
p.printf("nil")
return
}
switch x.Kind() {
case reflect.Interface:
p.print(x.Elem())
case reflect.Map:
p.printf("%s (len = %d) {", x.Type(), x.Len())
if x.Len() > 0 {
p.prefixIndent++
p.printf("\n")
for _, key := range x.MapKeys() {
p.print(key)
p.printf(": ")
p.print(x.MapIndex(key))
p.printf("\n")
}
p.prefixIndent--
}
p.printf("}")
case reflect.Pointer:
p.printf("*")
// type-checked ASTs may contain cycles - use ptrmap
// to keep track of objects that have been printed
// already and print the respective line number instead
ptr := x.Interface()
if line, exists := p.ptrmap[ptr]; exists {
p.printf("(obj @ %d)", line)
} else {
p.ptrmap[ptr] = p.line
p.print(x.Elem())
}
case reflect.Array:
p.printf("%s {", x.Type())
if x.Len() > 0 {
p.prefixIndent++
p.printf("\n")
for i, n := 0, x.Len(); i < n; i++ {
p.printf("%d: ", i)
p.print(x.Index(i))
p.printf("\n")
}
p.prefixIndent--
}
p.printf("}")
case reflect.Slice:
if s, ok := x.Interface().([]byte); ok {
p.printf("%#q", s)
return
}
p.printf("%s (len = %d) {", x.Type(), x.Len())
if x.Len() > 0 {
p.prefixIndent++
p.printf("\n")
for i, n := 0, x.Len(); i < n; i++ {
p.printf("%d: ", i)
p.print(x.Index(i))
p.printf("\n")
}
p.prefixIndent--
}
p.printf("}")
case reflect.Struct:
if val, ok := x.Interface().(apitoken.Position); ok {
p.printf(val.String())
return
}
t := x.Type()
p.printf("%s {", t)
p.prefixIndent++
first := true
for i, n := 0, t.NumField(); i < n; i++ {
// exclude non-exported fields because their
// values cannot be accessed via reflection
if name := t.Field(i).Name; token.IsExported(name) {
value := x.Field(i)
if p.filter == nil || p.filter(name, value) {
if first {
p.printf("\n")
first = false
}
p.printf("%s: ", name)
p.print(value)
p.printf("\n")
}
}
}
p.prefixIndent--
p.printf("}")
default:
v := x.Interface()
switch v := v.(type) {
case string:
// print strings in quotes
p.printf("%q", v)
return
}
// default
p.printf("%v", v)
}
}
| go | MIT | 8e7e5695eb2095917864b5d6615dab4c90bde3ac | 2026-01-07T08:36:18.042207Z | false |
zeromicro/go-zero | https://github.com/zeromicro/go-zero/blob/8e7e5695eb2095917864b5d6615dab4c90bde3ac/tools/goctl/pkg/parser/api/ast/typestatement.go | tools/goctl/pkg/parser/api/ast/typestatement.go | package ast
import "github.com/zeromicro/go-zero/tools/goctl/pkg/parser/api/token"
/*******************TypeStmt Begin********************/
// TypeStmt is the interface for type statement.
type TypeStmt interface {
Stmt
typeNode()
}
// TypeLiteralStmt is the type statement for type literal.
type TypeLiteralStmt struct {
// Type is the type keyword.
Type *TokenNode
// Expr is the type expression.
Expr *TypeExpr
}
func (t *TypeLiteralStmt) HasHeadCommentGroup() bool {
return t.Type.HasHeadCommentGroup()
}
func (t *TypeLiteralStmt) HasLeadingCommentGroup() bool {
return t.Expr.HasLeadingCommentGroup()
}
func (t *TypeLiteralStmt) CommentGroup() (head, leading CommentGroup) {
_, leading = t.Expr.CommentGroup()
return t.Type.HeadCommentGroup, leading
}
func (t *TypeLiteralStmt) Format(prefix ...string) string {
w := NewBufferWriter()
w.Write(withNode(t.Type, t.Expr), withPrefix(prefix...), expectSameLine())
return w.String()
}
func (t *TypeLiteralStmt) End() token.Position {
return t.Expr.End()
}
func (t *TypeLiteralStmt) Pos() token.Position {
return t.Type.Pos()
}
func (t *TypeLiteralStmt) stmtNode() {}
func (t *TypeLiteralStmt) typeNode() {}
// TypeGroupStmt is the type statement for type group.
type TypeGroupStmt struct {
// Type is the type keyword.
Type *TokenNode
// LParen is the left parenthesis.
LParen *TokenNode
// ExprList is the type expression list.
ExprList []*TypeExpr
// RParen is the right parenthesis.
RParen *TokenNode
}
func (t *TypeGroupStmt) HasHeadCommentGroup() bool {
return t.Type.HasHeadCommentGroup()
}
func (t *TypeGroupStmt) HasLeadingCommentGroup() bool {
return t.RParen.HasLeadingCommentGroup()
}
func (t *TypeGroupStmt) CommentGroup() (head, leading CommentGroup) {
return t.Type.HeadCommentGroup, t.RParen.LeadingCommentGroup
}
func (t *TypeGroupStmt) Format(prefix ...string) string {
if len(t.ExprList) == 0 {
return ""
}
w := NewBufferWriter()
typeNode := transferTokenNode(t.Type, withTokenNodePrefix(prefix...))
w.Write(withNode(typeNode, t.LParen), expectSameLine())
w.NewLine()
for _, e := range t.ExprList {
w.Write(withNode(e), withPrefix(peekOne(prefix)+Indent))
w.NewLine()
}
w.WriteText(t.RParen.Format(prefix...))
return w.String()
}
func (t *TypeGroupStmt) End() token.Position {
return t.RParen.End()
}
func (t *TypeGroupStmt) Pos() token.Position {
return t.Type.Pos()
}
func (t *TypeGroupStmt) stmtNode() {}
func (t *TypeGroupStmt) typeNode() {}
/*******************TypeStmt End********************/
/*******************TypeExpr Begin********************/
// TypeExpr is the type expression.
type TypeExpr struct {
// Name is the type name.
Name *TokenNode
// Assign is the assign operator.
Assign *TokenNode
// DataType is the data type.
DataType DataType
}
func (e *TypeExpr) HasHeadCommentGroup() bool {
return e.Name.HasHeadCommentGroup()
}
func (e *TypeExpr) HasLeadingCommentGroup() bool {
return e.DataType.HasLeadingCommentGroup()
}
func (e *TypeExpr) CommentGroup() (head, leading CommentGroup) {
_, leading = e.DataType.CommentGroup()
return e.Name.HeadCommentGroup, leading
}
func (e *TypeExpr) Format(prefix ...string) string {
w := NewBufferWriter()
nameNode := transferTokenNode(e.Name, withTokenNodePrefix(prefix...))
dataTypeNode := transfer2TokenNode(e.DataType, false, withTokenNodePrefix(prefix...))
if e.Assign != nil {
w.Write(withNode(nameNode, e.Assign, dataTypeNode), expectSameLine())
} else {
w.Write(withNode(nameNode, dataTypeNode), expectSameLine())
}
return w.String()
}
func (e *TypeExpr) End() token.Position {
return e.DataType.End()
}
func (e *TypeExpr) Pos() token.Position {
return e.Name.Pos()
}
func (e *TypeExpr) exprNode() {}
func (e *TypeExpr) isStruct() bool {
return e.DataType.ContainsStruct()
}
/*******************TypeExpr Begin********************/
/*******************Elem Begin********************/
// ElemExpr is the element expression.
type ElemExpr struct {
// Name is the field element name.
Name []*TokenNode
// DataType is the field data type.
DataType DataType
// Tag is the field tag.
Tag *TokenNode
}
// IsAnonymous returns true if the element is anonymous.
func (e *ElemExpr) IsAnonymous() bool {
return len(e.Name) == 0
}
func (e *ElemExpr) HasHeadCommentGroup() bool {
if e.IsAnonymous() {
return e.DataType.HasHeadCommentGroup()
}
return e.Name[0].HasHeadCommentGroup()
}
func (e *ElemExpr) HasLeadingCommentGroup() bool {
if e.Tag != nil {
return e.Tag.HasLeadingCommentGroup()
}
return e.DataType.HasLeadingCommentGroup()
}
func (e *ElemExpr) CommentGroup() (head, leading CommentGroup) {
if e.Tag != nil {
leading = e.Tag.LeadingCommentGroup
} else {
_, leading = e.DataType.CommentGroup()
}
if e.IsAnonymous() {
head, _ := e.DataType.CommentGroup()
return head, leading
}
return e.Name[0].HeadCommentGroup, leading
}
func (e *ElemExpr) Format(prefix ...string) string {
w := NewBufferWriter()
var nameNodeList []*TokenNode
for idx, n := range e.Name {
if idx == 0 {
nameNodeList = append(nameNodeList,
transferTokenNode(n, ignoreLeadingComment()))
} else if idx < len(e.Name)-1 {
nameNodeList = append(nameNodeList,
transferTokenNode(n, ignoreLeadingComment(), ignoreHeadComment()))
} else {
nameNodeList = append(nameNodeList, transferTokenNode(n, ignoreHeadComment()))
}
}
var dataTypeOption []tokenNodeOption
if e.DataType.ContainsStruct() {
dataTypeOption = append(dataTypeOption, withTokenNodePrefix(peekOne(prefix)+Indent))
} else {
dataTypeOption = append(dataTypeOption, withTokenNodePrefix(prefix...))
}
dataTypeNode := transfer2TokenNode(e.DataType, false, dataTypeOption...)
if len(nameNodeList) > 0 {
nameNode := transferNilInfixNode(nameNodeList,
withTokenNodePrefix(prefix...), withTokenNodeInfix(", "))
if e.Tag != nil {
w.Write(withNode(nameNode, dataTypeNode, e.Tag), expectIndentInfix(), expectSameLine())
} else {
w.Write(withNode(nameNode, dataTypeNode), expectIndentInfix(), expectSameLine())
}
} else {
if e.Tag != nil {
w.Write(withNode(dataTypeNode, e.Tag), expectIndentInfix(), expectSameLine())
} else {
w.Write(withNode(dataTypeNode), expectIndentInfix(), expectSameLine())
}
}
return w.String()
}
func (e *ElemExpr) End() token.Position {
if e.Tag != nil {
return e.Tag.End()
}
return e.DataType.End()
}
func (e *ElemExpr) Pos() token.Position {
if len(e.Name) > 0 {
return e.Name[0].Pos()
}
return token.IllegalPosition
}
func (e *ElemExpr) exprNode() {}
/*******************Elem End********************/
/*******************ElemExprList Begin********************/
// ElemExprList is the element expression list.
type ElemExprList []*ElemExpr
/*******************ElemExprList Begin********************/
/*******************DataType Begin********************/
// DataType represents the data type.
type DataType interface {
Expr
dataTypeNode()
// CanEqual returns true if the data type can be equal.
CanEqual() bool
// ContainsStruct returns true if the data type contains struct.
ContainsStruct() bool
// RawText returns the raw text of the data type.
RawText() string
}
// AnyDataType is the any data type.
type AnyDataType struct {
// Any is the any token node.
Any *TokenNode
isChild bool
}
func (t *AnyDataType) HasHeadCommentGroup() bool {
return t.Any.HasHeadCommentGroup()
}
func (t *AnyDataType) HasLeadingCommentGroup() bool {
return t.Any.HasLeadingCommentGroup()
}
func (t *AnyDataType) CommentGroup() (head, leading CommentGroup) {
return t.Any.HeadCommentGroup, t.Any.LeadingCommentGroup
}
func (t *AnyDataType) Format(prefix ...string) string {
return t.Any.Format(prefix...)
}
func (t *AnyDataType) End() token.Position {
return t.Any.End()
}
func (t *AnyDataType) RawText() string {
return t.Any.Token.Text
}
func (t *AnyDataType) ContainsStruct() bool {
return false
}
func (t *AnyDataType) Pos() token.Position {
return t.Any.Pos()
}
func (t *AnyDataType) exprNode() {}
func (t *AnyDataType) dataTypeNode() {}
func (t *AnyDataType) CanEqual() bool {
return true
}
// ArrayDataType is the array data type.
type ArrayDataType struct {
// LB is the left bracket token node.
LBrack *TokenNode
// Len is the array length.
Length *TokenNode
// RB is the right bracket token node.
RBrack *TokenNode
// DataType is the array data type.
DataType DataType
isChild bool
}
func (t *ArrayDataType) HasHeadCommentGroup() bool {
return t.LBrack.HasHeadCommentGroup()
}
func (t *ArrayDataType) HasLeadingCommentGroup() bool {
return t.DataType.HasLeadingCommentGroup()
}
func (t *ArrayDataType) CommentGroup() (head, leading CommentGroup) {
_, leading = t.DataType.CommentGroup()
return t.LBrack.HeadCommentGroup, leading
}
func (t *ArrayDataType) Format(prefix ...string) string {
w := NewBufferWriter()
lbrack := transferTokenNode(t.LBrack, ignoreLeadingComment())
lengthNode := transferTokenNode(t.Length, ignoreLeadingComment())
rbrack := transferTokenNode(t.RBrack, ignoreHeadComment())
var dataType *TokenNode
var options []tokenNodeOption
options = append(options, withTokenNodePrefix(prefix...))
if t.isChild {
options = append(options, ignoreComment())
} else {
options = append(options, ignoreHeadComment())
}
dataType = transfer2TokenNode(t.DataType, false, options...)
node := transferNilInfixNode([]*TokenNode{lbrack, lengthNode, rbrack, dataType})
w.Write(withNode(node))
return w.String()
}
func (t *ArrayDataType) End() token.Position {
return t.DataType.End()
}
func (t *ArrayDataType) RawText() string {
return t.Format("")
}
func (t *ArrayDataType) ContainsStruct() bool {
return t.DataType.ContainsStruct()
}
func (t *ArrayDataType) CanEqual() bool {
return t.DataType.CanEqual()
}
func (t *ArrayDataType) Pos() token.Position {
return t.LBrack.Pos()
}
func (t *ArrayDataType) exprNode() {}
func (t *ArrayDataType) dataTypeNode() {}
// BaseDataType is a common id type which contains bool, uint8, uint16, uint32,
// uint64, int8, int16, int32, int64, float32, float64, complex64, complex128,
// string, int, uint, uintptr, byte, rune, any.
type BaseDataType struct {
// Base is the base token node.
Base *TokenNode
isChild bool
}
func (t *BaseDataType) HasHeadCommentGroup() bool {
return t.Base.HasHeadCommentGroup()
}
func (t *BaseDataType) HasLeadingCommentGroup() bool {
return t.Base.HasLeadingCommentGroup()
}
func (t *BaseDataType) CommentGroup() (head, leading CommentGroup) {
return t.Base.HeadCommentGroup, t.Base.LeadingCommentGroup
}
func (t *BaseDataType) Format(prefix ...string) string {
return t.Base.Format(prefix...)
}
func (t *BaseDataType) End() token.Position {
return t.Base.End()
}
func (t *BaseDataType) RawText() string {
return t.Base.Token.Text
}
func (t *BaseDataType) ContainsStruct() bool {
return false
}
func (t *BaseDataType) CanEqual() bool {
return true
}
func (t *BaseDataType) Pos() token.Position {
return t.Base.Pos()
}
func (t *BaseDataType) exprNode() {}
func (t *BaseDataType) dataTypeNode() {}
// InterfaceDataType is the interface data type.
type InterfaceDataType struct {
// Interface is the interface token node.
Interface *TokenNode
isChild bool
}
func (t *InterfaceDataType) HasHeadCommentGroup() bool {
return t.Interface.HasHeadCommentGroup()
}
func (t *InterfaceDataType) HasLeadingCommentGroup() bool {
return t.Interface.HasLeadingCommentGroup()
}
func (t *InterfaceDataType) CommentGroup() (head, leading CommentGroup) {
return t.Interface.HeadCommentGroup, t.Interface.LeadingCommentGroup
}
func (t *InterfaceDataType) Format(prefix ...string) string {
return t.Interface.Format(prefix...)
}
func (t *InterfaceDataType) End() token.Position {
return t.Interface.End()
}
func (t *InterfaceDataType) RawText() string {
return t.Interface.Token.Text
}
func (t *InterfaceDataType) ContainsStruct() bool {
return false
}
func (t *InterfaceDataType) CanEqual() bool {
return true
}
func (t *InterfaceDataType) Pos() token.Position {
return t.Interface.Pos()
}
func (t *InterfaceDataType) exprNode() {}
func (t *InterfaceDataType) dataTypeNode() {}
// MapDataType is the map data type.
type MapDataType struct {
// Map is the map token node.
Map *TokenNode
// Lbrack is the left bracket token node.
LBrack *TokenNode
// Key is the map key data type.
Key DataType
// Rbrack is the right bracket token node.
RBrack *TokenNode
// Value is the map value data type.
Value DataType
isChild bool
}
func (t *MapDataType) HasHeadCommentGroup() bool {
return t.Map.HasHeadCommentGroup()
}
func (t *MapDataType) HasLeadingCommentGroup() bool {
return t.Value.HasLeadingCommentGroup()
}
func (t *MapDataType) CommentGroup() (head, leading CommentGroup) {
_, leading = t.Value.CommentGroup()
return t.Map.HeadCommentGroup, leading
}
func (t *MapDataType) Format(prefix ...string) string {
w := NewBufferWriter()
mapNode := transferTokenNode(t.Map, ignoreLeadingComment())
lbrack := transferTokenNode(t.LBrack, ignoreLeadingComment())
rbrack := transferTokenNode(t.RBrack, ignoreComment())
var keyOption, valueOption []tokenNodeOption
keyOption = append(keyOption, ignoreComment())
valueOption = append(valueOption, withTokenNodePrefix(prefix...))
if t.isChild {
valueOption = append(valueOption, ignoreComment())
} else {
valueOption = append(valueOption, ignoreHeadComment())
}
keyDataType := transfer2TokenNode(t.Key, true, keyOption...)
valueDataType := transfer2TokenNode(t.Value, false, valueOption...)
node := transferNilInfixNode([]*TokenNode{mapNode, lbrack, keyDataType, rbrack, valueDataType})
w.Write(withNode(node))
return w.String()
}
func (t *MapDataType) End() token.Position {
return t.Value.End()
}
func (t *MapDataType) RawText() string {
return t.Format("")
}
func (t *MapDataType) ContainsStruct() bool {
return t.Key.ContainsStruct() || t.Value.ContainsStruct()
}
func (t *MapDataType) CanEqual() bool {
return false
}
func (t *MapDataType) Pos() token.Position {
return t.Map.Pos()
}
func (t *MapDataType) exprNode() {}
func (t *MapDataType) dataTypeNode() {}
// PointerDataType is the pointer data type.
type PointerDataType struct {
// Star is the star token node.
Star *TokenNode
// DataType is the pointer data type.
DataType DataType
isChild bool
}
func (t *PointerDataType) HasHeadCommentGroup() bool {
return t.Star.HasHeadCommentGroup()
}
func (t *PointerDataType) HasLeadingCommentGroup() bool {
return t.DataType.HasLeadingCommentGroup()
}
func (t *PointerDataType) CommentGroup() (head, leading CommentGroup) {
_, leading = t.DataType.CommentGroup()
return t.Star.HeadCommentGroup, leading
}
func (t *PointerDataType) Format(prefix ...string) string {
w := NewBufferWriter()
star := transferTokenNode(t.Star, ignoreLeadingComment(), withTokenNodePrefix(prefix...))
var dataTypeOption []tokenNodeOption
dataTypeOption = append(dataTypeOption, ignoreHeadComment())
dataType := transfer2TokenNode(t.DataType, false, dataTypeOption...)
node := transferNilInfixNode([]*TokenNode{star, dataType})
w.Write(withNode(node))
return w.String()
}
func (t *PointerDataType) End() token.Position {
return t.DataType.End()
}
func (t *PointerDataType) RawText() string {
return t.Format("")
}
func (t *PointerDataType) ContainsStruct() bool {
return t.DataType.ContainsStruct()
}
func (t *PointerDataType) CanEqual() bool {
return t.DataType.CanEqual()
}
func (t *PointerDataType) Pos() token.Position {
return t.Star.Pos()
}
func (t *PointerDataType) exprNode() {}
func (t *PointerDataType) dataTypeNode() {}
// SliceDataType is the slice data type.
type SliceDataType struct {
// Lbrack is the left bracket token node.
LBrack *TokenNode
// Rbrack is the right bracket token node.
RBrack *TokenNode
// DataType is the slice data type.
DataType DataType
isChild bool
}
func (t *SliceDataType) HasHeadCommentGroup() bool {
return t.LBrack.HasHeadCommentGroup()
}
func (t *SliceDataType) HasLeadingCommentGroup() bool {
return t.DataType.HasLeadingCommentGroup()
}
func (t *SliceDataType) CommentGroup() (head, leading CommentGroup) {
_, leading = t.DataType.CommentGroup()
return t.LBrack.HeadCommentGroup, leading
}
func (t *SliceDataType) Format(prefix ...string) string {
w := NewBufferWriter()
lbrack := transferTokenNode(t.LBrack, ignoreLeadingComment())
rbrack := transferTokenNode(t.RBrack, ignoreHeadComment())
dataType := transfer2TokenNode(t.DataType, false, withTokenNodePrefix(prefix...), ignoreHeadComment())
node := transferNilInfixNode([]*TokenNode{lbrack, rbrack, dataType})
w.Write(withNode(node))
return w.String()
}
func (t *SliceDataType) End() token.Position {
return t.DataType.End()
}
func (t *SliceDataType) RawText() string {
return t.Format("")
}
func (t *SliceDataType) ContainsStruct() bool {
return t.DataType.ContainsStruct()
}
func (t *SliceDataType) CanEqual() bool {
return false
}
func (t *SliceDataType) Pos() token.Position {
return t.LBrack.Pos()
}
func (t *SliceDataType) exprNode() {}
func (t *SliceDataType) dataTypeNode() {}
// StructDataType is the structure data type.
type StructDataType struct {
// Lbrace is the left brace token node.
LBrace *TokenNode
// Elements is the structure elements.
Elements ElemExprList
// Rbrace is the right brace token node.
RBrace *TokenNode
isChild bool
}
func (t *StructDataType) HasHeadCommentGroup() bool {
return t.LBrace.HasHeadCommentGroup()
}
func (t *StructDataType) HasLeadingCommentGroup() bool {
return t.RBrace.HasLeadingCommentGroup()
}
func (t *StructDataType) CommentGroup() (head, leading CommentGroup) {
return t.LBrace.HeadCommentGroup, t.RBrace.LeadingCommentGroup
}
func (t *StructDataType) Format(prefix ...string) string {
w := NewBufferWriter()
if len(t.Elements) == 0 {
lbrace := transferTokenNode(t.LBrace, withTokenNodePrefix(prefix...), ignoreLeadingComment())
rbrace := transferTokenNode(t.RBrace, ignoreHeadComment())
brace := transferNilInfixNode([]*TokenNode{lbrace, rbrace})
w.Write(withNode(brace), expectSameLine())
return w.String()
}
w.WriteText(t.LBrace.Format(NilIndent))
w.NewLine()
for _, e := range t.Elements {
var nameNodeList []*TokenNode
if len(e.Name) > 0 {
for idx, n := range e.Name {
if idx == 0 {
nameNodeList = append(nameNodeList,
transferTokenNode(n, withTokenNodePrefix(peekOne(prefix)+Indent), ignoreLeadingComment()))
} else if idx < len(e.Name)-1 {
nameNodeList = append(nameNodeList,
transferTokenNode(n, ignoreLeadingComment(), ignoreHeadComment()))
} else {
nameNodeList = append(nameNodeList, transferTokenNode(n, ignoreHeadComment()))
}
}
}
var dataTypeOption []tokenNodeOption
if e.DataType.ContainsStruct() || e.IsAnonymous() {
dataTypeOption = append(dataTypeOption, withTokenNodePrefix(peekOne(prefix)+Indent))
} else {
dataTypeOption = append(dataTypeOption, withTokenNodePrefix(prefix...))
}
dataTypeNode := transfer2TokenNode(e.DataType, false, dataTypeOption...)
if len(nameNodeList) > 0 {
nameNode := transferNilInfixNode(nameNodeList, withTokenNodeInfix(", "))
if e.Tag != nil {
if e.DataType.ContainsStruct() {
w.Write(withNode(nameNode, dataTypeNode, e.Tag), expectSameLine())
} else {
w.Write(withNode(nameNode, e.DataType, e.Tag), expectIndentInfix(), expectSameLine())
}
} else {
if e.DataType.ContainsStruct() {
w.Write(withNode(nameNode, dataTypeNode), expectSameLine())
} else {
w.Write(withNode(nameNode, e.DataType), expectIndentInfix(), expectSameLine())
}
}
} else {
if e.Tag != nil {
if e.DataType.ContainsStruct() {
w.Write(withNode(dataTypeNode, e.Tag), expectSameLine())
} else {
w.Write(withNode(e.DataType, e.Tag), expectIndentInfix(), expectSameLine())
}
} else {
if e.DataType.ContainsStruct() {
w.Write(withNode(dataTypeNode), expectSameLine())
} else {
w.Write(withNode(dataTypeNode), expectIndentInfix(), expectSameLine())
}
}
}
w.NewLine()
}
w.WriteText(t.RBrace.Format(prefix...))
return w.String()
}
func (t *StructDataType) End() token.Position {
return t.RBrace.End()
}
func (t *StructDataType) RawText() string {
return t.Format("")
}
func (t *StructDataType) ContainsStruct() bool {
return true
}
func (t *StructDataType) CanEqual() bool {
for _, v := range t.Elements {
if !v.DataType.CanEqual() {
return false
}
}
return true
}
func (t *StructDataType) Pos() token.Position {
return t.LBrace.Pos()
}
func (t *StructDataType) exprNode() {}
func (t *StructDataType) dataTypeNode() {}
/*******************DataType End********************/
| go | MIT | 8e7e5695eb2095917864b5d6615dab4c90bde3ac | 2026-01-07T08:36:18.042207Z | false |
zeromicro/go-zero | https://github.com/zeromicro/go-zero/blob/8e7e5695eb2095917864b5d6615dab4c90bde3ac/tools/goctl/pkg/parser/api/ast/writer.go | tools/goctl/pkg/parser/api/ast/writer.go | package ast
import (
"bytes"
"fmt"
"io"
"strings"
"text/tabwriter"
"github.com/zeromicro/go-zero/tools/goctl/pkg/parser/api/token"
"github.com/zeromicro/go-zero/tools/goctl/util"
)
const (
NilIndent = ""
WhiteSpace = " "
Indent = "\t"
NewLine = "\n"
)
const (
_ WriteMode = 1 << iota
// ModeAuto is the default mode, which will automatically
//determine whether to write a newline.
ModeAuto
// ModeExpectInSameLine will write in the same line.
ModeExpectInSameLine
)
type Option func(o *option)
type option struct {
prefix string
infix string
mode WriteMode
nodes []Node
rawText bool
}
type tokenNodeOption func(o *tokenNodeOpt)
type tokenNodeOpt struct {
prefix string
infix string
ignoreHeadComment bool
ignoreLeadingComment bool
}
// WriteMode is the mode of writing.
type WriteMode int
// Writer is the writer of ast.
type Writer struct {
tw *tabwriter.Writer
writer io.Writer
}
func transfer2TokenNode(node Node, isChild bool, opt ...tokenNodeOption) *TokenNode {
option := new(tokenNodeOpt)
for _, o := range opt {
o(option)
}
var copyOpt = append([]tokenNodeOption(nil), opt...)
var tn *TokenNode
switch val := node.(type) {
case *AnyDataType:
copyOpt = append(copyOpt, withTokenNodePrefix(NilIndent))
tn = transferTokenNode(val.Any, copyOpt...)
if option.ignoreHeadComment {
tn.HeadCommentGroup = nil
}
if option.ignoreLeadingComment {
tn.LeadingCommentGroup = nil
}
val.isChild = isChild
val.Any = tn
case *ArrayDataType:
copyOpt = append(copyOpt, withTokenNodePrefix(NilIndent))
tn = transferTokenNode(val.LBrack, copyOpt...)
if option.ignoreHeadComment {
tn.HeadCommentGroup = nil
}
if option.ignoreLeadingComment {
tn.LeadingCommentGroup = nil
}
val.isChild = isChild
val.LBrack = tn
case *BaseDataType:
copyOpt = append(copyOpt, withTokenNodePrefix(NilIndent))
tn = transferTokenNode(val.Base, copyOpt...)
if option.ignoreHeadComment {
tn.HeadCommentGroup = nil
}
if option.ignoreLeadingComment {
tn.LeadingCommentGroup = nil
}
val.isChild = isChild
val.Base = tn
case *InterfaceDataType:
copyOpt = append(copyOpt, withTokenNodePrefix(NilIndent))
tn = transferTokenNode(val.Interface, copyOpt...)
if option.ignoreHeadComment {
tn.HeadCommentGroup = nil
}
if option.ignoreLeadingComment {
tn.LeadingCommentGroup = nil
}
val.isChild = isChild
val.Interface = tn
case *MapDataType:
copyOpt = append(copyOpt, withTokenNodePrefix(NilIndent))
tn = transferTokenNode(val.Map, copyOpt...)
if option.ignoreHeadComment {
tn.HeadCommentGroup = nil
}
if option.ignoreLeadingComment {
tn.LeadingCommentGroup = nil
}
val.isChild = isChild
val.Map = tn
case *PointerDataType:
copyOpt = append(copyOpt, withTokenNodePrefix(NilIndent))
tn = transferTokenNode(val.Star, copyOpt...)
if option.ignoreHeadComment {
tn.HeadCommentGroup = nil
}
if option.ignoreLeadingComment {
tn.LeadingCommentGroup = nil
}
val.isChild = isChild
val.Star = tn
case *SliceDataType:
copyOpt = append(copyOpt, withTokenNodePrefix(NilIndent))
tn = transferTokenNode(val.LBrack, copyOpt...)
if option.ignoreHeadComment {
tn.HeadCommentGroup = nil
}
if option.ignoreLeadingComment {
tn.LeadingCommentGroup = nil
}
val.isChild = isChild
val.LBrack = tn
case *StructDataType:
copyOpt = append(copyOpt, withTokenNodePrefix(NilIndent))
tn = transferTokenNode(val.LBrace, copyOpt...)
if option.ignoreHeadComment {
tn.HeadCommentGroup = nil
}
if option.ignoreLeadingComment {
tn.LeadingCommentGroup = nil
}
val.isChild = isChild
val.LBrace = tn
default:
}
return &TokenNode{
headFlag: node.HasHeadCommentGroup(),
leadingFlag: node.HasLeadingCommentGroup(),
Token: token.Token{
Text: node.Format(option.prefix),
Position: node.Pos(),
},
LeadingCommentGroup: CommentGroup{
{
token.Token{Position: node.End()},
},
},
}
}
func transferNilInfixNode(nodes []*TokenNode, opt ...tokenNodeOption) *TokenNode {
result := &TokenNode{}
var option = new(tokenNodeOpt)
for _, o := range opt {
o(option)
}
var list []string
for _, n := range nodes {
list = append(list, n.Token.Text)
}
result.Token = token.Token{
Text: option.prefix + strings.Join(list, option.infix),
Position: nodes[0].Pos(),
}
if !option.ignoreHeadComment {
result.HeadCommentGroup = nodes[0].HeadCommentGroup
}
if !option.ignoreLeadingComment {
result.LeadingCommentGroup = nodes[len(nodes)-1].LeadingCommentGroup
}
return result
}
func transferTokenNode(node *TokenNode, opt ...tokenNodeOption) *TokenNode {
result := &TokenNode{}
var option = new(tokenNodeOpt)
for _, o := range opt {
o(option)
}
result.Token = token.Token{
Type: node.Token.Type,
Text: option.prefix + node.Token.Text,
Position: node.Token.Position,
}
if !option.ignoreHeadComment {
for _, v := range node.HeadCommentGroup {
result.HeadCommentGroup = append(result.HeadCommentGroup,
&CommentStmt{Comment: token.Token{
Type: v.Comment.Type,
Text: option.prefix + v.Comment.Text,
Position: v.Comment.Position,
}})
}
}
if !option.ignoreLeadingComment {
result.LeadingCommentGroup = append(result.LeadingCommentGroup, node.LeadingCommentGroup...)
}
return result
}
func ignoreHeadComment() tokenNodeOption {
return func(o *tokenNodeOpt) {
o.ignoreHeadComment = true
}
}
func ignoreLeadingComment() tokenNodeOption {
return func(o *tokenNodeOpt) {
o.ignoreLeadingComment = true
}
}
func ignoreComment() tokenNodeOption {
return func(o *tokenNodeOpt) {
o.ignoreHeadComment = true
o.ignoreLeadingComment = true
}
}
func withTokenNodePrefix(prefix ...string) tokenNodeOption {
return func(o *tokenNodeOpt) {
for _, p := range prefix {
o.prefix = p
}
}
}
func withTokenNodeInfix(infix string) tokenNodeOption {
return func(o *tokenNodeOpt) {
o.infix = infix
}
}
func expectSameLine() Option {
return func(o *option) {
o.mode = ModeExpectInSameLine
}
}
func expectIndentInfix() Option {
return func(o *option) {
o.infix = Indent
}
}
func withNode(nodes ...Node) Option {
return func(o *option) {
o.nodes = nodes
}
}
func withMode(mode WriteMode) Option {
return func(o *option) {
o.mode = mode
}
}
func withPrefix(prefix ...string) Option {
return func(o *option) {
for _, p := range prefix {
o.prefix = p
}
}
}
func withInfix(infix string) Option {
return func(o *option) {
o.infix = infix
}
}
func withRawText() Option {
return func(o *option) {
o.rawText = true
}
}
// NewWriter returns a new Writer.
func NewWriter(writer io.Writer) *Writer {
return &Writer{
tw: tabwriter.NewWriter(writer, 1, 8, 1, ' ', tabwriter.TabIndent),
writer: writer,
}
}
// NewBufferWriter returns a new buffer Writer.
func NewBufferWriter() *Writer {
writer := bytes.NewBuffer(nil)
return &Writer{
tw: tabwriter.NewWriter(writer, 1, 8, 1, ' ', tabwriter.TabIndent),
writer: writer,
}
}
// String returns the string of the buffer.
func (w *Writer) String() string {
buffer, ok := w.writer.(*bytes.Buffer)
if !ok {
return ""
}
w.Flush()
return buffer.String()
}
// Flush flushes the buffer.
func (w *Writer) Flush() {
_ = w.tw.Flush()
}
// NewLine writes a new line.
func (w *Writer) NewLine() {
_, _ = fmt.Fprint(w.tw, NewLine)
}
// Write writes the node.
func (w *Writer) Write(opts ...Option) {
if len(opts) == 0 {
return
}
var opt = new(option)
opt.mode = ModeAuto
opt.prefix = NilIndent
opt.infix = WhiteSpace
for _, v := range opts {
v(opt)
}
w.write(opt)
}
// WriteText writes the text.
func (w *Writer) WriteText(text string) {
_, _ = fmt.Fprintf(w.tw, text)
}
func (w *Writer) write(opt *option) {
if len(opt.nodes) == 0 {
return
}
var textList []string
line := opt.nodes[0].End().Line
for idx, node := range opt.nodes {
mode := opt.mode
preIdx := idx - 1
var preNodeHasLeading bool
if preIdx > -1 && preIdx < len(opt.nodes) {
preNode := opt.nodes[preIdx]
preNodeHasLeading = preNode.HasLeadingCommentGroup()
}
if node.HasHeadCommentGroup() || preNodeHasLeading {
mode = ModeAuto
}
if mode == ModeAuto && node.Pos().Line > line {
textList = append(textList, NewLine)
}
line = node.End().Line
if util.TrimWhiteSpace(node.Format()) == "" {
continue
}
textList = append(textList, node.Format(opt.prefix))
}
text := strings.Join(textList, opt.infix)
text = strings.ReplaceAll(text, " \n", "\n")
text = strings.ReplaceAll(text, "\n ", "\n")
if opt.rawText {
_, _ = fmt.Fprint(w.writer, text)
return
}
_, _ = fmt.Fprint(w.tw, text)
}
| go | MIT | 8e7e5695eb2095917864b5d6615dab4c90bde3ac | 2026-01-07T08:36:18.042207Z | false |
zeromicro/go-zero | https://github.com/zeromicro/go-zero/blob/8e7e5695eb2095917864b5d6615dab4c90bde3ac/tools/goctl/pkg/parser/api/ast/syntaxstatement.go | tools/goctl/pkg/parser/api/ast/syntaxstatement.go | package ast
import "github.com/zeromicro/go-zero/tools/goctl/pkg/parser/api/token"
// SyntaxStmt represents a syntax statement.
type SyntaxStmt struct {
// Syntax is the syntax token.
Syntax *TokenNode
// Assign is the assign token.
Assign *TokenNode
// Value is the syntax value.
Value *TokenNode
}
func (s *SyntaxStmt) HasHeadCommentGroup() bool {
return s.Syntax.HasHeadCommentGroup()
}
func (s *SyntaxStmt) HasLeadingCommentGroup() bool {
return s.Value.HasLeadingCommentGroup()
}
func (s *SyntaxStmt) CommentGroup() (head, leading CommentGroup) {
return s.Syntax.HeadCommentGroup, s.Syntax.LeadingCommentGroup
}
func (s *SyntaxStmt) Format(prefix ...string) string {
w := NewBufferWriter()
syntaxNode := transferTokenNode(s.Syntax,
withTokenNodePrefix(prefix...), ignoreLeadingComment())
assignNode := transferTokenNode(s.Assign, ignoreLeadingComment())
w.Write(withNode(syntaxNode, assignNode, s.Value), withPrefix(prefix...), expectSameLine())
return w.String()
}
func (s *SyntaxStmt) End() token.Position {
return s.Value.End()
}
func (s *SyntaxStmt) Pos() token.Position {
return s.Syntax.Pos()
}
func (s *SyntaxStmt) stmtNode() {}
| go | MIT | 8e7e5695eb2095917864b5d6615dab4c90bde3ac | 2026-01-07T08:36:18.042207Z | false |
zeromicro/go-zero | https://github.com/zeromicro/go-zero/blob/8e7e5695eb2095917864b5d6615dab4c90bde3ac/tools/goctl/pkg/parser/api/ast/ast.go | tools/goctl/pkg/parser/api/ast/ast.go | package ast
import (
"fmt"
"io"
"strings"
"github.com/zeromicro/go-zero/tools/goctl/pkg/parser/api/token"
"github.com/zeromicro/go-zero/tools/goctl/util"
)
// Node represents a node in the AST.
type Node interface {
// Pos returns the position of the first character belonging to the node.
Pos() token.Position
// End returns the position of the first character immediately after the node.
End() token.Position
// Format returns the node's text after format.
Format(...string) string
// HasHeadCommentGroup returns true if the node has head comment group.
HasHeadCommentGroup() bool
// HasLeadingCommentGroup returns true if the node has leading comment group.
HasLeadingCommentGroup() bool
// CommentGroup returns the node's head comment group and leading comment group.
CommentGroup() (head, leading CommentGroup)
}
// Stmt represents a statement in the AST.
type Stmt interface {
Node
stmtNode()
}
// Expr represents an expression in the AST.
type Expr interface {
Node
exprNode()
}
// AST represents a parsed API file.
type AST struct {
Filename string
Stmts []Stmt
readPosition int
}
// TokenNode represents a token node in the AST.
type TokenNode struct {
// HeadCommentGroup are the comments in prev lines.
HeadCommentGroup CommentGroup
// Token is the token of the node.
Token token.Token
// LeadingCommentGroup are the tail comments in same line.
LeadingCommentGroup CommentGroup
// headFlag and leadingFlag is a comment flag only used in transfer another Node to TokenNode,
// headFlag's value is true do not represent HeadCommentGroup is not empty,
// leadingFlag's values is true do not represent LeadingCommentGroup is not empty.
headFlag, leadingFlag bool
}
// NewTokenNode creates and returns a new TokenNode.
func NewTokenNode(tok token.Token) *TokenNode {
return &TokenNode{Token: tok}
}
// IsEmptyString returns true if the node is empty string.
func (t *TokenNode) IsEmptyString() bool {
return t.Equal("")
}
// IsZeroString returns true if the node is zero string.
func (t *TokenNode) IsZeroString() bool {
return t.Equal(`""`) || t.Equal("``")
}
// Equal returns true if the node's text is equal to the given text.
func (t *TokenNode) Equal(s string) bool {
return t.Token.Text == s
}
// SetLeadingCommentGroup sets the node's leading comment group.
func (t *TokenNode) SetLeadingCommentGroup(cg CommentGroup) {
t.LeadingCommentGroup = cg
}
// RawText returns the node's raw text.
func (t *TokenNode) RawText() string {
text := t.Token.Text
if strings.HasPrefix(text, "`") {
text = strings.TrimPrefix(text, "`")
text = strings.TrimSuffix(text, "`")
} else if strings.HasPrefix(text, `"`) {
text = strings.TrimPrefix(text, `"`)
text = strings.TrimSuffix(text, `"`)
}
return text
}
func (t *TokenNode) HasLeadingCommentGroup() bool {
return t.LeadingCommentGroup.Valid() || t.leadingFlag
}
func (t *TokenNode) HasHeadCommentGroup() bool {
return t.HeadCommentGroup.Valid() || t.headFlag
}
func (t *TokenNode) CommentGroup() (head, leading CommentGroup) {
return t.HeadCommentGroup, t.LeadingCommentGroup
}
// PeekFirstLeadingComment returns the first leading comment of the node.
func (t *TokenNode) PeekFirstLeadingComment() *CommentStmt {
if len(t.LeadingCommentGroup) > 0 {
return t.LeadingCommentGroup[0]
}
return nil
}
// PeekFirstHeadComment returns the first head comment of the node.
func (t *TokenNode) PeekFirstHeadComment() *CommentStmt {
if len(t.HeadCommentGroup) > 0 {
return t.HeadCommentGroup[0]
}
return nil
}
func (t *TokenNode) Format(prefix ...string) string {
p := peekOne(prefix)
var textList []string
for _, v := range t.HeadCommentGroup {
textList = append(textList, v.Format(p))
}
var tokenText = p + t.Token.Text
var validLeadingCommentGroup CommentGroup
for _, e := range t.LeadingCommentGroup {
if util.IsEmptyStringOrWhiteSpace(e.Comment.Text) {
continue
}
validLeadingCommentGroup = append(validLeadingCommentGroup, e)
}
if len(validLeadingCommentGroup) > 0 {
tokenText = tokenText + WhiteSpace + t.LeadingCommentGroup.Join(WhiteSpace)
}
textList = append(textList, tokenText)
return strings.Join(textList, NewLine)
}
func (t *TokenNode) Pos() token.Position {
if len(t.HeadCommentGroup) > 0 {
return t.PeekFirstHeadComment().Pos()
}
return t.Token.Position
}
func (t *TokenNode) End() token.Position {
if len(t.LeadingCommentGroup) > 0 {
return t.LeadingCommentGroup[len(t.LeadingCommentGroup)-1].End()
}
return t.Token.Position
}
// Format formats the AST.
func (a *AST) Format(w io.Writer) {
fw := NewWriter(w)
defer fw.Flush()
for idx, e := range a.Stmts {
if e.Format() == NilIndent {
continue
}
fw.Write(withNode(e))
fw.NewLine()
switch e.(type) {
case *SyntaxStmt:
fw.NewLine()
case *ImportGroupStmt:
fw.NewLine()
case *ImportLiteralStmt:
if idx < len(a.Stmts)-1 {
_, ok := a.Stmts[idx+1].(*ImportLiteralStmt)
if !ok {
fw.NewLine()
}
}
case *InfoStmt:
fw.NewLine()
case *ServiceStmt:
fw.NewLine()
case *TypeGroupStmt:
fw.NewLine()
case *TypeLiteralStmt:
fw.NewLine()
case *CommentStmt:
}
}
}
// FormatForUnitTest formats the AST for unit test.
func (a *AST) FormatForUnitTest(w io.Writer) {
fw := NewWriter(w)
defer fw.Flush()
for _, e := range a.Stmts {
text := e.Format()
if text == NilIndent {
continue
}
fw.WriteText(text)
}
}
// Print prints the AST.
func (a *AST) Print() {
_ = Print(a)
}
// SyntaxError represents a syntax error.
func SyntaxError(pos token.Position, format string, v ...interface{}) error {
return fmt.Errorf("syntax error: %s %s", pos.String(), fmt.Sprintf(format, v...))
}
// DuplicateStmtError represents a duplicate statement error.
func DuplicateStmtError(pos token.Position, msg string) error {
return fmt.Errorf("duplicate declaration: %s %s", pos.String(), msg)
}
func peekOne(list []string) string {
if len(list) == 0 {
return ""
}
return list[0]
}
| go | MIT | 8e7e5695eb2095917864b5d6615dab4c90bde3ac | 2026-01-07T08:36:18.042207Z | false |
zeromicro/go-zero | https://github.com/zeromicro/go-zero/blob/8e7e5695eb2095917864b5d6615dab4c90bde3ac/tools/goctl/pkg/parser/api/ast/servicestatement.go | tools/goctl/pkg/parser/api/ast/servicestatement.go | package ast
import "github.com/zeromicro/go-zero/tools/goctl/pkg/parser/api/token"
// AtServerStmt represents @server statement.
type AtServerStmt struct {
// AtServer is the @server token.
AtServer *TokenNode
// LParen is the left parenthesis token.
LParen *TokenNode
// Values is the key-value pairs.
Values []*KVExpr
// RParen is the right parenthesis token.
RParen *TokenNode
}
func (a *AtServerStmt) HasHeadCommentGroup() bool {
return a.AtServer.HasHeadCommentGroup()
}
func (a *AtServerStmt) HasLeadingCommentGroup() bool {
return a.RParen.HasLeadingCommentGroup()
}
func (a *AtServerStmt) CommentGroup() (head, leading CommentGroup) {
return a.AtServer.HeadCommentGroup, a.RParen.LeadingCommentGroup
}
func (a *AtServerStmt) Format(prefix ...string) string {
if len(a.Values) == 0 {
return ""
}
var textList []string
for _, v := range a.Values {
if v.Value.IsZeroString() {
continue
}
textList = append(textList, v.Format())
}
if len(textList) == 0 {
return ""
}
w := NewBufferWriter()
atServerNode := transferTokenNode(a.AtServer, withTokenNodePrefix(prefix...), ignoreLeadingComment())
w.Write(withNode(atServerNode, a.LParen), expectSameLine())
w.NewLine()
for _, v := range a.Values {
node := transferNilInfixNode([]*TokenNode{v.Key, v.Colon})
node = transferTokenNode(node, withTokenNodePrefix(peekOne(prefix)+Indent), ignoreLeadingComment())
w.Write(withNode(node, v.Value), expectIndentInfix(), expectSameLine())
w.NewLine()
}
w.Write(withNode(transferTokenNode(a.RParen, withTokenNodePrefix(prefix...))))
return w.String()
}
func (a *AtServerStmt) End() token.Position {
return a.RParen.End()
}
func (a *AtServerStmt) Pos() token.Position {
return a.AtServer.Pos()
}
func (a *AtServerStmt) stmtNode() {}
type AtDocStmt interface {
Stmt
atDocNode()
}
type AtDocLiteralStmt struct {
AtDoc *TokenNode
Value *TokenNode
}
func (a *AtDocLiteralStmt) HasHeadCommentGroup() bool {
return a.AtDoc.HasHeadCommentGroup()
}
func (a *AtDocLiteralStmt) HasLeadingCommentGroup() bool {
return a.Value.HasLeadingCommentGroup()
}
func (a *AtDocLiteralStmt) CommentGroup() (head, leading CommentGroup) {
return a.AtDoc.HeadCommentGroup, a.Value.LeadingCommentGroup
}
func (a *AtDocLiteralStmt) Format(prefix ...string) string {
if a.Value.IsZeroString() {
return ""
}
w := NewBufferWriter()
atDocNode := transferTokenNode(a.AtDoc, withTokenNodePrefix(prefix...), ignoreLeadingComment())
valueNode := transferTokenNode(a.Value, ignoreHeadComment())
w.Write(withNode(atDocNode, valueNode), expectSameLine())
return w.String()
}
func (a *AtDocLiteralStmt) End() token.Position {
return a.Value.End()
}
func (a *AtDocLiteralStmt) atDocNode() {}
func (a *AtDocLiteralStmt) Pos() token.Position {
return a.AtDoc.Pos()
}
func (a *AtDocLiteralStmt) stmtNode() {}
type AtDocGroupStmt struct {
AtDoc *TokenNode
LParen *TokenNode
Values []*KVExpr
RParen *TokenNode
}
func (a *AtDocGroupStmt) HasHeadCommentGroup() bool {
return a.AtDoc.HasHeadCommentGroup()
}
func (a *AtDocGroupStmt) HasLeadingCommentGroup() bool {
return a.RParen.HasLeadingCommentGroup()
}
func (a *AtDocGroupStmt) CommentGroup() (head, leading CommentGroup) {
return a.AtDoc.HeadCommentGroup, a.RParen.LeadingCommentGroup
}
func (a *AtDocGroupStmt) Format(prefix ...string) string {
if len(a.Values) == 0 {
return ""
}
var textList []string
for _, v := range a.Values {
if v.Value.IsZeroString() {
continue
}
textList = append(textList, v.Format(peekOne(prefix)+Indent))
}
if len(textList) == 0 {
return ""
}
w := NewBufferWriter()
atDocNode := transferTokenNode(a.AtDoc, withTokenNodePrefix(prefix...), ignoreLeadingComment())
w.Write(withNode(atDocNode, a.LParen), expectSameLine())
w.NewLine()
for _, v := range a.Values {
node := transferNilInfixNode([]*TokenNode{v.Key, v.Colon})
node = transferTokenNode(node, withTokenNodePrefix(peekOne(prefix)+Indent), ignoreLeadingComment())
w.Write(withNode(node, v.Value), expectIndentInfix(), expectSameLine())
w.NewLine()
}
w.Write(withNode(transferTokenNode(a.RParen, withTokenNodePrefix(prefix...))))
return w.String()
}
func (a *AtDocGroupStmt) End() token.Position {
return a.RParen.End()
}
func (a *AtDocGroupStmt) atDocNode() {}
func (a *AtDocGroupStmt) Pos() token.Position {
return a.AtDoc.Pos()
}
func (a *AtDocGroupStmt) stmtNode() {}
type ServiceStmt struct {
AtServerStmt *AtServerStmt
Service *TokenNode
Name *ServiceNameExpr
LBrace *TokenNode
Routes []*ServiceItemStmt
RBrace *TokenNode
}
func (s *ServiceStmt) HasHeadCommentGroup() bool {
if s.AtServerStmt != nil {
return s.AtServerStmt.HasHeadCommentGroup()
}
return s.Service.HasHeadCommentGroup()
}
func (s *ServiceStmt) HasLeadingCommentGroup() bool {
return s.RBrace.HasLeadingCommentGroup()
}
func (s *ServiceStmt) CommentGroup() (head, leading CommentGroup) {
if s.AtServerStmt != nil {
head, _ = s.AtServerStmt.CommentGroup()
return head, s.RBrace.LeadingCommentGroup
}
return s.Service.HeadCommentGroup, s.RBrace.LeadingCommentGroup
}
func (s *ServiceStmt) Format(prefix ...string) string {
w := NewBufferWriter()
if s.AtServerStmt != nil {
text := s.AtServerStmt.Format()
if len(text) > 0 {
w.WriteText(text)
w.NewLine()
}
}
serviceNode := transferTokenNode(s.Service, withTokenNodePrefix(prefix...))
w.Write(withNode(serviceNode, s.Name, s.LBrace), expectSameLine())
if len(s.Routes) == 0 {
w.Write(withNode(transferTokenNode(s.RBrace, withTokenNodePrefix(prefix...))))
return w.String()
}
w.NewLine()
for idx, route := range s.Routes {
routeNode := transfer2TokenNode(route, false, withTokenNodePrefix(peekOne(prefix)+Indent))
w.Write(withNode(routeNode))
if idx < len(s.Routes)-1 {
w.NewLine()
}
}
w.Write(withNode(transferTokenNode(s.RBrace, withTokenNodePrefix(prefix...))))
return w.String()
}
func (s *ServiceStmt) End() token.Position {
return s.RBrace.End()
}
func (s *ServiceStmt) Pos() token.Position {
if s.AtServerStmt != nil {
return s.AtServerStmt.Pos()
}
return s.Service.Pos()
}
func (s *ServiceStmt) stmtNode() {}
type ServiceNameExpr struct {
Name *TokenNode
}
func (s *ServiceNameExpr) HasHeadCommentGroup() bool {
return s.Name.HasHeadCommentGroup()
}
func (s *ServiceNameExpr) HasLeadingCommentGroup() bool {
return s.Name.HasLeadingCommentGroup()
}
func (s *ServiceNameExpr) CommentGroup() (head, leading CommentGroup) {
return s.Name.HeadCommentGroup, s.Name.LeadingCommentGroup
}
func (s *ServiceNameExpr) Format(...string) string {
w := NewBufferWriter()
w.WriteText(s.Name.Format())
return w.String()
}
func (s *ServiceNameExpr) End() token.Position {
return s.Name.End()
}
func (s *ServiceNameExpr) Pos() token.Position {
return s.Name.Pos()
}
func (s *ServiceNameExpr) exprNode() {}
type AtHandlerStmt struct {
AtHandler *TokenNode
Name *TokenNode
}
func (a *AtHandlerStmt) HasHeadCommentGroup() bool {
return a.AtHandler.HasHeadCommentGroup()
}
func (a *AtHandlerStmt) HasLeadingCommentGroup() bool {
return a.Name.HasLeadingCommentGroup()
}
func (a *AtHandlerStmt) CommentGroup() (head, leading CommentGroup) {
return a.AtHandler.HeadCommentGroup, a.Name.LeadingCommentGroup
}
func (a *AtHandlerStmt) Format(prefix ...string) string {
w := NewBufferWriter()
atDocNode := transferTokenNode(a.AtHandler, withTokenNodePrefix(prefix...), ignoreLeadingComment())
nameNode := transferTokenNode(a.Name, ignoreHeadComment())
w.Write(withNode(atDocNode, nameNode), expectSameLine())
return w.String()
}
func (a *AtHandlerStmt) End() token.Position {
return a.Name.End()
}
func (a *AtHandlerStmt) Pos() token.Position {
return a.AtHandler.Pos()
}
func (a *AtHandlerStmt) stmtNode() {}
type ServiceItemStmt struct {
AtDoc AtDocStmt
AtHandler *AtHandlerStmt
Route *RouteStmt
}
func (s *ServiceItemStmt) HasHeadCommentGroup() bool {
if s.AtDoc != nil {
return s.AtDoc.HasHeadCommentGroup()
}
return s.AtHandler.HasHeadCommentGroup()
}
func (s *ServiceItemStmt) HasLeadingCommentGroup() bool {
return s.Route.HasLeadingCommentGroup()
}
func (s *ServiceItemStmt) CommentGroup() (head, leading CommentGroup) {
_, leading = s.Route.CommentGroup()
if s.AtDoc != nil {
head, _ = s.AtDoc.CommentGroup()
return head, leading
}
head, _ = s.AtHandler.CommentGroup()
return head, leading
}
func (s *ServiceItemStmt) Format(prefix ...string) string {
w := NewBufferWriter()
if s.AtDoc != nil {
w.WriteText(s.AtDoc.Format(prefix...))
w.NewLine()
}
w.WriteText(s.AtHandler.Format(prefix...))
w.NewLine()
routeNode := transfer2TokenNode(s.Route, false, withTokenNodePrefix(prefix...))
w.Write(withNode(routeNode))
w.NewLine()
return w.String()
}
func (s *ServiceItemStmt) End() token.Position {
return s.Route.End()
}
func (s *ServiceItemStmt) Pos() token.Position {
if s.AtDoc != nil {
return s.AtDoc.Pos()
}
return s.AtHandler.Pos()
}
func (s *ServiceItemStmt) stmtNode() {}
type RouteStmt struct {
Method *TokenNode
Path *PathExpr
Request *BodyStmt
Returns *TokenNode
Response *BodyStmt
}
func (r *RouteStmt) HasHeadCommentGroup() bool {
return r.Method.HasHeadCommentGroup()
}
func (r *RouteStmt) HasLeadingCommentGroup() bool {
if r.Response != nil {
return r.Response.HasLeadingCommentGroup()
} else if r.Returns != nil {
return r.Returns.HasLeadingCommentGroup()
} else if r.Request != nil {
return r.Request.HasLeadingCommentGroup()
}
return r.Path.HasLeadingCommentGroup()
}
func (r *RouteStmt) CommentGroup() (head, leading CommentGroup) {
head, _ = r.Method.CommentGroup()
if r.Response != nil {
_, leading = r.Response.CommentGroup()
} else if r.Returns != nil {
_, leading = r.Returns.CommentGroup()
} else if r.Request != nil {
_, leading = r.Request.CommentGroup()
}
return head, leading
}
func (r *RouteStmt) Format(prefix ...string) string {
w := NewBufferWriter()
methodNode := transferTokenNode(r.Method, withTokenNodePrefix(prefix...), ignoreLeadingComment())
if r.Response != nil {
if r.Response.Body == nil {
r.Response.RParen = transferTokenNode(r.Response.RParen, ignoreHeadComment())
if r.Request != nil {
w.Write(withNode(methodNode, r.Path, r.Request), expectSameLine())
} else {
w.Write(withNode(methodNode, r.Path), expectSameLine())
}
} else {
r.Response.RParen = transferTokenNode(r.Response.RParen, ignoreHeadComment())
if r.Request != nil {
w.Write(withNode(methodNode, r.Path, r.Request, r.Returns, r.Response), expectSameLine())
} else {
w.Write(withNode(methodNode, r.Path, r.Returns, r.Response), expectSameLine())
}
}
} else if r.Request != nil {
r.Request.RParen = transferTokenNode(r.Request.RParen, ignoreHeadComment())
w.Write(withNode(methodNode, r.Path, r.Request), expectSameLine())
} else {
pathNode := transferTokenNode(r.Path.Value, ignoreHeadComment())
w.Write(withNode(methodNode, pathNode), expectSameLine())
}
return w.String()
}
func (r *RouteStmt) End() token.Position {
if r.Response != nil {
return r.Response.End()
}
if r.Returns != nil {
return r.Returns.Pos()
}
if r.Request != nil {
return r.Request.End()
}
return r.Path.End()
}
func (r *RouteStmt) Pos() token.Position {
return r.Method.Pos()
}
func (r *RouteStmt) stmtNode() {}
type PathExpr struct {
Value *TokenNode
}
func (p *PathExpr) HasHeadCommentGroup() bool {
return p.Value.HasHeadCommentGroup()
}
func (p *PathExpr) HasLeadingCommentGroup() bool {
return p.Value.HasLeadingCommentGroup()
}
func (p *PathExpr) CommentGroup() (head, leading CommentGroup) {
return p.Value.CommentGroup()
}
func (p *PathExpr) Format(prefix ...string) string {
pathNode := transferTokenNode(p.Value, ignoreComment())
return pathNode.Format(prefix...)
}
func (p *PathExpr) End() token.Position {
return p.Value.End()
}
func (p *PathExpr) Pos() token.Position {
return p.Value.Pos()
}
func (p *PathExpr) exprNode() {}
type BodyStmt struct {
LParen *TokenNode
Body *BodyExpr
RParen *TokenNode
}
func (b *BodyStmt) HasHeadCommentGroup() bool {
return b.LParen.HasHeadCommentGroup()
}
func (b *BodyStmt) HasLeadingCommentGroup() bool {
return b.RParen.HasLeadingCommentGroup()
}
func (b *BodyStmt) CommentGroup() (head, leading CommentGroup) {
return b.LParen.HeadCommentGroup, b.RParen.LeadingCommentGroup
}
func (b *BodyStmt) Format(...string) string {
w := NewBufferWriter()
if b.Body == nil {
return ""
}
w.Write(withNode(b.LParen, b.Body, b.RParen), withInfix(NilIndent), expectSameLine())
return w.String()
}
func (b *BodyStmt) End() token.Position {
return b.RParen.End()
}
func (b *BodyStmt) Pos() token.Position {
return b.LParen.Pos()
}
func (b *BodyStmt) stmtNode() {}
type BodyExpr struct {
LBrack *TokenNode
RBrack *TokenNode
Star *TokenNode
Value *TokenNode
}
func (e *BodyExpr) HasHeadCommentGroup() bool {
if e.LBrack != nil {
return e.LBrack.HasHeadCommentGroup()
} else if e.Star != nil {
return e.Star.HasHeadCommentGroup()
} else {
return e.Value.HasHeadCommentGroup()
}
}
func (e *BodyExpr) HasLeadingCommentGroup() bool {
return e.Value.HasLeadingCommentGroup()
}
func (e *BodyExpr) CommentGroup() (head, leading CommentGroup) {
if e.LBrack != nil {
head = e.LBrack.HeadCommentGroup
} else if e.Star != nil {
head = e.Star.HeadCommentGroup
} else {
head = e.Value.HeadCommentGroup
}
return head, e.Value.LeadingCommentGroup
}
func (e *BodyExpr) End() token.Position {
return e.Value.End()
}
func (e *BodyExpr) Format(...string) string {
w := NewBufferWriter()
if e.LBrack != nil {
lbrackNode := transferTokenNode(e.LBrack, ignoreComment())
rbrackNode := transferTokenNode(e.RBrack, ignoreComment())
if e.Star != nil {
starNode := transferTokenNode(e.Star, ignoreComment())
w.Write(withNode(lbrackNode, rbrackNode, starNode, e.Value), withInfix(NilIndent), expectSameLine())
} else {
w.Write(withNode(lbrackNode, rbrackNode, e.Value), withInfix(NilIndent), expectSameLine())
}
} else if e.Star != nil {
starNode := transferTokenNode(e.Star, ignoreComment())
w.Write(withNode(starNode, e.Value), withInfix(NilIndent), expectSameLine())
} else {
w.Write(withNode(e.Value))
}
return w.String()
}
func (e *BodyExpr) Pos() token.Position {
if e.LBrack != nil {
return e.LBrack.Pos()
}
if e.Star != nil {
return e.Star.Pos()
}
return e.Value.Pos()
}
func (e *BodyExpr) exprNode() {}
func (e *BodyExpr) IsArrayType() bool {
return e.LBrack != nil
}
| go | MIT | 8e7e5695eb2095917864b5d6615dab4c90bde3ac | 2026-01-07T08:36:18.042207Z | false |
zeromicro/go-zero | https://github.com/zeromicro/go-zero/blob/8e7e5695eb2095917864b5d6615dab4c90bde3ac/tools/goctl/pkg/parser/api/ast/infostatement.go | tools/goctl/pkg/parser/api/ast/infostatement.go | package ast
import "github.com/zeromicro/go-zero/tools/goctl/pkg/parser/api/token"
// InfoStmt is the info statement.
type InfoStmt struct {
// Info is the info keyword.
Info *TokenNode
// LParen is the left parenthesis.
LParen *TokenNode
// Values is the info values.
Values []*KVExpr
// RParen is the right parenthesis.
RParen *TokenNode
}
func (i *InfoStmt) HasHeadCommentGroup() bool {
return i.Info.HasHeadCommentGroup()
}
func (i *InfoStmt) HasLeadingCommentGroup() bool {
return i.RParen.HasLeadingCommentGroup()
}
func (i *InfoStmt) CommentGroup() (head, leading CommentGroup) {
return i.Info.HeadCommentGroup, i.RParen.LeadingCommentGroup
}
func (i *InfoStmt) Format(prefix ...string) string {
if len(i.Values) == 0 {
return ""
}
var textList []string
for _, v := range i.Values {
if v.Value.IsZeroString() {
continue
}
textList = append(textList, v.Format(Indent))
}
if len(textList) == 0 {
return ""
}
w := NewBufferWriter()
infoNode := transferTokenNode(i.Info, withTokenNodePrefix(prefix...), ignoreLeadingComment())
w.Write(withNode(infoNode, i.LParen))
w.NewLine()
for _, v := range i.Values {
node := transferNilInfixNode([]*TokenNode{v.Key, v.Colon})
node = transferTokenNode(node, withTokenNodePrefix(peekOne(prefix)+Indent), ignoreLeadingComment())
w.Write(withNode(node, v.Value), expectIndentInfix(), expectSameLine())
w.NewLine()
}
w.Write(withNode(transferTokenNode(i.RParen, withTokenNodePrefix(prefix...))))
return w.String()
}
func (i *InfoStmt) End() token.Position {
return i.RParen.End()
}
func (i *InfoStmt) Pos() token.Position {
return i.Info.Pos()
}
func (i *InfoStmt) stmtNode() {}
| go | MIT | 8e7e5695eb2095917864b5d6615dab4c90bde3ac | 2026-01-07T08:36:18.042207Z | false |
zeromicro/go-zero | https://github.com/zeromicro/go-zero/blob/8e7e5695eb2095917864b5d6615dab4c90bde3ac/tools/goctl/pkg/parser/api/ast/importstatement.go | tools/goctl/pkg/parser/api/ast/importstatement.go | package ast
import "github.com/zeromicro/go-zero/tools/goctl/pkg/parser/api/token"
// ImportStmt represents an import statement.
type ImportStmt interface {
Stmt
importNode()
}
// ImportLiteralStmt represents an import literal statement.
type ImportLiteralStmt struct {
// Import is the import token.
Import *TokenNode
// Value is the import value.
Value *TokenNode
}
func (i *ImportLiteralStmt) HasHeadCommentGroup() bool {
return i.Import.HasHeadCommentGroup()
}
func (i *ImportLiteralStmt) HasLeadingCommentGroup() bool {
return i.Value.HasLeadingCommentGroup()
}
func (i *ImportLiteralStmt) CommentGroup() (head, leading CommentGroup) {
return i.Import.HeadCommentGroup, i.Value.LeadingCommentGroup
}
func (i *ImportLiteralStmt) Format(prefix ...string) (result string) {
if i.Value.IsZeroString() {
return ""
}
w := NewBufferWriter()
importNode := transferTokenNode(i.Import, ignoreLeadingComment(), withTokenNodePrefix(prefix...))
w.Write(withNode(importNode, i.Value), withMode(ModeExpectInSameLine))
return w.String()
}
func (i *ImportLiteralStmt) End() token.Position {
return i.Value.End()
}
func (i *ImportLiteralStmt) importNode() {}
func (i *ImportLiteralStmt) Pos() token.Position {
return i.Import.Pos()
}
func (i *ImportLiteralStmt) stmtNode() {}
type ImportGroupStmt struct {
// Import is the import token.
Import *TokenNode
// LParen is the left parenthesis token.
LParen *TokenNode
// Values is the import values.
Values []*TokenNode
// RParen is the right parenthesis token.
RParen *TokenNode
}
func (i *ImportGroupStmt) HasHeadCommentGroup() bool {
return i.Import.HasHeadCommentGroup()
}
func (i *ImportGroupStmt) HasLeadingCommentGroup() bool {
return i.RParen.HasLeadingCommentGroup()
}
func (i *ImportGroupStmt) CommentGroup() (head, leading CommentGroup) {
return i.Import.HeadCommentGroup, i.RParen.LeadingCommentGroup
}
func (i *ImportGroupStmt) Format(prefix ...string) string {
var textList []string
for _, v := range i.Values {
if v.IsZeroString() {
continue
}
textList = append(textList, v.Format(Indent))
}
if len(textList) == 0 {
return ""
}
importNode := transferTokenNode(i.Import, ignoreLeadingComment(), withTokenNodePrefix(prefix...))
w := NewBufferWriter()
w.Write(withNode(importNode, i.LParen), expectSameLine())
w.NewLine()
for _, v := range i.Values {
node := transferTokenNode(v, withTokenNodePrefix(peekOne(prefix)+Indent))
w.Write(withNode(node), expectSameLine())
w.NewLine()
}
w.Write(withNode(transferTokenNode(i.RParen, withTokenNodePrefix(prefix...))))
return w.String()
}
func (i *ImportGroupStmt) End() token.Position {
return i.RParen.End()
}
func (i *ImportGroupStmt) importNode() {}
func (i *ImportGroupStmt) Pos() token.Position {
return i.Import.Pos()
}
func (i *ImportGroupStmt) stmtNode() {}
| go | MIT | 8e7e5695eb2095917864b5d6615dab4c90bde3ac | 2026-01-07T08:36:18.042207Z | false |
zeromicro/go-zero | https://github.com/zeromicro/go-zero/blob/8e7e5695eb2095917864b5d6615dab4c90bde3ac/tools/goctl/pkg/parser/api/parser/parser.go | tools/goctl/pkg/parser/api/parser/parser.go | package parser
import (
"fmt"
"log"
"path/filepath"
"reflect"
"strings"
"github.com/zeromicro/go-zero/tools/goctl/pkg/parser/api/ast"
"github.com/zeromicro/go-zero/tools/goctl/pkg/parser/api/scanner"
"github.com/zeromicro/go-zero/tools/goctl/pkg/parser/api/token"
)
const (
idAPI = "api"
groupKeyText = "group"
infoTitleKey = "Title"
infoDescKey = "Desc"
infoVersionKey = "Version"
infoAuthorKey = "Author"
infoEmailKey = "Email"
)
// Parser is the parser for api file.
type Parser struct {
s *scanner.Scanner
errors []error
curTok token.Token
peekTok token.Token
headCommentGroup ast.CommentGroup
api *ast.AST
node map[token.Token]*ast.TokenNode
}
// New creates a new parser.
func New(filename string, src interface{}) *Parser {
abs, err := filepath.Abs(filename)
if err != nil {
log.Fatalln(err)
}
p := &Parser{
s: scanner.MustNewScanner(abs, src),
api: &ast.AST{Filename: abs},
node: make(map[token.Token]*ast.TokenNode),
}
return p
}
// Parse parses the api file.
func (p *Parser) Parse() *ast.AST {
if !p.init() {
return nil
}
for p.curTokenIsNotEof() {
stmt := p.parseStmt()
if isNil(stmt) {
return nil
}
p.appendStmt(stmt)
if !p.nextToken() {
return nil
}
}
return p.api
}
func (p *Parser) parseStmt() ast.Stmt {
switch p.curTok.Type {
case token.IDENT:
switch {
case p.curTok.Is(token.Syntax):
return p.parseSyntaxStmt()
case p.curTok.Is(token.Info):
return p.parseInfoStmt()
case p.curTok.Is(token.Service):
return p.parseService()
case p.curTok.Is(token.TypeKeyword):
return p.parseTypeStmt()
case p.curTok.Is(token.ImportKeyword):
return p.parseImportStmt()
default:
p.expectIdentError(p.curTok, token.Syntax, token.Info, token.Service, token.TYPE)
return nil
}
case token.AT_SERVER:
return p.parseService()
default:
p.errors = append(p.errors, fmt.Errorf("%s unexpected token '%s'", p.curTok.Position.String(), p.peekTok.Text))
return nil
}
}
func (p *Parser) parseService() *ast.ServiceStmt {
var stmt = &ast.ServiceStmt{}
if p.curTokenIs(token.AT_SERVER) {
atServerStmt := p.parseAtServerStmt()
if atServerStmt == nil {
return nil
}
stmt.AtServerStmt = atServerStmt
if !p.advanceIfPeekTokenIs(token.Service) {
return nil
}
}
stmt.Service = p.curTokenNode()
if !p.advanceIfPeekTokenIs(token.IDENT) {
return nil
}
// service name expr
nameExpr := p.parseServiceNameExpr()
if nameExpr == nil {
return nil
}
stmt.Name = nameExpr
// token '{'
if !p.advanceIfPeekTokenIs(token.LBRACE) {
return nil
}
stmt.LBrace = p.curTokenNode()
// service item statements
routes := p.parseServiceItemsStmt()
if routes == nil {
return nil
}
stmt.Routes = routes
// token '}'
if !p.advanceIfPeekTokenIs(token.RBRACE) {
return nil
}
stmt.RBrace = p.curTokenNode()
return stmt
}
func (p *Parser) parseServiceItemsStmt() []*ast.ServiceItemStmt {
var stmt = make([]*ast.ServiceItemStmt, 0)
for p.curTokenIsNotEof() && p.peekTokenIsNot(token.RBRACE) {
item := p.parseServiceItemStmt()
if item == nil {
return nil
}
stmt = append(stmt, item)
if p.peekTokenIs(token.RBRACE) {
break
}
if p.notExpectPeekToken(token.AT_DOC, token.AT_HANDLER, token.RBRACE) {
return nil
}
}
return stmt
}
func (p *Parser) parseServiceItemStmt() *ast.ServiceItemStmt {
var stmt = &ast.ServiceItemStmt{}
// statement @doc
if p.peekTokenIs(token.AT_DOC) {
if !p.nextToken() {
return nil
}
atDocStmt := p.parseAtDocStmt()
if atDocStmt == nil {
return nil
}
stmt.AtDoc = atDocStmt
}
// statement @handler
if !p.advanceIfPeekTokenIs(token.AT_HANDLER, token.RBRACE) {
return nil
}
if p.peekTokenIs(token.RBRACE) {
return stmt
}
atHandlerStmt := p.parseAtHandlerStmt()
if atHandlerStmt == nil {
return nil
}
stmt.AtHandler = atHandlerStmt
// statement route
route := p.parseRouteStmt()
if route == nil {
return nil
}
stmt.Route = route
return stmt
}
func (p *Parser) parseRouteStmt() *ast.RouteStmt {
var stmt = &ast.RouteStmt{}
// token http method
if !p.advanceIfPeekTokenIs(token.HttpMethods...) {
return nil
}
stmt.Method = p.curTokenNode()
// path expression
pathExpr := p.parsePathExpr()
if pathExpr == nil {
return nil
}
stmt.Path = pathExpr
if p.peekTokenIs(token.AT_DOC, token.AT_HANDLER, token.RBRACE) {
return stmt
}
if p.peekTokenIs(token.SEMICOLON) {
p.nextToken()
return stmt
}
if p.notExpectPeekToken(token.Returns, token.LPAREN) {
return nil
}
if p.peekTokenIs(token.LPAREN) {
// request expression
requestBodyStmt := p.parseBodyStmt()
if requestBodyStmt == nil {
return nil
}
stmt.Request = requestBodyStmt
}
if p.notExpectPeekToken(token.Returns, token.AT_DOC, token.AT_HANDLER, token.RBRACE, token.SEMICOLON) {
return nil
}
// token 'returns'
if p.peekTokenIs(token.Returns) {
if !p.nextToken() {
return nil
}
stmt.Returns = p.curTokenNode()
responseBodyStmt := p.parseBodyStmt()
if responseBodyStmt == nil {
return nil
}
stmt.Response = responseBodyStmt
}
if p.peekTokenIs(token.SEMICOLON) {
p.nextToken()
}
return stmt
}
func (p *Parser) parseBodyStmt() *ast.BodyStmt {
var stmt = &ast.BodyStmt{}
// token '('
if !p.advanceIfPeekTokenIs(token.LPAREN) {
return nil
}
stmt.LParen = p.curTokenNode()
// token ')'
if p.peekTokenIs(token.RPAREN) {
if !p.nextToken() {
return nil
}
stmt.RParen = p.curTokenNode()
return stmt
}
expr := p.parseBodyExpr()
if expr == nil {
return nil
}
stmt.Body = expr
// token ')'
if !p.advanceIfPeekTokenIs(token.RPAREN) {
return nil
}
stmt.RParen = p.curTokenNode()
return stmt
}
func (p *Parser) parseBodyExpr() *ast.BodyExpr {
var expr = &ast.BodyExpr{}
switch {
case p.peekTokenIs(token.LBRACK): // token '['
if !p.nextToken() {
return nil
}
expr.LBrack = p.curTokenNode()
// token ']'
if !p.advanceIfPeekTokenIs(token.RBRACK) {
return nil
}
expr.RBrack = p.curTokenNode()
switch {
case p.peekTokenIs(token.MUL):
if !p.nextToken() {
return nil
}
expr.Star = p.curTokenNode()
if !p.advanceIfPeekTokenIs(token.IDENT) {
return nil
}
expr.Value = p.curTokenNode()
return expr
case p.peekTokenIs(token.IDENT):
if !p.nextToken() {
return nil
}
expr.Value = p.curTokenNode()
return expr
default:
p.expectPeekToken(token.MUL, token.IDENT)
return nil
}
case p.peekTokenIs(token.MUL):
if !p.nextToken() {
return nil
}
expr.Star = p.curTokenNode()
if !p.advanceIfPeekTokenIs(token.IDENT) {
return nil
}
expr.Value = p.curTokenNode()
return expr
case p.peekTokenIs(token.IDENT):
if !p.nextToken() {
return nil
}
expr.Value = p.curTokenNode()
return expr
default:
p.expectPeekToken(token.LBRACK, token.MUL, token.IDENT)
return nil
}
}
func (p *Parser) parsePathExpr() *ast.PathExpr {
var expr = &ast.PathExpr{}
var values []token.Token
for p.curTokenIsNotEof() &&
p.peekTokenIsNot(token.LPAREN, token.Returns, token.AT_DOC, token.AT_HANDLER, token.SEMICOLON, token.RBRACE) {
// token '/'
if !p.advanceIfPeekTokenIs(token.QUO) {
return nil
}
values = append(values, p.curTok)
if p.peekTokenIs(token.LPAREN, token.Returns, token.AT_DOC, token.AT_HANDLER, token.SEMICOLON, token.RBRACE) {
break
}
if p.notExpectPeekTokenGotComment(p.curTokenNode().PeekFirstLeadingComment(), token.COLON, token.IDENT, token.INT) {
return nil
}
// token ':' or IDENT
if p.notExpectPeekToken(token.COLON, token.IDENT, token.INT) {
return nil
}
if p.notExpectPeekTokenGotComment(p.curTokenNode().PeekFirstLeadingComment(), token.COLON) {
return nil
}
// token ':'
if p.peekTokenIs(token.COLON) {
if !p.nextToken() {
return nil
}
values = append(values, p.curTok)
}
// path id tokens
pathTokens := p.parsePathItem()
if pathTokens == nil {
return nil
}
values = append(values, pathTokens...)
if p.notExpectPeekToken(token.QUO, token.LPAREN, token.Returns, token.AT_DOC, token.AT_HANDLER, token.SEMICOLON, token.RBRACE) {
return nil
}
}
var textList []string
for _, v := range values {
textList = append(textList, v.Text)
}
node := ast.NewTokenNode(token.Token{
Type: token.PATH,
Text: strings.Join(textList, ""),
Position: values[0].Position,
})
node.SetLeadingCommentGroup(p.curTokenNode().LeadingCommentGroup)
expr.Value = node
return expr
}
func (p *Parser) parsePathItem() []token.Token {
var list []token.Token
if !p.advanceIfPeekTokenIs(token.IDENT, token.INT) {
return nil
}
list = append(list, p.curTok)
for p.curTokenIsNotEof() &&
p.peekTokenIsNot(token.QUO, token.LPAREN, token.Returns, token.AT_DOC, token.AT_HANDLER, token.RBRACE, token.SEMICOLON, token.EOF) {
if p.peekTokenIs(token.SUB) {
if !p.nextToken() {
return nil
}
list = append(list, p.curTok)
if !p.advanceIfPeekTokenIs(token.IDENT) {
return nil
}
list = append(list, p.curTok)
} else if p.peekTokenIs(token.DOT) {
// Allow dot (.) in path segments for file extensions like .php, .html, etc.
if !p.nextToken() {
return nil
}
list = append(list, p.curTok)
// After a dot, we expect an identifier (e.g., .php, .html)
if !p.advanceIfPeekTokenIs(token.IDENT) {
return nil
}
list = append(list, p.curTok)
} else {
if p.peekTokenIs(token.LPAREN, token.Returns, token.AT_DOC, token.AT_HANDLER, token.SEMICOLON, token.RBRACE) {
return list
}
if !p.advanceIfPeekTokenIs(token.IDENT) {
return nil
}
list = append(list, p.curTok)
}
}
return list
}
func (p *Parser) parseServiceNameExpr() *ast.ServiceNameExpr {
var expr = &ast.ServiceNameExpr{}
var text = p.curTok.Text
pos := p.curTok.Position
if p.peekTokenIs(token.SUB) {
if !p.nextToken() {
return nil
}
text += p.curTok.Text
if !p.expectPeekToken(idAPI) {
return nil
}
if !p.nextToken() {
return nil
}
text += p.curTok.Text
}
node := ast.NewTokenNode(token.Token{
Type: token.IDENT,
Text: text,
Position: pos,
})
node.SetLeadingCommentGroup(p.curTokenNode().LeadingCommentGroup)
expr.Name = node
return expr
}
func (p *Parser) parseAtDocStmt() ast.AtDocStmt {
if p.notExpectPeekToken(token.LPAREN, token.STRING) {
return nil
}
if p.peekTokenIs(token.LPAREN) {
return p.parseAtDocGroupStmt()
}
return p.parseAtDocLiteralStmt()
}
func (p *Parser) parseAtDocGroupStmt() ast.AtDocStmt {
var stmt = &ast.AtDocGroupStmt{}
stmt.AtDoc = p.curTokenNode()
// token '('
if !p.advanceIfPeekTokenIs(token.LPAREN) {
return nil
}
stmt.LParen = p.curTokenNode()
for p.curTokenIsNotEof() && p.peekTokenIsNot(token.RPAREN) {
expr := p.parseKVExpression()
if expr == nil {
return nil
}
stmt.Values = append(stmt.Values, expr)
if p.notExpectPeekToken(token.RPAREN, token.IDENT) {
return nil
}
}
// token ')'
if !p.advanceIfPeekTokenIs(token.RPAREN) {
return nil
}
stmt.RParen = p.curTokenNode()
return stmt
}
func (p *Parser) parseAtDocLiteralStmt() ast.AtDocStmt {
var stmt = &ast.AtDocLiteralStmt{}
stmt.AtDoc = p.curTokenNode()
if !p.advanceIfPeekTokenIs(token.STRING) {
return nil
}
stmt.Value = p.curTokenNode()
return stmt
}
func (p *Parser) parseAtHandlerStmt() *ast.AtHandlerStmt {
var stmt = &ast.AtHandlerStmt{}
stmt.AtHandler = p.curTokenNode()
// token IDENT
if !p.advanceIfPeekTokenIs(token.IDENT) {
return nil
}
stmt.Name = p.curTokenNode()
return stmt
}
func (p *Parser) parseAtServerStmt() *ast.AtServerStmt {
var stmt = &ast.AtServerStmt{}
stmt.AtServer = p.curTokenNode()
// token '('
if !p.advanceIfPeekTokenIs(token.LPAREN) {
return nil
}
stmt.LParen = p.curTokenNode()
for p.curTokenIsNotEof() && p.peekTokenIsNot(token.RPAREN) {
expr := p.parseAtServerKVExpression()
if expr == nil {
return nil
}
stmt.Values = append(stmt.Values, expr)
if p.notExpectPeekToken(token.RPAREN, token.IDENT) {
return nil
}
}
// token ')'
if !p.advanceIfPeekTokenIs(token.RPAREN) {
return nil
}
stmt.RParen = p.curTokenNode()
return stmt
}
func (p *Parser) parseTypeStmt() ast.TypeStmt {
switch {
case p.peekTokenIs(token.LPAREN):
return p.parseTypeGroupStmt()
case p.peekTokenIs(token.IDENT):
return p.parseTypeLiteralStmt()
default:
p.expectPeekToken(token.LPAREN, token.IDENT)
return nil
}
}
func (p *Parser) parseTypeLiteralStmt() ast.TypeStmt {
var stmt = &ast.TypeLiteralStmt{}
stmt.Type = p.curTokenNode()
expr := p.parseTypeExpr()
if expr == nil {
return nil
}
stmt.Expr = expr
return stmt
}
func (p *Parser) parseTypeGroupStmt() ast.TypeStmt {
var stmt = &ast.TypeGroupStmt{}
stmt.Type = p.curTokenNode()
// token '('
if !p.nextToken() {
return nil
}
stmt.LParen = p.curTokenNode()
exprList := p.parseTypeExprList()
if exprList == nil {
return nil
}
stmt.ExprList = exprList
// token ')'
if !p.advanceIfPeekTokenIs(token.RPAREN) {
return nil
}
stmt.RParen = p.curTokenNode()
return stmt
}
func (p *Parser) parseTypeExprList() []*ast.TypeExpr {
if !p.expectPeekToken(token.IDENT, token.RPAREN) {
return nil
}
var exprList = make([]*ast.TypeExpr, 0)
for p.curTokenIsNotEof() && p.peekTokenIsNot(token.RPAREN, token.EOF) {
expr := p.parseTypeExpr()
if expr == nil {
return nil
}
exprList = append(exprList, expr)
if !p.expectPeekToken(token.IDENT, token.RPAREN) {
return nil
}
}
return exprList
}
func (p *Parser) parseTypeExpr() *ast.TypeExpr {
var expr = &ast.TypeExpr{}
// token IDENT
if !p.advanceIfPeekTokenIs(token.IDENT) {
return nil
}
if p.curTokenIsKeyword() {
return nil
}
expr.Name = p.curTokenNode()
// token '='
if p.peekTokenIs(token.ASSIGN) {
if !p.nextToken() {
return nil
}
expr.Assign = p.curTokenNode()
}
dt := p.parseDataType()
if isNil(dt) {
return nil
}
expr.DataType = dt
return expr
}
func (p *Parser) parseDataType() ast.DataType {
switch {
case p.peekTokenIs(token.Any):
return p.parseAnyDataType()
case p.peekTokenIs(token.LBRACE):
return p.parseStructDataType()
case p.peekTokenIs(token.IDENT):
if p.peekTokenIs(token.MapKeyword) {
return p.parseMapDataType()
}
if !p.nextToken() {
return nil
}
if p.curTokenIsKeyword() {
return nil
}
node := p.curTokenNode()
baseDT := &ast.BaseDataType{Base: node}
return baseDT
case p.peekTokenIs(token.LBRACK):
if !p.nextToken() {
return nil
}
switch {
case p.peekTokenIs(token.RBRACK):
return p.parseSliceDataType()
case p.peekTokenIs(token.INT, token.ELLIPSIS):
return p.parseArrayDataType()
default:
p.expectPeekToken(token.RBRACK, token.INT, token.ELLIPSIS)
return nil
}
case p.peekTokenIs(token.ANY):
return p.parseInterfaceDataType()
case p.peekTokenIs(token.MUL):
return p.parsePointerDataType()
default:
p.expectPeekToken(token.IDENT, token.LBRACK, token.ANY, token.MUL, token.LBRACE)
return nil
}
}
func (p *Parser) parseStructDataType() *ast.StructDataType {
var tp = &ast.StructDataType{}
if !p.nextToken() {
return nil
}
tp.LBrace = p.curTokenNode()
if p.notExpectPeekToken(token.IDENT, token.MUL, token.RBRACE) {
return nil
}
// ElemExprList
elems := p.parseElemExprList()
if elems == nil {
return nil
}
tp.Elements = elems
if !p.advanceIfPeekTokenIs(token.RBRACE) {
return nil
}
tp.RBrace = p.curTokenNode()
return tp
}
func (p *Parser) parseElemExprList() ast.ElemExprList {
var list = make(ast.ElemExprList, 0)
for p.curTokenIsNotEof() && p.peekTokenIsNot(token.RBRACE, token.EOF) {
if p.notExpectPeekToken(token.IDENT, token.MUL, token.RBRACE) {
return nil
}
expr := p.parseElemExpr()
if expr == nil {
return nil
}
list = append(list, expr)
if p.notExpectPeekToken(token.IDENT, token.MUL, token.RBRACE) {
return nil
}
}
return list
}
func (p *Parser) parseElemExpr() *ast.ElemExpr {
var expr = &ast.ElemExpr{}
if !p.advanceIfPeekTokenIs(token.IDENT, token.MUL) {
return nil
}
if p.curTokenIsKeyword() {
return nil
}
identNode := p.curTokenNode()
if p.curTokenIs(token.MUL) {
star := p.curTokenNode()
if !p.advanceIfPeekTokenIs(token.IDENT) {
return nil
}
var dt ast.DataType
if p.curTokenIs(token.Any) {
dt = &ast.AnyDataType{Any: p.curTokenNode()}
} else {
dt = &ast.BaseDataType{Base: p.curTokenNode()}
}
expr.DataType = &ast.PointerDataType{
Star: star,
DataType: dt,
}
} else if p.peekTok.Line() > identNode.Token.Line() || p.peekTokenIs(token.RAW_STRING) {
if p.curTokenIs(token.Any) {
expr.DataType = &ast.AnyDataType{Any: identNode}
} else {
expr.DataType = &ast.BaseDataType{Base: identNode}
}
} else {
expr.Name = append(expr.Name, identNode)
if p.notExpectPeekToken(token.COMMA, token.IDENT, token.LBRACK, token.ANY, token.MUL, token.LBRACE) {
return nil
}
for p.peekTokenIs(token.COMMA) {
if !p.nextToken() {
return nil
}
if !p.advanceIfPeekTokenIs(token.IDENT) {
return nil
}
if p.curTokenIsKeyword() {
return nil
}
expr.Name = append(expr.Name, p.curTokenNode())
}
dt := p.parseDataType()
if isNil(dt) {
return nil
}
expr.DataType = dt
}
if p.notExpectPeekToken(token.RAW_STRING, token.MUL, token.IDENT, token.RBRACE) {
return nil
}
if p.peekTokenIs(token.RAW_STRING) {
if !p.nextToken() {
return nil
}
expr.Tag = p.curTokenNode()
}
return expr
}
func (p *Parser) parseAnyDataType() *ast.AnyDataType {
var tp = &ast.AnyDataType{}
if !p.nextToken() {
return nil
}
tp.Any = p.curTokenNode()
return tp
}
func (p *Parser) parsePointerDataType() *ast.PointerDataType {
var tp = &ast.PointerDataType{}
if !p.nextToken() {
return nil
}
tp.Star = p.curTokenNode()
if p.notExpectPeekToken(token.IDENT, token.LBRACK, token.ANY, token.MUL) {
return nil
}
// DataType
dt := p.parseDataType()
if isNil(dt) {
return nil
}
tp.DataType = dt
return tp
}
func (p *Parser) parseInterfaceDataType() *ast.InterfaceDataType {
var tp = &ast.InterfaceDataType{}
if !p.nextToken() {
return nil
}
tp.Interface = p.curTokenNode()
return tp
}
func (p *Parser) parseMapDataType() *ast.MapDataType {
var tp = &ast.MapDataType{}
if !p.nextToken() {
return nil
}
tp.Map = p.curTokenNode()
// token '['
if !p.advanceIfPeekTokenIs(token.LBRACK) {
return nil
}
tp.LBrack = p.curTokenNode()
// DataType
dt := p.parseDataType()
if isNil(dt) {
return nil
}
tp.Key = dt
// token ']'
if !p.advanceIfPeekTokenIs(token.RBRACK) {
return nil
}
tp.RBrack = p.curTokenNode()
// DataType
dt = p.parseDataType()
if isNil(dt) {
return nil
}
tp.Value = dt
return tp
}
func (p *Parser) parseArrayDataType() *ast.ArrayDataType {
var tp = &ast.ArrayDataType{}
tp.LBrack = p.curTokenNode()
// token INT | ELLIPSIS
if !p.nextToken() {
return nil
}
tp.Length = p.curTokenNode()
// token ']'
if !p.advanceIfPeekTokenIs(token.RBRACK) {
return nil
}
tp.RBrack = p.curTokenNode()
// DataType
dt := p.parseDataType()
if isNil(dt) {
return nil
}
tp.DataType = dt
return tp
}
func (p *Parser) parseSliceDataType() *ast.SliceDataType {
var tp = &ast.SliceDataType{}
tp.LBrack = p.curTokenNode()
// token ']'
if !p.advanceIfPeekTokenIs(token.RBRACK) {
return nil
}
tp.RBrack = p.curTokenNode()
// DataType
dt := p.parseDataType()
if isNil(dt) {
return nil
}
tp.DataType = dt
return tp
}
func (p *Parser) parseImportStmt() ast.ImportStmt {
if p.notExpectPeekToken(token.LPAREN, token.STRING) {
return nil
}
if p.peekTokenIs(token.LPAREN) {
return p.parseImportGroupStmt()
}
return p.parseImportLiteralStmt()
}
func (p *Parser) parseImportLiteralStmt() ast.ImportStmt {
var stmt = &ast.ImportLiteralStmt{}
stmt.Import = p.curTokenNode()
// token STRING
if !p.advanceIfPeekTokenIs(token.STRING) {
return nil
}
stmt.Value = p.curTokenNode()
return stmt
}
func (p *Parser) parseImportGroupStmt() ast.ImportStmt {
var stmt = &ast.ImportGroupStmt{}
stmt.Import = p.curTokenNode()
// token '('
if !p.advanceIfPeekTokenIs(token.LPAREN) { // assert: dead code
return nil
}
stmt.LParen = p.curTokenNode()
// token STRING
for p.curTokenIsNotEof() && p.peekTokenIsNot(token.RPAREN) {
if !p.advanceIfPeekTokenIs(token.STRING) {
return nil
}
stmt.Values = append(stmt.Values, p.curTokenNode())
if p.notExpectPeekToken(token.RPAREN, token.STRING) {
return nil
}
}
// token ')'
if !p.advanceIfPeekTokenIs(token.RPAREN) {
return nil
}
stmt.RParen = p.curTokenNode()
return stmt
}
func (p *Parser) parseInfoStmt() *ast.InfoStmt {
var stmt = &ast.InfoStmt{}
stmt.Info = p.curTokenNode()
// token '('
if !p.advanceIfPeekTokenIs(token.LPAREN) {
return nil
}
stmt.LParen = p.curTokenNode()
for p.curTokenIsNotEof() && p.peekTokenIsNot(token.RPAREN) {
expr := p.parseKVExpression()
if expr == nil {
return nil
}
stmt.Values = append(stmt.Values, expr)
if p.notExpectPeekToken(token.RPAREN, token.IDENT) {
return nil
}
}
// token ')'
if !p.advanceIfPeekTokenIs(token.RPAREN) {
return nil
}
stmt.RParen = p.curTokenNode()
return stmt
}
func (p *Parser) parseAtServerKVExpression() *ast.KVExpr {
var expr = &ast.KVExpr{}
// token IDENT
if !p.advanceIfPeekTokenIs(token.IDENT, token.RPAREN) {
return nil
}
expr.Key = p.curTokenNode()
if !p.advanceIfPeekTokenIs(token.COLON) {
return nil
}
expr.Colon = p.curTokenNode()
var valueTok token.Token
var leadingCommentGroup ast.CommentGroup
if p.notExpectPeekToken(token.QUO, token.DURATION, token.IDENT, token.INT, token.STRING) {
return nil
}
if p.peekTokenIs(token.QUO) {
if !p.nextToken() {
return nil
}
slashTok := p.curTok
var pathText = slashTok.Text
if !p.advanceIfPeekTokenIs(token.IDENT) {
return nil
}
pathText += p.curTok.Text
if p.peekTokenIs(token.SUB) { // parse abc-efg format
if !p.nextToken() {
return nil
}
pathText += p.curTok.Text
if !p.advanceIfPeekTokenIs(token.IDENT) {
return nil
}
pathText += p.curTok.Text
}
valueTok = token.Token{
Text: pathText,
Position: slashTok.Position,
}
leadingCommentGroup = p.curTokenNode().LeadingCommentGroup
} else if p.peekTokenIs(token.DURATION) {
if !p.nextToken() {
return nil
}
valueTok = p.curTok
leadingCommentGroup = p.curTokenNode().LeadingCommentGroup
node := ast.NewTokenNode(valueTok)
node.SetLeadingCommentGroup(leadingCommentGroup)
expr.Value = node
return expr
} else if p.peekTokenIs(token.INT) {
if !p.nextToken() {
return nil
}
valueTok = p.curTok
leadingCommentGroup = p.curTokenNode().LeadingCommentGroup
node := ast.NewTokenNode(valueTok)
node.SetLeadingCommentGroup(leadingCommentGroup)
expr.Value = node
return expr
} else if p.peekTokenIs(token.STRING) {
if !p.nextToken() {
return nil
}
valueTok = p.curTok
leadingCommentGroup = p.curTokenNode().LeadingCommentGroup
node := ast.NewTokenNode(valueTok)
node.SetLeadingCommentGroup(leadingCommentGroup)
expr.Value = node
return expr
} else {
if !p.advanceIfPeekTokenIs(token.IDENT) {
return nil
}
valueTok = p.curTok
leadingCommentGroup = p.curTokenNode().LeadingCommentGroup
if p.peekTokenIs(token.COMMA) {
for {
if p.peekTokenIs(token.COMMA) {
if !p.nextToken() {
return nil
}
slashTok := p.curTok
if !p.advanceIfPeekTokenIs(token.IDENT) {
return nil
}
idTok := p.curTok
valueTok = token.Token{
Text: valueTok.Text + slashTok.Text + idTok.Text,
Position: valueTok.Position,
}
leadingCommentGroup = p.curTokenNode().LeadingCommentGroup
} else {
break
}
}
valueTok.Type = token.PATH
node := ast.NewTokenNode(valueTok)
node.SetLeadingCommentGroup(leadingCommentGroup)
expr.Value = node
return expr
} else if p.peekTokenIs(token.SUB) {
for {
if p.peekTokenIs(token.SUB) {
if !p.nextToken() {
return nil
}
subTok := p.curTok
if !p.advanceIfPeekTokenIs(token.IDENT) {
return nil
}
idTok := p.curTok
valueTok = token.Token{
Text: valueTok.Text + subTok.Text + idTok.Text,
Position: valueTok.Position,
}
leadingCommentGroup = p.curTokenNode().LeadingCommentGroup
} else {
break
}
}
valueTok.Type = token.PATH
node := ast.NewTokenNode(valueTok)
node.SetLeadingCommentGroup(leadingCommentGroup)
expr.Value = node
return expr
}
}
for {
if p.peekTokenIs(token.QUO) {
if !p.nextToken() {
return nil
}
slashTok := p.curTok
var pathText = valueTok.Text
pathText += slashTok.Text
if !p.advanceIfPeekTokenIs(token.IDENT) {
return nil
}
pathText += p.curTok.Text
if p.peekTokenIs(token.SUB) { // parse abc-efg format
if !p.nextToken() {
return nil
}
pathText += p.curTok.Text
if !p.advanceIfPeekTokenIs(token.IDENT) {
return nil
}
pathText += p.curTok.Text
}
valueTok = token.Token{
Text: pathText,
Position: valueTok.Position,
}
leadingCommentGroup = p.curTokenNode().LeadingCommentGroup
} else {
break
}
}
valueTok.Type = token.PATH
node := ast.NewTokenNode(valueTok)
node.SetLeadingCommentGroup(leadingCommentGroup)
expr.Value = node
return expr
}
func (p *Parser) parseKVExpression() *ast.KVExpr {
var expr = &ast.KVExpr{}
// token IDENT
if !p.advanceIfPeekTokenIs(token.IDENT) {
return nil
}
expr.Key = p.curTokenNode()
// token COLON
if !p.advanceIfPeekTokenIs(token.COLON) {
return nil
}
expr.Colon = p.curTokenNode()
// token STRING
if !p.advanceIfPeekTokenIs(token.STRING, token.RAW_STRING, token.IDENT) {
return nil
}
expr.Value = p.curTokenNode()
return expr
}
// syntax = "v1"
func (p *Parser) parseSyntaxStmt() *ast.SyntaxStmt {
var stmt = &ast.SyntaxStmt{}
stmt.Syntax = p.curTokenNode()
// token '='
if !p.advanceIfPeekTokenIs(token.ASSIGN) {
return nil
}
stmt.Assign = p.curTokenNode()
// token STRING
if !p.advanceIfPeekTokenIs(token.STRING) {
return nil
}
stmt.Value = p.curTokenNode()
return stmt
}
func (p *Parser) curTokenIsNotEof() bool {
return p.curTokenIsNot(token.EOF)
}
func (p *Parser) curTokenIsNot(expected token.Type) bool {
return p.curTok.Type != expected
}
func (p *Parser) curTokenIsKeyword() bool {
tp, ok := token.LookupKeyword(p.curTok.Text)
if ok {
p.curTokenIs()
p.expectIdentError(p.curTok.Fork(tp), token.IDENT)
return true
}
return false
}
func (p *Parser) curTokenIs(expected ...interface{}) bool {
for _, v := range expected {
switch val := v.(type) {
case token.Type:
if p.curTok.Type == val {
return true
}
case string:
if p.curTok.Text == val {
return true
}
}
}
return false
}
func (p *Parser) advanceIfPeekTokenIs(expected ...interface{}) bool {
if p.expectPeekToken(expected...) {
if !p.nextToken() {
return false
}
return true
}
return false
}
func (p *Parser) peekTokenIs(expected ...interface{}) bool {
for _, v := range expected {
switch val := v.(type) {
case token.Type:
if p.peekTok.Type == val {
return true
}
case string:
if p.peekTok.Text == val {
return true
}
}
}
return false
}
func (p *Parser) peekTokenIsNot(expected ...interface{}) bool {
for _, v := range expected {
switch val := v.(type) {
case token.Type:
if p.peekTok.Type == val {
return false
}
case string:
if p.peekTok.Text == val {
return false
}
}
}
return true
}
func (p *Parser) notExpectPeekToken(expected ...interface{}) bool {
if !p.peekTokenIsNot(expected...) {
return false
}
var expectedString []string
for _, v := range expected {
expectedString = append(expectedString, fmt.Sprintf("'%s'", v))
}
var got string
if p.peekTok.Type == token.ILLEGAL {
got = p.peekTok.Text
} else {
got = p.peekTok.Type.String()
}
var err error
if p.peekTok.Type == token.EOF {
position := p.curTok.Position
position.Column = position.Column + len(p.curTok.Text)
err = fmt.Errorf(
"%s syntax error: expected %s, got '%s'",
position,
strings.Join(expectedString, " | "),
got)
} else {
err = fmt.Errorf(
"%s syntax error: expected %s, got '%s'",
p.peekTok.Position,
strings.Join(expectedString, " | "),
got)
}
p.errors = append(p.errors, err)
return true
}
func (p *Parser) notExpectPeekTokenGotComment(actual *ast.CommentStmt, expected ...interface{}) bool {
if actual == nil {
return false
}
var expectedString []string
for _, v := range expected {
switch val := v.(type) {
case token.Token:
expectedString = append(expectedString, fmt.Sprintf("'%s'", val.Text))
default:
expectedString = append(expectedString, fmt.Sprintf("'%s'", v))
}
}
got := actual.Comment.Type.String()
p.errors = append(p.errors, fmt.Errorf(
"%s syntax error: expected %s, got '%s'",
p.peekTok.Position,
strings.Join(expectedString, " | "),
got))
return true
}
func (p *Parser) expectPeekToken(expected ...interface{}) bool {
if p.peekTokenIs(expected...) {
return true
}
var expectedString []string
for _, v := range expected {
expectedString = append(expectedString, fmt.Sprintf("'%s'", v))
}
var got string
if p.peekTok.Type == token.ILLEGAL {
got = p.peekTok.Text
} else {
got = p.peekTok.Type.String()
}
var err error
if p.peekTok.Type == token.EOF {
position := p.curTok.Position
position.Column = position.Column + len(p.curTok.Text)
err = fmt.Errorf(
"%s syntax error: expected %s, got '%s'",
position,
strings.Join(expectedString, " | "),
got)
} else {
err = fmt.Errorf(
"%s syntax error: expected %s, got '%s'",
p.peekTok.Position,
strings.Join(expectedString, " | "),
got)
}
p.errors = append(p.errors, err)
return false
}
func (p *Parser) expectIdentError(tok token.Token, expected ...interface{}) {
var expectedString []string
for _, v := range expected {
expectedString = append(expectedString, fmt.Sprintf("'%s'", v))
}
p.errors = append(p.errors, fmt.Errorf(
"%s syntax error: expected %s, got '%s'",
tok.Position,
strings.Join(expectedString, " | "),
tok.Type.String()))
}
func (p *Parser) init() bool {
if !p.nextToken() {
return false
}
return p.nextToken()
}
func (p *Parser) nextToken() bool {
var err error
p.curTok = p.peekTok
var line = -1
if p.curTok.Valid() {
if p.curTokenIs(token.EOF) {
for _, v := range p.headCommentGroup {
p.appendStmt(v)
}
p.headCommentGroup = ast.CommentGroup{}
return true
}
node := ast.NewTokenNode(p.curTok)
if p.headCommentGroup.Valid() {
node.HeadCommentGroup = append(node.HeadCommentGroup, p.headCommentGroup...)
p.headCommentGroup = ast.CommentGroup{}
}
p.node[p.curTok] = node
line = p.curTok.Line()
}
p.peekTok, err = p.s.NextToken()
if err != nil {
p.errors = append(p.errors, err)
return false
}
var leadingCommentGroup ast.CommentGroup
for p.peekTok.Type == token.COMMENT || p.peekTok.Type == token.DOCUMENT {
commentStmt := &ast.CommentStmt{Comment: p.peekTok}
if p.peekTok.Line() == line && line > -1 {
leadingCommentGroup = append(leadingCommentGroup, commentStmt)
} else {
p.headCommentGroup = append(p.headCommentGroup, commentStmt)
}
p.peekTok, err = p.s.NextToken()
if err != nil {
p.errors = append(p.errors, err)
return false
}
}
if len(leadingCommentGroup) > 0 {
p.curTokenNode().SetLeadingCommentGroup(leadingCommentGroup)
}
return true
}
func (p *Parser) curTokenNode() *ast.TokenNode {
return p.getNode(p.curTok)
}
func (p *Parser) getNode(tok token.Token) *ast.TokenNode {
return p.node[tok]
}
func isNil(v interface{}) bool {
if v == nil {
return true
}
vo := reflect.ValueOf(v)
if vo.Kind() == reflect.Ptr {
return vo.IsNil()
}
return false
}
// CheckErrors check parser errors.
func (p *Parser) CheckErrors() error {
if len(p.errors) == 0 {
return nil
}
var errors []string
for _, e := range p.errors {
errors = append(errors, e.Error())
}
return fmt.Errorf(strings.Join(errors, "\n"))
}
func (p *Parser) appendStmt(stmt ...ast.Stmt) {
p.api.Stmts = append(p.api.Stmts, stmt...)
}
func (p *Parser) hasNoErrors() bool {
return len(p.errors) == 0
}
/************************EXPERIMENTAL CODE BG************************/
// The following code block are experimental, do not call it out of unit test.
// ParseForUintTest parse the source code for unit test.
func (p *Parser) ParseForUintTest() *ast.AST {
api := &ast.AST{}
if !p.init() {
return nil
}
| go | MIT | 8e7e5695eb2095917864b5d6615dab4c90bde3ac | 2026-01-07T08:36:18.042207Z | true |
zeromicro/go-zero | https://github.com/zeromicro/go-zero/blob/8e7e5695eb2095917864b5d6615dab4c90bde3ac/tools/goctl/pkg/parser/api/parser/api.go | tools/goctl/pkg/parser/api/parser/api.go | package parser
import (
"fmt"
"path/filepath"
"strings"
"github.com/zeromicro/go-zero/core/lang"
"github.com/zeromicro/go-zero/tools/goctl/pkg/parser/api/ast"
"github.com/zeromicro/go-zero/tools/goctl/pkg/parser/api/importstack"
"github.com/zeromicro/go-zero/tools/goctl/pkg/parser/api/placeholder"
"github.com/zeromicro/go-zero/tools/goctl/pkg/parser/api/token"
)
const (
atServerGroupKey = "group"
atServerPrefixKey = "prefix"
)
// API is the parsed api file.
type API struct {
Filename string
Syntax *ast.SyntaxStmt
info *ast.InfoStmt // Info block does not participate in code generation.
importStmt []ast.ImportStmt // ImportStmt block does not participate in code generation.
TypeStmt []ast.TypeStmt
ServiceStmts []*ast.ServiceStmt
importManager *importstack.ImportStack
importSet map[string]lang.PlaceholderType
}
func convert2API(a *ast.AST, importSet map[string]lang.PlaceholderType, is *importstack.ImportStack) (*API, error) {
var api = new(API)
api.importManager = is
api.importSet = importSet
api.Filename = a.Filename
one := a.Stmts[0]
syntax, ok := one.(*ast.SyntaxStmt)
if !ok {
syntax = &ast.SyntaxStmt{
Syntax: ast.NewTokenNode(
token.Token{
Type: token.IDENT,
Text: token.Syntax,
},
),
Assign: ast.NewTokenNode(
token.Token{
Type: token.ASSIGN,
Text: "=",
},
),
Value: ast.NewTokenNode(
token.Token{
Type: token.STRING,
Text: `"v1"`,
},
),
}
}
api.Syntax = syntax
var hasSyntax, hasInfo bool
for i := 0; i < len(a.Stmts); i++ {
one := a.Stmts[i]
switch val := one.(type) {
case *ast.SyntaxStmt:
if hasSyntax {
return nil, ast.DuplicateStmtError(val.Pos(), "duplicate syntax statement")
} else {
hasSyntax = true
}
case *ast.InfoStmt:
if api.info != nil {
if hasInfo {
return nil, ast.DuplicateStmtError(val.Pos(), "duplicate info statement")
}
} else {
hasInfo = true
}
api.info = val
case ast.ImportStmt:
api.importStmt = append(api.importStmt, val)
case ast.TypeStmt:
api.TypeStmt = append(api.TypeStmt, val)
case *ast.ServiceStmt:
api.ServiceStmts = append(api.ServiceStmts, val)
}
}
return api, nil
}
func (api *API) checkImportStmt() error {
f := newFilter()
b := f.addCheckItem(api.Filename, "import value expression")
for _, v := range api.importStmt {
switch val := v.(type) {
case *ast.ImportLiteralStmt:
b.check(val.Value)
case *ast.ImportGroupStmt:
b.check(val.Values...)
}
}
return f.error()
}
func (api *API) checkInfoStmt() error {
if api.info == nil {
return nil
}
f := newFilter()
b := f.addCheckItem(api.Filename, "info key expression")
for _, v := range api.info.Values {
b.check(v.Key)
}
return f.error()
}
func (api *API) checkServiceStmt() error {
f := newFilter()
serviceNameChecker := f.addCheckItem(api.Filename, "service name expression")
handlerChecker := f.addCheckItem(api.Filename, "handler expression")
pathChecker := f.addCheckItem(api.Filename, "path expression")
var serviceName = map[string]string{}
for _, v := range api.ServiceStmts {
name := strings.TrimSuffix(v.Name.Format(""), "-api")
if sn, ok := serviceName[name]; ok {
if sn != name {
serviceNameChecker.errorManager.add(ast.SyntaxError(v.Name.Pos(), "multiple service name"))
}
} else {
serviceName[name] = name
}
var (
prefix = api.getAtServerValue(v.AtServerStmt, atServerPrefixKey)
group = api.getAtServerValue(v.AtServerStmt, atServerGroupKey)
)
for _, item := range v.Routes {
handlerChecker.checkNodeWithPrefix(group, item.AtHandler.Name)
path := fmt.Sprintf("[%s]:%s", prefix, item.Route.Format(""))
pathChecker.check(
ast.NewTokenNode(
token.Token{
Text: path,
Position: item.Route.Pos(),
},
),
)
}
}
return f.error()
}
func (api *API) checkTypeStmt() error {
f := newFilter()
b := f.addCheckItem(api.Filename, "type expression")
for _, v := range api.TypeStmt {
switch val := v.(type) {
case *ast.TypeLiteralStmt:
b.check(val.Expr.Name)
case *ast.TypeGroupStmt:
for _, expr := range val.ExprList {
b.check(expr.Name)
}
}
}
return f.error()
}
func (api *API) checkTypeDeclareContext() error {
var typeMap = map[string]placeholder.Type{}
for _, v := range api.TypeStmt {
switch tp := v.(type) {
case *ast.TypeLiteralStmt:
typeMap[tp.Expr.Name.Token.Text] = placeholder.PlaceHolder
case *ast.TypeGroupStmt:
for _, v := range tp.ExprList {
typeMap[v.Name.Token.Text] = placeholder.PlaceHolder
}
}
}
return api.checkTypeContext(typeMap)
}
func (api *API) checkTypeContext(declareContext map[string]placeholder.Type) error {
var em = newErrorManager()
for _, v := range api.TypeStmt {
switch tp := v.(type) {
case *ast.TypeLiteralStmt:
em.add(api.checkTypeExprContext(declareContext, tp.Expr.DataType))
case *ast.TypeGroupStmt:
for _, v := range tp.ExprList {
em.add(api.checkTypeExprContext(declareContext, v.DataType))
}
}
}
return em.error()
}
func (api *API) checkTypeExprContext(declareContext map[string]placeholder.Type, tp ast.DataType) error {
switch val := tp.(type) {
case *ast.ArrayDataType:
return api.checkTypeExprContext(declareContext, val.DataType)
case *ast.BaseDataType:
if IsBaseType(val.Base.Token.Text) {
return nil
}
_, ok := declareContext[val.Base.Token.Text]
if !ok {
return ast.SyntaxError(val.Base.Pos(), "unresolved type <%s>", val.Base.Token.Text)
}
return nil
case *ast.MapDataType:
var manager = newErrorManager()
manager.add(api.checkTypeExprContext(declareContext, val.Key))
manager.add(api.checkTypeExprContext(declareContext, val.Value))
return manager.error()
case *ast.PointerDataType:
return api.checkTypeExprContext(declareContext, val.DataType)
case *ast.SliceDataType:
return api.checkTypeExprContext(declareContext, val.DataType)
case *ast.StructDataType:
var manager = newErrorManager()
for _, e := range val.Elements {
manager.add(api.checkTypeExprContext(declareContext, e.DataType))
}
return manager.error()
}
return nil
}
func (api *API) getAtServerValue(atServer *ast.AtServerStmt, key string) string {
if atServer == nil {
return ""
}
for _, val := range atServer.Values {
if val.Key.Token.Text == key {
return val.Value.Token.Text
}
}
return ""
}
func (api *API) mergeAPI(in *API) error {
if api.Syntax.Value.Format() != in.Syntax.Value.Format() {
return ast.SyntaxError(
in.Syntax.Value.Pos(),
"multiple syntax value expression, expected <%s>, got <%s>",
api.Syntax.Value.Format(),
in.Syntax.Value.Format(),
)
}
api.TypeStmt = append(api.TypeStmt, in.TypeStmt...)
api.ServiceStmts = append(api.ServiceStmts, in.ServiceStmts...)
return nil
}
func (api *API) parseImportedAPI(imports []ast.ImportStmt) ([]*API, error) {
var list []*API
if len(imports) == 0 {
return list, nil
}
var importValueSet = map[string]token.Token{}
for _, imp := range imports {
switch val := imp.(type) {
case *ast.ImportLiteralStmt:
importValueSet[strings.ReplaceAll(val.Value.Token.Text, `"`, "")] = val.Value.Token
case *ast.ImportGroupStmt:
for _, v := range val.Values {
importValueSet[strings.ReplaceAll(v.Token.Text, `"`, "")] = v.Token
}
}
}
dir := filepath.Dir(api.Filename)
for impPath, tok := range importValueSet {
if !filepath.IsAbs(impPath) {
impPath = filepath.Join(dir, impPath)
}
// import cycle check
if err := api.importManager.Push(impPath); err != nil {
return nil, ast.SyntaxError(tok.Position, err.Error())
}
if _, ok := api.importSet[impPath]; ok {
api.importManager.Pop()
continue
}
api.importSet[impPath] = lang.Placeholder
p := New(impPath, "")
ast := p.Parse()
if err := p.CheckErrors(); err != nil {
return nil, err
}
nestedApi, err := convert2API(ast, api.importSet, api.importManager)
if err != nil {
return nil, err
}
if err = nestedApi.parseReverse(); err != nil {
return nil, err
}
api.importManager.Pop()
list = append(list, nestedApi)
if err != nil {
return nil, err
}
}
return list, nil
}
func (api *API) parseReverse() error {
list, err := api.parseImportedAPI(api.importStmt)
if err != nil {
return err
}
for _, e := range list {
if err = api.mergeAPI(e); err != nil {
return err
}
}
return nil
}
func (api *API) SelfCheck() error {
if err := api.parseReverse(); err != nil {
return err
}
if err := api.checkImportStmt(); err != nil {
return err
}
if err := api.checkInfoStmt(); err != nil {
return err
}
if err := api.checkTypeStmt(); err != nil {
return err
}
if err := api.checkServiceStmt(); err != nil {
return err
}
return api.checkTypeDeclareContext()
}
| go | MIT | 8e7e5695eb2095917864b5d6615dab4c90bde3ac | 2026-01-07T08:36:18.042207Z | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.