_id stringlengths 2 7 | title stringlengths 1 118 | partition stringclasses 3
values | text stringlengths 52 85.5k | language stringclasses 1
value | meta_information dict |
|---|---|---|---|---|---|
q26400 | Bytes | train | func (f ServiceFlags) Bytes() []byte {
x := make([]byte, 8)
var b [4]byte
*(*uint32)(unsafe.Pointer(&b)) = uint32(f)
copy(x[:4], b[:])
*(*uint32)(unsafe.Pointer(&b)) = ^uint32(0)
copy(x[4:], b[:])
return x
} | go | {
"resource": ""
} |
q26401 | SetBytes | train | func (f *ServiceFlags) SetBytes(x []byte) {
var b [4]byte
copy(b[:], x)
*f = ServiceFlags(*(*uint32)(unsafe.Pointer(&b)))
} | go | {
"resource": ""
} |
q26402 | Equal | train | func (svc Service) Equal(other Service) bool {
return svc.Address.Equal(other.Address) &&
svc.Protocol == other.Protocol &&
svc.Port == other.Port &&
svc.FirewallMark == other.FirewallMark &&
svc.Scheduler == other.Scheduler &&
svc.Flags == other.Flags &&
svc.Timeout == other.Timeout &&
svc.PersistenceEn... | go | {
"resource": ""
} |
q26403 | String | train | func (svc Service) String() string {
switch {
case svc.FirewallMark > 0:
return fmt.Sprintf("FWM %d (%s)", svc.FirewallMark, svc.Scheduler)
case svc.Address.To4() == nil:
return fmt.Sprintf("%v [%v]:%d (%s)", svc.Protocol, svc.Address, svc.Port, svc.Scheduler)
default:
return fmt.Sprintf("%v %v:%d (%s)", svc.... | go | {
"resource": ""
} |
q26404 | Equal | train | func (dest Destination) Equal(other Destination) bool {
return dest.Address.Equal(other.Address) &&
dest.Port == other.Port &&
dest.Weight == other.Weight &&
dest.Flags == other.Flags &&
dest.LowerThreshold == other.LowerThreshold &&
dest.UpperThreshold == other.UpperThreshold
} | go | {
"resource": ""
} |
q26405 | String | train | func (dest Destination) String() string {
addr := dest.Address.String()
if dest.Address.To4() == nil {
addr = fmt.Sprintf("[%s]", addr)
}
return fmt.Sprintf("%s:%d", addr, dest.Port)
} | go | {
"resource": ""
} |
q26406 | Init | train | func Init() error {
var err error
family, err = netlink.Family(familyName)
if err != nil {
return err
}
return netlink.SendMessageUnmarshal(C.IPVS_CMD_GET_INFO, family, 0, &info)
} | go | {
"resource": ""
} |
q26407 | Version | train | func Version() IPVSVersion {
v := uint(info.Version)
return IPVSVersion{
Major: (v >> 16) & 0xff,
Minor: (v >> 8) & 0xff,
Patch: v & 0xff,
}
} | go | {
"resource": ""
} |
q26408 | AddService | train | func AddService(svc Service) error {
ic := &ipvsCommand{Service: newIPVSService(&svc)}
if err := netlink.SendMessageMarshalled(C.IPVS_CMD_NEW_SERVICE, family, 0, ic); err != nil {
return err
}
for _, dst := range svc.Destinations {
if err := AddDestination(svc, *dst); err != nil {
return err
}
}
return n... | go | {
"resource": ""
} |
q26409 | UpdateService | train | func UpdateService(svc Service) error {
ic := &ipvsCommand{Service: newIPVSService(&svc)}
return netlink.SendMessageMarshalled(C.IPVS_CMD_SET_SERVICE, family, 0, ic)
} | go | {
"resource": ""
} |
q26410 | DeleteService | train | func DeleteService(svc Service) error {
ic := &ipvsCommand{Service: newIPVSService(&svc)}
return netlink.SendMessageMarshalled(C.IPVS_CMD_DEL_SERVICE, family, 0, ic)
} | go | {
"resource": ""
} |
q26411 | AddDestination | train | func AddDestination(svc Service, dst Destination) error {
ic := &ipvsCommand{
Service: newIPVSService(&svc),
Destination: newIPVSDestination(&dst),
}
return netlink.SendMessageMarshalled(C.IPVS_CMD_NEW_DEST, family, 0, ic)
} | go | {
"resource": ""
} |
q26412 | UpdateDestination | train | func UpdateDestination(svc Service, dst Destination) error {
ic := &ipvsCommand{
Service: newIPVSService(&svc),
Destination: newIPVSDestination(&dst),
}
return netlink.SendMessageMarshalled(C.IPVS_CMD_SET_DEST, family, 0, ic)
} | go | {
"resource": ""
} |
q26413 | DeleteDestination | train | func DeleteDestination(svc Service, dst Destination) error {
ic := &ipvsCommand{
Service: newIPVSService(&svc),
Destination: newIPVSDestination(&dst),
}
return netlink.SendMessageMarshalled(C.IPVS_CMD_DEL_DEST, family, 0, ic)
} | go | {
"resource": ""
} |
q26414 | destinations | train | func destinations(svc *Service) ([]*Destination, error) {
msg, err := netlink.NewMessage(C.IPVS_CMD_GET_DEST, family, netlink.MFDump)
if err != nil {
return nil, err
}
defer msg.Free()
ic := &ipvsCommand{Service: newIPVSService(svc)}
if err := msg.Marshal(ic); err != nil {
return nil, err
}
var dsts []*De... | go | {
"resource": ""
} |
q26415 | services | train | func services(svc *Service) ([]*Service, error) {
var flags int
if svc == nil {
flags = netlink.MFDump
}
msg, err := netlink.NewMessage(C.IPVS_CMD_GET_SERVICE, family, flags)
if err != nil {
return nil, err
}
defer msg.Free()
if svc != nil {
ic := &ipvsCommand{Service: newIPVSService(svc)}
if err := m... | go | {
"resource": ""
} |
q26416 | GetService | train | func GetService(svc *Service) (*Service, error) {
svcs, err := services(svc)
if err != nil {
return nil, err
}
if len(svcs) == 0 {
return nil, errors.New("no service found")
}
return svcs[0], nil
} | go | {
"resource": ""
} |
q26417 | HAStatus | train | func (c *engineIPC) HAStatus() (*seesaw.HAStatus, error) {
var ha seesaw.HAStatus
if err := c.client.Call("SeesawEngine.HAStatus", c.ctx, &ha); err != nil {
return nil, err
}
return &ha, nil
} | go | {
"resource": ""
} |
q26418 | ConfigSource | train | func (c *engineIPC) ConfigSource(source string) (string, error) {
cs := &ipc.ConfigSource{c.ctx, source}
if err := c.client.Call("SeesawEngine.ConfigSource", cs, &source); err != nil {
return "", err
}
return source, nil
} | go | {
"resource": ""
} |
q26419 | BGPNeighbors | train | func (c *engineIPC) BGPNeighbors() ([]*quagga.Neighbor, error) {
var bn quagga.Neighbors
if err := c.client.Call("SeesawEngine.BGPNeighbors", c.ctx, &bn); err != nil {
return nil, err
}
return bn.Neighbors, nil
} | go | {
"resource": ""
} |
q26420 | VLANs | train | func (c *engineIPC) VLANs() (*seesaw.VLANs, error) {
var v seesaw.VLANs
if err := c.client.Call("SeesawEngine.VLANs", c.ctx, &v); err != nil {
return nil, err
}
return &v, nil
} | go | {
"resource": ""
} |
q26421 | Vservers | train | func (c *engineIPC) Vservers() (map[string]*seesaw.Vserver, error) {
var vm seesaw.VserverMap
if err := c.client.Call("SeesawEngine.Vservers", c.ctx, &vm); err != nil {
return nil, err
}
return vm.Vservers, nil
} | go | {
"resource": ""
} |
q26422 | OverrideVserver | train | func (c *engineIPC) OverrideVserver(vserver *seesaw.VserverOverride) error {
override := &ipc.Override{Ctx: c.ctx, Vserver: vserver}
return c.client.Call("SeesawEngine.OverrideVserver", override, nil)
} | go | {
"resource": ""
} |
q26423 | HAConfig | train | func (e *EngineClient) HAConfig() (*seesaw.HAConfig, error) {
engineConn, err := net.DialTimeout("unix", e.Socket, engineTimeout)
if err != nil {
return nil, fmt.Errorf("HAConfig: Dial failed: %v", err)
}
engineConn.SetDeadline(time.Now().Add(engineTimeout))
engine := rpc.NewClient(engineConn)
defer engine.Clos... | go | {
"resource": ""
} |
q26424 | HAUpdate | train | func (e *EngineClient) HAUpdate(status seesaw.HAStatus) (bool, error) {
engineConn, err := net.DialTimeout("unix", e.Socket, engineTimeout)
if err != nil {
return false, fmt.Errorf("HAUpdate: Dial failed: %v", err)
}
engineConn.SetDeadline(time.Now().Add(engineTimeout))
engine := rpc.NewClient(engineConn)
defer... | go | {
"resource": ""
} |
q26425 | HAUpdate | train | func (e *DummyEngine) HAUpdate(status seesaw.HAStatus) (bool, error) {
return false, nil
} | go | {
"resource": ""
} |
q26426 | signalName | train | func signalName(s syscall.Signal) string {
if name, ok := signalNames[s]; ok {
return name
}
return fmt.Sprintf("SIG %d", s)
} | go | {
"resource": ""
} |
q26427 | ShutdownHandler | train | func ShutdownHandler(server Shutdowner) {
sigc := make(chan os.Signal, 3)
signal.Notify(sigc, syscall.SIGINT, syscall.SIGQUIT, syscall.SIGTERM)
go func() {
for s := range sigc {
name := s.String()
if sig, ok := s.(syscall.Signal); ok {
name = signalName(sig)
}
log.Infof("Received %v, initiating shu... | go | {
"resource": ""
} |
q26428 | RemoveUnixSocket | train | func RemoveUnixSocket(socket string) error {
if _, err := os.Stat(socket); err == nil {
c, err := net.DialTimeout("unix", socket, 5*time.Second)
if err == nil {
c.Close()
return fmt.Errorf("Socket %v is in use", socket)
}
log.Infof("Removing stale socket %v", socket)
return os.Remove(socket)
}
return... | go | {
"resource": ""
} |
q26429 | ServerRunDirectory | train | func ServerRunDirectory(server string, owner, group int) error {
serverRunDir := path.Join(seesaw.RunPath, server)
if err := os.MkdirAll(seesaw.RunPath, 0755); err != nil {
return fmt.Errorf("Failed to make run directory: %v", err)
}
if err := os.MkdirAll(serverRunDir, 0700); err != nil {
return fmt.Errorf("Fai... | go | {
"resource": ""
} |
q26430 | RPCAccept | train | func RPCAccept(ln net.Listener, server *rpc.Server) error {
errClosing := errors.New("use of closed network connection")
for {
conn, err := ln.Accept()
if err != nil {
if ne, ok := err.(net.Error); ok && ne.Temporary() {
log.Warningf("RPC accept temporary error: %v", err)
time.Sleep(1 * time.Second)
... | go | {
"resource": ""
} |
q26431 | SourceByName | train | func SourceByName(name string) (Source, error) {
for s, n := range sourceNames {
if n == name {
return s, nil
}
}
return -1, fmt.Errorf("unknown source %q", name)
} | go | {
"resource": ""
} |
q26432 | String | train | func (s Source) String() string {
if name, ok := sourceNames[s]; ok {
return name
}
return "(unknown)"
} | go | {
"resource": ""
} |
q26433 | ReadConfig | train | func ReadConfig(filename, clusterName string) (*Notification, error) {
p := &pb.Cluster{}
b, err := ioutil.ReadFile(filename)
if err != nil {
return nil, err
}
if err = proto.UnmarshalText(string(b), p); err != nil {
return nil, err
}
c, err := protoToCluster(p, clusterName)
if err != nil {
return nil, e... | go | {
"resource": ""
} |
q26434 | ConfigFromServer | train | func ConfigFromServer(cluster string) (*Notification, error) {
cfg := DefaultEngineConfig()
cfg.ClusterName = cluster
n := &Notifier{engineCfg: &cfg}
return n.configFromServer()
} | go | {
"resource": ""
} |
q26435 | pruneArchive | train | func pruneArchive(archiveDir string, refTime time.Time, max archiveConfig) (*pruneStats, error) {
d, err := os.Open(archiveDir)
if err != nil {
return nil, err
}
defer d.Close()
files, err := d.Readdir(0)
if err != nil {
return nil, err
}
sort.Sort(sort.Reverse(byModTime(files)))
var seen, curr pruneSta... | go | {
"resource": ""
} |
q26436 | NewServer | train | func NewServer(socket string) *Server {
return &Server{
nccSocket: socket,
shutdown: make(chan bool),
}
} | go | {
"resource": ""
} |
q26437 | Run | train | func (n *Server) Run() {
if err := server.RemoveUnixSocket(n.nccSocket); err != nil {
log.Fatalf("Failed to remove socket: %v", err)
}
ln, err := net.Listen("unix", n.nccSocket)
if err != nil {
log.Fatalf("listen error: %v", err)
}
defer ln.Close()
defer os.Remove(n.nccSocket)
seesawNCC := rpc.NewServer()
... | go | {
"resource": ""
} |
q26438 | NewNode | train | func NewNode(cfg NodeConfig, conn HAConn, engine Engine) *Node {
n := &Node{
NodeConfig: cfg,
conn: conn,
engine: engine,
lastMasterAdvertTime: time.Now(),
errChannel: make(chan error),
recvChannel: make(chan *advertisement, 20),
stopSenderChanne... | go | {
"resource": ""
} |
q26439 | resetMasterDownInterval | train | func (n *Node) resetMasterDownInterval(advertInterval time.Duration) {
skewTime := (time.Duration((256 - int(n.Priority))) * (advertInterval)) / 256
masterDownInterval := 3*(advertInterval) + skewTime
if masterDownInterval != n.masterDownInterval {
n.masterDownInterval = masterDownInterval
log.Infof("resetMaster... | go | {
"resource": ""
} |
q26440 | state | train | func (n *Node) state() seesaw.HAState {
n.statusLock.RLock()
defer n.statusLock.RUnlock()
return n.haStatus.State
} | go | {
"resource": ""
} |
q26441 | setState | train | func (n *Node) setState(s seesaw.HAState) {
n.statusLock.Lock()
defer n.statusLock.Unlock()
if n.haStatus.State != s {
n.haStatus.State = s
n.haStatus.Since = time.Now()
n.haStatus.Transitions++
}
} | go | {
"resource": ""
} |
q26442 | status | train | func (n *Node) status() seesaw.HAStatus {
n.statusLock.Lock()
defer n.statusLock.Unlock()
n.haStatus.Sent = atomic.LoadUint64(&n.sendCount)
n.haStatus.Received = atomic.LoadUint64(&n.receiveCount)
n.haStatus.ReceivedQueued = uint64(len(n.recvChannel))
return n.haStatus
} | go | {
"resource": ""
} |
q26443 | newAdvertisement | train | func (n *Node) newAdvertisement() *advertisement {
return &advertisement{
VersionType: vrrpVersionType,
VRID: n.VRID,
Priority: n.Priority,
AdvertInt: uint16(n.MasterAdvertInterval / time.Millisecond / 10), // AdvertInt is in centiseconds
}
} | go | {
"resource": ""
} |
q26444 | Run | train | func (n *Node) Run() error {
go n.receiveAdvertisements()
go n.reportStatus()
go n.checkConfig()
for n.state() != seesaw.HAShutdown {
if err := n.runOnce(); err != nil {
return err
}
}
return nil
} | go | {
"resource": ""
} |
q26445 | registerCallback | train | func registerCallback(cbArg *callbackArg) uintptr {
callbacksLock.Lock()
defer callbacksLock.Unlock()
cbArg.id = nextCallbackID
nextCallbackID++
if _, ok := callbacks[cbArg.id]; ok {
panic(fmt.Sprintf("Callback ID %d already in use", cbArg.id))
}
callbacks[cbArg.id] = cbArg
return cbArg.id
} | go | {
"resource": ""
} |
q26446 | unregisterCallback | train | func unregisterCallback(cbArg *callbackArg) {
callbacksLock.Lock()
defer callbacksLock.Unlock()
if _, ok := callbacks[cbArg.id]; !ok {
panic(fmt.Sprintf("Callback ID %d not registered", cbArg.id))
}
delete(callbacks, cbArg.id)
} | go | {
"resource": ""
} |
q26447 | callback | train | func callback(nlm *C.struct_nl_msg, nla unsafe.Pointer) C.int {
cbID := uintptr(nla)
callbacksLock.RLock()
cbArg := callbacks[cbID]
callbacksLock.RUnlock()
if cbArg == nil {
panic(fmt.Sprintf("No netlink callback with ID %d", cbID))
}
cbMsg := &Message{nlm: nlm}
if err := cbArg.fn(cbMsg, cbArg.arg); err != ... | go | {
"resource": ""
} |
q26448 | NewMessage | train | func NewMessage(command, family, flags int) (*Message, error) {
nlm := C.nlmsg_alloc()
if nlm == nil {
return nil, errors.New("failed to create netlink message")
}
C.genlmsg_put(nlm, C.NL_AUTO_PID, C.NL_AUTO_SEQ, C.int(family), 0, C.int(flags), C.uint8_t(command), genlVersion)
return &Message{nlm: nlm}, nil
} | go | {
"resource": ""
} |
q26449 | NewMessageFromBytes | train | func NewMessageFromBytes(nlb []byte) (*Message, error) {
nlm := C.nlmsg_alloc_size(C.size_t(len(nlb)))
if nlm == nil {
return nil, errors.New("failed to create netlink message")
}
nlh := C.nlmsg_hdr(nlm)
copy((*[1 << 20]byte)(unsafe.Pointer(nlh))[:len(nlb)], nlb)
return &Message{nlm: nlm}, nil
} | go | {
"resource": ""
} |
q26450 | Free | train | func (m *Message) Free() {
C.nlmsg_free(m.nlm)
m.nlm = nil
} | go | {
"resource": ""
} |
q26451 | Bytes | train | func (m *Message) Bytes() ([]byte, error) {
if m.nlm == nil {
return nil, errors.New("no netlink message")
}
nlh := C.nlmsg_hdr(m.nlm)
nlb := make([]byte, nlh.nlmsg_len)
copy(nlb, (*[1 << 20]byte)(unsafe.Pointer(nlh))[:nlh.nlmsg_len])
return nlb, nil
} | go | {
"resource": ""
} |
q26452 | Unmarshal | train | func (m *Message) Unmarshal(v interface{}) error {
val := reflect.Indirect(reflect.ValueOf(v))
if val.Kind() != reflect.Struct || !val.CanSet() {
return fmt.Errorf("%v is not a pointer to a struct", reflect.TypeOf(v))
}
maxAttrID, err := structMaxAttrID(val)
if err != nil {
return err
}
attrs, err := parseMe... | go | {
"resource": ""
} |
q26453 | SendCallback | train | func (m *Message) SendCallback(fn CallbackFunc, arg interface{}) error {
s, err := newSocket()
if err != nil {
return err
}
defer s.free()
if errno := C.genl_connect(s.nls); errno != 0 {
return &Error{errno, "failed to connect to netlink"}
}
defer C.nl_close(s.nls)
cbArg := &callbackArg{fn: fn, arg: arg}
... | go | {
"resource": ""
} |
q26454 | SendMessage | train | func SendMessage(command, family, flags int) error {
return SendMessageCallback(command, family, flags, callbackDefault, nil)
} | go | {
"resource": ""
} |
q26455 | SendMessageCallback | train | func SendMessageCallback(command, family, flags int, cb CallbackFunc, arg interface{}) error {
msg, err := NewMessage(command, family, flags)
if err != nil {
return err
}
defer msg.Free()
return msg.SendCallback(cb, arg)
} | go | {
"resource": ""
} |
q26456 | SendMessageMarshalled | train | func SendMessageMarshalled(command, family, flags int, v interface{}) error {
msg, err := NewMessage(command, family, flags)
if err != nil {
return err
}
defer msg.Free()
if err := msg.Marshal(v); err != nil {
return err
}
return msg.Send()
} | go | {
"resource": ""
} |
q26457 | SendMessageUnmarshal | train | func SendMessageUnmarshal(command, family, flags int, v interface{}) error {
return SendMessageCallback(command, family, flags, callbackUnmarshal, v)
} | go | {
"resource": ""
} |
q26458 | config | train | func config(e ha.Engine) *seesaw.HAConfig {
for {
c, err := e.HAConfig()
switch {
case err != nil:
log.Errorf("config: Failed to retrieve HAConfig: %v", err)
case !c.Enabled:
log.Infof("config: HA peering is currently disabled for this node")
default:
return c
}
time.Sleep(*initConfigRetryDela... | go | {
"resource": ""
} |
q26459 | newBGPManager | train | func newBGPManager(engine *Engine, interval time.Duration) *bgpManager {
return &bgpManager{engine: engine, updateInterval: interval}
} | go | {
"resource": ""
} |
q26460 | run | train | func (b *bgpManager) run() {
ticker := time.NewTicker(b.updateInterval)
for {
log.V(1).Infof("Updating BGP state and statistics...")
b.update()
<-ticker.C
}
} | go | {
"resource": ""
} |
q26461 | update | train | func (b *bgpManager) update() {
ncc := b.engine.ncc
if err := ncc.Dial(); err != nil {
log.Warningf("BGP manager failed to connect to NCC: %v", err)
return
}
defer ncc.Close()
neighbors, err := ncc.BGPNeighbors()
if err != nil {
log.Warningf("Failed to get BGP neighbors: %v", err)
return
}
b.lock.Lock(... | go | {
"resource": ""
} |
q26462 | NewHTTPChecker | train | func NewHTTPChecker(ip net.IP, port int) *HTTPChecker {
return &HTTPChecker{
Target: Target{
IP: ip,
Port: port,
Proto: seesaw.IPProtoTCP,
},
Secure: false,
TLSVerify: true,
Method: "GET",
Proxy: false,
Request: "/",
Response: "",
ResponseCode: 200,
}
} | go | {
"resource": ""
} |
q26463 | String | train | func (hc *HTTPChecker) String() string {
attr := []string{fmt.Sprintf("code %d", hc.ResponseCode)}
if hc.Proxy {
attr = append(attr, "proxy")
}
if hc.Secure {
attr = append(attr, "secure")
if hc.TLSVerify {
attr = append(attr, "verify")
}
}
s := strings.Join(attr, "; ")
return fmt.Sprintf("HTTP %s %s ... | go | {
"resource": ""
} |
q26464 | NewTCPChecker | train | func NewTCPChecker(ip net.IP, port int) *TCPChecker {
return &TCPChecker{
Target: Target{
IP: ip,
Port: port,
Proto: seesaw.IPProtoTCP,
},
}
} | go | {
"resource": ""
} |
q26465 | String | train | func (hc *TCPChecker) String() string {
attr := []string{}
if hc.Secure {
attr = append(attr, "secure")
if hc.TLSVerify {
attr = append(attr, "verify")
}
}
var s string
if len(attr) > 0 {
s = fmt.Sprintf(" [%s]", strings.Join(attr, "; "))
}
return fmt.Sprintf("TCP%s %s", s, hc.Target)
} | go | {
"resource": ""
} |
q26466 | Check | train | func (hc *TCPChecker) Check(timeout time.Duration) *Result {
msg := fmt.Sprintf("TCP connect to %s", hc.addr())
start := time.Now()
if timeout == time.Duration(0) {
timeout = defaultTCPTimeout
}
deadline := start.Add(timeout)
tcpConn, err := dialTCP(hc.network(), hc.addr(), timeout, hc.Mark)
if err != nil {
... | go | {
"resource": ""
} |
q26467 | Interface | train | func (lb *LBInterface) Interface() (*net.Interface, error) {
iface, err := net.InterfaceByName(lb.Name)
if err != nil {
return nil, err
}
return iface, nil
} | go | {
"resource": ""
} |
q26468 | label | train | func label(l string, indent, width int) string {
pad := width - indent - len(l)
if pad < 0 {
pad = 0
}
return fmt.Sprintf("%s%s%s", strings.Repeat(" ", indent), l,
strings.Repeat(" ", pad))
} | go | {
"resource": ""
} |
q26469 | printFmt | train | func printFmt(l, v string, args ...interface{}) {
l = label(l, subIndent, valIndent)
fmt.Printf("%s %s\n", l, fmt.Sprintf(v, args...))
} | go | {
"resource": ""
} |
q26470 | printVal | train | func printVal(l string, v interface{}) {
switch f := v.(type) {
case uint, uint64:
printFmt(l, "%d", f)
case string:
printFmt(l, "%s", f)
default:
printFmt(l, "%v", f)
}
} | go | {
"resource": ""
} |
q26471 | String | train | func (snt SyncNoteType) String() string {
if name, ok := syncNoteTypeNames[snt]; ok {
return name
}
return fmt.Sprintf("(Unknown %d)", snt)
} | go | {
"resource": ""
} |
q26472 | Register | train | func (s *SeesawSync) Register(node net.IP, id *SyncSessionID) error {
if id == nil {
return errors.New("id is nil")
}
// TODO(jsing): Reject if not master?
s.sync.sessionLock.Lock()
session := newSyncSession(node, s.sync.nextSessionID)
s.sync.nextSessionID++
s.sync.sessions[session.id] = session
s.sync.sess... | go | {
"resource": ""
} |
q26473 | Deregister | train | func (s *SeesawSync) Deregister(id SyncSessionID, reply *int) error {
s.sync.sessionLock.Lock()
session, ok := s.sync.sessions[id]
delete(s.sync.sessions, id)
s.sync.sessionLock.Unlock()
if ok {
log.Infof("Synchronisation session %d deregistered with %v", id, session.node)
}
return nil
} | go | {
"resource": ""
} |
q26474 | Poll | train | func (s *SeesawSync) Poll(id SyncSessionID, sn *SyncNotes) error {
if sn == nil {
return errors.New("sync notes is nil")
}
s.sync.sessionLock.RLock()
session, ok := s.sync.sessions[id]
s.sync.sessionLock.RUnlock()
if !ok {
return errors.New("no session with ID %d")
}
// Reset expiry time and check for des... | go | {
"resource": ""
} |
q26475 | Config | train | func (s *SeesawSync) Config(arg int, config *config.Notification) error {
return errors.New("unimplemented")
} | go | {
"resource": ""
} |
q26476 | Failover | train | func (s *SeesawSync) Failover(arg int, reply *int) error {
return s.sync.engine.haManager.requestFailover(true)
} | go | {
"resource": ""
} |
q26477 | Healthchecks | train | func (s *SeesawSync) Healthchecks(arg int, reply *int) error {
return errors.New("unimplemented")
} | go | {
"resource": ""
} |
q26478 | newSyncSession | train | func newSyncSession(node net.IP, id SyncSessionID) *syncSession {
return &syncSession{
id: id,
node: node,
desync: true,
startTime: time.Now(),
expiryTime: time.Now().Add(sessionDeadtime),
notes: make(chan *SyncNote, sessionNotesQueueSize),
}
} | go | {
"resource": ""
} |
q26479 | addNote | train | func (ss *syncSession) addNote(note *SyncNote) {
select {
case ss.notes <- note:
default:
ss.Lock()
if !ss.desync {
log.Warningf("Sync session with %v is desynchronised", ss.node)
ss.desync = true
}
ss.Unlock()
}
} | go | {
"resource": ""
} |
q26480 | newSyncServer | train | func newSyncServer(e *Engine) *syncServer {
return &syncServer{
engine: e,
heartbeatInterval: syncHeartbeatInterval,
sessions: make(map[SyncSessionID]*syncSession),
}
} | go | {
"resource": ""
} |
q26481 | serve | train | func (s *syncServer) serve(l *net.TCPListener) error {
defer l.Close()
s.server = rpc.NewServer()
s.server.Register(&SeesawSync{s})
for {
c, err := l.AcceptTCP()
if err != nil {
if ne, ok := err.(net.Error); ok && ne.Temporary() {
time.Sleep(100 * time.Millisecond)
continue
}
return err
}
... | go | {
"resource": ""
} |
q26482 | notify | train | func (s *syncServer) notify(sn *SyncNote) {
s.sessionLock.RLock()
sessions := s.sessions
s.sessionLock.RUnlock()
for _, ss := range sessions {
ss.addNote(sn)
}
} | go | {
"resource": ""
} |
q26483 | run | train | func (s *syncServer) run() error {
heartbeat := time.NewTicker(s.heartbeatInterval)
for {
select {
case <-heartbeat.C:
now := time.Now()
s.sessionLock.Lock()
for id, ss := range s.sessions {
ss.RLock()
expiry := ss.expiryTime
ss.RUnlock()
if now.After(expiry) {
log.Warningf("Sync ses... | go | {
"resource": ""
} |
q26484 | newSyncClient | train | func newSyncClient(e *Engine) *syncClient {
sc := &syncClient{
engine: e,
quit: make(chan bool),
start: make(chan bool),
stopped: make(chan bool, 1),
}
sc.dispatch = sc.handleNote
sc.stopped <- true
return sc
} | go | {
"resource": ""
} |
q26485 | dial | train | func (sc *syncClient) dial() error {
sc.lock.Lock()
defer sc.lock.Unlock()
if sc.client != nil {
sc.refs++
return nil
}
// TODO(jsing): Make this default to IPv6, if configured.
peer := &net.TCPAddr{
IP: sc.engine.config.Peer.IPv4Addr,
Port: sc.engine.config.SyncPort,
}
self := &net.TCPAddr{
IP: sc... | go | {
"resource": ""
} |
q26486 | close | train | func (sc *syncClient) close() error {
sc.lock.Lock()
defer sc.lock.Unlock()
if sc.client == nil {
return nil
}
sc.refs--
if sc.refs > 0 {
return nil
}
if err := sc.client.Close(); err != nil {
sc.client = nil
return fmt.Errorf("client close failed: %v", err)
}
sc.client = nil
return nil
} | go | {
"resource": ""
} |
q26487 | failover | train | func (sc *syncClient) failover() error {
if err := sc.dial(); err != nil {
return err
}
defer sc.close()
if err := sc.client.Call("SeesawSync.Failover", 0, nil); err != nil {
return err
}
return nil
} | go | {
"resource": ""
} |
q26488 | runOnce | train | func (sc *syncClient) runOnce() {
if err := sc.dial(); err != nil {
log.Warningf("Sync client dial failed: %v", err)
return
}
defer sc.close()
var sid SyncSessionID
self := sc.engine.config.Node.IPv4Addr
// Register for synchronisation events.
// TODO(jsing): Implement timeout on RPC?
if err := sc.client.... | go | {
"resource": ""
} |
q26489 | poll | train | func (sc *syncClient) poll(sid SyncSessionID) {
for {
var sn SyncNotes
poll := sc.client.Go("SeesawSync.Poll", sid, &sn, nil)
select {
case <-poll.Done:
if poll.Error != nil {
log.Errorf("Synchronisation polling failed: %v", poll.Error)
return
}
for _, note := range sn.Notes {
sc.dispatch(... | go | {
"resource": ""
} |
q26490 | handleNote | train | func (sc *syncClient) handleNote(note *SyncNote) {
switch note.Type {
case SNTHeartbeat:
log.V(1).Infoln("Sync client received heartbeat")
case SNTDesync:
sc.handleDesync()
case SNTConfigUpdate:
sc.handleConfigUpdate(note)
case SNTHealthcheck:
sc.handleHealthcheck(note)
case SNTOverride:
sc.handleOv... | go | {
"resource": ""
} |
q26491 | handleOverride | train | func (sc *syncClient) handleOverride(sn *SyncNote) {
log.V(1).Infoln("Sync client received override notification")
if o := sn.VserverOverride; o != nil {
sc.engine.queueOverride(o)
}
if o := sn.DestinationOverride; o != nil {
sc.engine.queueOverride(o)
}
if o := sn.BackendOverride; o != nil {
sc.engine.que... | go | {
"resource": ""
} |
q26492 | run | train | func (sc *syncClient) run() error {
for {
select {
case <-sc.stopped:
<-sc.start
log.Infof("Starting sync client...")
default:
sc.runOnce()
select {
case <-time.After(5 * time.Second):
case <-sc.quit:
sc.stopped <- true
}
}
}
} | go | {
"resource": ""
} |
q26493 | enable | train | func (sc *syncClient) enable() {
sc.lock.Lock()
start := !sc.enabled
sc.enabled = true
sc.lock.Unlock()
if start {
sc.start <- true
}
} | go | {
"resource": ""
} |
q26494 | disable | train | func (sc *syncClient) disable() {
sc.lock.Lock()
quit := sc.enabled
sc.enabled = false
sc.lock.Unlock()
if quit {
sc.quit <- true
}
} | go | {
"resource": ""
} |
q26495 | String | train | func (sc Component) String() string {
if name, ok := componentNames[sc]; ok {
return name
}
return "(unknown)"
} | go | {
"resource": ""
} |
q26496 | String | train | func (h HealthcheckType) String() string {
switch h {
case HCTypeDNS:
return "DNS"
case HCTypeHTTP:
return "HTTP"
// TODO(angusc): Drop HTTPS as a separate type.
case HCTypeHTTPS:
return "HTTP" // NB: Not HTTPS
case HCTypeICMP:
return "ICMP"
case HCTypeRADIUS:
return "RADIUS"
case HCTypeTCP:
return ... | go | {
"resource": ""
} |
q26497 | String | train | func (v VIP) String() string {
return fmt.Sprintf("%v (%v)", v.IP, v.Type)
} | go | {
"resource": ""
} |
q26498 | NewVIP | train | func NewVIP(ip net.IP, vipSubnets map[string]*net.IPNet) *VIP {
vipType := UnicastVIP
switch {
case IsAnycast(ip):
vipType = AnycastVIP
case InSubnets(ip, vipSubnets):
vipType = DedicatedVIP
}
return &VIP{
IP: NewIP(ip),
Type: vipType,
}
} | go | {
"resource": ""
} |
q26499 | NewIP | train | func NewIP(nip net.IP) IP {
var ip IP
copy(ip[:], nip.To16())
return ip
} | go | {
"resource": ""
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.