text stringlengths 14 100k | source stringclasses 1
value | repo stringclasses 810
values | language stringclasses 13
values |
|---|---|---|---|
<|fim_suffix|> name",
moduleName: "simplemodule",
expectMod: "simplemodule",
},
{
name: "empty module name uses directory",
moduleName: "",
expectMod: "", // Will be set to directory name
},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
// Create a temporary direc... | fim | zeromicro/go-zero | go |
<|fim_suffix|>, err := execRun("go list -json -m", workDir)
if err != nil {
return nil, err
}
modules, err := decodePackages(strings.NewReader(data))
if err != nil {
return nil, err
}
if workDir[len(workDir)-1] != os.PathSeparator {
workDir = workDir + string(os.PathSeparator)
}
for _, m := range modules... | fim | zeromicro/go-zero | go |
package ctx
import (
"bytes"
"go/build"
"io"
"os"
"path/filepath"
"reflect"
"strings"
"testing"
"github.com/stretchr/testify/assert"
"github.com/zeromicro/go-zero/core/stringx"
"github.com/zeromicro/go-zero/tools/goctl/rpc/execx"
"github.com/zeromicro/go-zero/tools/goctl/util/pathx"
)
func TestProjectFro... | fim | zeromicro/go-zero | go |
<|fim_prefix|>package ctx
import (
"errors"
"go/build"
"os"
"path/filepath"
"strings"
"github.com/zeromicro/g<|fim_suffix|>) {
return nil, errModuleCheck
}
wd, err := filepath.Abs(workDir)
if err != nil {
return nil, err
}
if !strings.HasPrefix(wd, goSrc) {
return nil, errModuleCheck
}
projectNa... | fim | zeromicro/go-zero | go |
<|fim_suffix|>
projectName := stringx.Rand()
dir := filepath.Join(gp, "src", projectName)
err := pathx.MkdirIfNotExist(dir)
if err != nil {
return
}
defer func() {
_ = os.RemoveAll(dir)
}()
_, err = projectFromGoPath("testPath")
assert.NotNil(t, err)
}
<|fim_prefix|>package ctx
import (
"go/build"
"os"... | fim | zeromicro/go-zero | go |
package ctx
import (
"errors"
"os"
"github.com/zeromicro/go-zero/tools/goctl/rpc/execx"
)
// UpdateGoWorkIfExist updates go work if workDir is in a go workspace
func UpdateGoWorkIfExist(workDir string) error {
if isGoWork, err := isGoWork(workDir); !isGoWork || err != nil {
return err
}
_, err := execx.Run(... | fim | zeromicro/go-zero | go |
<|fim_suffix|>assert.Nil(t, err)
}
<|fim_prefix|>package ctx
import (
"os"
"path/filepath"
"testing"
"github.com/stretchr/testify/assert"
"gith<|fim_middle|>ub.com/zeromicro/go-zero/core/stringx"
"github.com/zeromicro/go-zero/tools/goctl/rpc/execx"
"github.com/zeromicro/go-zero/tools/goctl/util/pathx"
)
func ... | fim | zeromicro/go-zero | go |
<|fim_prefix|>package ctx
import (
"errors"
"os"
<|fim_suffix|>= "/dev/null" {
return false, nil
}
return true, nil
}
<|fim_middle|>
"github.com/zeromicro/go-zero/tools/goctl/rpc/execx"
)
// IsGoMod is used to determine whether workDir is a go module project through command `go env GOMOD`
func IsGoMod(workDir... | fim | zeromicro/go-zero | go |
<|fim_prefix|>package ctx
import (
"go/build"
"os"
"path/filepath"
"testing"
"github.com/stretchr/testify/assert"
"github.com/zeromicro/go-z<|fim_suffix|>IsGoModWorkDirIsNil(t *testing.T) {
_, err := IsGoMod("")
assert.Equal(t, err.Error(), func() string {
return "the work directory is not found"
}())
}
<|... | fim | zeromicro/go-zero | go |
<|fim_prefix|>package env
import (
"os"
"os/exec"
"path/filepath"
"runtime"
"strings"
"time"
"github.com/zeromicro/go-zero/tools/goctl/vars"
)
const (
bin = "bin"
binGo = "go"
binProtoc = "protoc"
binProtocGenGo = "protoc-gen-go"
binProtocGenGrpcGo = "protoc-gen-g... | fim | zeromicro/go-zero | go |
package env
import (
"bytes"
"fmt"
"os/exec"
"runtime"
"strings"
"testing"
"github.com/stretchr/testify/assert"
"github.com/zeromicro/go-zero/tools/goctl/util/pathx"
"github.com/zeromicro/go-zero/tools/goctl/vars"
)
func TestLookUpGo(t *testing.T) {
xGo, err := LookUpGo()
if err != nil {
return
}
ass... | fim | zeromicro/go-zero | go |
<|fim_suffix|> }
if r >= 'A' && r <= 'Z' {
if buffer.Len() > 0 {
list = append(list, buffer.String())
}
buffer.Reset()
}
buffer.WriteRune(r)
}
}
func getStyle(flag string) (style, error) {
compare := strings.ToLower(flag)
switch flag {
case strings.ToLower(compare):
return lower, nil
case st... | fim | zeromicro/go-zero | go |
package format
import (
"testing"
"github.com/stretchr/testify/assert"
)
func TestSplit(t *testing.T) {
list, err := split("A")
assert.Nil(t, err)
assert.Equal(t, []string{"A"}, list)
list, err = split("goZero")
assert.Nil(t, err)
assert.Equal(t, []string{"go", "Zero"}, list)
list, err = split("Gozero")
... | fim | zeromicro/go-zero | go |
<|fim_prefix|>package util
import (
"fmt"
"os"
"os/exec"
"path/filepath"
"runtime"
"strings"
"github.com/zeromicro/go-zero/tools/goctl/util/env"
"github.com/zeromicro/go-zero/tools/goctl/util/pathx"
)
func CloneIntoGitHome(url, branch string) (dir string, err error) {
gitHome, err := pathx.GetGitHome()
if ... | fim | zeromicro/go-zero | go |
<|fim_prefix|>package util
import "github.com/zeromicro/go-zero/tools/goctl/internal/version"
const (
// DoNotEditHead added to the beginning of a file to prompt the user not to edit
DoNotEditHead = "// C<|fim_suffix|>).Execute(map[string]any{
"source": source,
"version": version.BuildVersion,
})
return buff... | fim | zeromicro/go-zero | go |
<|fim_suffix|>of stringx
func FormatFilename(filename string, style NamingStyle) string {
switch style {
case NamingCamel:
return stringx.From(filename).ToCamel()
case NamingSnake:
return stringx.From(filename).ToSnake()
default:
return strings.ToLower(stringx.From(filename).ToCamel())
}
}
<|fim_prefix|>// P... | fim | zeromicro/go-zero | go |
<|fim_prefix|>packag<|fim_suffix|>ower1")
assert.False(t, valid)
_, valid = IsNamingValid("lower")
assert.True(t, valid)
_, valid = IsNamingValid("snake")
assert.True(t, valid)
_, valid = IsNamingValid("camel")
assert.True(t, valid)
}
func TestFormatFilename(t *testing.T) {
assert.Equal(t, "abc", FormatFile... | fim | zeromicro/go-zero | go |
<|fim_prefix|>package pathx
import (
"bufio"
"crypto/md5"
"encoding/hex"
"fmt"
"io"
"io/fs"
"log"
"os"
"path/filepath"
"strings"
"github.com/gookit/color"
"github.com/zeromicro/go-zero/tools/goctl/internal/version"
)
// NL defines a new line.
const (
NL = "\n"
goctlDir = ".goctl"
g... | fim | zeromicro/go-zero | go |
<|fim_suffix|>r, gitDir)
assert.Equal(t, expected, actual)
}
func TestGetGoctlHome(t *testing.T) {
t.Run("goctl_is_file", func(t *testing.T) {
tmpFile := filepath.Join(t.TempDir(), "a.tmp")
backupTempFile := tmpFile + ".old"
err := os.WriteFile(tmpFile, nil, 0o666)
if err != nil {
return
}
RegisterGoc... | fim | zeromicro/go-zero | go |
<|fim_prefix|>package pathx
import (
"fmt"
"os"
"path"
"path/filepath"
"strings"
"github.com/zeromicro/go-zero/tools/goctl/vars"
)
const (
pkgSep = "/"
goModeIdentifier = "go.mod"
)
// JoinPackages calls strings.Join and returns
func JoinPackages(pkgs ...string) string {
return strings.Join(pkgs,... | fim | zeromicro/go-zero | go |
<|fim_prefix|>package pathx
import (
"os"
"path/filepath"
"testing"
"github.com/stretchr/testify/assert"
)
func TestReadLink(t *testing.T) {
dir, err := os.MkdirTemp("", "go-zero")
assert.Nil(t, err)
<|fim_suffix|>(err, t)
err = os.Symlink(pwd, symLink)
assertError(err, t)
t.Run("linked", func(t *testing... | fim | zeromicro/go-zero | go |
<|fim_prefix|>//go:build windows
package pathx
func ReadLin<|fim_suffix|> error) {
return name, nil
}
<|fim_middle|>k(name string) (string,<|endoftext|> | fim | zeromicro/go-zero | go |
<|fim_prefix|>//go:build linux || darwin || freebsd
package pathx
import (
"os"
"path/filepath"
)
// ReadLink returns the destination of the named symbolic link recursively.
func ReadLink(name string) (string, error) {
name, err := filepath.Abs(name)
if err != nil {
return "", err
}
if _, err := os.Lstat(na... | fim | zeromicro/go-zero | go |
<|fim_suffix|>to %q", s, r)
return r
}
func isGolangKeyword(s string) bool {
_, ok := goKeyword[s]
return ok
}
func TrimWhiteSpace(s string) string {
r := strings.NewReplacer(" ", "", "\t", "", "\n", "", "\f", "", "\r", "")
return r.Replace(s)
}
func IsEmptyStringOrWhiteSpace(s string) bool {
v := TrimWhiteSpa... | fim | zeromicro/go-zero | go |
package util
import (
"strings"
"testing"
"unicode"
"github.com/stretchr/testify/assert"
)
type data struct {
input string
expected string
}
func TestTitle(t *testing.T) {
list := []*data{
{input: "_", expected: "_"},
{input: "abc", expected: "Abc"},
{input: "ABC", expected: "ABC"},
{input: "", ex... | fim | zeromicro/go-zero | go |
<|fim_prefix|>package stringx
import (
"bytes"
"strings"
"unicode"
"golang.org/x/text/cases"
"golang.org/x/text/language"
)
var WhiteSpace = []rune{'\n', '\t', '\f', '\v', ' '}
// String provides for converting the source text into other spell case,like lower,snake,camel
type String struct {
source string
}
... | fim | zeromicro/go-zero | go |
package stringx
import (
"testing"
"github.com/stretchr/testify/assert"
)
func TestString_IsEmptyOrSpace(t *testing.T) {
cases := []struct {
input string
want bool
}{
{
want: true,
},
{
input: " ",
want: true,
},
{
input: "\t",
want: true,
},
{
input: "\n",
want: true,
... | fim | zeromicro/go-zero | go |
<|fim_suffix|> adds a template function. It returns the template instance for chaining.
// If funcName is empty or function is nil, it returns the template without modification.
func (t *DefaultTemplate) AddFunc(funcName string, function any) *DefaultTemplate {
if funcName == "" || function == nil {
return t
}
t.f... | fim | zeromicro/go-zero | go |
<|fim_suffix|>ring]()
executor.Add([]test.Data[string, string]{
{
Name: "empty",
},
{
Name: "invalid",
Input: "{foo}",
},
{
Name: "invalid",
Input: "{.foo}",
},
{
Name: "invalid",
Input: "$foo",
},
{
Name: "invalid",
Input: "{{foo}}",
},
{
Name: "invalid",
In... | fim | zeromicro/go-zero | go |
<|fim_prefix|>pa<|fim_suffix|>thub.com/zeromicro/go-zero/tools/goctl/util/pathx"
)
func Unpacking(name, destPath string, mapper func(f *zip.File) bool) error {
r, err := zip.OpenReader(name)
if err != nil {
return err
}
defer r.Close()
destAbsPath, err := filepath.Abs(destPath)
if err != nil {
return err
}... | fim | zeromicro/go-zero | go |
<|fim_suffix|>ire.NoError(t, err)
content, err := os.ReadFile(filepath.Join(dest, "hello.txt"))
assert.NoError(t, err)
assert.Equal(t, "hello world", string(content))
_, err = os.Stat(filepath.Join(dest, "skip.txt"))
assert.True(t, os.IsNotExist(err))
}
func TestUnpackingPreservesExecutablePermission(t *testing... | fim | zeromicro/go-zero | go |
<|fim_prefix|>package vars
const (
// ProjectName the const value of zero
ProjectName = "zero"
// ProjectOpenSourceURL the github url of go-zero
ProjectOpenSourceURL = "github.com/zeromicro/go-zero"
// OsWindows represents os windows
OsWindows = "windows"
// OsMac<|fim_suffix|>s os ios
OsIOS = "ios"
)
<|fim_mi... | fim | zeromicro/go-zero | go |
<|fim_prefix|>package zrpc
import (
"context"
"fmt"
"time"
"github.com/zeromicro/go-zero/core/conf"
"github.com/zeromicro/go-zero/core/logx"
"github.com/zeromicro/go-zero/zrpc/internal"
"github.com/zeromicro/go-zero/zrpc/internal/auth"
"github.com/zeromicro/go-zero/zrpc/internal/balancer/consistenthash"
"git... | fim | zeromicro/go-zero | go |
<|fim_suffix|>ClientConn, invoker grpc.UnaryInvoker, opts ...grpc.CallOption) error {
return invoker(ctx, method, req, reply, cc, opts...)
}),
)
assert.NotNil(t, err)
}
func TestNewClientWithTarget(t *testing.T) {
_, err := NewClientWithTarget("",
WithDialOption(grpc.WithTransportCredentials(insecure.NewCred... | fim | zeromicro/go-zero | go |
<|fim_prefix|>package zrpc
import (
"time"
"github.com/zeromicro/go-zero/core/discov"
"github.com/zeromicro/go-zero/core/service"
"github.com/zeromicro/go-zero/core/stores/redis"
"github.com/zeromicro/go-zero/zrpc/internal"
"github.com/zeromicro/go-zero/zrpc/resolver"
)
type (
// ClientMiddlewaresConf defines... | fim | zeromicro/go-zero | go |
<|fim_suffix|>(t, p2c.Name, conf.BalancerName)
})
}
func TestRpcServerConf(t *testing.T) {
conf := RpcServerConf{
ServiceConf: service.ServiceConf{},
ListenOn: "",
Etcd: discov.EtcdConf{
Hosts: []string{"localhost:1234"},
Key: "key",
},
Auth: true,
Redis: redis.RedisKeyConf{
RedisConf: redi... | fim | zeromicro/go-zero | go |
<|fim_prefix|>package auth
import (
"context"
"time"
"github.com/zeromicro/go-zero/core/collection"
"github.co<|fim_suffix|>ens := 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... | fim | zeromicro/go-zero | go |
<|fim_prefix|>package auth
<|fim_suffix|>und()))
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.NewIncomingCo... | fim | zeromicro/go-zero | go |
<|fim_suffix|>ens[0]
if len(app) == 0 || len(token) == 0 {
return credential
}
credential.App = app
credential.Token = token
return credential
}
<|fim_prefix|>package auth
import (
"context"
"google.golang.org/grpc/metadata"
)
// A Credential is used to authenticate.
type Credential struct {
App string... | fim | zeromicro/go-zero | go |
<|fim_prefix|>package auth
import (
"context"
"testing"
"github.com/stretchr/testify/assert"
<|fim_suffix|> test.withNil {
ctx = context.Background()
} else if test.withEmptyMd {
ctx = metadata.NewIncomingContext(context.Background(), metadata.MD{})
} else {
md := metadata.New(map[string]string{... | fim | zeromicro/go-zero | go |
<|fim_prefix|><|fim_suffix|>ccessDenied = "access denied"
missingMetadata = "app/token required"
)
<|fim_middle|>package auth
const (
appKey = "app"
tokenKey = "token"
a<|endoftext|> | fim | zeromicro/go-zero | go |
<|fim_suffix|>lable,
"[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 co... | fim | zeromicro/go-zero | go |
<|fim_suffix|>r.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 := &fakeSub... | fim | zeromicro/go-zero | go |
<|fim_prefix|>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... | fim | zeromicro/go-zero | go |
<|fim_suffix|>ncer.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.thr... | fim | zeromicro/go-zero | go |
<|fim_suffix|>ntinterceptors.DurationInterceptor)
}
if c.middlewares.Prometheus {
interceptors = append(interceptors, clientinterceptors.PrometheusInterceptor)
}
if c.middlewares.Breaker {
interceptors = append(interceptors, clientinterceptors.BreakerInterceptor)
}
if c.middlewares.Timeout {
interceptors = ... | fim | zeromicro/go-zero | go |
<|fim_suffix|> 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("chrom... | fim | zeromicro/go-zero | 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, ... | fim | zeromicro/go-zero | go |
<|fim_suffix|>estBreakerInterceptorNotFound(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) ... | fim | zeromicro/go-zero | go |
<|fim_prefix|>package<|fim_suffix|>s 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,... | fim | zeromicro/go-zero | go |
<|fim_prefix|>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"... | fim | zeromicro/go-zero | go |
<|fim_prefix|>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.... | fim | zeromicro/go-zero | go |
<|fim_suffix|> 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.Cal... | fim | zeromicro/go-zero | go |
<|fim_suffix|> }
}
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
}
<|fim_prefix|>package clientinterceptors
import (
"context"
"time"
"g... | fim | zeromicro/go-zero | go |
<|fim_prefix|>package clientinterceptors
import (
"context"
"strconv"
"sync"
"testing"
"time"
"github.com/stretchr/testify/assert"
"google.golang.org/grpc"
)
func TestTimeoutInterceptor(t *testing.T) {
timeouts := []time.D<|fim_suffix|>r := TimeoutInterceptor(tt.args.interceptorTimeout)
cc := new(grpc.Cl... | fim | zeromicro/go-zero | go |
<|fim_prefix|>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/metad... | fim | zeromicro/go-zero | 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"
... | fim | zeromicro/go-zero | go |
<|fim_prefix|>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, cod<|fim_suffix|> return false
defa... | fim | zeromicro/go-zero | go |
<|fim_prefix|>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 <|fim_suffix|>unc(t *testing.T) {
assert.Equal(t, test.accept, Accep... | fim | zeromicro/go-zero | go |
<|fim_prefix|>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:",def... | fim | zeromicro/go-zero | go |
<|fim_suffix|>r) 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 lo... | fim | zeromicro/go-zero | go |
<|fim_prefix|>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)... | fim | zeromicro/go-zero | go |
<|fim_suffix|>cd(); 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)... | fim | zeromicro/go-zero | go |
<|fim_prefix|>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,
}, "")
as... | fim | zeromicro/go-zero | go |
<|fim_prefix|>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 rpcServ... | fim | zeromicro/go-zero | go |
<|fim_suffix|>stRpcServer_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()
}
<|fim_prefi... | fim | zeromicro/go-zero | go |
<|fim_suffix|>yInterceptors = append(s.unaryInterceptors, interceptors...)
}
<|fim_prefix|>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... | fim | zeromicro/go-zero | go |
<|fim_suffix|>unc(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.... | fim | zeromicro/go-zero | 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.StreamServerI... | fim | zeromicro/go-zero | go |
<|fim_prefix|>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 TestStreamAuthorizeIntercept... | fim | zeromicro/go-zero | go |
<|fim_prefix|>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"
)
// St... | fim | zeromicro/go-zero | go |
<|fim_suffix|>default:
assert.Equal(t, context.DeadlineExceeded, err)
}
}
assert.True(t, dropped)
}
<|fim_prefix|>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... | fim | zeromicro/go-zero | go |
<|fim_suffix|>(info.FullMethod, strconv.Itoa(int(status.Code(err))))
return resp, err
}
<|fim_prefix|>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 se... | fim | zeromicro/go-zero | go |
<|fim_prefix|>package serverinterceptors
import (
"context"
"testing"
"github.com/stretchr/testify/assert"
"github.com/zeromicro/go-zero/core/prometheus"
"google.golang.org/gr<|fim_suffix|>usInterceptor(context.Background(), nil, &grpc.UnaryServerInfo{
FullMethod: "/",
}, func(ctx context.Context, req any) (a... | fim | zeromicro/go-zero | go |
<|fim_suffix|> {
logc.Errorf(ctx, "%+v\n\n%s", r, debug.Stack())
return status.Errorf(codes.Internal, "panic: %v", r)
}
<|fim_prefix|>package serverinterceptors
import (
"context"
"runtime/debug"
"github.com/zeromicro/go-zero/core/logc"
"google.golang.org/grpc"
"google.golang.org/grpc/codes"
"google.golang.or... | fim | zeromicro/go-zero | go |
<|fim_suffix|>ecoverInterceptor(context.Background(), nil, nil,
func(ctx context.Context, req any) (any, error) {
panic("mock panic")
})
assert.NotNil(t, err)
}
<|fim_prefix|>package serverinterceptors
import (
"context"
"testing"
"github.com/stretchr/testify/assert"
"github.com/zeromicro/go-zero/core/log... | fim | zeromicro/go-zero | go |
<|fim_suffix|>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... | fim | zeromicro/go-zero | go |
<|fim_suffix|>eptor(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,... | fim | zeromicro/go-zero | go |
<|fim_suffix|>hold > 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(... | fim | zeromicro/go-zero | go |
<|fim_suffix|> 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,... | fim | zeromicro/go-zero | go |
<|fim_prefix|>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 {
... | fim | zeromicro/go-zero | go |
<|fim_prefix|>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()... | fim | zeromicro/go-zero | 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... | fim | zeromicro/go-zero | go |
<|fim_prefix|>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... | fim | zeromicro/go-zero | go |
<|fim_suffix|> err != nil {
return nil, err
}
p.lock.Lock()
p.clients[key] = client
p.lock.Unlock()
return client, nil
})
if err != nil {
return nil, err
}
return val.(Client).Conn(), nil
}
<|fim_prefix|>package zrpc
import (
"context"
"sync"
"github.com/zeromicro/go-zero/core/syncx"
"github.... | fim | zeromicro/go-zero | go |
<|fim_suffix|>
proxy := NewProxy("foo", WithDialOption(grpc.WithTransportCredentials(insecure.NewCredentials())),
WithDialOption(grpc.WithBlock()))
_, err := proxy.TakeConn(context.Background())
assert.NotNil(t, err)
}
<|fim_prefix|>package zrpc
import (
"context"
"fmt"
"testing"
"github.com/stretchr/testify... | fim | zeromicro/go-zero | 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 := str... | fim | zeromicro/go-zero | go |
<|fim_prefix|>package internal
import (
"errors"
"fmt"
"net/url"
"strconv"
"strings"
"testing"
"github.com/stretchr/testify/assert"
"github.com/zeromicro/go-zero/core/lang"
"google.golang.org/grpc/resolver"
)
func TestDirectBuilder_Build(t *testing.T) {
tests := []int{
0,
1,
2,
subsetSize / 2,
su... | fim | zeromicro/go-zero | go |
<|fim_suffix|>ResolveNow(_ resolver.ResolveNowOptions) {
}
<|fim_prefix|>package internal
import (
"strings"
"github.com/zeromicro/go-zero/core/discov"
"github.com/zeromicro/go-zero/core/logx"
"github.com/zeromicro/go-zero/zrpc/resolver/internal/targets"
"google.golang.org/grpc/resolver"
)
type discovBui<|fim_m... | fim | zeromicro/go-zero | go |
<|fim_prefix|>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
as<|fim_s... | fim | zeromicro/go-zero | go |
<|fim_prefix|>package internal
type etcdBu<|fim_suffix|>me() string {
return EtcdScheme
}
<|fim_middle|>ilder struct {
discovBuilder
}
func (b *etcdBuilder) Sche<|endoftext|> | fim | zeromicro/go-zero | go |
<|fim_suffix|>e())
}
<|fim_prefix|>package internal
import (
"testing"
"github.com/stretchr/testify/a<|fim_middle|>ssert"
)
func TestEtcdBuilder_Scheme(t *testing.T) {
assert.Equal(t, EtcdScheme, new(etcdBuilder).Schem<|endoftext|> | fim | zeromicro/go-zero | go |
<|fim_prefix|>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 EventHandl... | fim | zeromicro/go-zero | go |
<|fim_suffix|> {
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: []discoveryv... | fim | zeromicro/go-zero | go |
<|fim_suffix|>oints
}
return service, nil
}
<|fim_prefix|>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... | fim | zeromicro/go-zero | go |
<|fim_prefix|>package<|fim_suffix|>},
{
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)
... | fim | zeromicro/go-zero | go |
<|fim_suffix|>ble.
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 servi... | fim | zeromicro/go-zero | go |
package internal
import (
"fmt"
"net/url"
"testing"
"github.com/stretchr/testify/assert"
"google.golang.org/grpc/resolver"
)
func TestKubeBuilder_Scheme(t *testing.T) {
var b kubeBuilder
assert.Equal(t, KubernetesScheme, b.Scheme())
}
func TestKubeBuilder_Build(t *testing.T) {
var b kubeBuilder
u, err := u... | fim | zeromicro/go-zero | go |
<|fim_prefix|>//go:build no_k8s
package internal<|fim_suffix|> direct, etcd and discov schemes to the resolver.
func RegisterResolver() {
register()
}
<|fim_middle|>
// RegisterResolver registers the<|endoftext|> | fim | zeromicro/go-zero | go |
<|fim_suffix|>ar k8sResolverBuilder kubeBuilder
// RegisterResolver registers the direct, etcd, discov and k8s schemes to the resolver.
func RegisterResolver() {
register()
resolver.Register(&k8sResolverBuilder)
}
<|fim_prefix|>//go:build !<|fim_middle|>no_k8s
package internal
import "google.golang.org/grpc/resolv... | fim | zeromicro/go-zero | go |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.