_id stringlengths 2 7 | title stringlengths 1 118 | partition stringclasses 3
values | text stringlengths 52 85.5k | language stringclasses 1
value | meta_information dict |
|---|---|---|---|---|---|
q28000 | stompHeaderToMap | train | func stompHeaderToMap(h *frame.Header) map[string]string {
m := map[string]string{}
for i := 0; i < h.Len(); i++ {
k, v := h.GetAt(i)
m[k] = v
}
return m
} | go | {
"resource": ""
} |
q28001 | defaults | train | func (r *rbroker) defaults() {
ConnectTimeout(30 * time.Second)(&r.opts)
VirtualHost("/")(&r.opts)
} | go | {
"resource": ""
} |
q28002 | NewBroker | train | func NewBroker(opts ...broker.Option) broker.Broker {
r := &rbroker{
opts: broker.Options{
Context: context.Background(),
},
}
r.Init(opts...)
return r
} | go | {
"resource": ""
} |
q28003 | finishWithError | train | func (t *tracker) finishWithError(err error, noDebugStack bool) {
if t.span == nil {
return
}
statusCode := codes.OK
finishOptions := []tracer.FinishOption{
tracer.FinishTime(time.Now()),
}
microErr, ok := err.(*microerr.Error)
if ok {
finishOptions = append(finishOptions, tracer.WithError(
fmt.Error... | go | {
"resource": ""
} |
q28004 | AuthTLS | train | func AuthTLS(t *tls.Config) client.Option {
return func(o *client.Options) {
if o.Context == nil {
o.Context = context.Background()
}
o.Context = context.WithValue(o.Context, tlsAuth{}, t)
}
} | go | {
"resource": ""
} |
q28005 | MaxRecvMsgSize | train | func MaxRecvMsgSize(s int) client.Option {
return func(o *client.Options) {
if o.Context == nil {
o.Context = context.Background()
}
o.Context = context.WithValue(o.Context, maxRecvMsgSizeKey{}, s)
}
} | go | {
"resource": ""
} |
q28006 | MaxSendMsgSize | train | func MaxSendMsgSize(s int) client.Option {
return func(o *client.Options) {
if o.Context == nil {
o.Context = context.Background()
}
o.Context = context.WithValue(o.Context, maxSendMsgSizeKey{}, s)
}
} | go | {
"resource": ""
} |
q28007 | DeduplicationFunction | train | func DeduplicationFunction(dedup StringFromMessageFunc) broker.Option {
return func(o *broker.Options) {
if o.Context == nil {
o.Context = context.Background()
}
o.Context = context.WithValue(o.Context, dedupFunctionKey{}, dedup)
}
} | go | {
"resource": ""
} |
q28008 | GroupIDFunction | train | func GroupIDFunction(groupfunc StringFromMessageFunc) broker.Option {
return func(o *broker.Options) {
if o.Context == nil {
o.Context = context.Background()
}
o.Context = context.WithValue(o.Context, groupIdFunctionKey{}, groupfunc)
}
} | go | {
"resource": ""
} |
q28009 | MaxReceiveMessages | train | func MaxReceiveMessages(max int64) broker.SubscribeOption {
return func(o *broker.SubscribeOptions) {
if o.Context == nil {
o.Context = context.Background()
}
o.Context = context.WithValue(o.Context, maxMessagesKey{}, max)
}
} | go | {
"resource": ""
} |
q28010 | VisibilityTimeout | train | func VisibilityTimeout(seconds int64) broker.SubscribeOption {
return func(o *broker.SubscribeOptions) {
if o.Context == nil {
o.Context = context.Background()
}
o.Context = context.WithValue(o.Context, visiblityTimeoutKey{}, seconds)
}
} | go | {
"resource": ""
} |
q28011 | WaitTimeSeconds | train | func WaitTimeSeconds(seconds int64) broker.SubscribeOption {
return func(o *broker.SubscribeOptions) {
if o.Context == nil {
o.Context = context.Background()
}
o.Context = context.WithValue(o.Context, waitTimeSecondsKey{}, seconds)
}
} | go | {
"resource": ""
} |
q28012 | Client | train | func Client(c *sqs.SQS) broker.Option {
return func(o *broker.Options) {
if o.Context == nil {
o.Context = context.Background()
}
o.Context = context.WithValue(o.Context, sqsClientKey{}, c)
}
} | go | {
"resource": ""
} |
q28013 | NewClientWrapper | train | func NewClientWrapper(rate int, opts ...ratelimit.Option) client.Wrapper {
r := ratelimit.New(rate, opts...)
return func(c client.Client) client.Client {
return &clientWrapper{r, c}
}
} | go | {
"resource": ""
} |
q28014 | NewHandlerWrapper | train | func NewHandlerWrapper(rate int, opts ...ratelimit.Option) server.HandlerWrapper {
r := ratelimit.New(rate, opts...)
return func(h server.HandlerFunc) server.HandlerFunc {
return func(ctx context.Context, req server.Request, rsp interface{}) error {
r.Take()
return h(ctx, req, rsp)
}
}
} | go | {
"resource": ""
} |
q28015 | NewClientWrapper | train | func NewClientWrapper() client.Wrapper {
return func(c client.Client) client.Client {
return &roundrobin{
rr: make(map[string]int),
Client: c,
}
}
} | go | {
"resource": ""
} |
q28016 | complete | train | func complete(s *awsxray.Segment, status int) {
switch {
case status >= 500:
s.Fault = true
case status >= 400:
s.Error = true
}
s.HTTP.Response.Status = status
s.EndTime = float64(time.Now().Truncate(time.Millisecond).UnixNano()) / 1e9
} | go | {
"resource": ""
} |
q28017 | getIp | train | func getIp(r *http.Request) string {
for _, h := range []string{"X-Forwarded-For", "X-Real-Ip"} {
for _, ip := range strings.Split(r.Header.Get(h), ",") {
if len(ip) == 0 {
continue
}
realIP := net.ParseIP(strings.Replace(ip, " ", "", -1))
return realIP.String()
}
}
// not found in header
host,... | go | {
"resource": ""
} |
q28018 | newHTTP | train | func newHTTP(r *http.Request) *awsxray.HTTP {
scheme := "http"
host := r.Host
if len(r.URL.Scheme) > 0 {
scheme = r.URL.Scheme
}
if len(r.URL.Host) > 0 {
host = r.URL.Host
}
return &awsxray.HTTP{
Request: &awsxray.Request{
Method: r.Method,
URL: fmt.Sprintf("%s://%s%s", scheme, host, r.UR... | go | {
"resource": ""
} |
q28019 | newSegment | train | func newSegment(name string, r *http.Request) *awsxray.Segment {
// attempt to get IDs first
parentId := getParentId(r.Header)
traceId := getTraceId(r.Header)
// now set the trace ID
traceHdr := r.Header.Get(awsxray.TraceHeader)
traceHdr = awsxray.SetTraceId(traceHdr, traceId)
// create segment
s := &awsxray.... | go | {
"resource": ""
} |
q28020 | NewClientWrapper | train | func NewClientWrapper() client.Wrapper {
return func(c client.Client) client.Client {
w := &clientWrapper{}
w.bs = gobreaker.Settings{}
w.cbs = make(map[string]*gobreaker.TwoStepCircuitBreaker)
w.Client = c
return w
}
} | go | {
"resource": ""
} |
q28021 | NewCustomClientWrapper | train | func NewCustomClientWrapper(bs gobreaker.Settings, bm BreakerMethod) client.Wrapper {
return func(c client.Client) client.Client {
w := &clientWrapper{}
w.bm = bm
w.bs = bs
w.cbs = make(map[string]*gobreaker.TwoStepCircuitBreaker)
w.Client = c
return w
}
} | go | {
"resource": ""
} |
q28022 | Call | train | func (w *clientWrapper) Call(
ctx context.Context,
req client.Request,
rsp interface{},
opts ...client.CallOption) (err error) {
t := newRequestTracker(req, ClientProfile)
ctx = t.start(ctx, true)
defer func() { t.end(ctx, err) }()
ctx = injectTraceIntoCtx(ctx, t.span)
err = w.Client.Call(ctx, req, rsp, opt... | go | {
"resource": ""
} |
q28023 | Publish | train | func (w *clientWrapper) Publish(ctx context.Context, p client.Message, opts ...client.PublishOption) (err error) {
t := newPublicationTracker(p, ClientProfile)
ctx = t.start(ctx, true)
defer func() { t.end(ctx, err) }()
ctx = injectTraceIntoCtx(ctx, t.span)
err = w.Client.Publish(ctx, p, opts...)
return
} | go | {
"resource": ""
} |
q28024 | NewHandlerWrapper | train | func NewHandlerWrapper() server.HandlerWrapper {
return func(fn server.HandlerFunc) server.HandlerFunc {
return func(ctx context.Context, req server.Request, rsp interface{}) (err error) {
t := newRequestTracker(req, ServerProfile)
ctx = t.start(ctx, false)
defer func() { t.end(ctx, err) }()
spanCtx :=... | go | {
"resource": ""
} |
q28025 | NewSubscriberWrapper | train | func NewSubscriberWrapper() server.SubscriberWrapper {
return func(fn server.SubscriberFunc) server.SubscriberFunc {
return func(ctx context.Context, p server.Message) (err error) {
t := newPublicationTracker(p, ServerProfile)
ctx = t.start(ctx, false)
defer func() { t.end(ctx, err) }()
spanCtx := getT... | go | {
"resource": ""
} |
q28026 | Publish | train | func (b *pubsubBroker) Publish(topic string, msg *broker.Message, opts ...broker.PublishOption) error {
t := b.client.Topic(topic)
ctx := context.Background()
exists, err := t.Exists(ctx)
if err != nil {
return err
}
if !exists {
tt, err := b.client.CreateTopic(ctx, topic)
if err != nil {
return err
... | go | {
"resource": ""
} |
q28027 | Subscribe | train | func (b *pubsubBroker) Subscribe(topic string, h broker.Handler, opts ...broker.SubscribeOption) (broker.Subscriber, error) {
options := broker.SubscribeOptions{
AutoAck: true,
Queue: "q-" + uuid.New().String(),
Context: b.options.Context,
}
for _, o := range opts {
o(&options)
}
ctx := context.Backgro... | go | {
"resource": ""
} |
q28028 | NewBroker | train | func NewBroker(opts ...broker.Option) broker.Broker {
options := broker.Options{
Context: context.Background(),
}
for _, o := range opts {
o(&options)
}
// retrieve project id
prjID, _ := options.Context.Value(projectIDKey{}).(string)
// retrieve client opts
cOpts, _ := options.Context.Value(clientOptionK... | go | {
"resource": ""
} |
q28029 | Options | train | func Options(opts ...grpc.ServerOption) server.Option {
return func(o *server.Options) {
if o.Context == nil {
o.Context = context.Background()
}
o.Context = context.WithValue(o.Context, grpcOptions{}, opts)
}
} | go | {
"resource": ""
} |
q28030 | MaxMsgSize | train | func MaxMsgSize(s int) server.Option {
return func(o *server.Options) {
if o.Context == nil {
o.Context = context.Background()
}
o.Context = context.WithValue(o.Context, maxMsgSizeKey{}, s)
}
} | go | {
"resource": ""
} |
q28031 | NewSelector | train | func NewSelector(keys []string) selector.SelectOption {
return selector.WithStrategy(func(services []*registry.Service) selector.Next {
return Next(keys, services)
})
} | go | {
"resource": ""
} |
q28032 | Next | train | func Next(keys []string, services []*registry.Service) selector.Next {
possibleNodes, scores := ScoreNodes(keys, services)
return func() (*registry.Node, error) {
var best uint64
pos := -1
// Find the best scoring node from those available.
for i, score := range scores {
if score >= best && possibleNodes... | go | {
"resource": ""
} |
q28033 | ScoreNodes | train | func ScoreNodes(keys []string, services []*registry.Service) (possibleNodes []*registry.Node, scores []uint64) {
// Generate a base hashing key based off the supplied keys values.
key := highwayhash.Sum([]byte(strings.Join(keys, ":")), zeroKey[:])
// Get all the possible nodes for the services, and assign a hash-ba... | go | {
"resource": ""
} |
q28034 | ReadHeader | train | func (c *msgpackCodec) ReadHeader(m *codec.Message, mt codec.MessageType) error {
c.mt = mt
switch mt {
case codec.Request:
var h Request
if err := msgp.Decode(c.rwc, &h); err != nil {
return err
}
c.body = h.hasBody
m.Id = h.ID
m.Endpoint = h.Method
case codec.Response:
var h Response
if er... | go | {
"resource": ""
} |
q28035 | ReadBody | train | func (c *msgpackCodec) ReadBody(v interface{}) error {
if !c.body {
return nil
}
r := msgp.NewReader(c.rwc)
// Body is present, but no value to decode into.
if v == nil {
return r.Skip()
}
switch c.mt {
case codec.Request, codec.Response, codec.Publication:
return decodeBody(r, v)
default:
return fm... | go | {
"resource": ""
} |
q28036 | Write | train | func (c *msgpackCodec) Write(m *codec.Message, b interface{}) error {
switch m.Type {
case codec.Request:
h := Request{
ID: m.Id,
Method: m.Endpoint,
Body: b,
}
return msgp.Encode(c.rwc, &h)
case codec.Response:
h := Response{
ID: m.Id,
Body: b,
}
h.Error = m.Error
return msg... | go | {
"resource": ""
} |
q28037 | NewError | train | func NewError(code int, message string) *Error {
return &Error{Code: code, Message: message}
} | go | {
"resource": ""
} |
q28038 | newError | train | func newError(message string) *Error {
switch {
case strings.HasPrefix(message, "rpc: service/method request ill-formed"):
return NewError(errMethod.Code, message)
case strings.HasPrefix(message, "rpc: can't find service"):
return NewError(errMethod.Code, message)
case strings.HasPrefix(message, "rpc: can't fin... | go | {
"resource": ""
} |
q28039 | Error | train | func (e *Error) Error() string {
buf, err := json.Marshal(e)
if err != nil {
msg, err := json.Marshal(err.Error())
if err != nil {
msg = []byte(`"` + errServerError.Message + `"`)
}
return fmt.Sprintf(`{"code":%d,"message":%s}`, errServerError.Code, string(msg))
}
return string(buf)
} | go | {
"resource": ""
} |
q28040 | serviceName | train | func serviceName(name string) string {
aname := make([]byte, len(name))
for i, r := range []byte(name) {
if !labelRe.Match([]byte{r}) {
aname[i] = '_'
continue
}
aname[i] = r
}
return string(aname)
} | go | {
"resource": ""
} |
q28041 | Init | train | func (c *kregistry) Init(opts ...registry.Option) error {
return configure(c, opts...)
} | go | {
"resource": ""
} |
q28042 | Register | train | func (c *kregistry) Register(s *registry.Service, opts ...registry.RegisterOption) error {
if len(s.Nodes) == 0 {
return errors.New("you must register at least one node")
}
// TODO: grab podname from somewhere better than this.
podName := os.Getenv("HOSTNAME")
svcName := s.Name
// encode micro service
b, err... | go | {
"resource": ""
} |
q28043 | Deregister | train | func (c *kregistry) Deregister(s *registry.Service) error {
if len(s.Nodes) == 0 {
return errors.New("you must deregister at least one node")
}
// TODO: grab podname from somewhere better than this.
podName := os.Getenv("HOSTNAME")
svcName := s.Name
pod := &client.Pod{
Metadata: &client.Meta{
Labels: map... | go | {
"resource": ""
} |
q28044 | GetService | train | func (c *kregistry) GetService(name string) ([]*registry.Service, error) {
pods, err := c.client.ListPods(map[string]string{
svcSelectorPrefix + serviceName(name): svcSelectorValue,
})
if err != nil {
return nil, err
}
if len(pods.Items) == 0 {
return nil, registry.ErrNotFound
}
// svcs mapped by version... | go | {
"resource": ""
} |
q28045 | ListServices | train | func (c *kregistry) ListServices() ([]*registry.Service, error) {
pods, err := c.client.ListPods(podSelector)
if err != nil {
return nil, err
}
// svcs mapped by name
svcs := make(map[string]bool)
for _, pod := range pods.Items {
if pod.Status.Phase != podRunning {
continue
}
for k, v := range pod.Me... | go | {
"resource": ""
} |
q28046 | Watch | train | func (c *kregistry) Watch(opts ...registry.WatchOption) (registry.Watcher, error) {
return newWatcher(c, opts...)
} | go | {
"resource": ""
} |
q28047 | NewRegistry | train | func NewRegistry(opts ...registry.Option) registry.Registry {
k := &kregistry{
options: registry.Options{},
}
configure(k, opts...)
return k
} | go | {
"resource": ""
} |
q28048 | CheckPrefixFactory | train | func CheckPrefixFactory(prefixes ...string) func(string) (string, bool) {
return func(content string) (string, bool) {
for _, prefix := range prefixes {
if strings.HasPrefix(content, prefix) {
return strings.TrimPrefix(content, prefix), true
}
}
return "", false
}
} | go | {
"resource": ""
} |
q28049 | Stop | train | func (wr *bodyWatcher) Stop() {
select {
case <-wr.stop:
return
default:
close(wr.stop)
close(wr.results)
}
} | go | {
"resource": ""
} |
q28050 | NewBodyWatcher | train | func NewBodyWatcher(req *http.Request, client *http.Client) (Watch, error) {
stop := make(chan struct{})
req.Cancel = stop
res, err := client.Do(req)
if err != nil {
return nil, err
}
wr := &bodyWatcher{
results: make(chan Event),
stop: stop,
req: req,
res: res,
}
go wr.stream()
return ... | go | {
"resource": ""
} |
q28051 | NewBroker | train | func NewBroker(opts ...broker.Option) broker.Broker {
options := broker.Options{
Context: context.Background(),
}
for _, o := range opts {
o(&options)
}
var openTopic topicOpener
var openSub subOpener
var err error
if projID, ok := options.Context.Value(gcpProjectIDKey{}).(gcp.ProjectID); ok {
ts := opti... | go | {
"resource": ""
} |
q28052 | Publish | train | func (b *pubsubBroker) Publish(topic string, msg *broker.Message, opts ...broker.PublishOption) error {
if b.err != nil {
return b.err
}
t := b.topic(topic)
return t.Send(context.Background(), &pubsub.Message{Metadata: msg.Header, Body: msg.Body})
} | go | {
"resource": ""
} |
q28053 | topic | train | func (b *pubsubBroker) topic(name string) *pubsub.Topic {
b.mu.Lock()
defer b.mu.Unlock()
t := b.topics[name]
if t == nil {
t = b.openTopic(name)
b.topics[name] = t
}
return t
} | go | {
"resource": ""
} |
q28054 | NewClientWrapper | train | func NewClientWrapper(ot opentracing.Tracer) client.Wrapper {
return func(c client.Client) client.Client {
if ot == nil {
ot = opentracing.GlobalTracer()
}
return &otWrapper{ot, c}
}
} | go | {
"resource": ""
} |
q28055 | NewCallWrapper | train | func NewCallWrapper(ot opentracing.Tracer) client.CallWrapper {
return func(cf client.CallFunc) client.CallFunc {
return func(ctx context.Context, node *registry.Node, req client.Request, rsp interface{}, opts client.CallOptions) error {
if ot == nil {
ot = opentracing.GlobalTracer()
}
name := fmt.Sprin... | go | {
"resource": ""
} |
q28056 | NewHandlerWrapper | train | func NewHandlerWrapper(ot opentracing.Tracer) server.HandlerWrapper {
return func(h server.HandlerFunc) server.HandlerFunc {
return func(ctx context.Context, req server.Request, rsp interface{}) error {
if ot == nil {
ot = opentracing.GlobalTracer()
}
name := fmt.Sprintf("%s.%s", req.Service(), req.Endp... | go | {
"resource": ""
} |
q28057 | NewSubscriberWrapper | train | func NewSubscriberWrapper(ot opentracing.Tracer) server.SubscriberWrapper {
return func(next server.SubscriberFunc) server.SubscriberFunc {
return func(ctx context.Context, msg server.Message) error {
name := "Pub to " + msg.Topic()
if ot == nil {
ot = opentracing.GlobalTracer()
}
ctx, span, err := S... | go | {
"resource": ""
} |
q28058 | NewClientWrapper | train | func NewClientWrapper(b *ratelimit.Bucket, wait bool) client.Wrapper {
fn := limit(b, wait, "go.micro.client")
return func(c client.Client) client.Client {
return &clientWrapper{fn, c}
}
} | go | {
"resource": ""
} |
q28059 | NewHandlerWrapper | train | func NewHandlerWrapper(b *ratelimit.Bucket, wait bool) server.HandlerWrapper {
fn := limit(b, wait, "go.micro.server")
return func(h server.HandlerFunc) server.HandlerFunc {
return func(ctx context.Context, req server.Request, rsp interface{}) error {
if err := fn(); err != nil {
return err
}
return h... | go | {
"resource": ""
} |
q28060 | WithClient | train | func WithClient(x *xray.XRay) Option {
return func(o *Options) {
o.Client = x
}
} | go | {
"resource": ""
} |
q28061 | end | train | func (t *tracker) end(ctx context.Context, err error) {
status := getResponseStatus(err)
ctx, _ = tag.New(ctx, tag.Upsert(StatusCode, strconv.Itoa(int(status.Code))))
stats.Record(ctx, t.profile.LatencyMeasure.M(float64(time.Since(t.startedAt))/float64(time.Millisecond)))
if t.span != nil {
t.span.SetStatus(sta... | go | {
"resource": ""
} |
q28062 | serviceToInstance | train | func serviceToInstance(service *registry.Service) (*fargo.Instance, error) {
if len(service.Nodes) == 0 {
return nil, errors.New("Require nodes")
}
node := service.Nodes[0]
instance := &fargo.Instance{
App: service.Name,
HostName: node.Address,
IPAddr: node.Address,
VipAdd... | go | {
"resource": ""
} |
q28063 | updateCache | train | func (k *k8sWatcher) updateCache() ([]*registry.Result, error) {
podList, err := k.registry.client.ListPods(podSelector)
if err != nil {
return nil, err
}
k.RLock()
k.RUnlock()
var results []*registry.Result
for _, pod := range podList.Items {
rslts := k.buildPodResults(&pod, nil)
for _, r := range rsl... | go | {
"resource": ""
} |
q28064 | buildPodResults | train | func (k *k8sWatcher) buildPodResults(pod *client.Pod, cache *client.Pod) []*registry.Result {
var results []*registry.Result
ignore := make(map[string]bool)
if pod.Metadata != nil {
for ak, av := range pod.Metadata.Annotations {
// check this annotation kv is a service notation
if !strings.HasPrefix(ak, ann... | go | {
"resource": ""
} |
q28065 | handleEvent | train | func (k *k8sWatcher) handleEvent(event watch.Event) {
var pod client.Pod
if err := json.Unmarshal([]byte(event.Object), &pod); err != nil {
log.Log("K8s Watcher: Couldnt unmarshal event object from pod")
return
}
switch event.Type {
case watch.Modified:
// Pod was modified
k.RLock()
cache := k.pods[pod... | go | {
"resource": ""
} |
q28066 | Next | train | func (k *k8sWatcher) Next() (*registry.Result, error) {
r, ok := <-k.next
if !ok {
return nil, errors.New("result chan closed")
}
return r, nil
} | go | {
"resource": ""
} |
q28067 | Stop | train | func (k *k8sWatcher) Stop() {
k.watcher.Stop()
select {
case <-k.next:
return
default:
close(k.next)
}
} | go | {
"resource": ""
} |
q28068 | NewClientWrapper | train | func NewClientWrapper() client.Wrapper {
return func(c client.Client) client.Client {
return &ddWrapper{c}
}
} | go | {
"resource": ""
} |
q28069 | NewCallWrapper | train | func NewCallWrapper() client.CallWrapper {
return func(cf client.CallFunc) client.CallFunc {
return func(ctx context.Context, node *registry.Node, req client.Request, rsp interface{}, opts client.CallOptions) error {
t := newRequestTracker(req, ClientProfile)
ctx = t.StartSpanFromContext(ctx)
defer func() ... | go | {
"resource": ""
} |
q28070 | NewHandlerWrapper | train | func NewHandlerWrapper() server.HandlerWrapper {
return func(h server.HandlerFunc) server.HandlerFunc {
return func(ctx context.Context, req server.Request, rsp interface{}) (err error) {
if req.Endpoint() != "Debug.Health" {
t := newRequestTracker(req, ServerProfile)
ctx = t.StartSpanFromContext(ctx)
... | go | {
"resource": ""
} |
q28071 | NewSubscriberWrapper | train | func NewSubscriberWrapper() server.SubscriberWrapper {
return func(next server.SubscriberFunc) server.SubscriberFunc {
return func(ctx context.Context, msg server.Message) (err error) {
t := newPublicationTracker(msg, ServerProfile)
ctx = t.StartSpanFromContext(ctx)
defer func() {
t.finishWithError(err,... | go | {
"resource": ""
} |
q28072 | Into | train | func (r *Response) Into(data interface{}) error {
if r.err != nil {
return r.err
}
defer r.res.Body.Close()
decoder := json.NewDecoder(r.res.Body)
err := decoder.Decode(&data)
if err != nil {
return ErrDecode
}
return r.err
} | go | {
"resource": ""
} |
q28073 | Options | train | func Options(nopts nats.Options) registry.Option {
return func(o *registry.Options) {
if o.Context == nil {
o.Context = context.Background()
}
o.Context = context.WithValue(o.Context, optionsKey{}, nopts)
}
} | go | {
"resource": ""
} |
q28074 | NewClientByHost | train | func NewClientByHost(host string) Kubernetes {
tr := &http.Transport{
TLSClientConfig: &tls.Config{
InsecureSkipVerify: true,
},
DisableCompression: true,
}
c := &http.Client{
Transport: tr,
}
return &client{
opts: &api.Options{
Client: c,
Host: host,
Namespace: "default",
},
}
} | go | {
"resource": ""
} |
q28075 | NewClientInCluster | train | func NewClientInCluster() Kubernetes {
host := "https://" + os.Getenv("KUBERNETES_SERVICE_HOST") + ":" + os.Getenv("KUBERNETES_SERVICE_PORT")
s, err := os.Stat(serviceAccountPath)
if err != nil {
log.Fatal(err)
}
if s == nil || !s.IsDir() {
log.Fatal(errors.New("no k8s service account found"))
}
token, err... | go | {
"resource": ""
} |
q28076 | Outbound | train | func (Stats *Stats) Outbound(ctx context.Context, in []byte) ([]byte, error) {
Stats.outboundBytes += len(in)
return in, nil
} | go | {
"resource": ""
} |
q28077 | Inbound | train | func (Stats *Stats) Inbound(ctx context.Context, in []byte) ([]byte, error) {
Stats.inboundBytes += len(in)
return in, nil
} | go | {
"resource": ""
} |
q28078 | MessageRemote | train | func (r *Room) MessageRemote(ctx context.Context, msg *UserMessage, b bool, s string) (*UserMessage, error) {
return msg, nil
} | go | {
"resource": ""
} |
q28079 | NewMockNetworkEntity | train | func NewMockNetworkEntity(ctrl *gomock.Controller) *MockNetworkEntity {
mock := &MockNetworkEntity{ctrl: ctrl}
mock.recorder = &MockNetworkEntityMockRecorder{mock}
return mock
} | go | {
"resource": ""
} |
q28080 | Push | train | func (m *MockNetworkEntity) Push(route string, v interface{}) error {
ret := m.ctrl.Call(m, "Push", route, v)
ret0, _ := ret[0].(error)
return ret0
} | go | {
"resource": ""
} |
q28081 | Push | train | func (mr *MockNetworkEntityMockRecorder) Push(route, v interface{}) *gomock.Call {
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Push", reflect.TypeOf((*MockNetworkEntity)(nil).Push), route, v)
} | go | {
"resource": ""
} |
q28082 | ResponseMID | train | func (m *MockNetworkEntity) ResponseMID(ctx context.Context, mid uint, v interface{}, isError ...bool) error {
varargs := []interface{}{ctx, mid, v}
for _, a := range isError {
varargs = append(varargs, a)
}
ret := m.ctrl.Call(m, "ResponseMID", varargs...)
ret0, _ := ret[0].(error)
return ret0
} | go | {
"resource": ""
} |
q28083 | ResponseMID | train | func (mr *MockNetworkEntityMockRecorder) ResponseMID(ctx, mid, v interface{}, isError ...interface{}) *gomock.Call {
varargs := append([]interface{}{ctx, mid, v}, isError...)
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ResponseMID", reflect.TypeOf((*MockNetworkEntity)(nil).ResponseMID), varargs...)
} | go | {
"resource": ""
} |
q28084 | Kick | train | func (m *MockNetworkEntity) Kick(ctx context.Context) error {
ret := m.ctrl.Call(m, "Kick", ctx)
ret0, _ := ret[0].(error)
return ret0
} | go | {
"resource": ""
} |
q28085 | Kick | train | func (mr *MockNetworkEntityMockRecorder) Kick(ctx interface{}) *gomock.Call {
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Kick", reflect.TypeOf((*MockNetworkEntity)(nil).Kick), ctx)
} | go | {
"resource": ""
} |
q28086 | RemoteAddr | train | func (mr *MockNetworkEntityMockRecorder) RemoteAddr() *gomock.Call {
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RemoteAddr", reflect.TypeOf((*MockNetworkEntity)(nil).RemoteAddr))
} | go | {
"resource": ""
} |
q28087 | SendRequest | train | func (m *MockNetworkEntity) SendRequest(ctx context.Context, serverID, route string, v interface{}) (*protos.Response, error) {
ret := m.ctrl.Call(m, "SendRequest", ctx, serverID, route, v)
ret0, _ := ret[0].(*protos.Response)
ret1, _ := ret[1].(error)
return ret0, ret1
} | go | {
"resource": ""
} |
q28088 | SendRequest | train | func (mr *MockNetworkEntityMockRecorder) SendRequest(ctx, serverID, route, v interface{}) *gomock.Call {
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SendRequest", reflect.TypeOf((*MockNetworkEntity)(nil).SendRequest), ctx, serverID, route, v)
} | go | {
"resource": ""
} |
q28089 | NewHandlerService | train | func NewHandlerService(
dieChan chan bool,
packetDecoder codec.PacketDecoder,
packetEncoder codec.PacketEncoder,
serializer serialize.Serializer,
heartbeatTime time.Duration,
messagesBufferSize,
localProcessBufferSize,
remoteProcessBufferSize int,
server *cluster.Server,
remoteService *RemoteService,
message... | go | {
"resource": ""
} |
q28090 | Dispatch | train | func (h *HandlerService) Dispatch(thread int) {
// TODO: This timer is being stopped multiple times, it probably doesn't need to be stopped here
defer timer.GlobalTicker.Stop()
for {
// Calls to remote servers block calls to local server
select {
case lm := <-h.chLocalProcess:
metrics.ReportMessageProcessD... | go | {
"resource": ""
} |
q28091 | Handle | train | func (h *HandlerService) Handle(conn net.Conn) {
// create a client agent and startup write goroutine
a := agent.NewAgent(conn, h.decoder, h.encoder, h.serializer, h.heartbeatTimeout, h.messagesBufferSize, h.appDieChan, h.messageEncoder, h.metricsReporters)
// startup agent goroutine
go a.Handle()
logger.Log.Deb... | go | {
"resource": ""
} |
q28092 | DumpServices | train | func (h *HandlerService) DumpServices() {
for name := range handlers {
logger.Log.Infof("registered handler %s, isRawArg: %s", name, handlers[name].IsRawArg)
}
} | go | {
"resource": ""
} |
q28093 | Docs | train | func (h *HandlerService) Docs(getPtrNames bool) (map[string]interface{}, error) {
if h == nil {
return map[string]interface{}{}, nil
}
return docgenerator.HandlersDocs(h.server.Type, h.services, getPtrNames)
} | go | {
"resource": ""
} |
q28094 | EnqueueRPC | train | func (w *Worker) EnqueueRPC(
routeStr string,
metadata map[string]interface{},
reply, arg proto.Message,
) (jid string, err error) {
opts := w.enqueueOptions(w.opts)
return workers.EnqueueWithOptions(rpcQueue, class, &rpcInfo{
Route: routeStr,
Metadata: metadata,
Arg: arg,
Reply: reply,
}, opts... | go | {
"resource": ""
} |
q28095 | RegisterRPCJob | train | func (w *Worker) RegisterRPCJob(rpcJob RPCJob) error {
if w.registered {
return constants.ErrRPCJobAlreadyRegistered
}
job := w.parsedRPCJob(rpcJob)
workers.Process(rpcQueue, job, w.concurrency)
w.registered = true
return nil
} | go | {
"resource": ""
} |
q28096 | SendKickToUsers | train | func SendKickToUsers(uids []string, frontendType string) ([]string, error) {
if !app.server.Frontend && frontendType == "" {
return uids, constants.ErrFrontendTypeNotSpecified
}
var notKickedUids []string
for _, uid := range uids {
if s := session.GetSessionByUID(uid); s != nil {
if err := s.Kick(context.B... | go | {
"resource": ""
} |
q28097 | unpackDescriptor | train | func unpackDescriptor(compressedDescriptor []byte) (*protobuf.FileDescriptorProto, error) {
r, err := gzip.NewReader(bytes.NewReader(compressedDescriptor))
if err != nil {
return nil, err
}
defer r.Close()
b, err := ioutil.ReadAll(r)
if err != nil {
return nil, err
}
var fileDescriptorProto protobuf.FileD... | go | {
"resource": ""
} |
q28098 | buildProtosFromDescriptor | train | func (pc *ProtoClient) buildProtosFromDescriptor(descriptorArray []*protobuf.FileDescriptorProto) error {
descriptorsMap := make(map[string]*desc.MessageDescriptor)
descriptors, err := desc.CreateFileDescriptors(descriptorArray)
if err != nil {
return err
}
for name := range pc.descriptorsNames {
for _, v :... | go | {
"resource": ""
} |
q28099 | getOutputInputNames | train | func getOutputInputNames(command map[string]interface{}) (string, string, error) {
outputName := ""
inputName := ""
in := command["input"]
inputDocs, ok := in.(map[string]interface{})
if ok {
for k := range inputDocs {
if strings.Contains(k, "proto") {
inputName = strings.Replace(k, "*", "", 1)
}
}
... | go | {
"resource": ""
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.