_id stringlengths 2 7 | title stringlengths 1 118 | partition stringclasses 3
values | text stringlengths 52 85.5k | language stringclasses 1
value | meta_information dict |
|---|---|---|---|---|---|
q178100 | Exec | test | func (r *RequestBuilder) Exec(ctx context.Context, res interface{}) error {
httpRes, err := r.Send(ctx)
if err != nil {
return err
}
if res == nil {
lateErr := httpRes.Close()
if httpRes.Error != nil {
return httpRes.Error
}
return lateErr
}
return httpRes.Decode(res)
} | go | {
"resource": ""
} |
q178101 | Next | test | func (s *PubSubSubscription) Next() (*Message, error) {
if s.resp.Error != nil {
return nil, s.resp.Error
}
d := json.NewDecoder(s.resp.Output)
var r struct {
From []byte `json:"from,omitempty"`
Data []byte `json:"data,omitempty"`
Seqno []byte `json:"seqno,omitempty"`
TopicIDs []string ... | go | {
"resource": ""
} |
q178102 | Cancel | test | func (s *PubSubSubscription) Cancel() error {
if s.resp.Output == nil {
return nil
}
return s.resp.Output.Close()
} | go | {
"resource": ""
} |
q178103 | FileList | test | func (s *Shell) FileList(path string) (*UnixLsObject, error) {
var out lsOutput
if err := s.Request("file/ls", path).Exec(context.Background(), &out); err != nil {
return nil, err
}
for _, object := range out.Objects {
return object, nil
}
return nil, fmt.Errorf("no object in results")
} | go | {
"resource": ""
} |
q178104 | Cat | test | func (s *Shell) Cat(path string) (io.ReadCloser, error) {
resp, err := s.Request("cat", path).Send(context.Background())
if err != nil {
return nil, err
}
if resp.Error != nil {
return nil, resp.Error
}
return resp.Output, nil
} | go | {
"resource": ""
} |
q178105 | List | test | func (s *Shell) List(path string) ([]*LsLink, error) {
var out struct{ Objects []LsObject }
err := s.Request("ls", path).Exec(context.Background(), &out)
if err != nil {
return nil, err
}
if len(out.Objects) != 1 {
return nil, errors.New("bad response from server")
}
return out.Objects[0].Links, nil
} | go | {
"resource": ""
} |
q178106 | Pin | test | func (s *Shell) Pin(path string) error {
return s.Request("pin/add", path).
Option("recursive", true).
Exec(context.Background(), nil)
} | go | {
"resource": ""
} |
q178107 | Pins | test | func (s *Shell) Pins() (map[string]PinInfo, error) {
var raw struct{ Keys map[string]PinInfo }
return raw.Keys, s.Request("pin/ls").Exec(context.Background(), &raw)
} | go | {
"resource": ""
} |
q178108 | Version | test | func (s *Shell) Version() (string, string, error) {
ver := struct {
Version string
Commit string
}{}
if err := s.Request("version").Exec(context.Background(), &ver); err != nil {
return "", "", err
}
return ver.Version, ver.Commit, nil
} | go | {
"resource": ""
} |
q178109 | SwarmPeers | test | func (s *Shell) SwarmPeers(ctx context.Context) (*SwarmConnInfos, error) {
v := &SwarmConnInfos{}
err := s.Request("swarm/peers").Exec(ctx, &v)
return v, err
} | go | {
"resource": ""
} |
q178110 | SwarmConnect | test | func (s *Shell) SwarmConnect(ctx context.Context, addr ...string) error {
var conn *swarmConnection
err := s.Request("swarm/connect").
Arguments(addr...).
Exec(ctx, &conn)
return err
} | go | {
"resource": ""
} |
q178111 | DagPutOptions | test | func DagPutOptions(opts ...DagPutOption) (*DagPutSettings, error) {
options := &DagPutSettings{
InputEnc: "json",
Kind: "cbor",
Pin: "false",
Hash: "sha2-256",
}
for _, opt := range opts {
err := opt(options)
if err != nil {
return nil, err
}
}
return options, nil
} | go | {
"resource": ""
} |
q178112 | Pin | test | func (dagOpts) Pin(pin string) DagPutOption {
return func(opts *DagPutSettings) error {
opts.Pin = pin
return nil
}
} | go | {
"resource": ""
} |
q178113 | Kind | test | func (dagOpts) Kind(kind string) DagPutOption {
return func(opts *DagPutSettings) error {
opts.Kind = kind
return nil
}
} | go | {
"resource": ""
} |
q178114 | Hash | test | func (dagOpts) Hash(hash string) DagPutOption {
return func(opts *DagPutSettings) error {
opts.Hash = hash
return nil
}
} | go | {
"resource": ""
} |
q178115 | AddDir | test | func (s *Shell) AddDir(dir string) (string, error) {
stat, err := os.Lstat(dir)
if err != nil {
return "", err
}
sf, err := files.NewSerialFile(dir, false, stat)
if err != nil {
return "", err
}
slf := files.NewSliceDirectory([]files.DirEntry{files.FileEntry(filepath.Base(dir), sf)})
reader := files.NewMul... | go | {
"resource": ""
} |
q178116 | Publish | test | func (s *Shell) Publish(node string, value string) error {
var pubResp PublishResponse
req := s.Request("name/publish")
if node != "" {
req.Arguments(node)
}
req.Arguments(value)
return req.Exec(context.Background(), &pubResp)
} | go | {
"resource": ""
} |
q178117 | PublishWithDetails | test | func (s *Shell) PublishWithDetails(contentHash, key string, lifetime, ttl time.Duration, resolve bool) (*PublishResponse, error) {
var pubResp PublishResponse
req := s.Request("name/publish", contentHash).Option("resolve", resolve)
if key != "" {
req.Option("key", key)
}
if lifetime != 0 {
req.Option("lifetime... | go | {
"resource": ""
} |
q178118 | ResolveValue | test | func (pv PlanValue) ResolveValue(bindVars map[string]*querypb.BindVariable) (Value, error) {
switch {
case pv.Key != "":
bv, err := pv.lookupValue(bindVars)
if err != nil {
return NULL, err
}
return MakeTrusted(bv.Type, bv.Value), nil
case !pv.Value.IsNull():
return pv.Value, nil
case pv.ListKey != "" ... | go | {
"resource": ""
} |
q178119 | GenerateQuery | test | func (pq *ParsedQuery) GenerateQuery(bindVariables map[string]*querypb.BindVariable, extras map[string]Encodable) ([]byte, error) {
if len(pq.bindLocations) == 0 {
return []byte(pq.Query), nil
}
buf := bytes.NewBuffer(make([]byte, 0, len(pq.Query)))
current := 0
for _, loc := range pq.bindLocations {
buf.Write... | go | {
"resource": ""
} |
q178120 | EncodeValue | test | func EncodeValue(buf *bytes.Buffer, value *querypb.BindVariable) {
if value.Type != querypb.Type_TUPLE {
// Since we already check for TUPLE, we don't expect an error.
v, _ := sqltypes.BindVariableToValue(value)
v.EncodeSQL(buf)
return
}
// It's a TUPLE.
buf.WriteByte('(')
for i, bv := range value.Values ... | go | {
"resource": ""
} |
q178121 | Lex | test | func (tkn *Tokenizer) Lex(lval *yySymType) int {
typ, val := tkn.Scan()
for typ == COMMENT {
if tkn.AllowComments {
break
}
typ, val = tkn.Scan()
}
lval.bytes = val
tkn.lastToken = val
return typ
} | go | {
"resource": ""
} |
q178122 | skipStatement | test | func (tkn *Tokenizer) skipStatement() {
ch := tkn.lastChar
for ch != ';' && ch != eofChar {
tkn.next()
ch = tkn.lastChar
}
} | go | {
"resource": ""
} |
q178123 | reset | test | func (tkn *Tokenizer) reset() {
tkn.ParseTree = nil
tkn.partialDDL = nil
tkn.specialComment = nil
tkn.posVarIndex = 0
tkn.nesting = 0
tkn.ForceEOF = false
} | go | {
"resource": ""
} |
q178124 | Preview | test | func Preview(sql string) int {
trimmed := StripLeadingComments(sql)
firstWord := trimmed
if end := strings.IndexFunc(trimmed, unicode.IsSpace); end != -1 {
firstWord = trimmed[:end]
}
firstWord = strings.TrimLeftFunc(firstWord, func(r rune) bool { return !unicode.IsLetter(r) })
// Comparison is done in order o... | go | {
"resource": ""
} |
q178125 | NewPlanValue | test | func NewPlanValue(node Expr) (sqltypes.PlanValue, error) {
switch node := node.(type) {
case *SQLVal:
switch node.Type {
case ValArg:
return sqltypes.PlanValue{Key: string(node.Val[1:])}, nil
case IntVal:
n, err := sqltypes.NewIntegral(string(node.Val))
if err != nil {
return sqltypes.PlanValue{}, ... | go | {
"resource": ""
} |
q178126 | StringIn | test | func StringIn(str string, values ...string) bool {
for _, val := range values {
if str == val {
return true
}
}
return false
} | go | {
"resource": ""
} |
q178127 | NewTrackedBuffer | test | func NewTrackedBuffer(nodeFormatter NodeFormatter) *TrackedBuffer {
return &TrackedBuffer{
Buffer: new(bytes.Buffer),
nodeFormatter: nodeFormatter,
}
} | go | {
"resource": ""
} |
q178128 | NewStringArena | test | func NewStringArena(size int) *StringArena {
sa := &StringArena{buf: make([]byte, 0, size)}
pbytes := (*reflect.SliceHeader)(unsafe.Pointer(&sa.buf))
pstring := (*reflect.StringHeader)(unsafe.Pointer(&sa.str))
pstring.Data = pbytes.Data
pstring.Len = pbytes.Cap
return sa
} | go | {
"resource": ""
} |
q178129 | NewString | test | func (sa *StringArena) NewString(b []byte) string {
if len(b) == 0 {
return ""
}
if len(sa.buf)+len(b) > cap(sa.buf) {
return string(b)
}
start := len(sa.buf)
sa.buf = append(sa.buf, b...)
return sa.str[start : start+len(b)]
} | go | {
"resource": ""
} |
q178130 | SpaceLeft | test | func (sa *StringArena) SpaceLeft() int {
return cap(sa.buf) - len(sa.buf)
} | go | {
"resource": ""
} |
q178131 | ParseStrictDDL | test | func ParseStrictDDL(sql string) (Statement, error) {
tokenizer := NewStringTokenizer(sql)
if yyParse(tokenizer) != 0 {
return nil, tokenizer.LastError
}
return tokenizer.ParseTree, nil
} | go | {
"resource": ""
} |
q178132 | ParseNext | test | func ParseNext(tokenizer *Tokenizer) (Statement, error) {
if tokenizer.lastChar == ';' {
tokenizer.next()
tokenizer.skipBlank()
}
if tokenizer.lastChar == eofChar {
return nil, io.EOF
}
tokenizer.reset()
tokenizer.multi = true
if yyParse(tokenizer) != 0 {
if tokenizer.partialDDL != nil {
tokenizer.Pa... | go | {
"resource": ""
} |
q178133 | Append | test | func Append(buf *bytes.Buffer, node SQLNode) {
tbuf := &TrackedBuffer{
Buffer: buf,
}
node.Format(tbuf)
} | go | {
"resource": ""
} |
q178134 | ExprFromValue | test | func ExprFromValue(value sqltypes.Value) (Expr, error) {
// The type checks here follow the rules defined in sqltypes/types.go.
switch {
case value.Type() == sqltypes.Null:
return &NullVal{}, nil
case value.IsIntegral():
return NewIntVal(value.ToBytes()), nil
case value.IsFloat() || value.Type() == sqltypes.De... | go | {
"resource": ""
} |
q178135 | Backtick | test | func Backtick(in string) string {
var buf bytes.Buffer
buf.WriteByte('`')
for _, c := range in {
buf.WriteRune(c)
if c == '`' {
buf.WriteByte('`')
}
}
buf.WriteByte('`')
return buf.String()
} | go | {
"resource": ""
} |
q178136 | NewValue | test | func NewValue(typ querypb.Type, val []byte) (v Value, err error) {
switch {
case IsSigned(typ):
if _, err := strconv.ParseInt(string(val), 0, 64); err != nil {
return NULL, err
}
return MakeTrusted(typ, val), nil
case IsUnsigned(typ):
if _, err := strconv.ParseUint(string(val), 0, 64); err != nil {
ret... | go | {
"resource": ""
} |
q178137 | String | test | func (v Value) String() string {
if v.typ == Null {
return "NULL"
}
if v.IsQuoted() {
return fmt.Sprintf("%v(%q)", v.typ, v.val)
}
return fmt.Sprintf("%v(%s)", v.typ, v.val)
} | go | {
"resource": ""
} |
q178138 | EncodeSQL | test | func (v Value) EncodeSQL(b BinWriter) {
switch {
case v.typ == Null:
b.Write(nullstr)
case v.IsQuoted():
encodeBytesSQL(v.val, b)
default:
b.Write(v.val)
}
} | go | {
"resource": ""
} |
q178139 | EncodeSQL | test | func (iv InsertValues) EncodeSQL(buf *bytes.Buffer) {
for i, rows := range iv {
if i != 0 {
buf.WriteString(", ")
}
buf.WriteByte('(')
for j, bv := range rows {
if j != 0 {
buf.WriteString(", ")
}
bv.EncodeSQL(buf)
}
buf.WriteByte(')')
}
} | go | {
"resource": ""
} |
q178140 | EncodeSQL | test | func (tpl *TupleEqualityList) EncodeSQL(buf *bytes.Buffer) {
if len(tpl.Columns) == 1 {
tpl.encodeAsIn(buf)
return
}
tpl.encodeAsEquality(buf)
} | go | {
"resource": ""
} |
q178141 | WalkStatement | test | func (nz *normalizer) WalkStatement(node SQLNode) (bool, error) {
switch node := node.(type) {
case *Select:
_ = Walk(nz.WalkSelect, node)
// Don't continue
return false, nil
case *SQLVal:
nz.convertSQLVal(node)
case *ComparisonExpr:
nz.convertComparison(node)
}
return true, nil
} | go | {
"resource": ""
} |
q178142 | WalkSelect | test | func (nz *normalizer) WalkSelect(node SQLNode) (bool, error) {
switch node := node.(type) {
case *SQLVal:
nz.convertSQLValDedup(node)
case *ComparisonExpr:
nz.convertComparison(node)
}
return true, nil
} | go | {
"resource": ""
} |
q178143 | BindVariablesEqual | test | func BindVariablesEqual(x, y map[string]*querypb.BindVariable) bool {
return reflect.DeepEqual(&querypb.BoundQuery{BindVariables: x}, &querypb.BoundQuery{BindVariables: y})
} | go | {
"resource": ""
} |
q178144 | New | test | func New(options ...Options) *JWTMiddleware {
var opts Options
if len(options) == 0 {
opts = Options{}
} else {
opts = options[0]
}
if opts.UserProperty == "" {
opts.UserProperty = "user"
}
if opts.ErrorHandler == nil {
opts.ErrorHandler = OnError
}
if opts.Extractor == nil {
opts.Extractor = Fro... | go | {
"resource": ""
} |
q178145 | HandlerWithNext | test | func (m *JWTMiddleware) HandlerWithNext(w http.ResponseWriter, r *http.Request, next http.HandlerFunc) {
err := m.CheckJWT(w, r)
// If there was an error, do not call next.
if err == nil && next != nil {
next(w, r)
}
} | go | {
"resource": ""
} |
q178146 | FromAuthHeader | test | func FromAuthHeader(r *http.Request) (string, error) {
authHeader := r.Header.Get("Authorization")
if authHeader == "" {
return "", nil // No error, just no token
}
// TODO: Make this a bit more robust, parsing-wise
authHeaderParts := strings.Split(authHeader, " ")
if len(authHeaderParts) != 2 || strings.ToLow... | go | {
"resource": ""
} |
q178147 | FromParameter | test | func FromParameter(param string) TokenExtractor {
return func(r *http.Request) (string, error) {
return r.URL.Query().Get(param), nil
}
} | go | {
"resource": ""
} |
q178148 | FromFirst | test | func FromFirst(extractors ...TokenExtractor) TokenExtractor {
return func(r *http.Request) (string, error) {
for _, ex := range extractors {
token, err := ex(r)
if err != nil {
return "", err
}
if token != "" {
return token, nil
}
}
return "", nil
}
} | go | {
"resource": ""
} |
q178149 | getHelloPacket | test | func (p *PubSub) getHelloPacket() *RPC {
var rpc RPC
for t := range p.myTopics {
as := &pb.RPC_SubOpts{
Topicid: proto.String(t),
Subscribe: proto.Bool(true),
}
rpc.Subscriptions = append(rpc.Subscriptions, as)
}
return &rpc
} | go | {
"resource": ""
} |
q178150 | NewFloodsubWithProtocols | test | func NewFloodsubWithProtocols(ctx context.Context, h host.Host, ps []protocol.ID, opts ...Option) (*PubSub, error) {
rt := &FloodSubRouter{
protocols: ps,
}
return NewPubSub(ctx, h, rt, opts...)
} | go | {
"resource": ""
} |
q178151 | NewFloodSub | test | func NewFloodSub(ctx context.Context, h host.Host, opts ...Option) (*PubSub, error) {
return NewFloodsubWithProtocols(ctx, h, []protocol.ID{FloodSubID}, opts...)
} | go | {
"resource": ""
} |
q178152 | NewLRUBlacklist | test | func NewLRUBlacklist(cap int) (Blacklist, error) {
c, err := lru.New(cap)
if err != nil {
return nil, err
}
b := &LRUBlacklist{lru: c}
return b, nil
} | go | {
"resource": ""
} |
q178153 | NewRandomSub | test | func NewRandomSub(ctx context.Context, h host.Host, opts ...Option) (*PubSub, error) {
rt := &RandomSubRouter{
peers: make(map[peer.ID]protocol.ID),
}
return NewPubSub(ctx, h, rt, opts...)
} | go | {
"resource": ""
} |
q178154 | NewGossipSub | test | func NewGossipSub(ctx context.Context, h host.Host, opts ...Option) (*PubSub, error) {
rt := &GossipSubRouter{
peers: make(map[peer.ID]protocol.ID),
mesh: make(map[string]map[peer.ID]struct{}),
fanout: make(map[string]map[peer.ID]struct{}),
lastpub: make(map[string]int64),
gossip: make(map[peer.ID][]*... | go | {
"resource": ""
} |
q178155 | NewPubSub | test | func NewPubSub(ctx context.Context, h host.Host, rt PubSubRouter, opts ...Option) (*PubSub, error) {
ps := &PubSub{
host: h,
ctx: ctx,
rt: rt,
signID: h.ID(),
signKey: h.Peerstore().PrivKey(h.ID()),
signStrict: true,
incoming: make(c... | go | {
"resource": ""
} |
q178156 | WithValidateThrottle | test | func WithValidateThrottle(n int) Option {
return func(ps *PubSub) error {
ps.validateThrottle = make(chan struct{}, n)
return nil
}
} | go | {
"resource": ""
} |
q178157 | WithBlacklist | test | func WithBlacklist(b Blacklist) Option {
return func(p *PubSub) error {
p.blacklist = b
return nil
}
} | go | {
"resource": ""
} |
q178158 | handleRemoveSubscription | test | func (p *PubSub) handleRemoveSubscription(sub *Subscription) {
subs := p.myTopics[sub.topic]
if subs == nil {
return
}
sub.err = fmt.Errorf("subscription cancelled by calling sub.Cancel()")
close(sub.ch)
delete(subs, sub)
if len(subs) == 0 {
delete(p.myTopics, sub.topic)
p.announce(sub.topic, false)
p... | go | {
"resource": ""
} |
q178159 | handleAddSubscription | test | func (p *PubSub) handleAddSubscription(req *addSubReq) {
sub := req.sub
subs := p.myTopics[sub.topic]
// announce we want this topic
if len(subs) == 0 {
p.announce(sub.topic, true)
p.rt.Join(sub.topic)
}
// make new if not there
if subs == nil {
p.myTopics[sub.topic] = make(map[*Subscription]struct{})
... | go | {
"resource": ""
} |
q178160 | announce | test | func (p *PubSub) announce(topic string, sub bool) {
subopt := &pb.RPC_SubOpts{
Topicid: &topic,
Subscribe: &sub,
}
out := rpcWithSubs(subopt)
for pid, peer := range p.peers {
select {
case peer <- out:
default:
log.Infof("Can't send announce message to peer %s: queue full; scheduling retry", pid)
... | go | {
"resource": ""
} |
q178161 | notifySubs | test | func (p *PubSub) notifySubs(msg *pb.Message) {
for _, topic := range msg.GetTopicIDs() {
subs := p.myTopics[topic]
for f := range subs {
select {
case f.ch <- &Message{msg}:
default:
log.Infof("Can't deliver message to subscription for topic %s; subscriber too slow", topic)
}
}
}
} | go | {
"resource": ""
} |
q178162 | seenMessage | test | func (p *PubSub) seenMessage(id string) bool {
return p.seenMessages.Has(id)
} | go | {
"resource": ""
} |
q178163 | subscribedToMsg | test | func (p *PubSub) subscribedToMsg(msg *pb.Message) bool {
if len(p.myTopics) == 0 {
return false
}
for _, t := range msg.GetTopicIDs() {
if _, ok := p.myTopics[t]; ok {
return true
}
}
return false
} | go | {
"resource": ""
} |
q178164 | msgID | test | func msgID(pmsg *pb.Message) string {
return string(pmsg.GetFrom()) + string(pmsg.GetSeqno())
} | go | {
"resource": ""
} |
q178165 | pushMsg | test | func (p *PubSub) pushMsg(vals []*topicVal, src peer.ID, msg *Message) {
// reject messages from blacklisted peers
if p.blacklist.Contains(src) {
log.Warningf("dropping message from blacklisted peer %s", src)
return
}
// even if they are forwarded by good peers
if p.blacklist.Contains(msg.GetFrom()) {
log.Wa... | go | {
"resource": ""
} |
q178166 | validate | test | func (p *PubSub) validate(vals []*topicVal, src peer.ID, msg *Message) {
if msg.Signature != nil {
if !p.validateSignature(msg) {
log.Warningf("message signature validation failed; dropping message from %s", src)
return
}
}
if len(vals) > 0 {
if !p.validateTopic(vals, src, msg) {
log.Warningf("messag... | go | {
"resource": ""
} |
q178167 | validateSingleTopic | test | func (p *PubSub) validateSingleTopic(val *topicVal, src peer.ID, msg *Message) bool {
select {
case val.validateThrottle <- struct{}{}:
ctx, cancel := context.WithCancel(p.ctx)
defer cancel()
res := val.validateMsg(ctx, src, msg)
<-val.validateThrottle
return res
default:
log.Debugf("validation thrott... | go | {
"resource": ""
} |
q178168 | getValidators | test | func (p *PubSub) getValidators(msg *Message) []*topicVal {
var vals []*topicVal
for _, topic := range msg.GetTopicIDs() {
val, ok := p.topicVals[topic]
if !ok {
continue
}
vals = append(vals, val)
}
return vals
} | go | {
"resource": ""
} |
q178169 | Subscribe | test | func (p *PubSub) Subscribe(topic string, opts ...SubOpt) (*Subscription, error) {
td := pb.TopicDescriptor{Name: &topic}
return p.SubscribeByTopicDescriptor(&td, opts...)
} | go | {
"resource": ""
} |
q178170 | SubscribeByTopicDescriptor | test | func (p *PubSub) SubscribeByTopicDescriptor(td *pb.TopicDescriptor, opts ...SubOpt) (*Subscription, error) {
if td.GetAuth().GetMode() != pb.TopicDescriptor_AuthOpts_NONE {
return nil, fmt.Errorf("auth mode not yet supported")
}
if td.GetEnc().GetMode() != pb.TopicDescriptor_EncOpts_NONE {
return nil, fmt.Error... | go | {
"resource": ""
} |
q178171 | GetTopics | test | func (p *PubSub) GetTopics() []string {
out := make(chan []string, 1)
p.getTopics <- &topicReq{resp: out}
return <-out
} | go | {
"resource": ""
} |
q178172 | Publish | test | func (p *PubSub) Publish(topic string, data []byte) error {
seqno := p.nextSeqno()
m := &pb.Message{
Data: data,
TopicIDs: []string{topic},
From: []byte(p.host.ID()),
Seqno: seqno,
}
if p.signKey != nil {
m.From = []byte(p.signID)
err := signMessage(p.signID, p.signKey, m)
if err != nil {
... | go | {
"resource": ""
} |
q178173 | ListPeers | test | func (p *PubSub) ListPeers(topic string) []peer.ID {
out := make(chan []peer.ID)
p.getPeers <- &listPeerReq{
resp: out,
topic: topic,
}
return <-out
} | go | {
"resource": ""
} |
q178174 | WithValidatorTimeout | test | func WithValidatorTimeout(timeout time.Duration) ValidatorOpt {
return func(addVal *addValReq) error {
addVal.timeout = timeout
return nil
}
} | go | {
"resource": ""
} |
q178175 | WithValidatorConcurrency | test | func WithValidatorConcurrency(n int) ValidatorOpt {
return func(addVal *addValReq) error {
addVal.throttle = n
return nil
}
} | go | {
"resource": ""
} |
q178176 | RegisterTopicValidator | test | func (p *PubSub) RegisterTopicValidator(topic string, val Validator, opts ...ValidatorOpt) error {
addVal := &addValReq{
topic: topic,
validate: val,
resp: make(chan error, 1),
}
for _, opt := range opts {
err := opt(addVal)
if err != nil {
return err
}
}
p.addVal <- addVal
return <-addVal... | go | {
"resource": ""
} |
q178177 | UnregisterTopicValidator | test | func (p *PubSub) UnregisterTopicValidator(topic string) error {
rmVal := &rmValReq{
topic: topic,
resp: make(chan error, 1),
}
p.rmVal <- rmVal
return <-rmVal.resp
} | go | {
"resource": ""
} |
q178178 | DefaultMetricPrefix | test | func DefaultMetricPrefix(name string, tags map[string]string) string {
return MetricWithPrefix("tchannel.", name, tags)
} | go | {
"resource": ""
} |
q178179 | MetricWithPrefix | test | func MetricWithPrefix(prefix, name string, tags map[string]string) string {
buf := bufPool.Get().(*bytes.Buffer)
buf.Reset()
if prefix != "" {
buf.WriteString(prefix)
}
buf.WriteString(name)
addKeys := make([]string, 0, 5)
switch {
case strings.HasPrefix(name, "outbound"):
addKeys = append(addKeys, "servi... | go | {
"resource": ""
} |
q178180 | NewClient | test | func NewClient(ch *tchannel.Channel, targetService string, opts *ClientOptions) *Client {
client := &Client{
ch: ch,
targetService: targetService,
}
if opts != nil && opts.HostPort != "" {
client.hostPort = opts.HostPort
}
return client
} | go | {
"resource": ""
} |
q178181 | Call | test | func (c *Client) Call(ctx Context, method string, arg, resp interface{}) error {
var (
headers = ctx.Headers()
respHeaders map[string]string
respErr ErrApplication
errAt string
isOK bool
)
err := c.ch.RunWithRetry(ctx, func(ctx context.Context, rs *tchannel.RequestState) error {
respHe... | go | {
"resource": ""
} |
q178182 | CallPeer | test | func CallPeer(ctx Context, peer *tchannel.Peer, serviceName, method string, arg, resp interface{}) error {
call, err := peer.BeginCall(ctx, serviceName, method, &tchannel.CallOptions{Format: tchannel.JSON})
if err != nil {
return err
}
return wrapCall(ctx, call, method, arg, resp)
} | go | {
"resource": ""
} |
q178183 | CallSC | test | func CallSC(ctx Context, sc *tchannel.SubChannel, method string, arg, resp interface{}) error {
call, err := sc.BeginCall(ctx, method, &tchannel.CallOptions{Format: tchannel.JSON})
if err != nil {
return err
}
return wrapCall(ctx, call, method, arg, resp)
} | go | {
"resource": ""
} |
q178184 | ReadResponse | test | func ReadResponse(call tchannel.ArgReadable) (*http.Response, error) {
var arg2 []byte
if err := tchannel.NewArgReader(call.Arg2Reader()).Read(&arg2); err != nil {
return nil, err
}
rb := typed.NewReadBuffer(arg2)
statusCode := rb.ReadUint16()
message := readVarintString(rb)
response := &http.Response{
Sta... | go | {
"resource": ""
} |
q178185 | writeHeaders | test | func (w *tchanResponseWriter) writeHeaders() {
// TODO(prashant): Allow creating write buffers that let you grow the buffer underneath.
wb := typed.NewWriteBufferWithSize(10000)
wb.WriteUint16(uint16(w.statusCode))
writeVarintString(wb, http.StatusText(w.statusCode))
writeHeaders(wb, w.headers)
arg2Writer, err :... | go | {
"resource": ""
} |
q178186 | ResponseWriter | test | func ResponseWriter(response tchannel.ArgWritable) (http.ResponseWriter, func() error) {
responseWriter := newTChanResponseWriter(response)
return responseWriter, responseWriter.finish
} | go | {
"resource": ""
} |
q178187 | ReadHeaders | test | func ReadHeaders(r io.Reader) (map[string]string, error) {
reader := typed.NewReader(r)
m, err := readHeaders(reader)
reader.Release()
return m, err
} | go | {
"resource": ""
} |
q178188 | NewTCPRawRelay | test | func NewTCPRawRelay(dests []string) (Relay, error) {
return newTCPRelay(dests, func(_ bool, src, dst net.Conn) {
io.Copy(src, dst)
})
} | go | {
"resource": ""
} |
q178189 | NewClient | test | func NewClient(ch *tchannel.Channel, config Configuration, opts *ClientOptions) (*Client, error) {
client := &Client{tchan: ch, quit: make(chan struct{})}
if opts != nil {
client.opts = *opts
}
if client.opts.Timeout == 0 {
client.opts.Timeout = 3 * time.Second
}
if client.opts.TimeoutPerAttempt == 0 {
clie... | go | {
"resource": ""
} |
q178190 | Advertise | test | func (c *Client) Advertise(otherServices ...tchannel.Registrar) error {
c.getServiceNames(otherServices)
if err := c.initialAdvertise(); err != nil {
return err
}
c.opts.Handler.On(Advertised)
go c.advertiseLoop()
return nil
} | go | {
"resource": ""
} |
q178191 | Handle | test | func (h *handler) Handle(tctx context.Context, call *tchannel.InboundCall) error {
var headers map[string]string
if err := tchannel.NewArgReader(call.Arg2Reader()).ReadJSON(&headers); err != nil {
return fmt.Errorf("arg2 read failed: %v", err)
}
tctx = tchannel.ExtractInboundSpan(tctx, call, headers, h.tracer())
... | go | {
"resource": ""
} |
q178192 | Start | test | func (s *Server) Start() error {
if s.HostPort == "" {
s.HostPort = ":" + common.DefaultServerPort
}
channelOpts := &tchannel.ChannelOptions{
Tracer: s.Tracer,
}
ch, err := tchannel.NewChannel(common.DefaultServiceName, channelOpts)
if err != nil {
return err
}
if err := ch.ListenAndServe(s.HostPort); er... | go | {
"resource": ""
} |
q178193 | Port | test | func (s *Server) Port() string {
hostPortSplit := strings.Split(s.HostPort, ":")
port := hostPortSplit[len(hostPortSplit)-1]
return port
} | go | {
"resource": ""
} |
q178194 | SetStrategy | test | func (l *PeerList) SetStrategy(sc ScoreCalculator) {
l.Lock()
defer l.Unlock()
l.scoreCalculator = sc
for _, ps := range l.peersByHostPort {
newScore := l.scoreCalculator.GetScore(ps.Peer)
l.updatePeer(ps, newScore)
}
} | go | {
"resource": ""
} |
q178195 | Add | test | func (l *PeerList) Add(hostPort string) *Peer {
if ps, ok := l.exists(hostPort); ok {
return ps.Peer
}
l.Lock()
defer l.Unlock()
if p, ok := l.peersByHostPort[hostPort]; ok {
return p.Peer
}
p := l.parent.Add(hostPort)
p.addSC()
ps := newPeerScore(p, l.scoreCalculator.GetScore(p))
l.peersByHostPort[hos... | go | {
"resource": ""
} |
q178196 | GetNew | test | func (l *PeerList) GetNew(prevSelected map[string]struct{}) (*Peer, error) {
l.Lock()
defer l.Unlock()
if l.peerHeap.Len() == 0 {
return nil, ErrNoPeers
}
// Select a peer, avoiding previously selected peers. If all peers have been previously
// selected, then it's OK to repick them.
peer := l.choosePeer(prev... | go | {
"resource": ""
} |
q178197 | Get | test | func (l *PeerList) Get(prevSelected map[string]struct{}) (*Peer, error) {
peer, err := l.GetNew(prevSelected)
if err == ErrNoNewPeers {
l.Lock()
peer = l.choosePeer(nil, false /* avoidHost */)
l.Unlock()
} else if err != nil {
return nil, err
}
if peer == nil {
return nil, ErrNoPeers
}
return peer, nil... | go | {
"resource": ""
} |
q178198 | Remove | test | func (l *PeerList) Remove(hostPort string) error {
l.Lock()
defer l.Unlock()
p, ok := l.peersByHostPort[hostPort]
if !ok {
return ErrPeerNotFound
}
p.delSC()
delete(l.peersByHostPort, hostPort)
l.peerHeap.removePeer(p)
return nil
} | go | {
"resource": ""
} |
q178199 | Copy | test | func (l *PeerList) Copy() map[string]*Peer {
l.RLock()
defer l.RUnlock()
listCopy := make(map[string]*Peer)
for k, v := range l.peersByHostPort {
listCopy[k] = v.Peer
}
return listCopy
} | go | {
"resource": ""
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.