_id stringlengths 2 7 | title stringlengths 1 118 | partition stringclasses 3
values | text stringlengths 52 85.5k | language stringclasses 1
value | meta_information dict |
|---|---|---|---|---|---|
q26600 | String | train | func (rat radiusAttributeType) String() string {
if name, ok := ratNames[rat]; ok {
return name
}
return fmt.Sprintf("(unknown %d)", rat)
} | go | {
"resource": ""
} |
q26601 | radiusPassword | train | func radiusPassword(passwd, secret string, authenticator *radiusAuthenticator) []byte {
const blockSize = 16
length := (len(passwd) + 0xf) &^ 0xf
if length > 128 {
length = 128
}
blocks := make([]byte, length)
copy(blocks, []byte(passwd))
for i := 0; i < length; i += blockSize {
hash := md5.New()
hash.Writ... | go | {
"resource": ""
} |
q26602 | responseAuthenticator | train | func responseAuthenticator(rp *radiusPacket, requestAuthenticator *radiusAuthenticator, secret string) (*radiusAuthenticator, error) {
hash := md5.New()
hash.Write([]byte{byte(rp.Code), byte(rp.Identifier)})
if err := binary.Write(hash, binary.BigEndian, rp.Length); err != nil {
return nil, err
}
hash.Write(requ... | go | {
"resource": ""
} |
q26603 | NewRADIUSChecker | train | func NewRADIUSChecker(ip net.IP, port int) *RADIUSChecker {
return &RADIUSChecker{
Target: Target{
IP: ip,
Port: port,
Proto: seesaw.IPProtoUDP,
},
Response: "accept",
}
} | go | {
"resource": ""
} |
q26604 | NewCluster | train | func NewCluster(site string) *Cluster {
return &Cluster{
Site: site,
BGPPeers: make(map[string]*seesaw.Host),
Nodes: make(map[string]*seesaw.Node),
VIPSubnets: make(map[string]*net.IPNet),
Vservers: make(map[string]*Vserver),
VLANs: make(map[uint16]*seesaw.VLAN),
Status: seesaw.Config... | go | {
"resource": ""
} |
q26605 | AddBGPPeer | train | func (c *Cluster) AddBGPPeer(peer *seesaw.Host) error {
key := peer.Hostname
if _, ok := c.BGPPeers[key]; ok {
return fmt.Errorf("Cluster %q already contains peer %q", c.Site, key)
}
c.BGPPeers[key] = peer
return nil
} | go | {
"resource": ""
} |
q26606 | AddNode | train | func (c *Cluster) AddNode(node *seesaw.Node) error {
key := node.Key()
if _, ok := c.Nodes[key]; ok {
return fmt.Errorf("Cluster %q already contains Node %q", c.Site, key)
}
c.Nodes[key] = node
return nil
} | go | {
"resource": ""
} |
q26607 | AddVIPSubnet | train | func (c *Cluster) AddVIPSubnet(subnet *net.IPNet) error {
key := subnet.String()
if _, ok := c.VIPSubnets[key]; ok {
return fmt.Errorf("Cluster %q already contains VIP Subnet %q", c.Site, key)
}
c.VIPSubnets[key] = subnet
return nil
} | go | {
"resource": ""
} |
q26608 | AddVserver | train | func (c *Cluster) AddVserver(vserver *Vserver) error {
key := vserver.Key()
if _, ok := c.Vservers[key]; ok {
return fmt.Errorf("Cluster %q already contains Vserver %q", c.Site, key)
}
c.Vservers[key] = vserver
return nil
} | go | {
"resource": ""
} |
q26609 | AddVLAN | train | func (c *Cluster) AddVLAN(vlan *seesaw.VLAN) error {
key := vlan.Key()
if _, ok := c.VLANs[key]; ok {
return fmt.Errorf("Cluster %q already contains VLAN %q", c.Site, key)
}
c.VLANs[key] = vlan
return nil
} | go | {
"resource": ""
} |
q26610 | Equal | train | func (c *Cluster) Equal(other *Cluster) bool {
return reflect.DeepEqual(c, other)
} | go | {
"resource": ""
} |
q26611 | NewVserver | train | func NewVserver(name string, host seesaw.Host) *Vserver {
return &Vserver{
Name: name,
Host: host,
Entries: make(map[string]*VserverEntry),
Backends: make(map[string]*seesaw.Backend),
Healthchecks: make(map[string]*Healthcheck),
VIPs: make(map[string]*seesaw.VIP),
Warning... | go | {
"resource": ""
} |
q26612 | AddVserverEntry | train | func (v *Vserver) AddVserverEntry(e *VserverEntry) error {
key := e.Key()
if _, ok := v.Entries[key]; ok {
return fmt.Errorf("Vserver %q already contains VserverEntry %q", v.Name, key)
}
v.Entries[key] = e
return nil
} | go | {
"resource": ""
} |
q26613 | AddBackend | train | func (v *Vserver) AddBackend(backend *seesaw.Backend) error {
key := backend.Key()
if _, ok := v.Backends[key]; ok {
return fmt.Errorf("Vserver %q already contains Backend %q", v.Name, key)
}
v.Backends[key] = backend
return nil
} | go | {
"resource": ""
} |
q26614 | AddHealthcheck | train | func (v *Vserver) AddHealthcheck(h *Healthcheck) error {
key := h.Key()
if _, ok := v.Healthchecks[key]; ok {
return fmt.Errorf("Vserver %q already contains Healthcheck %q", v.Name, key)
}
v.Healthchecks[key] = h
return nil
} | go | {
"resource": ""
} |
q26615 | AddVIP | train | func (v *Vserver) AddVIP(vip *seesaw.VIP) error {
key := vip.String()
if _, ok := v.VIPs[key]; ok {
return fmt.Errorf("Vserver %q already contains VIP %q", v.Name, key)
}
v.VIPs[key] = vip
return nil
} | go | {
"resource": ""
} |
q26616 | NewVserverEntry | train | func NewVserverEntry(port uint16, proto seesaw.IPProto) *VserverEntry {
return &VserverEntry{
Port: port,
Proto: proto,
Healthchecks: make(map[string]*Healthcheck),
}
} | go | {
"resource": ""
} |
q26617 | Key | train | func (v *VserverEntry) Key() string {
return fmt.Sprintf("%d/%s", v.Port, v.Proto)
} | go | {
"resource": ""
} |
q26618 | Snapshot | train | func (v *VserverEntry) Snapshot() *seesaw.VserverEntry {
return &seesaw.VserverEntry{
Port: v.Port,
Proto: v.Proto,
Scheduler: v.Scheduler,
Mode: v.Mode,
Persistence: v.Persistence,
OnePacket: v.OnePacket,
HighWatermark: v.HighWatermark,
LowWatermark: v.LowWatermark... | go | {
"resource": ""
} |
q26619 | NewHealthcheck | train | func NewHealthcheck(m seesaw.HealthcheckMode, t seesaw.HealthcheckType, port uint16) *Healthcheck {
return &Healthcheck{
Mode: m,
Type: t,
Port: port,
}
} | go | {
"resource": ""
} |
q26620 | quaggaBGP | train | func quaggaBGP(asn uint32) (*quagga.BGP, error) {
bgp := quagga.NewBGP("", asn)
if err := bgp.Dial(); err != nil {
return nil, err
}
if err := bgp.Enable(); err != nil {
bgp.Close()
return nil, err
}
return bgp, nil
} | go | {
"resource": ""
} |
q26621 | BGPConfig | train | func (ncc *SeesawNCC) BGPConfig(unused int, cfg *ncctypes.BGPConfig) error {
bgp, err := quaggaBGP(seesawASN)
if err != nil {
return err
}
defer bgp.Close()
bgpCfg, err := bgp.Configuration()
if err != nil {
return err
}
if cfg != nil {
cfg.Config = bgpCfg
}
return nil
} | go | {
"resource": ""
} |
q26622 | BGPNeighbors | train | func (ncc *SeesawNCC) BGPNeighbors(unused int, neighbors *ncctypes.BGPNeighbors) error {
bgp, err := quaggaBGP(seesawASN)
if err != nil {
return err
}
defer bgp.Close()
bgpNeighbors, err := bgp.Neighbors()
if err != nil {
return err
}
if neighbors != nil {
neighbors.Neighbors = bgpNeighbors
}
return nil... | go | {
"resource": ""
} |
q26623 | hostMask | train | func hostMask(ip net.IP) net.IPMask {
var hl int
if ip.To4() != nil {
hl = net.IPv4len * 8
} else {
hl = net.IPv6len * 8
}
return net.CIDRMask(hl, hl)
} | go | {
"resource": ""
} |
q26624 | BGPWithdrawAll | train | func (ncc *SeesawNCC) BGPWithdrawAll(unused int, reply *int) error {
bgp, err := quaggaBGP(seesawASN)
if err != nil {
return err
}
defer bgp.Close()
bgpCfg, err := bgp.Configuration()
if err != nil {
return err
}
// Find the network statements within the router bgp section.
bgpStr := fmt.Sprintf("router ... | go | {
"resource": ""
} |
q26625 | BGPAdvertiseVIP | train | func (ncc *SeesawNCC) BGPAdvertiseVIP(vip net.IP, unused *int) error {
bgp, err := quaggaBGP(seesawASN)
if err != nil {
return err
}
defer bgp.Close()
return bgp.Advertise(&net.IPNet{IP: vip, Mask: hostMask(vip)})
} | go | {
"resource": ""
} |
q26626 | newHAManager | train | func newHAManager(engine *Engine, timeout time.Duration) *haManager {
now := time.Now()
return &haManager{
engine: engine,
status: seesaw.HAStatus{
LastUpdate: now,
Since: now,
State: seesaw.HAUnknown,
},
timeout: timeout,
stateChan: make(chan seesaw.HAState, 1),
statusChan: make(ch... | go | {
"resource": ""
} |
q26627 | state | train | func (h *haManager) state() seesaw.HAState {
h.statusLock.RLock()
defer h.statusLock.RUnlock()
return h.status.State
} | go | {
"resource": ""
} |
q26628 | enable | train | func (h *haManager) enable() {
if h.state() == seesaw.HADisabled {
h.setState(seesaw.HAUnknown)
}
} | go | {
"resource": ""
} |
q26629 | failover | train | func (h *haManager) failover() bool {
h.failoverLock.Lock()
pending := h.failoverPending
h.failoverPending = false
h.failoverLock.Unlock()
return pending
} | go | {
"resource": ""
} |
q26630 | requestFailover | train | func (h *haManager) requestFailover(peer bool) error {
state := h.state()
if state == seesaw.HAMaster {
h.failoverLock.Lock()
defer h.failoverLock.Unlock()
if h.failoverPending {
return fmt.Errorf("Failover request already pending")
}
h.failoverPending = true
return nil
}
if peer {
return fmt.Erro... | go | {
"resource": ""
} |
q26631 | setState | train | func (h *haManager) setState(s seesaw.HAState) {
state := h.state()
if state == seesaw.HADisabled && s != seesaw.HAUnknown {
log.Warningf("Invalid HA state transition %v -> %v", state, s)
return
}
if state != s {
log.Infof("HA state transition %v -> %v starting", state, s)
if s == seesaw.HAMaster {
h.e... | go | {
"resource": ""
} |
q26632 | setStatus | train | func (h *haManager) setStatus(s seesaw.HAStatus) {
h.setState(s.State)
h.statusLock.Lock()
h.status.Since = s.Since
h.status.Sent = s.Sent
h.status.Received = s.Received
h.status.Transitions = s.Transitions
h.statusLock.Unlock()
} | go | {
"resource": ""
} |
q26633 | timer | train | func (h *haManager) timer() <-chan time.Time {
if s := h.state(); s == seesaw.HADisabled || s == seesaw.HAUnknown {
return make(chan time.Time)
}
// TODO(angusc): Make this clock-jump safe.
h.statusLock.RLock()
deadline := h.status.LastUpdate.Add(h.timeout)
h.statusLock.RUnlock()
return time.After(deadline.Sub... | go | {
"resource": ""
} |
q26634 | Execute | train | func (cli *SeesawCLI) Execute(cmdline string) error {
cmd, subcmds, _, args := FindCommand(cmdline)
if cmd != nil {
return cmd.function(cli, args)
}
if subcmds != nil {
return errors.New("Incomplete command.")
}
return errors.New("Unknown command.")
} | go | {
"resource": ""
} |
q26635 | FindCommand | train | func FindCommand(cmdline string) (*Command, *[]Command, []*Command, []string) {
var chain []*Command
var matches []Command
var next *Command
cmds := &commands
// Tokenise string.
cmdstr := strings.Fields(cmdline)
if len(cmdstr) == 0 {
return nil, cmds, chain, nil
}
for idx, subcmd := range cmdstr {
match... | go | {
"resource": ""
} |
q26636 | String | train | func (s BGPState) String() string {
if name, ok := stateNames[s]; ok {
return name
}
return "Unknown"
} | go | {
"resource": ""
} |
q26637 | BGPStateByName | train | func BGPStateByName(name string) BGPState {
name = strings.ToLower(name)
for s := range stateNames {
if strings.ToLower(stateNames[s]) == name {
return s
}
}
return BGPStateUnknown
} | go | {
"resource": ""
} |
q26638 | NewBGP | train | func NewBGP(socket string, asn uint32) *BGP {
if socket == "" {
socket = BGPSocketPath
}
return &BGP{
vty: NewVTY(socket),
asn: asn,
}
} | go | {
"resource": ""
} |
q26639 | Enable | train | func (b *BGP) Enable() error {
_, err := b.vty.Command("enable")
return err
} | go | {
"resource": ""
} |
q26640 | Configuration | train | func (b *BGP) Configuration() ([]string, error) {
cfg, err := b.vty.Command("write terminal")
if err != nil {
return nil, err
}
return strings.Split(cfg, "\n"), nil
} | go | {
"resource": ""
} |
q26641 | Neighbors | train | func (b *BGP) Neighbors() ([]*Neighbor, error) {
ni, err := b.vty.Command("show ip bgp neighbors")
if err != nil {
return nil, err
}
// TODO(jsing): Include details for advertised/received routes.
return parseNeighbors(ni), nil
} | go | {
"resource": ""
} |
q26642 | network | train | func (b *BGP) network(n *net.IPNet, advertise bool) error {
var prefix string
if !advertise {
prefix = "no "
}
family := "ipv4 unicast"
if n.IP.To4() == nil {
family = "ipv6"
}
prefixLen, _ := n.Mask.Size()
cmds := []string{
"configure terminal",
fmt.Sprintf("router bgp %d", b.asn),
fmt.Sprintf("addre... | go | {
"resource": ""
} |
q26643 | Advertise | train | func (b *BGP) Advertise(n *net.IPNet) error {
return b.network(n, true)
} | go | {
"resource": ""
} |
q26644 | Withdraw | train | func (b *BGP) Withdraw(n *net.IPNet) error {
return b.network(n, false)
} | go | {
"resource": ""
} |
q26645 | parseNeighbors | train | func parseNeighbors(sn string) []*Neighbor {
neighbors := make([]*Neighbor, 0)
var neighbor *Neighbor
var msgStats bool
for _, s := range strings.Split(sn, "\n") {
if nm := neighborRE.FindStringSubmatch(s); nm != nil {
asn, _ := strconv.ParseUint(nm[2], 10, 32)
neighbor = &Neighbor{
IP: net.ParseIP(nm[... | go | {
"resource": ""
} |
q26646 | NewUDPChecker | train | func NewUDPChecker(ip net.IP, port int) *UDPChecker {
return &UDPChecker{
Target: Target{
IP: ip,
Port: port,
Proto: seesaw.IPProtoUDP,
},
}
} | go | {
"resource": ""
} |
q26647 | Check | train | func (hc *UDPChecker) Check(timeout time.Duration) *Result {
msg := fmt.Sprintf("UDP check to %s", hc.addr())
start := time.Now()
if timeout == time.Duration(0) {
timeout = defaultUDPTimeout
}
deadline := start.Add(timeout)
conn, err := dialUDP(hc.network(), hc.addr(), timeout, hc.Mark)
if err != nil {
msg ... | go | {
"resource": ""
} |
q26648 | cfgOpt | train | func cfgOpt(cfg *conf.ConfigFile, section, option string) string {
if !cfg.HasOption(section, option) {
return ""
}
s, err := cfg.GetString(section, option)
if err != nil {
log.Exitf("Failed to get %s for %s: %v", option, section, err)
}
return s
} | go | {
"resource": ""
} |
q26649 | cfgIP | train | func cfgIP(cfg *conf.ConfigFile, section, option string) (net.IP, error) {
ipStr := cfgOpt(cfg, section, option)
if ipStr == "" {
return nil, nil
}
ip := net.ParseIP(ipStr)
if ip == nil {
return nil, fmt.Errorf("%s: %q is not a valid IP address", option, ipStr)
}
return ip, nil
} | go | {
"resource": ""
} |
q26650 | Close | train | func (r *raftLog) Close() error {
r.Lock()
if r.closed {
r.Unlock()
return nil
}
r.closed = true
err := r.conn.Close()
r.Unlock()
return err
} | go | {
"resource": ""
} |
q26651 | FirstIndex | train | func (r *raftLog) FirstIndex() (uint64, error) {
r.RLock()
idx, err := r.getIndex(true)
r.RUnlock()
return idx, err
} | go | {
"resource": ""
} |
q26652 | LastIndex | train | func (r *raftLog) LastIndex() (uint64, error) {
r.RLock()
idx, err := r.getIndex(false)
r.RUnlock()
return idx, err
} | go | {
"resource": ""
} |
q26653 | GetLog | train | func (r *raftLog) GetLog(idx uint64, log *raft.Log) error {
r.RLock()
tx, err := r.conn.Begin(false)
if err != nil {
r.RUnlock()
return err
}
var key [8]byte
binary.BigEndian.PutUint64(key[:], idx)
bucket := tx.Bucket(logsBucket)
val := bucket.Get(key[:])
if val == nil {
err = raft.ErrLogNotFound
} else... | go | {
"resource": ""
} |
q26654 | StoreLog | train | func (r *raftLog) StoreLog(log *raft.Log) error {
return r.StoreLogs([]*raft.Log{log})
} | go | {
"resource": ""
} |
q26655 | StoreLogs | train | func (r *raftLog) StoreLogs(logs []*raft.Log) error {
r.Lock()
tx, err := r.conn.Begin(true)
if err != nil {
r.Unlock()
return err
}
bucket := tx.Bucket(logsBucket)
for _, log := range logs {
var (
key [8]byte
val []byte
)
binary.BigEndian.PutUint64(key[:], log.Index)
val, err = r.encodeRaftLog(... | go | {
"resource": ""
} |
q26656 | DeleteRange | train | func (r *raftLog) DeleteRange(min, max uint64) (retErr error) {
r.Lock()
defer r.Unlock()
start := time.Now()
r.log.Noticef("Deleting raft logs from %v to %v", min, max)
err := r.deleteRange(min, max)
dur := time.Since(start)
durTxt := fmt.Sprintf("Deletion took %v", dur)
if dur > 2*time.Second {
r.log.Error... | go | {
"resource": ""
} |
q26657 | Set | train | func (r *raftLog) Set(k, v []byte) error {
r.Lock()
tx, err := r.conn.Begin(true)
if err != nil {
r.Unlock()
return err
}
bucket := tx.Bucket(confBucket)
err = bucket.Put(k, v)
if err != nil {
tx.Rollback()
} else {
err = tx.Commit()
}
r.Unlock()
return err
} | go | {
"resource": ""
} |
q26658 | Get | train | func (r *raftLog) Get(k []byte) ([]byte, error) {
r.RLock()
tx, err := r.conn.Begin(false)
if err != nil {
r.RUnlock()
return nil, err
}
var v []byte
bucket := tx.Bucket(confBucket)
val := bucket.Get(k)
if val == nil {
err = errKeyNotFound
} else {
// Make a copy
v = append([]byte(nil), val...)
}
t... | go | {
"resource": ""
} |
q26659 | SetUint64 | train | func (r *raftLog) SetUint64(k []byte, v uint64) error {
var vbytes [8]byte
binary.BigEndian.PutUint64(vbytes[:], v)
err := r.Set(k, vbytes[:])
return err
} | go | {
"resource": ""
} |
q26660 | GetUint64 | train | func (r *raftLog) GetUint64(k []byte) (uint64, error) {
var v uint64
vbytes, err := r.Get(k)
if err == nil {
v = binary.BigEndian.Uint64(vbytes)
}
return v, err
} | go | {
"resource": ""
} |
q26661 | Restore | train | func (r *raftFSM) Restore(snapshot io.ReadCloser) (retErr error) {
s := r.server
defer snapshot.Close()
r.Lock()
defer r.Unlock()
// This function may be invoked directly from raft.NewRaft() when
// the node is initialized and if there were exisiting local snapshots,
// or later, when catching up with a leader... | go | {
"resource": ""
} |
q26662 | NewRaftStore | train | func NewRaftStore(log logger.Logger, s Store, limits *StoreLimits) *RaftStore {
return &RaftStore{Store: s, log: log}
} | go | {
"resource": ""
} |
q26663 | setLimits | train | func (gs *genericStore) setLimits(limits *StoreLimits) error {
// Make a copy.
gs.limits = limits.Clone()
// Build will validate and apply inheritance if no error.
if err := gs.limits.Build(); err != nil {
return err
}
// We don't need the PerChannel map and the sublist. So replace
// the map with the sublist ... | go | {
"resource": ""
} |
q26664 | getChannelLimits | train | func (gs *genericStore) getChannelLimits(channel string) *ChannelLimits {
r := gs.sublist.Match(channel)
if len(r) == 0 {
// If there is no match, that means we need to use the global limits.
return &gs.limits.ChannelLimits
}
// If there is a match, use the limits from the last element because
// we know that ... | go | {
"resource": ""
} |
q26665 | GetChannelLimits | train | func (gs *genericStore) GetChannelLimits(channel string) *ChannelLimits {
gs.RLock()
defer gs.RUnlock()
c := gs.channels[channel]
if c == nil {
return nil
}
// Return a copy
cl := *gs.getChannelLimits(channel)
return &cl
} | go | {
"resource": ""
} |
q26666 | SetLimits | train | func (gs *genericStore) SetLimits(limits *StoreLimits) error {
gs.Lock()
err := gs.setLimits(limits)
gs.Unlock()
return err
} | go | {
"resource": ""
} |
q26667 | canAddChannel | train | func (gs *genericStore) canAddChannel(name string) error {
if gs.channels[name] != nil {
return ErrAlreadyExists
}
if gs.limits.MaxChannels > 0 && len(gs.channels) >= gs.limits.MaxChannels {
return ErrTooManyChannels
}
return nil
} | go | {
"resource": ""
} |
q26668 | Close | train | func (gs *genericStore) Close() error {
gs.Lock()
defer gs.Unlock()
if gs.closed {
return nil
}
gs.closed = true
return gs.close()
} | go | {
"resource": ""
} |
q26669 | close | train | func (gs *genericStore) close() error {
var err error
var lerr error
for _, cs := range gs.channels {
lerr = cs.Subs.Close()
if lerr != nil && err == nil {
err = lerr
}
lerr = cs.Msgs.Close()
if lerr != nil && err == nil {
err = lerr
}
}
return err
} | go | {
"resource": ""
} |
q26670 | State | train | func (gms *genericMsgStore) State() (numMessages int, byteSize uint64, err error) {
gms.RLock()
c, b := gms.totalCount, gms.totalBytes
gms.RUnlock()
return c, b, nil
} | go | {
"resource": ""
} |
q26671 | FirstSequence | train | func (gms *genericMsgStore) FirstSequence() (uint64, error) {
gms.RLock()
first := gms.first
gms.RUnlock()
return first, nil
} | go | {
"resource": ""
} |
q26672 | LastSequence | train | func (gms *genericMsgStore) LastSequence() (uint64, error) {
gms.RLock()
last := gms.last
gms.RUnlock()
return last, nil
} | go | {
"resource": ""
} |
q26673 | FirstAndLastSequence | train | func (gms *genericMsgStore) FirstAndLastSequence() (uint64, uint64, error) {
gms.RLock()
first, last := gms.first, gms.last
gms.RUnlock()
return first, last, nil
} | go | {
"resource": ""
} |
q26674 | CreateSub | train | func (gss *genericSubStore) CreateSub(sub *spb.SubState) error {
gss.Lock()
err := gss.createSub(sub)
gss.Unlock()
return err
} | go | {
"resource": ""
} |
q26675 | createSub | train | func (gss *genericSubStore) createSub(sub *spb.SubState) error {
if gss.limits.MaxSubscriptions > 0 && len(gss.subs) >= gss.limits.MaxSubscriptions {
return ErrTooManySubs
}
// Bump the max value before assigning it to the new subscription.
gss.maxSubID++
// This new subscription has the max value.
sub.ID = g... | go | {
"resource": ""
} |
q26676 | initPartitions | train | func (s *StanServer) initPartitions() error {
// The option says that the server should only use the pre-defined channels,
// but none was specified. Don't see the point in continuing...
if len(s.opts.StoreLimits.PerChannel) == 0 {
return ErrNoChannel
}
nc, err := s.createNatsClientConn("pc")
if err != nil {
... | go | {
"resource": ""
} |
q26677 | createChannelsMapAndSublist | train | func (p *partitions) createChannelsMapAndSublist(storeChannels map[string]*stores.ChannelLimits) {
p.channels = make([]string, 0, len(storeChannels))
p.sl = util.NewSublist()
for c := range storeChannels {
p.channels = append(p.channels, c)
// When creating the store, we have already checked that channel names
... | go | {
"resource": ""
} |
q26678 | topologyChanged | train | func (p *partitions) topologyChanged(_ *nats.Conn) {
p.Lock()
defer p.Unlock()
if p.isShutdown {
return
}
// Let's wait before checking (sending the list and waiting for a reply)
// so that the new NATS Server has a chance to send its local
// subscriptions to the rest of the cluster. That will reduce the risk... | go | {
"resource": ""
} |
q26679 | initSubscriptions | train | func (p *partitions) initSubscriptions() error {
// NOTE: Use the server's nc connection here, not the partitions' one.
for _, channelName := range p.channels {
pubSubject := fmt.Sprintf("%s.%s", p.s.info.Publish, channelName)
if _, err := p.s.nc.Subscribe(pubSubject, p.s.processClientPublish); err != nil {
re... | go | {
"resource": ""
} |
q26680 | processChannelsListRequests | train | func (p *partitions) processChannelsListRequests(m *nats.Msg) {
// Message cannot be empty, we are supposed to receive
// a spb.CtrlMsg_Partitioning protocol. We should also
// have a repy subject
if len(m.Data) == 0 || m.Reply == "" {
return
}
req := spb.CtrlMsg{}
if err := req.Unmarshal(m.Data); err != nil {... | go | {
"resource": ""
} |
q26681 | shutdown | train | func (p *partitions) shutdown() {
p.Lock()
defer p.Unlock()
if p.isShutdown {
return
}
p.isShutdown = true
if p.nc != nil {
p.nc.Close()
}
} | go | {
"resource": ""
} |
q26682 | checkType | train | func checkType(name string, kind reflect.Kind, v interface{}) error {
actualKind := reflect.TypeOf(v).Kind()
if actualKind != kind {
return fmt.Errorf("parameter %q value is expected to be %v, got %v",
name, kind.String(), actualKind.String())
}
return nil
} | go | {
"resource": ""
} |
q26683 | parseTLS | train | func parseTLS(itf interface{}, opts *Options) error {
m, ok := itf.(map[string]interface{})
if !ok {
return fmt.Errorf("expected TLS to be a map/struct, got %v", itf)
}
for k, v := range m {
name := strings.ToLower(k)
switch name {
case "client_cert":
if err := checkType(k, reflect.String, v); err != nil... | go | {
"resource": ""
} |
q26684 | parseStoreLimits | train | func parseStoreLimits(itf interface{}, opts *Options) error {
m, ok := itf.(map[string]interface{})
if !ok {
return fmt.Errorf("expected store limits to be a map/struct, got %v", itf)
}
for k, v := range m {
name := strings.ToLower(k)
switch name {
case "mc", "max_channels", "maxchannels":
if err := chec... | go | {
"resource": ""
} |
q26685 | parseChannelLimits | train | func parseChannelLimits(cl *stores.ChannelLimits, k, name string, v interface{}, isGlobal bool) error {
switch name {
case "msu", "max_subs", "max_subscriptions", "maxsubscriptions":
if err := checkType(k, reflect.Int64, v); err != nil {
return err
}
cl.MaxSubscriptions = int(v.(int64))
if !isGlobal && cl.... | go | {
"resource": ""
} |
q26686 | parsePerChannelLimits | train | func parsePerChannelLimits(itf interface{}, opts *Options) error {
m, ok := itf.(map[string]interface{})
if !ok {
return fmt.Errorf("expected per channel limits to be a map/struct, got %v", itf)
}
for channelName, limits := range m {
limitsMap, ok := limits.(map[string]interface{})
if !ok {
return fmt.Erro... | go | {
"resource": ""
} |
q26687 | getBytes | train | func getBytes(f *flag.Flag) (int64, error) {
var res map[string]interface{}
// Use NATS parser to do the conversion for us.
res, err := conf.Parse(fmt.Sprintf("bytes: %v", f.Value.String()))
if err != nil {
return 0, err
}
resVal := res["bytes"]
if resVal == nil || reflect.TypeOf(resVal).Kind() != reflect.Int6... | go | {
"resource": ""
} |
q26688 | addToCache | train | func (s *Sublist) addToCache(subject string, element interface{}) {
for k, r := range s.cache {
if matchLiteral(k, subject) {
// Copy since others may have a reference.
nr := append([]interface{}(nil), r...)
nr = append(nr, element)
s.cache[k] = nr
}
}
} | go | {
"resource": ""
} |
q26689 | removeFromCache | train | func (s *Sublist) removeFromCache(subject string) {
for k := range s.cache {
if !matchLiteral(k, subject) {
continue
}
// Since someone else may be referencing, can't modify the list
// safely, just let it re-populate.
delete(s.cache, k)
}
} | go | {
"resource": ""
} |
q26690 | Match | train | func (s *Sublist) Match(subject string) []interface{} {
s.RLock()
rc, ok := s.cache[subject]
s.RUnlock()
if ok {
return rc
}
tsa := [32]string{}
tokens := tsa[:0]
start := 0
for i := 0; i < len(subject); i++ {
if subject[i] == btsep {
tokens = append(tokens, subject[start:i])
start = i + 1
}
}
t... | go | {
"resource": ""
} |
q26691 | Remove | train | func (s *Sublist) Remove(subject string, element interface{}) error {
tsa := [32]string{}
tokens := tsa[:0]
start := 0
for i := 0; i < len(subject); i++ {
if subject[i] == btsep {
tokens = append(tokens, subject[start:i])
start = i + 1
}
}
tokens = append(tokens, subject[start:])
s.Lock()
defer s.Unl... | go | {
"resource": ""
} |
q26692 | removeFromList | train | func removeFromList(element interface{}, l []interface{}) ([]interface{}, bool) {
for i := 0; i < len(l); i++ {
if l[i] == element {
last := len(l) - 1
l[i] = l[last]
l[last] = nil
l = l[:last]
return shrinkAsNeeded(l), true
}
}
return l, false
} | go | {
"resource": ""
} |
q26693 | shrinkAsNeeded | train | func shrinkAsNeeded(l []interface{}) []interface{} {
ll := len(l)
cl := cap(l)
// Don't bother if list not too big
if cl <= 8 {
return l
}
pFree := float32(cl-ll) / float32(cl)
if pFree > 0.50 {
return append([]interface{}(nil), l...)
}
return l
} | go | {
"resource": ""
} |
q26694 | CacheCount | train | func (s *Sublist) CacheCount() int {
s.RLock()
defer s.RUnlock()
return len(s.cache)
} | go | {
"resource": ""
} |
q26695 | startDeleteTimer | train | func (c *channel) startDeleteTimer() {
c.activity.last = time.Now()
c.resetDeleteTimer(c.activity.maxInactivity)
} | go | {
"resource": ""
} |
q26696 | stopDeleteTimer | train | func (c *channel) stopDeleteTimer() {
if c.activity.timer != nil {
c.activity.timer.Stop()
c.activity.timerSet = false
if c.stan.debug {
c.stan.log.Debugf("Channel %q delete timer stopped", c.name)
}
}
} | go | {
"resource": ""
} |
q26697 | resetDeleteTimer | train | func (c *channel) resetDeleteTimer(newDuration time.Duration) {
a := c.activity
if a.timer == nil {
a.timer = time.AfterFunc(newDuration, func() {
c.stan.sendDeleteChannelRequest(c)
})
} else {
a.timer.Reset(newDuration)
}
if c.stan.debug {
c.stan.log.Debugf("Channel %q delete timer set to fire in %v", ... | go | {
"resource": ""
} |
q26698 | pubMsgToMsgProto | train | func (c *channel) pubMsgToMsgProto(pm *pb.PubMsg, seq uint64) *pb.MsgProto {
m := &pb.MsgProto{
Sequence: seq,
Subject: pm.Subject,
Reply: pm.Reply,
Data: pm.Data,
Timestamp: time.Now().UnixNano(),
}
if c.lTimestamp > 0 && m.Timestamp < c.lTimestamp {
m.Timestamp = c.lTimestamp
}
c.lTimesta... | go | {
"resource": ""
} |
q26699 | subToSnapshotRestoreRequests | train | func (s *StanServer) subToSnapshotRestoreRequests() error {
var (
msgBuf []byte
buf []byte
snapshotRestorePrefix = fmt.Sprintf("%s.%s.", defaultSnapshotPrefix, s.info.ClusterID)
prefixLen = len(snapshotRestorePrefix)
)
sub, err := s.ncsr.Subscribe(snapshotRestoreP... | go | {
"resource": ""
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.