_id stringlengths 2 7 | title stringlengths 1 118 | partition stringclasses 3
values | text stringlengths 52 85.5k | language stringclasses 1
value | meta_information dict |
|---|---|---|---|---|---|
q179100 | Usage | test | func Usage(prefix string, spec interface{}) error {
// The default is to output the usage information as a table
// Create tabwriter instance to support table output
tabs := tabwriter.NewWriter(os.Stdout, 1, 0, 4, ' ', 0)
err := Usagef(prefix, spec, tabs, DefaultTableFormat)
tabs.Flush()
return err
} | go | {
"resource": ""
} |
q179101 | Usagef | test | func Usagef(prefix string, spec interface{}, out io.Writer, format string) error {
// Specify the default usage template functions
functions := template.FuncMap{
"usage_key": func(v varInfo) string { return v.Key },
"usage_description": func(v varInfo) string { return v.Tags.Get("desc") },
"usage_type"... | go | {
"resource": ""
} |
q179102 | Usaget | test | func Usaget(prefix string, spec interface{}, out io.Writer, tmpl *template.Template) error {
// gather first
infos, err := gatherInfo(prefix, spec)
if err != nil {
return err
}
return tmpl.Execute(out, infos)
} | go | {
"resource": ""
} |
q179103 | Scan | test | func (t *Time) Scan(value interface{}) error {
var err error
switch x := value.(type) {
case time.Time:
t.Time = x
case nil:
t.Valid = false
return nil
default:
err = fmt.Errorf("null: cannot scan type %T into null.Time: %v", value, value)
}
t.Valid = err == nil
return err
} | go | {
"resource": ""
} |
q179104 | Value | test | func (t Time) Value() (driver.Value, error) {
if !t.Valid {
return nil, nil
}
return t.Time, nil
} | go | {
"resource": ""
} |
q179105 | NewTime | test | func NewTime(t time.Time, valid bool) Time {
return Time{
Time: t,
Valid: valid,
}
} | go | {
"resource": ""
} |
q179106 | TimeFromPtr | test | func TimeFromPtr(t *time.Time) Time {
if t == nil {
return NewTime(time.Time{}, false)
}
return NewTime(*t, true)
} | go | {
"resource": ""
} |
q179107 | ValueOrZero | test | func (t Time) ValueOrZero() time.Time {
if !t.Valid {
return time.Time{}
}
return t.Time
} | go | {
"resource": ""
} |
q179108 | MarshalJSON | test | func (t Time) MarshalJSON() ([]byte, error) {
if !t.Valid {
return []byte("null"), nil
}
return t.Time.MarshalJSON()
} | go | {
"resource": ""
} |
q179109 | SetValid | test | func (t *Time) SetValid(v time.Time) {
t.Time = v
t.Valid = true
} | go | {
"resource": ""
} |
q179110 | Ptr | test | func (t Time) Ptr() *time.Time {
if !t.Valid {
return nil
}
return &t.Time
} | go | {
"resource": ""
} |
q179111 | NewBool | test | func NewBool(b bool, valid bool) Bool {
return Bool{
NullBool: sql.NullBool{
Bool: b,
Valid: valid,
},
}
} | go | {
"resource": ""
} |
q179112 | BoolFromPtr | test | func BoolFromPtr(b *bool) Bool {
if b == nil {
return NewBool(false, false)
}
return NewBool(*b, true)
} | go | {
"resource": ""
} |
q179113 | UnmarshalJSON | test | func (b *Bool) UnmarshalJSON(data []byte) error {
var err error
var v interface{}
if err = json.Unmarshal(data, &v); err != nil {
return err
}
switch x := v.(type) {
case bool:
b.Bool = x
case map[string]interface{}:
err = json.Unmarshal(data, &b.NullBool)
case nil:
b.Valid = false
return nil
default... | go | {
"resource": ""
} |
q179114 | UnmarshalText | test | func (b *Bool) UnmarshalText(text []byte) error {
str := string(text)
switch str {
case "", "null":
b.Valid = false
return nil
case "true":
b.Bool = true
case "false":
b.Bool = false
default:
b.Valid = false
return errors.New("invalid input:" + str)
}
b.Valid = true
return nil
} | go | {
"resource": ""
} |
q179115 | MarshalJSON | test | func (b Bool) MarshalJSON() ([]byte, error) {
if !b.Valid {
return []byte("null"), nil
}
if !b.Bool {
return []byte("false"), nil
}
return []byte("true"), nil
} | go | {
"resource": ""
} |
q179116 | SetValid | test | func (b *Bool) SetValid(v bool) {
b.Bool = v
b.Valid = true
} | go | {
"resource": ""
} |
q179117 | NewString | test | func NewString(s string, valid bool) String {
return String{
NullString: sql.NullString{
String: s,
Valid: valid,
},
}
} | go | {
"resource": ""
} |
q179118 | UnmarshalJSON | test | func (s *String) UnmarshalJSON(data []byte) error {
var err error
var v interface{}
if err = json.Unmarshal(data, &v); err != nil {
return err
}
switch x := v.(type) {
case string:
s.String = x
case map[string]interface{}:
err = json.Unmarshal(data, &s.NullString)
case nil:
s.Valid = false
return nil
... | go | {
"resource": ""
} |
q179119 | MarshalText | test | func (s String) MarshalText() ([]byte, error) {
if !s.Valid {
return []byte{}, nil
}
return []byte(s.String), nil
} | go | {
"resource": ""
} |
q179120 | UnmarshalText | test | func (s *String) UnmarshalText(text []byte) error {
s.String = string(text)
s.Valid = s.String != ""
return nil
} | go | {
"resource": ""
} |
q179121 | SetValid | test | func (s *String) SetValid(v string) {
s.String = v
s.Valid = true
} | go | {
"resource": ""
} |
q179122 | StringFromPtr | test | func StringFromPtr(s *string) String {
if s == nil {
return NewString("", false)
}
return NewString(*s, true)
} | go | {
"resource": ""
} |
q179123 | MarshalJSON | test | func (s String) MarshalJSON() ([]byte, error) {
if !s.Valid {
return []byte("null"), nil
}
return json.Marshal(s.String)
} | go | {
"resource": ""
} |
q179124 | NewInt | test | func NewInt(i int64, valid bool) Int {
return Int{
NullInt64: sql.NullInt64{
Int64: i,
Valid: valid,
},
}
} | go | {
"resource": ""
} |
q179125 | IntFromPtr | test | func IntFromPtr(i *int64) Int {
if i == nil {
return NewInt(0, false)
}
n := NewInt(*i, true)
return n
} | go | {
"resource": ""
} |
q179126 | UnmarshalJSON | test | func (i *Int) UnmarshalJSON(data []byte) error {
var err error
var v interface{}
if err = json.Unmarshal(data, &v); err != nil {
return err
}
switch x := v.(type) {
case float64:
// Unmarshal again, directly to int64, to avoid intermediate float64
err = json.Unmarshal(data, &i.Int64)
case string:
str := ... | go | {
"resource": ""
} |
q179127 | MarshalText | test | func (i Int) MarshalText() ([]byte, error) {
n := i.Int64
if !i.Valid {
n = 0
}
return []byte(strconv.FormatInt(n, 10)), nil
} | go | {
"resource": ""
} |
q179128 | SetValid | test | func (i *Int) SetValid(n int64) {
i.Int64 = n
i.Valid = true
} | go | {
"resource": ""
} |
q179129 | UnmarshalText | test | func (i *Int) UnmarshalText(text []byte) error {
str := string(text)
if str == "" || str == "null" {
i.Valid = false
return nil
}
var err error
i.Int64, err = strconv.ParseInt(string(text), 10, 64)
i.Valid = err == nil
return err
} | go | {
"resource": ""
} |
q179130 | MarshalText | test | func (b Bool) MarshalText() ([]byte, error) {
if !b.Valid || !b.Bool {
return []byte("false"), nil
}
return []byte("true"), nil
} | go | {
"resource": ""
} |
q179131 | SetValid | test | func (f *Float) SetValid(v float64) {
f.Float64 = v
f.Valid = true
} | go | {
"resource": ""
} |
q179132 | MarshalJSON | test | func (t Time) MarshalJSON() ([]byte, error) {
if !t.Valid {
return (time.Time{}).MarshalJSON()
}
return t.Time.MarshalJSON()
} | go | {
"resource": ""
} |
q179133 | UnmarshalJSON | test | func (f *Float) UnmarshalJSON(data []byte) error {
var err error
var v interface{}
if err = json.Unmarshal(data, &v); err != nil {
return err
}
switch x := v.(type) {
case float64:
f.Float64 = float64(x)
case string:
str := string(x)
if len(str) == 0 {
f.Valid = false
return nil
}
f.Float64, er... | go | {
"resource": ""
} |
q179134 | UnmarshalText | test | func (f *Float) UnmarshalText(text []byte) error {
str := string(text)
if str == "" || str == "null" {
f.Valid = false
return nil
}
var err error
f.Float64, err = strconv.ParseFloat(string(text), 64)
f.Valid = err == nil
return err
} | go | {
"resource": ""
} |
q179135 | MarshalJSON | test | func (f Float) MarshalJSON() ([]byte, error) {
if !f.Valid {
return []byte("null"), nil
}
if math.IsInf(f.Float64, 0) || math.IsNaN(f.Float64) {
return nil, &json.UnsupportedValueError{
Value: reflect.ValueOf(f.Float64),
Str: strconv.FormatFloat(f.Float64, 'g', -1, 64),
}
}
return []byte(strconv.Form... | go | {
"resource": ""
} |
q179136 | newGossipChannel | test | func newGossipChannel(channelName string, ourself *localPeer, r *routes, g Gossiper, logger Logger) *gossipChannel {
return &gossipChannel{
name: channelName,
ourself: ourself,
routes: r,
gossiper: g,
logger: logger,
}
} | go | {
"resource": ""
} |
q179137 | GossipUnicast | test | func (c *gossipChannel) GossipUnicast(dstPeerName PeerName, msg []byte) error {
return c.relayUnicast(dstPeerName, gobEncode(c.name, c.ourself.Name, dstPeerName, msg))
} | go | {
"resource": ""
} |
q179138 | GossipBroadcast | test | func (c *gossipChannel) GossipBroadcast(update GossipData) {
c.relayBroadcast(c.ourself.Name, update)
} | go | {
"resource": ""
} |
q179139 | Send | test | func (c *gossipChannel) Send(data GossipData) {
c.relay(c.ourself.Name, data)
} | go | {
"resource": ""
} |
q179140 | SendDown | test | func (c *gossipChannel) SendDown(conn Connection, data GossipData) {
c.senderFor(conn).Send(data)
} | go | {
"resource": ""
} |
q179141 | gobEncode | test | func gobEncode(items ...interface{}) []byte {
buf := new(bytes.Buffer)
enc := gob.NewEncoder(buf)
for _, i := range items {
if err := enc.Encode(i); err != nil {
panic(err)
}
}
return buf.Bytes()
} | go | {
"resource": ""
} |
q179142 | newTokenBucket | test | func newTokenBucket(capacity int64, tokenInterval time.Duration) *tokenBucket {
tb := tokenBucket{
capacity: capacity,
tokenInterval: tokenInterval,
refillDuration: tokenInterval * time.Duration(capacity)}
tb.earliestUnspentToken = tb.capacityToken()
return &tb
} | go | {
"resource": ""
} |
q179143 | wait | test | func (tb *tokenBucket) wait() {
// If earliest unspent token is in the future, sleep until then
time.Sleep(time.Until(tb.earliestUnspentToken))
// Alternatively, enforce bucket capacity if necessary
capacityToken := tb.capacityToken()
if tb.earliestUnspentToken.Before(capacityToken) {
tb.earliestUnspentToken = ... | go | {
"resource": ""
} |
q179144 | capacityToken | test | func (tb *tokenBucket) capacityToken() time.Time {
return time.Now().Add(-tb.refillDuration).Truncate(tb.tokenInterval)
} | go | {
"resource": ""
} |
q179145 | PrefixRangeEnd | test | func PrefixRangeEnd(prefix []byte) []byte {
// https://github.com/coreos/etcd/blob/17e32b6/clientv3/op.go#L187
end := make([]byte, len(prefix))
copy(end, prefix)
for i := len(end) - 1; i >= 0; i-- {
if end[i] < 0xff {
end[i] = end[i] + 1
end = end[:i+1]
return end
}
}
// next prefix does not exist (e... | go | {
"resource": ""
} |
q179146 | newLocalPeer | test | func newLocalPeer(name PeerName, nickName string, router *Router) *localPeer {
actionChan := make(chan localPeerAction, ChannelSize)
peer := &localPeer{
Peer: newPeer(name, nickName, randomPeerUID(), 0, randomPeerShortID()),
router: router,
actionChan: actionChan,
}
go peer.actorLoop(actionChan)
re... | go | {
"resource": ""
} |
q179147 | getConnections | test | func (peer *localPeer) getConnections() connectionSet {
connections := make(connectionSet)
peer.RLock()
defer peer.RUnlock()
for _, conn := range peer.connections {
connections[conn] = struct{}{}
}
return connections
} | go | {
"resource": ""
} |
q179148 | createConnection | test | func (peer *localPeer) createConnection(localAddr string, peerAddr string, acceptNewPeer bool, logger Logger) error {
if err := peer.checkConnectionLimit(); err != nil {
return err
}
localTCPAddr, err := net.ResolveTCPAddr("tcp", localAddr)
if err != nil {
return err
}
remoteTCPAddr, err := net.ResolveTCPAddr... | go | {
"resource": ""
} |
q179149 | doAddConnection | test | func (peer *localPeer) doAddConnection(conn ourConnection, isRestartedPeer bool) error {
resultChan := make(chan error)
peer.actionChan <- func() {
resultChan <- peer.handleAddConnection(conn, isRestartedPeer)
}
return <-resultChan
} | go | {
"resource": ""
} |
q179150 | startLocalConnection | test | func startLocalConnection(connRemote *remoteConnection, tcpConn *net.TCPConn, router *Router, acceptNewPeer bool, logger Logger) {
if connRemote.local != router.Ourself.Peer {
panic("attempt to create local connection from a peer which is not ourself")
}
errorChan := make(chan error, 1)
finished := make(chan stru... | go | {
"resource": ""
} |
q179151 | SendProtocolMsg | test | func (conn *LocalConnection) SendProtocolMsg(m protocolMsg) error {
if err := conn.sendProtocolMsg(m); err != nil {
conn.shutdown(err)
return err
}
return nil
} | go | {
"resource": ""
} |
q179152 | NewStatus | test | func NewStatus(router *Router) *Status {
return &Status{
Protocol: Protocol,
ProtocolMinVersion: int(router.ProtocolMinVersion),
ProtocolMaxVersion: ProtocolMaxVersion,
Encryption: router.usingPassword(),
PeerDiscovery: router.PeerDiscovery,
Name: router.Ourself.Name.St... | go | {
"resource": ""
} |
q179153 | makePeerStatusSlice | test | func makePeerStatusSlice(peers *Peers) []PeerStatus {
var slice []PeerStatus
peers.forEach(func(peer *Peer) {
var connections []connectionStatus
if peer == peers.ourself.Peer {
for conn := range peers.ourself.getConnections() {
connections = append(connections, makeConnectionStatus(conn))
}
} else {
... | go | {
"resource": ""
} |
q179154 | makeUnicastRouteStatusSlice | test | func makeUnicastRouteStatusSlice(r *routes) []unicastRouteStatus {
r.RLock()
defer r.RUnlock()
var slice []unicastRouteStatus
for dest, via := range r.unicast {
slice = append(slice, unicastRouteStatus{dest.String(), via.String()})
}
return slice
} | go | {
"resource": ""
} |
q179155 | makeBroadcastRouteStatusSlice | test | func makeBroadcastRouteStatusSlice(r *routes) []broadcastRouteStatus {
r.RLock()
defer r.RUnlock()
var slice []broadcastRouteStatus
for source, via := range r.broadcast {
var hops []string
for _, hop := range via {
hops = append(hops, hop.String())
}
slice = append(slice, broadcastRouteStatus{source.Str... | go | {
"resource": ""
} |
q179156 | makeLocalConnectionStatusSlice | test | func makeLocalConnectionStatusSlice(cm *connectionMaker) []LocalConnectionStatus {
resultChan := make(chan []LocalConnectionStatus)
cm.actionChan <- func() bool {
var slice []LocalConnectionStatus
for conn := range cm.connections {
state := "pending"
if conn.isEstablished() {
state = "established"
}
... | go | {
"resource": ""
} |
q179157 | makeTrustedSubnetsSlice | test | func makeTrustedSubnetsSlice(trustedSubnets []*net.IPNet) []string {
trustedSubnetStrs := []string{}
for _, trustedSubnet := range trustedSubnets {
trustedSubnetStrs = append(trustedSubnetStrs, trustedSubnet.String())
}
return trustedSubnetStrs
} | go | {
"resource": ""
} |
q179158 | Range | test | func (s *etcdStore) Range(ctx context.Context, req *etcdserverpb.RangeRequest) (*etcdserverpb.RangeResponse, error) {
ireq := etcdserverpb.InternalRaftRequest{ID: <-s.idgen, Range: req}
msgc, errc, err := s.proposeInternalRaftRequest(ireq)
if err != nil {
return nil, err
}
select {
case <-ctx.Done():
s.cancel... | go | {
"resource": ""
} |
q179159 | Put | test | func (s *etcdStore) Put(ctx context.Context, req *etcdserverpb.PutRequest) (*etcdserverpb.PutResponse, error) {
ireq := etcdserverpb.InternalRaftRequest{ID: <-s.idgen, Put: req}
msgc, errc, err := s.proposeInternalRaftRequest(ireq)
if err != nil {
return nil, err
}
select {
case <-ctx.Done():
s.cancelInternal... | go | {
"resource": ""
} |
q179160 | DeleteRange | test | func (s *etcdStore) DeleteRange(ctx context.Context, req *etcdserverpb.DeleteRangeRequest) (*etcdserverpb.DeleteRangeResponse, error) {
ireq := etcdserverpb.InternalRaftRequest{ID: <-s.idgen, DeleteRange: req}
msgc, errc, err := s.proposeInternalRaftRequest(ireq)
if err != nil {
return nil, err
}
select {
case ... | go | {
"resource": ""
} |
q179161 | Txn | test | func (s *etcdStore) Txn(ctx context.Context, req *etcdserverpb.TxnRequest) (*etcdserverpb.TxnResponse, error) {
ireq := etcdserverpb.InternalRaftRequest{ID: <-s.idgen, Txn: req}
msgc, errc, err := s.proposeInternalRaftRequest(ireq)
if err != nil {
return nil, err
}
select {
case <-ctx.Done():
s.cancelInternal... | go | {
"resource": ""
} |
q179162 | Compact | test | func (s *etcdStore) Compact(ctx context.Context, req *etcdserverpb.CompactionRequest) (*etcdserverpb.CompactionResponse, error) {
// We don't have snapshotting yet, so compact just puts us in a bad state.
// TODO(pb): fix this when we implement snapshotting.
return nil, errors.New("not implemented")
} | go | {
"resource": ""
} |
q179163 | proposeInternalRaftRequest | test | func (s *etcdStore) proposeInternalRaftRequest(req etcdserverpb.InternalRaftRequest) (<-chan proto.Message, <-chan error, error) {
data, err := req.Marshal()
if err != nil {
return nil, nil, err
}
if len(data) > maxRequestBytes {
return nil, nil, errTooBig
}
msgc, errc, err := s.registerPending(req.ID)
if er... | go | {
"resource": ""
} |
q179164 | applyCompare | test | func applyCompare(kv mvcc.KV, c *etcdserverpb.Compare) (int64, bool) {
ckvs, rev, err := kv.Range(c.Key, nil, 1, 0)
if err != nil {
if err == mvcc.ErrTxnIDMismatch {
panic("unexpected txn ID mismatch error")
}
return rev, false
}
var ckv mvccpb.KeyValue
if len(ckvs) != 0 {
ckv = ckvs[0]
} else {
// U... | go | {
"resource": ""
} |
q179165 | Descriptions | test | func (peers *Peers) Descriptions() []PeerDescription {
peers.RLock()
defer peers.RUnlock()
descriptions := make([]PeerDescription, 0, len(peers.byName))
for _, peer := range peers.byName {
descriptions = append(descriptions, PeerDescription{
Name: peer.Name,
NickName: peer.peerSummary.NickNa... | go | {
"resource": ""
} |
q179166 | OnGC | test | func (peers *Peers) OnGC(callback func(*Peer)) {
peers.Lock()
defer peers.Unlock()
// Although the array underlying peers.onGC might 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)
} | go | {
"resource": ""
} |
q179167 | OnInvalidateShortIDs | test | func (peers *Peers) OnInvalidateShortIDs(callback func()) {
peers.Lock()
defer peers.Unlock()
// Safe, as in OnGC
peers.onInvalidateShortIDs = append(peers.onInvalidateShortIDs, callback)
} | go | {
"resource": ""
} |
q179168 | chooseShortID | test | func (peers *Peers) chooseShortID() (PeerShortID, bool) {
rng := rand.New(rand.NewSource(int64(randUint64())))
// First, just try picking some short IDs at random, and
// seeing if they are available:
for i := 0; i < 10; i++ {
shortID := PeerShortID(rng.Intn(1 << peerShortIDBits))
if peers.byShortID[shortID].p... | go | {
"resource": ""
} |
q179169 | fetchWithDefault | test | func (peers *Peers) fetchWithDefault(peer *Peer) *Peer {
peers.Lock()
var pending peersPendingNotifications
defer peers.unlockAndNotify(&pending)
if existingPeer, found := peers.byName[peer.Name]; found {
existingPeer.localRefCount++
return existingPeer
}
peers.byName[peer.Name] = peer
peers.addByShortID(p... | go | {
"resource": ""
} |
q179170 | Fetch | test | func (peers *Peers) Fetch(name PeerName) *Peer {
peers.RLock()
defer peers.RUnlock()
return peers.byName[name]
} | go | {
"resource": ""
} |
q179171 | fetchAndAddRef | test | func (peers *Peers) fetchAndAddRef(name PeerName) *Peer {
peers.Lock()
defer peers.Unlock()
peer := peers.byName[name]
if peer != nil {
peer.localRefCount++
}
return peer
} | go | {
"resource": ""
} |
q179172 | FetchByShortID | test | func (peers *Peers) FetchByShortID(shortID PeerShortID) *Peer {
peers.RLock()
defer peers.RUnlock()
return peers.byShortID[shortID].peer
} | go | {
"resource": ""
} |
q179173 | GarbageCollect | test | func (peers *Peers) GarbageCollect() {
peers.Lock()
var pending peersPendingNotifications
defer peers.unlockAndNotify(&pending)
peers.garbageCollect(&pending)
} | go | {
"resource": ""
} |
q179174 | newRoutes | test | func newRoutes(ourself *localPeer, peers *Peers) *routes {
recalculate := make(chan *struct{}, 1)
wait := make(chan chan struct{})
action := make(chan func())
r := &routes{
ourself: ourself,
peers: peers,
unicast: unicastRoutes{ourself.Name: UnknownPeerName},
unicastAll: unicastRoutes{our... | go | {
"resource": ""
} |
q179175 | OnChange | test | func (r *routes) OnChange(callback func()) {
r.Lock()
defer r.Unlock()
r.onChange = append(r.onChange, callback)
} | go | {
"resource": ""
} |
q179176 | Unicast | test | func (r *routes) Unicast(name PeerName) (PeerName, bool) {
r.RLock()
defer r.RUnlock()
hop, found := r.unicast[name]
return hop, found
} | go | {
"resource": ""
} |
q179177 | UnicastAll | test | func (r *routes) UnicastAll(name PeerName) (PeerName, bool) {
r.RLock()
defer r.RUnlock()
hop, found := r.unicastAll[name]
return hop, found
} | go | {
"resource": ""
} |
q179178 | Broadcast | test | func (r *routes) Broadcast(name PeerName) []PeerName {
return r.lookupOrCalculate(name, &r.broadcast, true)
} | go | {
"resource": ""
} |
q179179 | BroadcastAll | test | func (r *routes) BroadcastAll(name PeerName) []PeerName {
return r.lookupOrCalculate(name, &r.broadcastAll, false)
} | go | {
"resource": ""
} |
q179180 | NewPeer | test | func NewPeer(name mesh.PeerName, uid mesh.PeerUID, logger mesh.Logger) *Peer {
p := &Peer{
name: name,
uid: uid,
gossip: nil, // initially no gossip
recv: make(chan pkt),
actions: make(chan func()),
quit: make(chan struct{}),
logger: logger,
}
go p.loop()
return p
} | go | {
"resource": ""
} |
q179181 | Register | test | func (p *Peer) Register(gossip mesh.Gossip) {
p.actions <- func() { p.gossip = gossip }
} | go | {
"resource": ""
} |
q179182 | ReadFrom | test | func (p *Peer) ReadFrom(b []byte) (n int, remote net.Addr, err error) {
c := make(chan struct{})
p.actions <- func() {
go func() { // so as not to block loop
defer close(c)
select {
case pkt := <-p.recv:
n = copy(b, pkt.Buf)
remote = MeshAddr{PeerName: pkt.SrcName, PeerUID: pkt.SrcUID}
if n < l... | go | {
"resource": ""
} |
q179183 | WriteTo | test | func (p *Peer) WriteTo(b []byte, dst net.Addr) (n int, err error) {
c := make(chan struct{})
p.actions <- func() {
defer close(c)
if p.gossip == nil {
err = ErrGossipNotRegistered
return
}
meshAddr, ok := dst.(MeshAddr)
if !ok {
err = ErrNotMeshAddr
return
}
pkt := pkt{SrcName: p.name, SrcUI... | go | {
"resource": ""
} |
q179184 | LocalAddr | test | func (p *Peer) LocalAddr() net.Addr {
return MeshAddr{PeerName: p.name, PeerUID: p.uid}
} | go | {
"resource": ""
} |
q179185 | OnGossip | test | func (p *Peer) OnGossip(buf []byte) (delta mesh.GossipData, err error) {
return pktSlice{makePkt(buf)}, nil
} | go | {
"resource": ""
} |
q179186 | OnGossipBroadcast | test | func (p *Peer) OnGossipBroadcast(_ mesh.PeerName, buf []byte) (received mesh.GossipData, err error) {
pkt := makePkt(buf)
p.recv <- pkt // to ReadFrom
return pktSlice{pkt}, nil
} | go | {
"resource": ""
} |
q179187 | OnGossipUnicast | test | func (p *Peer) OnGossipUnicast(_ mesh.PeerName, buf []byte) error {
pkt := makePkt(buf)
p.recv <- pkt // to ReadFrom
return nil
} | go | {
"resource": ""
} |
q179188 | NewDefaultServer | test | func NewDefaultServer(
minPeerCount int,
terminatec <-chan struct{},
terminatedc chan<- error,
logger mesh.Logger,
) Server {
var (
peerName = mustPeerName()
nickName = mustHostname()
host = "0.0.0.0"
port = 6379
password = ""
channel = "metcd"
)
router := mesh.NewRouter(mesh.Config{
Host:... | go | {
"resource": ""
} |
q179189 | PeerNameFromUserInput | test | func PeerNameFromUserInput(userInput string) (PeerName, error) {
// fixed-length identity
nameByteAry := sha256.Sum256([]byte(userInput))
return PeerNameFromBin(nameByteAry[:NameSize]), nil
} | go | {
"resource": ""
} |
q179190 | bytes | test | func (name PeerName) bytes() []byte {
res, err := hex.DecodeString(string(name))
if err != nil {
panic("unable to decode name to bytes: " + name)
}
return res
} | go | {
"resource": ""
} |
q179191 | NewRouter | test | func NewRouter(config Config, name PeerName, nickName string, overlay Overlay, logger Logger) (*Router, error) {
router := &Router{Config: config, gossipChannels: make(gossipChannels)}
if overlay == nil {
overlay = NullOverlay{}
}
router.Overlay = overlay
router.Ourself = newLocalPeer(name, nickName, router)
... | go | {
"resource": ""
} |
q179192 | sendAllGossip | test | func (router *Router) sendAllGossip() {
for channel := range router.gossipChannelSet() {
if gossip := channel.gossiper.Gossip(); gossip != nil {
channel.Send(gossip)
}
}
} | go | {
"resource": ""
} |
q179193 | sendAllGossipDown | test | func (router *Router) sendAllGossipDown(conn Connection) {
for channel := range router.gossipChannelSet() {
if gossip := channel.gossiper.Gossip(); gossip != nil {
channel.SendDown(conn, gossip)
}
}
} | go | {
"resource": ""
} |
q179194 | broadcastTopologyUpdate | test | func (router *Router) broadcastTopologyUpdate(update []*Peer) {
names := make(peerNameSet)
for _, p := range update {
names[p.Name] = struct{}{}
}
router.topologyGossip.GossipBroadcast(&topologyGossipData{peers: router.Peers, update: names})
} | go | {
"resource": ""
} |
q179195 | OnGossipUnicast | test | func (router *Router) OnGossipUnicast(sender PeerName, msg []byte) error {
return fmt.Errorf("unexpected topology gossip unicast: %v", msg)
} | go | {
"resource": ""
} |
q179196 | OnGossipBroadcast | test | func (router *Router) OnGossipBroadcast(_ PeerName, update []byte) (GossipData, error) {
origUpdate, _, err := router.applyTopologyUpdate(update)
if err != nil || len(origUpdate) == 0 {
return nil, err
}
return &topologyGossipData{peers: router.Peers, update: origUpdate}, nil
} | go | {
"resource": ""
} |
q179197 | Gossip | test | func (router *Router) Gossip() GossipData {
return &topologyGossipData{peers: router.Peers, update: router.Peers.names()}
} | go | {
"resource": ""
} |
q179198 | OnGossip | test | func (router *Router) OnGossip(update []byte) (GossipData, error) {
_, newUpdate, err := router.applyTopologyUpdate(update)
if err != nil || len(newUpdate) == 0 {
return nil, err
}
return &topologyGossipData{peers: router.Peers, update: newUpdate}, nil
} | go | {
"resource": ""
} |
q179199 | Encode | test | func (d *topologyGossipData) Encode() [][]byte {
return [][]byte{d.peers.encodePeers(d.update)}
} | go | {
"resource": ""
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.