_id stringlengths 2 7 | title stringlengths 1 118 | partition stringclasses 3
values | text stringlengths 52 85.5k | language stringclasses 1
value | meta_information dict |
|---|---|---|---|---|---|
q26300 | Walk | train | func (w *Watchdog) Walk() {
log.Info("Seesaw watchdog starting...")
w.mapDependencies()
for _, svc := range w.services {
go svc.run()
}
<-w.shutdown
for _, svc := range w.services {
go svc.stop()
}
for _, svc := range w.services {
stopped := <-svc.stopped
svc.stopped <- stopped
}
} | go | {
"resource": ""
} |
q26301 | mapDependencies | train | func (w *Watchdog) mapDependencies() {
for name := range w.services {
svc := w.services[name]
for depName := range svc.dependencies {
dep, ok := w.services[depName]
if !ok {
log.Fatalf("Failed to find dependency %q for service %q", depName, name)
}
svc.dependencies[depName] = dep
dep.dependents[... | go | {
"resource": ""
} |
q26302 | VLANs | train | func (s *SeesawECU) VLANs(ctx *ipc.Context, reply *seesaw.VLANs) error {
s.trace("VLANs", ctx)
authConn, err := s.ecu.authConnect(ctx)
if err != nil {
return err
}
defer authConn.Close()
vlans, err := authConn.VLANs()
if err != nil {
return err
}
if reply != nil {
*reply = *vlans
}
return nil
} | go | {
"resource": ""
} |
q26303 | DNSType | train | func DNSType(name string) (uint16, error) {
dt, ok := dns.StringToType[strings.ToUpper(name)]
if !ok {
return 0, fmt.Errorf("unknown DNS type %q", name)
}
return dt, nil
} | go | {
"resource": ""
} |
q26304 | NewDNSChecker | train | func NewDNSChecker(ip net.IP, port int) *DNSChecker {
return &DNSChecker{
Target: Target{
IP: ip,
Port: port,
Proto: seesaw.IPProtoUDP,
},
Question: dns.Question{
Qclass: dns.ClassINET,
Qtype: dns.TypeA,
},
}
} | go | {
"resource": ""
} |
q26305 | String | train | func (hc *DNSChecker) String() string {
return fmt.Sprintf("DNS %s %s", questionToString(hc.Question), hc.Target)
} | go | {
"resource": ""
} |
q26306 | NewVTY | train | func NewVTY(socket string) *VTY {
return &VTY{
socket: socket,
readTimeout: 1 * time.Second,
writeTimeout: 1 * time.Second,
}
} | go | {
"resource": ""
} |
q26307 | Dial | train | func (v *VTY) Dial() error {
if v.conn != nil {
return fmt.Errorf("connection already established")
}
conn, err := net.Dial("unix", v.socket)
if err != nil {
return err
}
v.conn = conn
return nil
} | go | {
"resource": ""
} |
q26308 | Close | train | func (v *VTY) Close() error {
if v.conn == nil {
return fmt.Errorf("No connection established")
}
err := v.conn.Close()
v.conn = nil
return err
} | go | {
"resource": ""
} |
q26309 | Commands | train | func (v *VTY) Commands(cmds []string) error {
for _, cmd := range cmds {
if _, err := v.Command(cmd); err != nil {
return err
}
}
return nil
} | go | {
"resource": ""
} |
q26310 | Command | train | func (v *VTY) Command(cmd string) (string, error) {
if err := v.write(cmd); err != nil {
return "", err
}
r, s, err := v.read()
if err != nil {
return "", err
}
if s != 0 {
return "", VTYError{r, s}
}
return r, nil
} | go | {
"resource": ""
} |
q26311 | String | train | func (at AuthType) String() string {
if name, ok := authTypeNames[at]; ok {
return name
}
return "(unknown)"
} | go | {
"resource": ""
} |
q26312 | NewContext | train | func NewContext(component seesaw.Component) *Context {
return &Context{
AuthType: ATNone,
Peer: Peer{
Component: component,
Identity: fmt.Sprintf("%s [pid %d]", component, os.Getpid()),
},
}
} | go | {
"resource": ""
} |
q26313 | NewAuthContext | train | func NewAuthContext(component seesaw.Component, token string) *Context {
ctx := NewContext(component)
ctx.AuthToken = token
ctx.AuthType = ATUntrusted
return ctx
} | go | {
"resource": ""
} |
q26314 | NewTrustedContext | train | func NewTrustedContext(component seesaw.Component) *Context {
ctx := NewContext(component)
ctx.AuthType = ATTrusted
if u, err := user.Current(); err == nil {
ctx.User = fmt.Sprintf("%s [uid %s]", u.Username, u.Uid)
} else {
ctx.User = fmt.Sprintf("(unknown) [uid %d]", os.Getuid())
}
return ctx
} | go | {
"resource": ""
} |
q26315 | String | train | func (ctx *Context) String() string {
if ctx == nil {
return "(nil context)"
}
var s []string
if ctx.Peer.Component != seesaw.SCNone {
s = append(s, fmt.Sprintf("peer %s", ctx.Peer.Identity))
}
if ctx.Proxy.Component != seesaw.SCNone {
s = append(s, fmt.Sprintf("via %s", ctx.Proxy.Identity))
}
s = append... | go | {
"resource": ""
} |
q26316 | NewECU | train | func NewECU(cfg *ECUConfig) *ECU {
if cfg == nil {
defaultCfg := DefaultECUConfig()
cfg = &defaultCfg
}
return &ECU{
cfg: cfg,
shutdown: make(chan bool),
shutdownControl: make(chan bool),
shutdownMonitor: make(chan bool),
}
} | go | {
"resource": ""
} |
q26317 | Run | train | func (e *ECU) Run() {
if err := e.authInit(); err != nil {
log.Warningf("Failed to initialise authentication, remote control will likely fail: %v", err)
}
stats := newECUStats(e)
go stats.run()
go e.control()
go e.monitoring()
<-e.shutdown
e.shutdownControl <- true
e.shutdownMonitor <- true
<-e.shutdownC... | go | {
"resource": ""
} |
q26318 | monitoring | train | func (e *ECU) monitoring() {
ln, err := net.Listen("tcp", e.cfg.MonitorAddress)
if err != nil {
log.Fatal("listen error:", err)
}
monitorHTTP := &http.Server{
ReadTimeout: 30 * time.Second,
WriteTimeout: 30 * time.Second,
MaxHeaderBytes: 1 << 20,
}
go monitorHTTP.Serve(ln)
<-e.shutdownMonitor
ln.... | go | {
"resource": ""
} |
q26319 | controlTLSConfig | train | func (e *ECU) controlTLSConfig() (*tls.Config, error) {
rootCACerts := x509.NewCertPool()
data, err := ioutil.ReadFile(e.cfg.CACertsFile)
if err != nil {
return nil, fmt.Errorf("failed to read CA cert file: %v", err)
}
if ok := rootCACerts.AppendCertsFromPEM(data); !ok {
return nil, errors.New("failed to load ... | go | {
"resource": ""
} |
q26320 | control | train | func (e *ECU) control() {
tlsConfig, err := e.controlTLSConfig()
if err != nil {
log.Errorf("Disabling ECU control server: %v", err)
<-e.shutdownControl
e.shutdownControl <- true
return
}
ln, err := net.Listen("tcp", e.cfg.ControlAddress)
if err != nil {
log.Fatal("listen error:", err)
}
seesawRPC :=... | go | {
"resource": ""
} |
q26321 | sysctlInitLB | train | func sysctlInitLB(nodeIface, lbIface *net.Interface) error {
// System level sysctls.
for _, ctl := range seesawSysctls {
if _, err := sysctl(ctl.name, ctl.value); err != nil {
return err
}
}
// Interface level sysctls.
ifaces := []string{"all", "default", nodeIface.Name, lbIface.Name}
for _, iface := ra... | go | {
"resource": ""
} |
q26322 | sysctlInitIface | train | func sysctlInitIface(iface string) error {
for _, ctl := range seesawIfaceSysctls {
if err := sysctlIface(iface, ctl.af, ctl.name, ctl.value); err != nil {
return err
}
}
return nil
} | go | {
"resource": ""
} |
q26323 | sysctlIface | train | func sysctlIface(iface string, af seesaw.AF, name, value string) error {
components := []string{
"net", strings.ToLower(af.String()), "conf", iface, name,
}
_, err := sysctlByComponents(components, value)
return err
} | go | {
"resource": ""
} |
q26324 | sysctl | train | func sysctl(name, value string) (string, error) {
return sysctlByComponents(strings.Split(name, "."), value)
} | go | {
"resource": ""
} |
q26325 | sysctlByComponents | train | func sysctlByComponents(components []string, value string) (string, error) {
components = append([]string{sysctlPath}, components...)
f, err := os.OpenFile(path.Join(components...), os.O_RDWR, 0)
if err != nil {
return "", err
}
defer f.Close()
b, err := ioutil.ReadAll(f)
if err != nil {
return "", err
}
i... | go | {
"resource": ""
} |
q26326 | newIPTRuleTemplate | train | func newIPTRuleTemplate(action iptAction, tmpl string) *iptRuleTemplate {
t, err := template.New("").Parse(tmpl)
if err != nil {
panic(fmt.Sprintf("Failed to parse iptables template: %q: %v", tmpl, err))
}
return &iptRuleTemplate{action, t}
} | go | {
"resource": ""
} |
q26327 | execute | train | func (te *iptTemplateExecuter) execute() ([]*iptRule, error) {
rules := make([]*iptRule, 0, len(te.templates))
for _, t := range te.templates {
w := new(bytes.Buffer)
if err := t.Template.Execute(w, te.data); err != nil {
return nil, err
}
af := seesaw.IPv6
if te.data.ServiceVIP.To4() != nil {
af = se... | go | {
"resource": ""
} |
q26328 | initIPTRuleTemplates | train | func initIPTRuleTemplates() {
// Allow traffic for VIP services.
svcRules = append(svcRules, newIPTRuleTemplate(iptAppend,
"INPUT -p {{.Proto}} -d {{.ServiceVIP}}{{with .Port}} --dport {{.}}{{end}} -j ACCEPT"))
// Mark packets for firemark based VIPs.
fwmRule := "PREROUTING -t mangle -p {{.Proto}} -d {{.ServiceV... | go | {
"resource": ""
} |
q26329 | iptablesInit | train | func iptablesInit(clusterVIP seesaw.Host) error {
if err := iptablesFlush(); err != nil {
return err
}
for _, af := range seesaw.AFs() {
// Allow connections to port 10257 for all VIPs.
if err := iptablesRun(af, "-I INPUT -p tcp --dport 10257 -j ACCEPT"); err != nil {
return err
}
// conntrack is only ... | go | {
"resource": ""
} |
q26330 | iptablesFlush | train | func iptablesFlush() error {
for _, af := range seesaw.AFs() {
for _, table := range []string{"filter", "mangle", "raw"} {
if err := iptablesRun(af, fmt.Sprintf("--flush -t %v", table)); err != nil {
return err
}
}
}
// NAT is IPv4-only until linux kernel version 3.7.
// TODO(angusc): Support IPv6 NAT... | go | {
"resource": ""
} |
q26331 | iptablesRules | train | func iptablesRules(v *seesaw.Vserver, clusterVIP seesaw.Host, af seesaw.AF) ([]*iptRule, error) {
var clusterIP, serviceIP net.IP
switch af {
case seesaw.IPv4:
clusterIP = clusterVIP.IPv4Addr
serviceIP = v.IPv4Addr
case seesaw.IPv6:
clusterIP = clusterVIP.IPv6Addr
serviceIP = v.IPv6Addr
}
if clusterIP == ... | go | {
"resource": ""
} |
q26332 | iptablesAddRules | train | func iptablesAddRules(v *seesaw.Vserver, clusterVIP seesaw.Host, af seesaw.AF) error {
rules, err := iptablesRules(v, clusterVIP, af)
if err != nil {
return err
}
for _, r := range rules {
if err := iptablesRun(r.AF, string(r.action)+" "+r.rule); err != nil {
return err
}
}
return nil
} | go | {
"resource": ""
} |
q26333 | initIPVS | train | func initIPVS() {
ipvsMutex.Lock()
defer ipvsMutex.Unlock()
log.Infof("Initialising IPVS...")
if err := ipvs.Init(); err != nil {
// TODO(jsing): modprobe ip_vs and try again.
log.Fatalf("IPVS initialisation failed: %v", err)
}
log.Infof("IPVS version %s", ipvs.Version())
} | go | {
"resource": ""
} |
q26334 | IPVSFlush | train | func (ncc *SeesawNCC) IPVSFlush(in int, out *int) error {
ipvsMutex.Lock()
defer ipvsMutex.Unlock()
return ipvs.Flush()
} | go | {
"resource": ""
} |
q26335 | IPVSGetServices | train | func (ncc *SeesawNCC) IPVSGetServices(in int, s *ncctypes.IPVSServices) error {
ipvsMutex.Lock()
defer ipvsMutex.Unlock()
svcs, err := ipvs.GetServices()
if err != nil {
return err
}
s.Services = nil
for _, svc := range svcs {
s.Services = append(s.Services, svc)
}
return nil
} | go | {
"resource": ""
} |
q26336 | IPVSGetService | train | func (ncc *SeesawNCC) IPVSGetService(si *ipvs.Service, s *ncctypes.IPVSServices) error {
ipvsMutex.Lock()
defer ipvsMutex.Unlock()
so, err := ipvs.GetService(si)
if err != nil {
return err
}
s.Services = []*ipvs.Service{so}
return nil
} | go | {
"resource": ""
} |
q26337 | IPVSAddService | train | func (ncc *SeesawNCC) IPVSAddService(svc *ipvs.Service, out *int) error {
ipvsMutex.Lock()
defer ipvsMutex.Unlock()
return ipvs.AddService(*svc)
} | go | {
"resource": ""
} |
q26338 | IPVSUpdateService | train | func (ncc *SeesawNCC) IPVSUpdateService(svc *ipvs.Service, out *int) error {
ipvsMutex.Lock()
defer ipvsMutex.Unlock()
return ipvs.UpdateService(*svc)
} | go | {
"resource": ""
} |
q26339 | IPVSDeleteService | train | func (ncc *SeesawNCC) IPVSDeleteService(svc *ipvs.Service, out *int) error {
ipvsMutex.Lock()
defer ipvsMutex.Unlock()
return ipvs.DeleteService(*svc)
} | go | {
"resource": ""
} |
q26340 | IPVSAddDestination | train | func (ncc *SeesawNCC) IPVSAddDestination(dst *ncctypes.IPVSDestination, out *int) error {
ipvsMutex.Lock()
defer ipvsMutex.Unlock()
return ipvs.AddDestination(*dst.Service, *dst.Destination)
} | go | {
"resource": ""
} |
q26341 | IPVSUpdateDestination | train | func (ncc *SeesawNCC) IPVSUpdateDestination(dst *ncctypes.IPVSDestination, out *int) error {
ipvsMutex.Lock()
defer ipvsMutex.Unlock()
return ipvs.UpdateDestination(*dst.Service, *dst.Destination)
} | go | {
"resource": ""
} |
q26342 | IPVSDeleteDestination | train | func (ncc *SeesawNCC) IPVSDeleteDestination(dst *ncctypes.IPVSDestination, out *int) error {
ipvsMutex.Lock()
defer ipvsMutex.Unlock()
return ipvs.DeleteDestination(*dst.Service, *dst.Destination)
} | go | {
"resource": ""
} |
q26343 | Copy | train | func (n *Node) Copy(c *Node) {
n.State = c.State
n.Priority = c.Priority
n.Host.Copy(&c.Host)
n.VserversEnabled = c.VserversEnabled
} | go | {
"resource": ""
} |
q26344 | Clone | train | func (n *Node) Clone() *Node {
var c Node
c.Copy(n)
return &c
} | go | {
"resource": ""
} |
q26345 | Copy | train | func (h *Host) Copy(c *Host) {
h.Hostname = c.Hostname
h.IPv4Addr = copyIP(c.IPv4Addr)
h.IPv4Mask = copyIPMask(c.IPv4Mask)
h.IPv6Addr = copyIP(c.IPv6Addr)
h.IPv6Mask = copyIPMask(c.IPv6Mask)
} | go | {
"resource": ""
} |
q26346 | Clone | train | func (h *Host) Clone() *Host {
var c Host
c.Copy(h)
return &c
} | go | {
"resource": ""
} |
q26347 | Equal | train | func (h *Host) Equal(other *Host) bool {
return reflect.DeepEqual(h, other)
} | go | {
"resource": ""
} |
q26348 | IPv4Net | train | func (h *Host) IPv4Net() *net.IPNet {
return &net.IPNet{IP: h.IPv4Addr, Mask: h.IPv4Mask}
} | go | {
"resource": ""
} |
q26349 | IPv6Net | train | func (h *Host) IPv6Net() *net.IPNet {
return &net.IPNet{IP: h.IPv6Addr, Mask: h.IPv6Mask}
} | go | {
"resource": ""
} |
q26350 | IPv4Printable | train | func (h *Host) IPv4Printable() string {
if h.IPv4Addr == nil {
return "<not configured>"
}
return h.IPv4Net().String()
} | go | {
"resource": ""
} |
q26351 | IPv6Printable | train | func (h *Host) IPv6Printable() string {
if h.IPv6Addr == nil {
return "<not configured>"
}
return h.IPv6Net().String()
} | go | {
"resource": ""
} |
q26352 | Copy | train | func (b *Backend) Copy(c *Backend) {
b.Enabled = c.Enabled
b.InService = c.InService
b.Weight = c.Weight
b.Host.Copy(&c.Host)
} | go | {
"resource": ""
} |
q26353 | Clone | train | func (b *Backend) Clone() *Backend {
var c Backend
c.Copy(b)
return &c
} | go | {
"resource": ""
} |
q26354 | Copy | train | func (h *HAConfig) Copy(c *HAConfig) {
h.Enabled = c.Enabled
h.LocalAddr = copyIP(c.LocalAddr)
h.RemoteAddr = copyIP(c.RemoteAddr)
h.Priority = c.Priority
h.VRID = c.VRID
} | go | {
"resource": ""
} |
q26355 | Clone | train | func (h *HAConfig) Clone() *HAConfig {
var c HAConfig
c.Copy(h)
return &c
} | go | {
"resource": ""
} |
q26356 | Equal | train | func (h *HAConfig) Equal(other *HAConfig) bool {
return h.Enabled == other.Enabled &&
h.LocalAddr.Equal(other.LocalAddr) &&
h.RemoteAddr.Equal(other.RemoteAddr) &&
h.Priority == other.Priority &&
h.VRID == other.VRID
} | go | {
"resource": ""
} |
q26357 | String | train | func (h HAConfig) String() string {
return fmt.Sprintf("Enabled: %v, LocalAddr: %v, RemoteAddr: %v, Priority: %d, VRID: %d",
h.Enabled, h.LocalAddr, h.RemoteAddr, h.Priority, h.VRID)
} | go | {
"resource": ""
} |
q26358 | String | train | func (h HAState) String() string {
switch h {
case HAUnknown:
return "Unknown"
case HABackup:
return "Backup"
case HADisabled:
return "Disabled"
case HAError:
return "Error"
case HAMaster:
return "Master"
case HAShutdown:
return "Shutdown"
}
return "(invalid)"
} | go | {
"resource": ""
} |
q26359 | Equal | train | func (v *VLAN) Equal(other *VLAN) bool {
// Exclude backend and VIP counters from comparison.
return v.ID == other.ID && v.Host.Equal(&other.Host)
} | go | {
"resource": ""
} |
q26360 | String | train | func (v *VLAN) String() string {
return fmt.Sprintf("{ID=%d, Host=%s, IPv4=%s, IPv6=%s}", v.ID, v.Hostname, v.IPv4Printable(), v.IPv6Printable())
} | go | {
"resource": ""
} |
q26361 | String | train | func (sk ServiceKey) String() string {
return fmt.Sprintf("%s %s %d", sk.AF, sk.Proto, sk.Port)
} | go | {
"resource": ""
} |
q26362 | IP | train | func (d *Destination) IP(af AF) net.IP {
switch af {
case IPv4:
return d.Backend.IPv4Addr
case IPv6:
return d.Backend.IPv6Addr
}
return nil
} | go | {
"resource": ""
} |
q26363 | copyIP | train | func copyIP(src net.IP) net.IP {
return net.IP(copyBytes(src))
} | go | {
"resource": ""
} |
q26364 | copyIPMask | train | func copyIPMask(src net.IPMask) net.IPMask {
return net.IPMask(copyBytes(src))
} | go | {
"resource": ""
} |
q26365 | copyBytes | train | func copyBytes(src []byte) []byte {
if src == nil {
return nil
}
dst := make([]byte, len(src))
copy(dst, src)
return dst
} | go | {
"resource": ""
} |
q26366 | IsAnycast | train | func IsAnycast(ip net.IP) bool {
return netIPv4Anycast.Contains(ip) || netIPv6Anycast.Contains(ip)
} | go | {
"resource": ""
} |
q26367 | InSubnets | train | func InSubnets(ip net.IP, subnets map[string]*net.IPNet) bool {
for _, subnet := range subnets {
if subnet.Contains(ip) {
return true
}
}
return false
} | go | {
"resource": ""
} |
q26368 | NewEngine | train | func NewEngine(cfg *config.EngineConfig) *Engine {
if cfg == nil {
defaultCfg := config.DefaultEngineConfig()
cfg = &defaultCfg
}
// TODO(jsing): Validate node, peer and cluster IP configuration.
engine := &Engine{
config: cfg,
fwmAlloc: newMarkAllocator(fwmAllocBase, fwmAllocSize),
ncc: ncclient.N... | go | {
"resource": ""
} |
q26369 | Run | train | func (e *Engine) Run() {
log.Infof("Seesaw Engine starting for %s", e.config.ClusterName)
e.initNetwork()
n, err := config.NewNotifier(e.config)
if err != nil {
log.Fatalf("config.NewNotifier() failed: %v", err)
}
e.notifier = n
if e.config.AnycastEnabled {
go e.bgpManager.run()
}
go e.hcManager.run()
... | go | {
"resource": ""
} |
q26370 | haStatus | train | func (e *Engine) haStatus() seesaw.HAStatus {
e.haManager.statusLock.RLock()
defer e.haManager.statusLock.RUnlock()
return e.haManager.status
} | go | {
"resource": ""
} |
q26371 | setHAState | train | func (e *Engine) setHAState(state seesaw.HAState) {
e.haManager.stateChan <- state
} | go | {
"resource": ""
} |
q26372 | setHAStatus | train | func (e *Engine) setHAStatus(status seesaw.HAStatus) {
e.haManager.statusChan <- status
} | go | {
"resource": ""
} |
q26373 | haConfig | train | func (e *Engine) haConfig() (*seesaw.HAConfig, error) {
n, err := e.thisNode()
if err != nil {
return nil, err
}
// TODO(jsing): This does not allow for IPv6-only operation.
return &seesaw.HAConfig{
Enabled: n.State != seesaw.HADisabled,
LocalAddr: e.config.Node.IPv4Addr,
RemoteAddr: e.config.VRRPDestI... | go | {
"resource": ""
} |
q26374 | thisNode | train | func (e *Engine) thisNode() (*seesaw.Node, error) {
e.clusterLock.RLock()
c := e.cluster
e.clusterLock.RUnlock()
if c == nil {
return nil, fmt.Errorf("cluster configuration not loaded")
}
// TODO(jsing): This does not allow for IPv6-only operation.
ip := e.config.Node.IPv4Addr
for _, n := range c.Nodes {
i... | go | {
"resource": ""
} |
q26375 | engineIPC | train | func (e *Engine) engineIPC() {
if err := server.RemoveUnixSocket(e.config.SocketPath); err != nil {
log.Fatalf("Failed to remove socket: %v", err)
}
ln, err := net.Listen("unix", e.config.SocketPath)
if err != nil {
log.Fatalf("Listen failed: %v", err)
}
defer os.Remove(e.config.SocketPath)
seesawIPC := rpc... | go | {
"resource": ""
} |
q26376 | syncRPC | train | func (e *Engine) syncRPC() {
// TODO(jsing): Make this default to IPv6, if configured.
addr := &net.TCPAddr{
IP: e.config.Node.IPv4Addr,
Port: e.config.SyncPort,
}
ln, err := net.ListenTCP("tcp", addr)
if err != nil {
log.Fatalf("Listen failed: %v", err)
}
go e.syncServer.serve(ln)
<-e.shutdownRPC
ln... | go | {
"resource": ""
} |
q26377 | initNetwork | train | func (e *Engine) initNetwork() {
if err := e.ncc.Dial(); err != nil {
log.Fatalf("Failed to connect to NCC: %v", err)
}
defer e.ncc.Close()
if e.config.AnycastEnabled {
if err := e.ncc.BGPWithdrawAll(); err != nil {
log.Fatalf("Failed to withdraw all BGP advertisements: %v", err)
}
}
if err := e.ncc.IPV... | go | {
"resource": ""
} |
q26378 | initAnycast | train | func (e *Engine) initAnycast() {
if err := e.ncc.Dial(); err != nil {
log.Fatalf("Failed to connect to NCC: %v", err)
}
defer e.ncc.Close()
vips := make([]*seesaw.VIP, 0)
if e.config.ClusterVIP.IPv4Addr != nil {
for _, ip := range e.config.ServiceAnycastIPv4 {
vips = append(vips, seesaw.NewVIP(ip, nil))
... | go | {
"resource": ""
} |
q26379 | gratuitousARP | train | func (e *Engine) gratuitousARP() {
arpTicker := time.NewTicker(e.config.GratuitousARPInterval)
var announced bool
for {
select {
case <-arpTicker.C:
if e.haManager.state() != seesaw.HAMaster {
if announced {
log.Infof("Stopping gratuitous ARPs for %s", e.config.ClusterVIP.IPv4Addr)
announced = f... | go | {
"resource": ""
} |
q26380 | updateVservers | train | func (e *Engine) updateVservers() {
e.clusterLock.RLock()
cluster := e.cluster
e.clusterLock.RUnlock()
// Delete vservers that no longer exist in the new configuration.
for name, vserver := range e.vservers {
if cluster.Vservers[name] == nil {
log.Infof("Stopping unconfigured vserver %s", name)
vserver.st... | go | {
"resource": ""
} |
q26381 | shutdownVservers | train | func (e *Engine) shutdownVservers() {
for _, v := range e.vservers {
v.stop()
}
for name, v := range e.vservers {
<-v.stopped
delete(e.vservers, name)
}
e.vserverLock.Lock()
e.vserverSnapshots = make(map[string]*seesaw.Vserver)
e.vserverLock.Unlock()
} | go | {
"resource": ""
} |
q26382 | updateVLANs | train | func (e *Engine) updateVLANs() {
e.clusterLock.RLock()
cluster := e.cluster
e.clusterLock.RUnlock()
add := make([]*seesaw.VLAN, 0)
remove := make([]*seesaw.VLAN, 0)
e.vlanLock.Lock()
defer e.vlanLock.Unlock()
for key, vlan := range e.vlans {
if cluster.VLANs[key] == nil {
remove = append(remove, vlan)
... | go | {
"resource": ""
} |
q26383 | deleteVLANs | train | func (e *Engine) deleteVLANs() {
if err := e.ncc.Dial(); err != nil {
log.Fatalf("Failed to connect to NCC: %v", err)
}
defer e.ncc.Close()
e.vlanLock.Lock()
defer e.vlanLock.Unlock()
for k, v := range e.vlans {
if err := e.lbInterface.DeleteVLAN(v); err != nil {
log.Fatalf("Failed to remove VLAN interfa... | go | {
"resource": ""
} |
q26384 | handleOverride | train | func (e *Engine) handleOverride(o seesaw.Override) {
e.overrides[o.Target()] = o
e.distributeOverride(o)
if o.State() == seesaw.OverrideDefault {
delete(e.overrides, o.Target())
}
} | go | {
"resource": ""
} |
q26385 | distributeOverride | train | func (e *Engine) distributeOverride(o seesaw.Override) {
// Send VserverOverrides and DestinationOverrides to the appropriate vserver.
// Send BackendOverrides to all vservers.
switch override := o.(type) {
case *seesaw.VserverOverride:
if vserver, ok := e.vservers[override.VserverName]; ok {
vserver.queueOver... | go | {
"resource": ""
} |
q26386 | becomeMaster | train | func (e *Engine) becomeMaster() {
if err := e.ncc.Dial(); err != nil {
log.Fatalf("Failed to connect to NCC: %v", err)
}
defer e.ncc.Close()
e.syncClient.disable()
e.hcManager.enable()
e.notifier.SetSource(config.SourceServer)
if err := e.lbInterface.Up(); err != nil {
log.Fatalf("Failed to bring LB interf... | go | {
"resource": ""
} |
q26387 | becomeBackup | train | func (e *Engine) becomeBackup() {
if err := e.ncc.Dial(); err != nil {
log.Fatalf("Failed to connect to NCC: %v", err)
}
defer e.ncc.Close()
e.syncClient.enable()
e.hcManager.disable()
e.notifier.SetSource(config.SourcePeer)
if err := e.lbInterface.Down(); err != nil {
log.Fatalf("Failed to bring LB interf... | go | {
"resource": ""
} |
q26388 | newMarkAllocator | train | func newMarkAllocator(base, size int) *markAllocator {
ma := &markAllocator{
marks: make([]uint32, 0, size),
}
for i := 0; i < size; i++ {
ma.put(uint32(base + i))
}
return ma
} | go | {
"resource": ""
} |
q26389 | get | train | func (ma *markAllocator) get() (uint32, error) {
ma.lock.Lock()
defer ma.lock.Unlock()
if len(ma.marks) == 0 {
return 0, errors.New("allocator exhausted")
}
mark := ma.marks[0]
ma.marks = ma.marks[1:]
return mark, nil
} | go | {
"resource": ""
} |
q26390 | put | train | func (ma *markAllocator) put(mark uint32) {
ma.lock.Lock()
defer ma.lock.Unlock()
ma.marks = append(ma.marks, mark)
} | go | {
"resource": ""
} |
q26391 | authenticate | train | func (e *ECU) authenticate(ctx *ipc.Context) (*ipc.Context, error) {
return nil, errors.New("unimplemented")
} | go | {
"resource": ""
} |
q26392 | authConnect | train | func (e *ECU) authConnect(ctx *ipc.Context) (*conn.Seesaw, error) {
if ctx == nil {
return nil, errors.New("context is nil")
}
authCtx, err := e.authenticate(ctx)
if err != nil {
return nil, fmt.Errorf("authentication failed: %v", err)
}
seesawConn, err := conn.NewSeesawIPC(authCtx)
if err != nil {
return... | go | {
"resource": ""
} |
q26393 | commandChain | train | func commandChain(chain []*cli.Command, args []string) string {
s := make([]string, 0)
for _, c := range chain {
s = append(s, c.Command)
}
s = append(s, args...)
if len(s) > 0 && len(args) == 0 {
s = append(s, "")
}
return strings.Join(s, " ")
} | go | {
"resource": ""
} |
q26394 | autoComplete | train | func autoComplete(line string, pos int, key rune) (string, int, bool) {
switch key {
case 0x01: // Ctrl-A
return line, 0, true
case 0x03: // Ctrl-C
exit()
case 0x05: // Ctrl-E
return line, len(line), true
case 0x09: // Ctrl-I (Tab)
_, _, chain, args := cli.FindCommand(string(line))
line := commandChain(c... | go | {
"resource": ""
} |
q26395 | interactive | train | func interactive() {
status, err := seesawConn.ClusterStatus()
if err != nil {
fatalf("Failed to get cluster status: %v", err)
}
fmt.Printf("\nSeesaw CLI - Engine version %d\n\n", status.Version)
u, err := user.Current()
if err != nil {
fatalf("Failed to get current user: %v", err)
}
ha, err := seesawConn... | go | {
"resource": ""
} |
q26396 | newIPVSService | train | func newIPVSService(svc *Service) *ipvsService {
ipvsSvc := &ipvsService{
Address: svc.Address,
Protocol: svc.Protocol,
Port: svc.Port,
FirewallMark: svc.FirewallMark,
Scheduler: svc.Scheduler,
Flags: svc.Flags,
Timeout: svc.Timeout,
Pe... | go | {
"resource": ""
} |
q26397 | newIPVSDestination | train | func newIPVSDestination(dst *Destination) *ipvsDestination {
return &ipvsDestination{
Address: dst.Address,
Port: dst.Port,
Flags: dst.Flags,
Weight: uint32(dst.Weight),
UpperThreshold: dst.UpperThreshold,
LowerThreshold: dst.LowerThreshold,
}
} | go | {
"resource": ""
} |
q26398 | toService | train | func (ipvsSvc ipvsService) toService() *Service {
svc := &Service{
Address: ipvsSvc.Address,
Protocol: ipvsSvc.Protocol,
Port: ipvsSvc.Port,
FirewallMark: ipvsSvc.FirewallMark,
Scheduler: ipvsSvc.Scheduler,
Flags: ipvsSvc.Flags,
Timeout: ... | go | {
"resource": ""
} |
q26399 | toDestination | train | func (ipvsDst ipvsDestination) toDestination() *Destination {
dst := &Destination{
Address: ipvsDst.Address,
Port: ipvsDst.Port,
Weight: int32(ipvsDst.Weight), // TODO(jsing): uint32?
Flags: ipvsDst.Flags,
LowerThreshold: ipvsDst.LowerThreshold,
UpperThreshold: ipvsDst.Upp... | go | {
"resource": ""
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.