_id stringlengths 2 7 | title stringlengths 1 118 | partition stringclasses 3
values | text stringlengths 52 85.5k | language stringclasses 1
value | meta_information dict |
|---|---|---|---|---|---|
q26500 | AF | train | func (ip IP) AF() AF {
if ip.IP().To4() != nil {
return IPv4
}
return IPv6
} | go | {
"resource": ""
} |
q26501 | String | train | func (lbm LBMode) String() string {
if name, ok := modeNames[lbm]; ok {
return name
}
return "(unknown)"
} | go | {
"resource": ""
} |
q26502 | String | train | func (lbs LBScheduler) String() string {
if name, ok := schedulerNames[lbs]; ok {
return name
}
return "(unknown)"
} | go | {
"resource": ""
} |
q26503 | setSocketMark | train | func setSocketMark(fd, mark int) error {
if err := syscall.SetsockoptInt(fd, syscall.SOL_SOCKET, syscall.SO_MARK, mark); err != nil {
return os.NewSyscallError("failed to set mark", err)
}
return nil
} | go | {
"resource": ""
} |
q26504 | setSocketTimeout | train | func setSocketTimeout(fd int, timeout time.Duration) error {
tv := syscall.NsecToTimeval(timeout.Nanoseconds())
for _, opt := range []int{syscall.SO_RCVTIMEO, syscall.SO_SNDTIMEO} {
if err := syscall.SetsockoptTimeval(fd, syscall.SOL_SOCKET, opt, &tv); err != nil {
return os.NewSyscallError("setsockopt", err)
... | go | {
"resource": ""
} |
q26505 | newVserver | train | func newVserver(e *Engine) *vserver {
return &vserver{
engine: e,
ncc: ncclient.NewNCC(e.config.NCCSocket),
fwm: make(map[seesaw.AF]uint32),
active: make(map[seesaw.IP]bool),
lbVservers: make(map[seesaw.IP]*seesaw.Vserver),
vips: make(map[seesaw.VIP]bool),
overrideChan: make(chan se... | go | {
"resource": ""
} |
q26506 | String | train | func (v *vserver) String() string {
if v.config != nil {
return v.config.Name
}
return fmt.Sprintf("Unconfigured vserver %+v", *v)
} | go | {
"resource": ""
} |
q26507 | ipvsService | train | func (svc *service) ipvsService() *ipvs.Service {
var flags ipvs.ServiceFlags
if svc.ventry.Persistence > 0 {
flags |= ipvs.SFPersistent
}
if svc.ventry.OnePacket {
flags |= ipvs.SFOnePacket
}
var ip net.IP
switch {
case svc.fwm > 0 && svc.af == seesaw.IPv4:
ip = net.IPv4zero
case svc.fwm > 0 && svc.af =... | go | {
"resource": ""
} |
q26508 | ipvsEqual | train | func (s *service) ipvsEqual(other *service) bool {
return s.ipvsSvc.Equal(*other.ipvsSvc) &&
s.ventry.Mode == other.ventry.Mode &&
s.ventry.LThreshold == other.ventry.LThreshold &&
s.ventry.UThreshold == other.ventry.UThreshold
} | go | {
"resource": ""
} |
q26509 | String | train | func (s *service) String() string {
if s.fwm != 0 {
return fmt.Sprintf("%v/fwm:%d", s.ip, s.fwm)
}
ip := s.ip.String()
port := strconv.Itoa(int(s.port))
return fmt.Sprintf("%v/%v", net.JoinHostPort(ip, port), s.proto)
} | go | {
"resource": ""
} |
q26510 | ipvsDestination | train | func (dst *destination) ipvsDestination() *ipvs.Destination {
var flags ipvs.DestinationFlags
switch dst.service.ventry.Mode {
case seesaw.LBModeNone:
log.Warningf("%v: Unspecified LB mode", dst)
case seesaw.LBModeDSR:
flags |= ipvs.DFForwardRoute
case seesaw.LBModeNAT:
flags |= ipvs.DFForwardMasq
}
return... | go | {
"resource": ""
} |
q26511 | ipvsEqual | train | func (d *destination) ipvsEqual(other *destination) bool {
return d.ipvsDst.Equal(*other.ipvsDst)
} | go | {
"resource": ""
} |
q26512 | String | train | func (d *destination) String() string {
if d.service.fwm != 0 {
return fmt.Sprintf("%v", d.ip)
}
ip := d.ip.String()
port := strconv.Itoa(int(d.service.port))
return fmt.Sprintf("%v/%v", net.JoinHostPort(ip, port), d.service.proto)
} | go | {
"resource": ""
} |
q26513 | name | train | func (d *destination) name() string {
return fmt.Sprintf("%v/%v", d.service.vserver.String(), d.String())
} | go | {
"resource": ""
} |
q26514 | newCheckKey | train | func newCheckKey(vip, bip seesaw.IP, port uint16, proto seesaw.IPProto, h *config.Healthcheck) checkKey {
return checkKey{
vserverIP: vip,
backendIP: bip,
servicePort: port,
serviceProtocol: proto,
healthcheckMode: h.Mode,
healthcheckType: h.Type,
healthcheckPort: h.Port,
name: ... | go | {
"resource": ""
} |
q26515 | String | train | func (c checkKey) String() string {
return fmt.Sprintf("%v:%d/%v backend %v:%d/%v %v %v port %d (%s)",
c.vserverIP, c.servicePort, c.serviceProtocol,
c.backendIP, c.servicePort, c.serviceProtocol,
c.healthcheckMode, c.healthcheckType, c.healthcheckPort, c.name)
} | go | {
"resource": ""
} |
q26516 | newCheck | train | func newCheck(key checkKey, v *vserver, h *config.Healthcheck) *check {
return &check{
key: key,
vserver: v,
healthcheck: h,
}
} | go | {
"resource": ""
} |
q26517 | expandServices | train | func (v *vserver) expandServices() map[serviceKey]*service {
if v.config.UseFWM {
return v.expandFWMServices()
}
svcs := make(map[serviceKey]*service)
for _, af := range seesaw.AFs() {
var ip net.IP
switch af {
case seesaw.IPv4:
ip = v.config.Host.IPv4Addr
case seesaw.IPv6:
ip = v.config.Host.IPv6A... | go | {
"resource": ""
} |
q26518 | expandFWMServices | train | func (v *vserver) expandFWMServices() map[serviceKey]*service {
svcs := make(map[serviceKey]*service)
for _, af := range seesaw.AFs() {
var ip net.IP
switch af {
case seesaw.IPv4:
ip = v.config.Host.IPv4Addr
case seesaw.IPv6:
ip = v.config.Host.IPv6Addr
}
if ip == nil {
continue
}
// Persist... | go | {
"resource": ""
} |
q26519 | expandDests | train | func (v *vserver) expandDests(svc *service) map[destinationKey]*destination {
dsts := make(map[destinationKey]*destination, len(v.config.Backends))
for _, backend := range v.config.Backends {
var ip net.IP
switch svc.af {
case seesaw.IPv4:
ip = backend.Host.IPv4Addr
case seesaw.IPv6:
ip = backend.Host.I... | go | {
"resource": ""
} |
q26520 | expandChecks | train | func (v *vserver) expandChecks() map[checkKey]*check {
checks := make(map[checkKey]*check)
for _, svc := range v.services {
for _, dest := range svc.dests {
dest.checks = make([]*check, 0)
if !dest.backend.Enabled {
continue
}
for _, hc := range v.config.Healthchecks {
// vserver-level healthche... | go | {
"resource": ""
} |
q26521 | healthchecks | train | func (v *vserver) healthchecks() vserverChecks {
vc := vserverChecks{vserverName: v.config.Name}
if v.enabled {
vc.checks = v.checks
}
return vc
} | go | {
"resource": ""
} |
q26522 | run | train | func (v *vserver) run() {
statsTicker := time.NewTicker(v.engine.config.StatsInterval)
for {
select {
case <-v.quit:
// Shutdown active vservers, services and destinations.
// There is no race between this and new healthcheck
// notifications, since they are also handled via the
// same vserver go rou... | go | {
"resource": ""
} |
q26523 | handleConfigUpdate | train | func (v *vserver) handleConfigUpdate(config *config.Vserver) {
if config == nil {
return
}
switch {
case v.config == nil:
v.configInit(config)
return
case v.enabled && !vserverEnabled(config, v.vserverOverride.State()):
log.Infof("%v: disabling vserver", v)
v.downAll()
v.unconfigureVIPs()
v.configIn... | go | {
"resource": ""
} |
q26524 | configInit | train | func (v *vserver) configInit(config *config.Vserver) {
v.config = config
v.enabled = vserverEnabled(config, v.vserverOverride.State())
newSvcs := v.expandServices()
// Preserve stats if this is a reinit
for svcK, svc := range newSvcs {
svc.dests = v.expandDests(svc)
if oldSvc, ok := v.services[svcK]; ok {
*... | go | {
"resource": ""
} |
q26525 | configUpdate | train | func (v *vserver) configUpdate() {
newSvcs := v.expandServices()
for svcKey, newSvc := range newSvcs {
if svc, ok := v.services[svcKey]; ok {
if svc.ip.Equal(newSvc.ip) {
svc.update(newSvc)
continue
}
log.Infof("%v: service %v: new IP address: %v", v, svc, newSvc.ip)
v.deleteService(svc)
}
l... | go | {
"resource": ""
} |
q26526 | deleteService | train | func (v *vserver) deleteService(s *service) {
if s.active {
s.healthy = false
v.updateState(s.ip)
}
log.Infof("%v: deleting service: %v", v, s)
delete(v.services, s.serviceKey)
// TODO(baptr): Once service contains seesaw.VIP, move check and
// unconfigureVIP here.
} | go | {
"resource": ""
} |
q26527 | handleCheckNotification | train | func (v *vserver) handleCheckNotification(n *checkNotification) {
if !v.enabled {
log.Infof("%v: ignoring healthcheck notification %s (vserver disabled)", v, n.description)
return
}
check := v.checks[n.key]
if check == nil {
log.Warningf("%v: unknown check key %v", v, n.key)
return
}
transition := (chec... | go | {
"resource": ""
} |
q26528 | handleOverride | train | func (v *vserver) handleOverride(o seesaw.Override) {
switch override := o.(type) {
case *seesaw.VserverOverride:
if v.vserverOverride == *override {
// No change
return
}
v.vserverOverride = *override
if vserverEnabled(v.config, o.State()) == v.enabled {
// enable state not changed - nothing to do
... | go | {
"resource": ""
} |
q26529 | vserverEnabled | train | func vserverEnabled(config *config.Vserver, os seesaw.OverrideState) bool {
switch {
case config == nil:
return false
case os == seesaw.OverrideDisable:
return false
case os == seesaw.OverrideEnable:
return true
}
return config.Enabled
} | go | {
"resource": ""
} |
q26530 | snapshot | train | func (v *vserver) snapshot() *seesaw.Vserver {
if v.config == nil {
return nil
}
sv := &seesaw.Vserver{
Name: v.config.Name,
Entries: make([]*seesaw.VserverEntry, 0, len(v.config.Entries)),
Host: seesaw.Host{
Hostname: v.config.Hostname,
IPv4Addr: v.config.IPv4Addr,
IPv4Mask: v.config.IPv4Mask,
... | go | {
"resource": ""
} |
q26531 | updateState | train | func (d *destination) updateState() {
// The destination is healthy if the backend is enabled and *all* the checks
// for that destination are healthy.
healthy := d.backend.Enabled
if healthy {
for _, c := range d.checks {
if c.status.State != healthcheck.StateHealthy {
healthy = false
break
}
}
... | go | {
"resource": ""
} |
q26532 | up | train | func (d *destination) up() {
d.active = true
log.Infof("%v: %v backend %v up", d.service.vserver, d.service, d)
ncc := d.service.vserver.ncc
if err := ncc.Dial(); err != nil {
log.Fatalf("%v: failed to connect to NCC: %v", d.service.vserver, err)
}
defer ncc.Close()
if err := ncc.IPVSAddDestination(d.service.... | go | {
"resource": ""
} |
q26533 | down | train | func (d *destination) down() {
d.active = false
log.Infof("%v: %v backend %v down", d.service.vserver, d.service, d)
ncc := d.service.vserver.ncc
if err := ncc.Dial(); err != nil {
log.Fatalf("%v: failed to connect to NCC: %v", d.service.vserver, err)
}
defer ncc.Close()
if err := ncc.IPVSDeleteDestination(d.... | go | {
"resource": ""
} |
q26534 | update | train | func (d *destination) update(dest *destination) {
if d.destinationKey != dest.destinationKey {
log.Fatalf("%v: can't update destination %v using %v: destinationKey mismatch: %v != %v",
d.service.vserver, d, dest, d.destinationKey, dest.destinationKey)
}
log.Infof("%v: %v updating destination %v", d.service.vser... | go | {
"resource": ""
} |
q26535 | snapshot | train | func (d *destination) snapshot() *seesaw.Destination {
return &seesaw.Destination{
Backend: d.backend,
Name: d.name(),
VserverName: d.service.vserver.String(),
Stats: d.stats,
Enabled: d.backend.Enabled,
Weight: d.weight,
Healthy: d.healthy,
Active: d.active,
}
} | go | {
"resource": ""
} |
q26536 | updateState | train | func (s *service) updateState() {
// The service is considered healthy if:
// 1) No watermarks are configured, and at least one destination is healthy.
// OR
// 2) (Num healthy dests) / (Num backends) >= high watermark.
// OR
// 3) Service is already healthy, and
// (Num healthy dests) / (Num backends) >= low... | go | {
"resource": ""
} |
q26537 | updateDests | train | func (s *service) updateDests() {
for _, d := range s.dests {
if !s.active {
d.stats.DestinationStats = &ipvs.DestinationStats{}
if d.active {
d.down()
}
continue
}
switch {
case !d.healthy && d.active:
d.down()
case d.healthy && !d.active:
d.up()
}
}
} | go | {
"resource": ""
} |
q26538 | up | train | func (s *service) up() {
s.active = true
log.Infof("%v: %v service up", s.vserver, s)
ncc := s.vserver.ncc
if err := ncc.Dial(); err != nil {
log.Fatalf("%v: failed to connect to NCC: %v", s.vserver, err)
}
defer ncc.Close()
log.Infof("%v: adding IPVS service %v", s.vserver, s.ipvsSvc)
if err := ncc.IPVSAdd... | go | {
"resource": ""
} |
q26539 | down | train | func (s *service) down() {
s.active = false
s.stats.ServiceStats = &ipvs.ServiceStats{}
log.Infof("%v: %v service down", s.vserver, s)
ncc := s.vserver.ncc
if err := ncc.Dial(); err != nil {
log.Fatalf("%v: failed to connect to NCC: %v", s.vserver, err)
}
defer ncc.Close()
// Remove IPVS destinations *befor... | go | {
"resource": ""
} |
q26540 | update | train | func (s *service) update(svc *service) {
if s.serviceKey != svc.serviceKey {
log.Fatalf("%v: can't update service %v using %v: serviceKey mismatch: %v != %v",
s.vserver, s, svc, s.serviceKey, svc.serviceKey)
}
log.Infof("%v: updating service %v", s.vserver, s)
updateIPVS := s.active && !s.ipvsEqual(svc)
svc.... | go | {
"resource": ""
} |
q26541 | updateStats | train | func (s *service) updateStats() {
if !s.active {
return
}
log.V(1).Infof("%v: updating IPVS statistics for %v", s.vserver, s)
ncc := s.vserver.ncc
if err := ncc.Dial(); err != nil {
log.Fatalf("%v: failed to connect to NCC: %v", s.vserver, err)
}
defer ncc.Close()
ipvsSvc, err := ncc.IPVSGetService(s.ipvs... | go | {
"resource": ""
} |
q26542 | snapshot | train | func (s *service) snapshot() *seesaw.Service {
ss := &seesaw.Service{
ServiceKey: seesaw.ServiceKey{
AF: s.af,
Proto: s.proto,
Port: s.port,
},
Mode: s.ventry.Mode,
Scheduler: s.ventry.Scheduler,
OnePacket: s.ventry.OnePacket,
Persistence: s.ventry.Persistence,
IP: ... | go | {
"resource": ""
} |
q26543 | updateState | train | func (v *vserver) updateState(ip seesaw.IP) {
// A vserver anycast IP is healthy if *all* services for that IP are healthy.
// A vserver unicast IP is healthy if *any* services for that IP are healthy.
var healthy bool
for _, s := range v.services {
if !s.ip.Equal(ip) {
continue
}
healthy = s.healthy
if ... | go | {
"resource": ""
} |
q26544 | updateServices | train | func (v *vserver) updateServices(ip seesaw.IP) {
for _, s := range v.services {
if !s.ip.Equal(ip) {
continue
}
if !v.active[ip] {
if s.active {
s.down()
}
continue
}
switch {
case !s.healthy && s.active:
s.down()
case s.healthy && !s.active:
s.up()
}
}
} | go | {
"resource": ""
} |
q26545 | up | train | func (v *vserver) up(ip seesaw.IP) {
ncc := v.engine.ncc
if err := ncc.Dial(); err != nil {
log.Fatalf("%v: failed to connect to NCC: %v", v, err)
}
defer ncc.Close()
v.active[ip] = true
v.updateServices(ip)
// If this is an anycast VIP, start advertising a BGP route.
nip := ip.IP()
if seesaw.IsAnycast(nip... | go | {
"resource": ""
} |
q26546 | downAll | train | func (v *vserver) downAll() {
for _, s := range v.services {
if v.active[s.ip] {
v.down(s.ip)
}
if s.active {
s.down()
}
}
} | go | {
"resource": ""
} |
q26547 | down | train | func (v *vserver) down(ip seesaw.IP) {
ncc := v.engine.ncc
if err := ncc.Dial(); err != nil {
log.Fatalf("%v: failed to connect to NCC: %v", v, err)
}
defer ncc.Close()
// If this is an anycast VIP, withdraw the BGP route.
nip := ip.IP()
if seesaw.IsAnycast(nip) {
if v.engine.config.AnycastEnabled {
log.... | go | {
"resource": ""
} |
q26548 | configureVIPs | train | func (v *vserver) configureVIPs() {
ncc := v.engine.ncc
if err := ncc.Dial(); err != nil {
log.Fatalf("%v: failed to connect to NCC: %v", v, err)
}
defer ncc.Close()
// TODO(ncope): Return to iterating over v.services once they contain seesaw.VIPs.
for _, vip := range v.config.VIPs {
if _, ok := v.vips[*vip]... | go | {
"resource": ""
} |
q26549 | unconfigureVIP | train | func (v *vserver) unconfigureVIP(vip *seesaw.VIP) {
configured, ok := v.vips[*vip]
if !ok {
return
}
if configured {
ncc := v.engine.ncc
if err := ncc.Dial(); err != nil {
log.Fatalf("%v: failed to connect to NCC: %v", v, err)
}
defer ncc.Close()
if err := v.engine.lbInterface.DeleteVIP(vip); err !=... | go | {
"resource": ""
} |
q26550 | unconfigureVIPs | train | func (v *vserver) unconfigureVIPs() {
ncc := v.engine.ncc
if err := ncc.Dial(); err != nil {
log.Fatalf("%v: failed to connect to NCC: %v", v, err)
}
defer ncc.Close()
// TODO(jsing): At a later date this will need to support VLAN
// interfaces and dedicated VIP subnets.
for vip := range v.vips {
v.unconfig... | go | {
"resource": ""
} |
q26551 | fetchFromHost | train | func (f *fetcher) fetchFromHost(ip net.IP, url, contentType string) ([]byte, error) {
// TODO(angusc): connection timeout?
tcpAddr := &net.TCPAddr{IP: ip, Port: f.port}
tcpConn, err := net.DialTCP("tcp", nil, tcpAddr)
if err != nil {
return nil, err
}
defer tcpConn.Close()
tcpConn.SetDeadline(time.Now().Add(f.... | go | {
"resource": ""
} |
q26552 | uint16FromNetwork | train | func uint16FromNetwork(u uint16) uint16 {
b := *(*[2]byte)(unsafe.Pointer(&u))
return binary.BigEndian.Uint16(b[:])
} | go | {
"resource": ""
} |
q26553 | uint16ToNetwork | train | func uint16ToNetwork(u uint16) uint16 {
var b [2]byte
binary.BigEndian.PutUint16(b[:], u)
return *(*uint16)(unsafe.Pointer(&b))
} | go | {
"resource": ""
} |
q26554 | uint32FromNetwork | train | func uint32FromNetwork(u uint32) uint32 {
b := *(*[4]byte)(unsafe.Pointer(&u))
return binary.BigEndian.Uint32(b[:])
} | go | {
"resource": ""
} |
q26555 | uint32ToNetwork | train | func uint32ToNetwork(u uint32) uint32 {
var b [4]byte
binary.BigEndian.PutUint32(b[:], u)
return *(*uint32)(unsafe.Pointer(&b))
} | go | {
"resource": ""
} |
q26556 | uint64FromNetwork | train | func uint64FromNetwork(u uint64) uint64 {
b := *(*[8]byte)(unsafe.Pointer(&u))
return binary.BigEndian.Uint64(b[:])
} | go | {
"resource": ""
} |
q26557 | uint64ToNetwork | train | func uint64ToNetwork(u uint64) uint64 {
var b [8]byte
binary.BigEndian.PutUint64(b[:], u)
return *(*uint64)(unsafe.Pointer(&b))
} | go | {
"resource": ""
} |
q26558 | structMaxAttrID | train | func structMaxAttrID(v reflect.Value) (uint16, error) {
if v.Kind() != reflect.Struct {
return 0, fmt.Errorf("%v is not a struct", v.Type())
}
st := v.Type()
var maxAttrID uint16
for i := 0; i < st.NumField(); i++ {
ft, fv := st.Field(i), v.Field(i)
fp, err := parseFieldParams(ft.Tag.Get("netlink"))
if er... | go | {
"resource": ""
} |
q26559 | Error | train | func (e *Error) Error() string {
nle := C.GoString(C.nl_geterror(e.errno))
return fmt.Sprintf("%s: %s", e.msg, strings.ToLower(nle))
} | go | {
"resource": ""
} |
q26560 | Family | train | func Family(name string) (int, error) {
s, err := newSocket()
if err != nil {
return -1, err
}
defer s.free()
if errno := C.genl_connect(s.nls); errno != 0 {
return -1, &Error{errno, "failed to connect to netlink"}
}
defer C.nl_close((*C.struct_nl_sock)(s.nls))
cn := C.CString(name)
defer C.free(unsafe.P... | go | {
"resource": ""
} |
q26561 | validateInterface | train | func validateInterface(iface *net.Interface) error {
if !ifaceNameRegexp.MatchString(iface.Name) {
return fmt.Errorf("Invalid interface name %q", iface.Name)
}
return nil
} | go | {
"resource": ""
} |
q26562 | ifaceDown | train | func ifaceDown(pIface *net.Interface) error {
out, err := ipRunOutput("link show dev %s", pIface.Name)
if !strings.Contains(out, "state UP") {
return nil
}
// Unlike IPv4, the kernel removes IPv6 addresses when the link goes down. We
// don't want that behavior, so we have to preserve the addresses manually.
/... | go | {
"resource": ""
} |
q26563 | ifaceSetMAC | train | func ifaceSetMAC(iface *net.Interface) error {
return ipRunIface(iface, "link set %s address %s", iface.Name, iface.HardwareAddr)
} | go | {
"resource": ""
} |
q26564 | ifaceAddIPAddr | train | func ifaceAddIPAddr(iface *net.Interface, ip net.IP, mask net.IPMask) error {
if ip.To4() != nil {
return ifaceAddIPv4Addr(iface, ip, mask)
}
return ifaceAddIPv6Addr(iface, ip, mask)
} | go | {
"resource": ""
} |
q26565 | ifaceAddIPv4Addr | train | func ifaceAddIPv4Addr(iface *net.Interface, ip net.IP, mask net.IPMask) error {
if ip.To4() == nil {
return fmt.Errorf("IP %v is not a valid IPv4 address", ip)
}
brd := make(net.IP, net.IPv4len)
copy(brd, ip.To4())
for i := 0; i < net.IPv4len; i++ {
brd[i] |= ^mask[i]
}
prefixLen, _ := mask.Size()
return ip... | go | {
"resource": ""
} |
q26566 | ifaceAddIPv6Addr | train | func ifaceAddIPv6Addr(iface *net.Interface, ip net.IP, mask net.IPMask) error {
prefixLen, _ := mask.Size()
return ipRunIface(iface, "addr add %s/%d dev %s", ip, prefixLen, iface.Name)
} | go | {
"resource": ""
} |
q26567 | ifaceAddVLAN | train | func ifaceAddVLAN(iface *net.Interface, vlan *seesaw.VLAN) error {
name := fmt.Sprintf("%s.%d", iface.Name, vlan.ID)
err := ipRunIface(iface, "link add link %s name %s type vlan id %d", iface.Name, name, vlan.ID)
if err != nil {
return fmt.Errorf("Failed to create VLAN interface %q: %v", name, err)
}
vlanIface,... | go | {
"resource": ""
} |
q26568 | ifaceDelVLAN | train | func ifaceDelVLAN(iface *net.Interface, vlan *seesaw.VLAN) error {
name := fmt.Sprintf("%s.%d", iface.Name, vlan.ID)
vlanIface, err := net.InterfaceByName(name)
if err != nil {
return fmt.Errorf("Failed to find VLAN interface %q: %v", name, err)
}
return ipRunIface(vlanIface, "link del dev %s", vlanIface.Name)
} | go | {
"resource": ""
} |
q26569 | ifaceFlushVLANs | train | func ifaceFlushVLANs(iface *net.Interface) error {
if err := validateInterface(iface); err != nil {
return err
}
vlanIfaces, err := vlanInterfaces(iface)
if err != nil {
return err
}
for _, vlanIface := range vlanIfaces {
if err := ipRunIface(vlanIface, "link del dev %s", vlanIface.Name); err != nil {
re... | go | {
"resource": ""
} |
q26570 | routeDefaultIPv4 | train | func routeDefaultIPv4() (net.IP, error) {
out, err := ipRunAFOutput(seesaw.IPv4, "route show default")
if err != nil {
return nil, err
}
if dr := routeDefaultIPv4Regexp.FindStringSubmatch(out); dr != nil {
return net.ParseIP(dr[1]).To4(), nil
}
return nil, fmt.Errorf("Default route not found")
} | go | {
"resource": ""
} |
q26571 | removeRoutes | train | func removeRoutes(table string, vip net.IP) error {
af := seesaw.IPv6
if vip.To4() != nil {
af = seesaw.IPv4
}
return ipRunAF(af, "route flush table %s %s", table, vip)
} | go | {
"resource": ""
} |
q26572 | routeLocal | train | func routeLocal(iface *net.Interface, vip net.IP, node seesaw.Host) error {
af := seesaw.IPv6
src := node.IPv6Addr
if vip.To4() != nil {
af = seesaw.IPv4
src = node.IPv4Addr
}
if err := removeLocalRoutes(vip); err != nil {
return err
}
return ipRunAF(af, "route add table local local %s dev %s src %s", vip,... | go | {
"resource": ""
} |
q26573 | RouteDefaultIPv4 | train | func (ncc *SeesawNCC) RouteDefaultIPv4(unused int, gateway *net.IP) error {
ip, err := routeDefaultIPv4()
if err != nil {
return err
}
if gateway != nil {
*gateway = make(net.IP, len(ip))
copy(*gateway, ip)
}
return nil
} | go | {
"resource": ""
} |
q26574 | addClusterVIP | train | func addClusterVIP(iface *ncctypes.LBInterface, netIface, nodeIface *net.Interface, clusterVIP net.IP) error {
nodeIP := iface.Node.IPv4Addr
family := seesaw.IPv4
if clusterVIP.To4() == nil {
nodeIP = iface.Node.IPv6Addr
family = seesaw.IPv6
}
if nodeIP == nil {
return fmt.Errorf("Node does not have an %s ad... | go | {
"resource": ""
} |
q26575 | LBInterfaceDown | train | func (ncc *SeesawNCC) LBInterfaceDown(iface *ncctypes.LBInterface, out *int) error {
netIface, err := iface.Interface()
if err != nil {
return err
}
log.Infof("Bringing down LB interface %s", netIface.Name)
return ifaceDown(netIface)
} | go | {
"resource": ""
} |
q26576 | LBInterfaceUp | train | func (ncc *SeesawNCC) LBInterfaceUp(iface *ncctypes.LBInterface, out *int) error {
// TODO(jsing): Handle IPv6-only, and improve IPv6 route setup.
netIface, err := iface.Interface()
if err != nil {
return err
}
nodeIface, err := net.InterfaceByName(iface.NodeInterface)
if err != nil {
return fmt.Errorf("Faile... | go | {
"resource": ""
} |
q26577 | LBInterfaceAddVserver | train | func (ncc *SeesawNCC) LBInterfaceAddVserver(lbVserver *ncctypes.LBInterfaceVserver, out *int) error {
return iptablesAddRules(lbVserver.Vserver, lbVserver.Iface.ClusterVIP, lbVserver.AF)
} | go | {
"resource": ""
} |
q26578 | LBInterfaceDeleteVserver | train | func (ncc *SeesawNCC) LBInterfaceDeleteVserver(lbVserver *ncctypes.LBInterfaceVserver, out *int) error {
return iptablesDeleteRules(lbVserver.Vserver, lbVserver.Iface.ClusterVIP, lbVserver.AF)
} | go | {
"resource": ""
} |
q26579 | LBInterfaceAddVIP | train | func (ncc *SeesawNCC) LBInterfaceAddVIP(vip *ncctypes.LBInterfaceVIP, out *int) error {
switch vip.Type {
case seesaw.UnicastVIP:
netIface, err := vip.Iface.Interface()
if err != nil {
return err
}
iface, network, err := selectInterfaceNetwork(netIface, vip.IP.IP())
if err != nil {
return fmt.Errorf("... | go | {
"resource": ""
} |
q26580 | LBInterfaceDeleteVIP | train | func (ncc *SeesawNCC) LBInterfaceDeleteVIP(vip *ncctypes.LBInterfaceVIP, out *int) error {
switch vip.Type {
case seesaw.UnicastVIP:
netIface, err := vip.Iface.Interface()
if err != nil {
return err
}
iface, network, err := findInterfaceNetwork(netIface, vip.IP.IP())
if err != nil {
return fmt.Errorf(... | go | {
"resource": ""
} |
q26581 | LBInterfaceAddVLAN | train | func (ncc *SeesawNCC) LBInterfaceAddVLAN(vlan *ncctypes.LBInterfaceVLAN, out *int) error {
netIface, err := vlan.Iface.Interface()
if err != nil {
return err
}
return ifaceAddVLAN(netIface, vlan.VLAN)
} | go | {
"resource": ""
} |
q26582 | LBInterfaceDeleteVLAN | train | func (ncc *SeesawNCC) LBInterfaceDeleteVLAN(vlan *ncctypes.LBInterfaceVLAN, out *int) error {
netIface, err := vlan.Iface.Interface()
if err != nil {
return err
}
return ifaceDelVLAN(netIface, vlan.VLAN)
} | go | {
"resource": ""
} |
q26583 | vlanInterfaces | train | func vlanInterfaces(pIface *net.Interface) ([]*net.Interface, error) {
allIfaces, err := net.Interfaces()
if err != nil {
return nil, err
}
ifaces := make([]*net.Interface, 0, len(allIfaces))
prefix := fmt.Sprintf("%s.", pIface.Name)
for i, iface := range allIfaces {
if strings.HasPrefix(iface.Name, prefix) {... | go | {
"resource": ""
} |
q26584 | findInterfaceNetwork | train | func findInterfaceNetwork(pIface *net.Interface, ip net.IP) (*net.Interface, *net.IPNet, error) {
ifaces, err := vlanInterfaces(pIface)
ifaces = append(ifaces, pIface)
if err != nil {
return nil, nil, err
}
for _, iface := range ifaces {
if network, _ := findNetwork(iface, ip); network != nil {
return iface... | go | {
"resource": ""
} |
q26585 | findNetwork | train | func findNetwork(iface *net.Interface, ip net.IP) (*net.IPNet, error) {
addrs, err := iface.Addrs()
if err != nil {
return nil, fmt.Errorf("Failed to get addresses for interface %q: %v", iface.Name, err)
}
for _, addr := range addrs {
ipStr := addr.String()
ipAddr, ipNet, err := net.ParseCIDR(ipStr)
if err ... | go | {
"resource": ""
} |
q26586 | newService | train | func newService(name, binary string) *Service {
return &Service{
name: name,
binary: binary,
args: make([]string, 0),
dependencies: make(map[string]*Service),
dependents: make(map[string]*Service),
done: make(chan bool),
shutdown: make(chan bool, 1),
started: make(chan boo... | go | {
"resource": ""
} |
q26587 | AddArgs | train | func (svc *Service) AddArgs(args string) {
svc.args = strings.Fields(args)
} | go | {
"resource": ""
} |
q26588 | SetPriority | train | func (svc *Service) SetPriority(priority int) error {
if priority < -20 || priority > 19 {
return fmt.Errorf("Invalid priority %d - must be between -20 and 19", priority)
}
svc.priority = priority
return nil
} | go | {
"resource": ""
} |
q26589 | SetUser | train | func (svc *Service) SetUser(username string) error {
u, err := user.Lookup(username)
if err != nil {
return err
}
uid, err := strconv.Atoi(u.Uid)
if err != nil {
return err
}
gid, err := strconv.Atoi(u.Gid)
if err != nil {
return err
}
svc.uid = uint32(uid)
svc.gid = uint32(gid)
return nil
} | go | {
"resource": ""
} |
q26590 | run | train | func (svc *Service) run() {
// Wait for dependencies to start.
for _, dep := range svc.dependencies {
log.Infof("Service %s waiting for %s to start", svc.name, dep.name)
select {
case started := <-dep.started:
dep.started <- started
case <-svc.shutdown:
goto done
}
}
for {
if svc.failures > 0 {
... | go | {
"resource": ""
} |
q26591 | logFile | train | func (svc *Service) logFile() (*os.File, error) {
name := "seesaw_" + svc.name
t := time.Now()
logName := fmt.Sprintf("%s.log.%04d%02d%02d-%02d%02d%02d", name,
t.Year(), t.Month(), t.Day(), t.Hour(), t.Minute(), t.Second())
f, err := os.Create(path.Join(logDir, logName))
if err != nil {
return nil, err
}
l... | go | {
"resource": ""
} |
q26592 | logSink | train | func (svc *Service) logSink(f *os.File, r io.ReadCloser) {
_, err := io.Copy(f, r)
if err != nil {
log.Warningf("Service %s - log sink failed: %v", svc.name, err)
}
f.Close()
r.Close()
} | go | {
"resource": ""
} |
q26593 | signal | train | func (svc *Service) signal(sig os.Signal) error {
svc.lock.Lock()
defer svc.lock.Unlock()
if svc.process == nil {
return nil
}
return svc.process.Signal(sig)
} | go | {
"resource": ""
} |
q26594 | stop | train | func (svc *Service) stop() {
// TODO(jsing): Check if it is actually running?
log.Infof("Stopping service %s...", svc.name)
// Wait for dependents to shutdown.
for _, dep := range svc.dependents {
log.Infof("Service %s waiting for %s to stop", svc.name, dep.name)
stopped := <-dep.stopped
dep.stopped <- stopp... | go | {
"resource": ""
} |
q26595 | bytes | train | func (m *arpMessage) bytes() ([]byte, error) {
buf := new(bytes.Buffer)
if err := binary.Write(buf, binary.BigEndian, m.arpHeader); err != nil {
return nil, fmt.Errorf("binary write failed: %v", err)
}
buf.Write(m.senderHardwareAddress)
buf.Write(m.senderProtocolAddress)
buf.Write(m.targetHardwareAddress)
buf... | go | {
"resource": ""
} |
q26596 | gratuitousARPReply | train | func gratuitousARPReply(ip net.IP, mac net.HardwareAddr) (*arpMessage, error) {
if ip.To4() == nil {
return nil, fmt.Errorf("%q is not an IPv4 address", ip)
}
if len(mac) != hwLen {
return nil, fmt.Errorf("%q is not an Ethernet MAC address", mac)
}
m := &arpMessage{
arpHeader{
1, // Ethernet
... | go | {
"resource": ""
} |
q26597 | sendARP | train | func sendARP(iface *net.Interface, m *arpMessage) error {
fd, err := syscall.Socket(syscall.AF_PACKET, syscall.SOCK_DGRAM, int(htons(syscall.ETH_P_ARP)))
if err != nil {
return fmt.Errorf("failed to get raw socket: %v", err)
}
defer syscall.Close(fd)
if err := syscall.BindToDevice(fd, iface.Name); err != nil {
... | go | {
"resource": ""
} |
q26598 | ARPSendGratuitous | train | func (ncc *SeesawNCC) ARPSendGratuitous(arp *ncctypes.ARPGratuitous, out *int) error {
iface, err := net.InterfaceByName(arp.IfaceName)
if err != nil {
return fmt.Errorf("failed to get interface %q: %v", arp.IfaceName, err)
}
log.V(2).Infof("Sending gratuitous ARP for %s (%s) via %s", arp.IP, iface.HardwareAddr, ... | go | {
"resource": ""
} |
q26599 | String | train | func (rc radiusCode) String() string {
if name, ok := rcNames[rc]; ok {
return name
}
return fmt.Sprintf("(unknown %d)", rc)
} | go | {
"resource": ""
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.