id stringlengths 2 7 | text stringlengths 17 51.2k | title stringclasses 1 value |
|---|---|---|
c179100 | tabwriter.NewWriter(os.Stdout, 1, 0, 4, ' ', 0)
err := Usagef(prefix, spec, tabs, DefaultTableFormat)
tabs.Flush()
return err
} | |
c179101 | "" {
reqB, err := strconv.ParseBool(req)
if err != nil {
return "", err
}
if reqB {
req = "true"
}
}
return req, nil
},
}
tmpl, err := template.New("envconfig").Funcs(functions).Parse(format)
if err != nil {
return err
}
return Usaget(prefix, spec, out, tmpl)
} | |
c179102 | gatherInfo(prefix, spec)
if err != nil {
return err
}
return tmpl.Execute(out, infos)
} | |
c179103 | = fmt.Errorf("null: cannot scan type %T into null.Time: %v", value, value)
}
t.Valid = err == nil
return err
} | |
c179104 | {
if !t.Valid {
return nil, nil
}
return t.Time, nil
} | |
c179105 | Time {
return Time{
Time: t,
Valid: valid,
}
} | |
c179106 | NewTime(time.Time{}, false)
}
return NewTime(*t, true)
} | |
c179107 |
if !t.Valid {
return time.Time{}
}
return t.Time
} | |
c179108 | return []byte("null"), nil
}
return t.Time.MarshalJSON()
} | |
c179109 | {
t.Time = v
t.Valid = true
} | |
c179110 |
if !t.Valid {
return nil
}
return &t.Time
} | |
c179111 | Bool{
NullBool: sql.NullBool{
Bool: b,
Valid: valid,
},
}
} | |
c179112 | NewBool(false, false)
}
return NewBool(*b, true)
} | |
c179113 | = false
return nil
default:
err = fmt.Errorf("json: cannot unmarshal %v into Go value of type null.Bool", reflect.TypeOf(v).Name())
}
b.Valid = err == nil
return err
} | |
c179114 | = false
default:
b.Valid = false
return errors.New("invalid input:" + str)
}
b.Valid = true
return nil
} | |
c179115 | return []byte("false"), nil
}
return []byte("true"), nil
} | |
c179116 | = v
b.Valid = true
} | |
c179117 | String{
NullString: sql.NullString{
String: s,
Valid: valid,
},
}
} | |
c179118 | false
return nil
default:
err = fmt.Errorf("json: cannot unmarshal %v into Go value of type zero.String", reflect.TypeOf(v).Name())
}
s.Valid = (err == nil) && (s.String != "")
return err
} | |
c179119 | if !s.Valid {
return []byte{}, nil
}
return []byte(s.String), nil
} | |
c179120 | string(text)
s.Valid = s.String != ""
return nil
} | |
c179121 | = v
s.Valid = true
} | |
c179122 | return NewString("", false)
}
return NewString(*s, true)
} | |
c179123 | return []byte("null"), nil
}
return json.Marshal(s.String)
} | |
c179124 |
NullInt64: sql.NullInt64{
Int64: i,
Valid: valid,
},
}
} | |
c179125 | n := NewInt(*i, true)
return n
} | |
c179126 | 64)
case map[string]interface{}:
err = json.Unmarshal(data, &i.NullInt64)
case nil:
i.Valid = false
return nil
default:
err = fmt.Errorf("json: cannot unmarshal %v into Go value of type zero.Int", reflect.TypeOf(v).Name())
}
i.Valid = (err == nil) && (i.Int64 != 0)
return err
} | |
c179127 |
}
return []byte(strconv.FormatInt(n, 10)), nil
} | |
c179128 | n
i.Valid = true
} | |
c179129 | err = strconv.ParseInt(string(text), 10, 64)
i.Valid = err == nil
return err
} | |
c179130 | return []byte("false"), nil
}
return []byte("true"), nil
} | |
c179131 | {
f.Float64 = v
f.Valid = true
} | |
c179132 | (time.Time{}).MarshalJSON()
}
return t.Time.MarshalJSON()
} | |
c179133 | nil:
f.Valid = false
return nil
default:
err = fmt.Errorf("json: cannot unmarshal %v into Go value of type null.Float", reflect.TypeOf(v).Name())
}
f.Valid = err == nil
return err
} | |
c179134 | err = strconv.ParseFloat(string(text), 64)
f.Valid = err == nil
return err
} | |
c179135 |
return nil, &json.UnsupportedValueError{
Value: reflect.ValueOf(f.Float64),
Str: strconv.FormatFloat(f.Float64, 'g', -1, 64),
}
}
return []byte(strconv.FormatFloat(f.Float64, 'f', -1, 64)), nil
} | |
c179136 | {
return &gossipChannel{
name: channelName,
ourself: ourself,
routes: r,
gossiper: g,
logger: logger,
}
} | |
c179137 | c.relayUnicast(dstPeerName, gobEncode(c.name, c.ourself.Name, dstPeerName, msg))
} | |
c179138 | GossipData) {
c.relayBroadcast(c.ourself.Name, update)
} | |
c179139 | GossipData) {
c.relay(c.ourself.Name, data)
} | |
c179140 | c.senderFor(conn).Send(data)
} | |
c179141 | if err := enc.Encode(i); err != nil {
panic(err)
}
}
return buf.Bytes()
} | |
c179142 | capacity,
tokenInterval: tokenInterval,
refillDuration: tokenInterval * time.Duration(capacity)}
tb.earliestUnspentToken = tb.capacityToken()
return &tb
} | |
c179143 | tb.earliestUnspentToken.Before(capacityToken) {
tb.earliestUnspentToken = capacityToken
}
// 'Remove' a token from the bucket
tb.earliestUnspentToken = tb.earliestUnspentToken.Add(tb.tokenInterval)
} | |
c179144 | {
return time.Now().Add(-tb.refillDuration).Truncate(tb.tokenInterval)
} | |
c179145 | return end
}
}
// next prefix does not exist (e.g., 0xffff);
// default to WithFromKey policy
return []byte{0}
} | |
c179146 | peer := &localPeer{
Peer: newPeer(name, nickName, randomPeerUID(), 0, randomPeerShortID()),
router: router,
actionChan: actionChan,
}
go peer.actorLoop(actionChan)
return peer
} | |
c179147 | := range peer.connections {
connections[conn] = struct{}{}
}
return connections
} | |
c179148 | != nil {
return err
}
connRemote := newRemoteConnection(peer.Peer, nil, peerAddr, true, false)
startLocalConnection(connRemote, tcpConn, peer.router, acceptNewPeer, logger)
return nil
} | |
c179149 | resultChan <- peer.handleAddConnection(conn, isRestartedPeer)
}
return <-resultChan
} | |
c179150 | tcpConn,
trustRemote: router.trusts(connRemote),
uid: randUint64(),
errorChan: errorChan,
finished: finished,
logger: logger,
}
conn.senders = newGossipSenders(conn, finished)
go conn.run(errorChan, finished, acceptNewPeer)
} | |
c179151 |
conn.shutdown(err)
return err
}
return nil
} | |
c179152 | UnicastRoutes: makeUnicastRouteStatusSlice(router.Routes),
BroadcastRoutes: makeBroadcastRouteStatusSlice(router.Routes),
Connections: makeLocalConnectionStatusSlice(router.ConnectionMaker),
TerminationCount: router.ConnectionMaker.terminationCount,
Targets: router.ConnectionMaker.Targets(false),
OverlayDiagnostics: router.Overlay.Diagnostics(),
TrustedSubnets: makeTrustedSubnetsSlice(router.TrustedSubnets),
}
} | |
c179153 | locking the peer is safe.
for _, conn := range peer.connections {
connections = append(connections, makeConnectionStatus(conn))
}
}
slice = append(slice, PeerStatus{
peer.Name.String(),
peer.NickName,
peer.UID,
peer.ShortID,
peer.Version,
connections,
})
})
return slice
} | |
c179154 | {
slice = append(slice, unicastRouteStatus{dest.String(), via.String()})
}
return slice
} | |
c179155 | via {
hops = append(hops, hop.String())
}
slice = append(slice, broadcastRouteStatus{source.String(), hops})
}
return slice
} | |
c179156 | append(slice, LocalConnectionStatus{address, true, state, info, nil})
}
switch target.state {
case targetWaiting:
until := "never"
if !target.tryAfter.IsZero() {
until = target.tryAfter.String()
}
if target.lastError == nil { // shouldn't happen
add("waiting", "until: "+until)
} else {
add("failed", target.lastError.Error()+", retry: "+until)
}
case targetAttempting:
if target.lastError == nil {
add("connecting", "")
} else {
add("retrying", target.lastError.Error())
}
case targetConnected:
case targetSuspended:
}
}
resultChan <- slice
return false
}
return <-resultChan
} | |
c179157 | trustedSubnetStrs = append(trustedSubnetStrs, trustedSubnet.String())
}
return trustedSubnetStrs
} | |
c179158 | <-ctx.Done():
s.cancelInternalRaftRequest(ireq)
return nil, ctx.Err()
case msg := <-msgc:
return msg.(*etcdserverpb.RangeResponse), nil
case err := <-errc:
return nil, err
case <-s.quitc:
return nil, errStopped
}
} | |
c179159 | <-ctx.Done():
s.cancelInternalRaftRequest(ireq)
return nil, ctx.Err()
case msg := <-msgc:
return msg.(*etcdserverpb.PutResponse), nil
case err := <-errc:
return nil, err
case <-s.quitc:
return nil, errStopped
}
} | |
c179160 | {
case <-ctx.Done():
s.cancelInternalRaftRequest(ireq)
return nil, ctx.Err()
case msg := <-msgc:
return msg.(*etcdserverpb.DeleteRangeResponse), nil
case err := <-errc:
return nil, err
case <-s.quitc:
return nil, errStopped
}
} | |
c179161 | <-ctx.Done():
s.cancelInternalRaftRequest(ireq)
return nil, ctx.Err()
case msg := <-msgc:
return msg.(*etcdserverpb.TxnResponse), nil
case err := <-errc:
return nil, err
case <-s.quitc:
return nil, errStopped
}
} | |
c179162 | // TODO(pb): fix this when we implement snapshotting.
return nil, errors.New("not implemented")
} | |
c179163 |
return nil, nil, errTooBig
}
msgc, errc, err := s.registerPending(req.ID)
if err != nil {
return nil, nil, err
}
s.proposalc <- data
return msgc, errc, nil
} | |
c179164 |
tv, _ := c.TargetUnion.(*etcdserverpb.Compare_ModRevision)
if tv != nil {
result = compareInt64(ckv.ModRevision, tv.ModRevision)
}
case etcdserverpb.Compare_VERSION:
tv, _ := c.TargetUnion.(*etcdserverpb.Compare_Version)
if tv != nil {
result = compareInt64(ckv.Version, tv.Version)
}
}
switch c.Result {
case etcdserverpb.Compare_EQUAL:
if result != 0 {
return rev, false
}
case etcdserverpb.Compare_GREATER:
if result != 1 {
return rev, false
}
case etcdserverpb.Compare_LESS:
if result != -1 {
return rev, false
}
}
return rev, true
} | |
c179165 | UID: peer.UID,
Self: peer.Name == peers.ourself.Name,
NumConnections: len(peer.connections),
})
}
return descriptions
} | |
c179166 | be accessed
// without holding the lock in unlockAndNotify, we don't
// support removing callbacks, so a simple append here is
// safe.
peers.onGC = append(peers.onGC, callback)
} | |
c179167 | peers.onInvalidateShortIDs = append(peers.onInvalidateShortIDs, callback)
} | |
c179168 |
available := int(1 << peerShortIDBits)
for _, entry := range peers.byShortID {
if entry.peer != nil {
available--
}
}
if available == 0 {
// All short IDs are used.
return 0, false
}
n := rng.Intn(available)
var i PeerShortID
for {
if peers.byShortID[i].peer == nil {
if n == 0 {
return i, true
}
n--
}
i++
}
} | |
c179169 |
if existingPeer, found := peers.byName[peer.Name]; found {
existingPeer.localRefCount++
return existingPeer
}
peers.byName[peer.Name] = peer
peers.addByShortID(peer, &pending)
peer.localRefCount++
return peer
} | |
c179170 | defer peers.RUnlock()
return peers.byName[name]
} | |
c179171 | defer peers.Unlock()
peer := peers.byName[name]
if peer != nil {
peer.localRefCount++
}
return peer
} | |
c179172 | defer peers.RUnlock()
return peers.byShortID[shortID].peer
} | |
c179173 | peers.unlockAndNotify(&pending)
peers.garbageCollect(&pending)
} | |
c179174 | []PeerName{}},
broadcastAll: broadcastRoutes{ourself.Name: []PeerName{}},
recalc: recalculate,
wait: wait,
action: action,
}
go r.run(recalculate, wait, action)
return r
} | |
c179175 | r.onChange = append(r.onChange, callback)
} | |
c179176 | {
r.RLock()
defer r.RUnlock()
hop, found := r.unicast[name]
return hop, found
} | |
c179177 | {
r.RLock()
defer r.RUnlock()
hop, found := r.unicastAll[name]
return hop, found
} | |
c179178 | {
return r.lookupOrCalculate(name, &r.broadcast, true)
} | |
c179179 | {
return r.lookupOrCalculate(name, &r.broadcastAll, false)
} | |
c179180 |
actions: make(chan func()),
quit: make(chan struct{}),
logger: logger,
}
go p.loop()
return p
} | |
c179181 | func() { p.gossip = gossip }
} | |
c179182 | select {
case pkt := <-p.recv:
n = copy(b, pkt.Buf)
remote = MeshAddr{PeerName: pkt.SrcName, PeerUID: pkt.SrcUID}
if n < len(pkt.Buf) {
err = ErrShortRead
}
case <-p.quit:
err = ErrPeerClosed
}
}()
}
<-c
return n, remote, err
} | |
c179183 | p.recv <- pkt
return
}
// TODO(pb): detect and support broadcast
buf := pkt.encode()
n = len(buf)
err = p.gossip.GossipUnicast(meshAddr.PeerName, buf)
}
<-c
return n, err
} | |
c179184 | MeshAddr{PeerName: p.name, PeerUID: p.uid}
} | |
c179185 | return pktSlice{makePkt(buf)}, nil
} | |
c179186 | err error) {
pkt := makePkt(buf)
p.recv <- pkt // to ReadFrom
return pktSlice{pkt}, nil
} | |
c179187 | error {
pkt := makePkt(buf)
p.recv <- pkt // to ReadFrom
return nil
} | |
c179188 | []byte(password),
ConnLimit: 64,
PeerDiscovery: true,
TrustedSubnets: []*net.IPNet{},
}, peerName, nickName, mesh.NullOverlay{}, logger)
// Create a meshconn.Peer and connect it to a channel.
peer := meshconn.NewPeer(router.Ourself.Peer.Name, router.Ourself.UID, logger)
gossip := router.NewGossip(channel, peer)
peer.Register(gossip)
// Start the router and join the mesh.
// Note that we don't ever stop the router.
// This may or may not be a problem.
// TODO(pb): determine if this is a super huge problem
router.Start()
return NewServer(router, peer, minPeerCount, terminatec, terminatedc, logger)
} | |
c179189 | sha256.Sum256([]byte(userInput))
return PeerNameFromBin(nameByteAry[:NameSize]), nil
} | |
c179190 | to decode name to bytes: " + name)
}
return res
} | |
c179191 | = newConnectionMaker(router.Ourself, router.Peers, net.JoinHostPort(router.Host, "0"), router.Port, router.PeerDiscovery, logger)
router.logger = logger
gossip, err := router.NewGossip("topology", router)
if err != nil {
return nil, err
}
router.topologyGossip = gossip
router.acceptLimiter = newTokenBucket(acceptMaxTokens, acceptTokenDelay)
return router, nil
} | |
c179192 | gossip := channel.gossiper.Gossip(); gossip != nil {
channel.Send(gossip)
}
}
} | |
c179193 | gossip := channel.gossiper.Gossip(); gossip != nil {
channel.SendDown(conn, gossip)
}
}
} | |
c179194 | struct{}{}
}
router.topologyGossip.GossipBroadcast(&topologyGossipData{peers: router.Peers, update: names})
} | |
c179195 | return fmt.Errorf("unexpected topology gossip unicast: %v", msg)
} | |
c179196 | {
return nil, err
}
return &topologyGossipData{peers: router.Peers, update: origUpdate}, nil
} | |
c179197 | &topologyGossipData{peers: router.Peers, update: router.Peers.names()}
} | |
c179198 | if err != nil || len(newUpdate) == 0 {
return nil, err
}
return &topologyGossipData{peers: router.Peers, update: newUpdate}, nil
} | |
c179199 | {
return [][]byte{d.peers.encodePeers(d.update)}
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.