id stringlengths 2 7 | text stringlengths 17 51.2k | title stringclasses 1
value |
|---|---|---|
c25400 | return g.maxX, g.maxY
} | |
c25401 | point")
}
termbox.SetCell(x, y, ch, termbox.Attribute(fgColor), termbox.Attribute(bgColor))
return nil
} | |
c25402 | errors.New("invalid point")
}
c := termbox.CellBuffer()[y*g.maxX+x]
return c.Ch, nil
} | |
c25403 | g.views[i+1:]...)
g.views = append(s, v)
return v, nil
}
}
return nil, ErrUnknownView
} | |
c25404 | {
return v, nil
}
}
return nil, ErrUnknownView
} | |
c25405 | x > v.x0 && x < v.x1 && y > v.y0 && y < v.y1 {
return v, nil
}
}
return nil, ErrUnknownView
} | |
c25406 | range g.views {
if v.name == name {
return v.x0, v.y0, v.x1, v.y1, nil
}
}
return 0, 0, 0, 0, ErrUnknownView
} | |
c25407 | append(g.views[:i], g.views[i+1:]...)
return nil
}
}
return ErrUnknownView
} | |
c25408 | && kb.mod == mod {
g.keybindings = append(g.keybindings[:i], g.keybindings[i+1:]...)
return nil
}
}
return errors.New("keybinding not found")
} | |
c25409 | kb.viewName != viewname {
s = append(s, kb)
}
}
g.keybindings = s
} | |
c25410 |
return t, 0, nil
case rune:
return 0, t, nil
default:
return 0, 0, errors.New("unknown type")
}
} | |
c25411 | { g.userEvents <- userEvent{f: f} }()
} | |
c25412 | nil
g.views = nil
g.keybindings = nil
go func() { g.tbEvents <- termbox.Event{Type: termbox.EventResize} }()
} | |
c25413 | error) {
g.SetManager(ManagerFunc(manager))
} | |
c25414 | err != nil {
return err
}
case ev := <-g.userEvents:
if err := ev.f(g); err != nil {
return err
}
}
if err := g.consumeevents(); err != nil {
return err
}
if err := g.flush(); err != nil {
return err
}
}
} | |
c25415 | := <-g.userEvents:
if err := ev.f(g); err != nil {
return err
}
default:
return nil
}
}
} | |
c25416 | err := g.drawFrameEdges(v, fgColor, bgColor); err != nil {
return err
}
if err := g.drawFrameCorners(v, fgColor, bgColor); err != nil {
return err
}
if v.Title != "" {
if err := g.drawTitle(v, fgColor, bgColor); err != nil {
return err
}
}
}
if err := g.draw(v); err != nil {
... | |
c25417 | continue
}
if v.x0 > -1 && v.x0 < g.maxX {
if err := g.SetRune(v.x0, y, runeV, fgColor, bgColor); err != nil {
return err
}
}
if v.x1 > -1 && v.x1 < g.maxX {
if err := g.SetRune(v.x1, y, runeV, fgColor, bgColor); err != nil {
return err
}
}
}
return nil
} | |
c25418 | if c.x >= 0 && c.y >= 0 && c.x < g.maxX && c.y < g.maxY {
if err := g.SetRune(c.x, c.y, c.ch, fgColor, bgColor); err != nil {
return err
}
}
}
return nil
} | |
c25419 | break
}
if err := g.SetRune(x, v.y0, ch, fgColor, bgColor); err != nil {
return err
}
}
return nil
} | |
c25420 | cx, cy := curview.x0+curview.cx+1, curview.y0+curview.cy+1
if cx >= 0 && cx < gMaxX && cy >= 0 && cy < gMaxY {
termbox.SetCursor(cx, cy)
} else {
termbox.HideCursor()
}
}
} else {
termbox.HideCursor()
}
v.clearRunes()
if err := v.draw(); err != nil {
return err
}
return nil
} | |
c25421 | mx, my := ev.MouseX, ev.MouseY
v, err := g.ViewByPosition(mx, my)
if err != nil {
break
}
if err := v.SetCursor(mx-v.x0-1, my-v.y0-1); err != nil {
return err
}
if _, err := g.execKeybindings(v, ev); err != nil {
return err
}
}
return nil
} | |
c25422 | {
if err := kb.handler(g, v); err != nil {
return false, err
}
matched = true
}
}
return matched, nil
} | |
c25423 | c <= 'z':
sb.WriteRune(c)
case c >= 'A' && c <= 'Z':
sb.WriteRune(c)
default:
sb.WriteRune('_')
}
}
return sb.String()
} | |
c25424 | extractVal(msg)
return val.IsValid() &&
val.FieldByName(fld).IsValid()
} | |
c25425 | err = msg.Extension(validate.E_Disabled, &disabled)
return
} | |
c25426 | err = oo.Extension(validate.E_Required, &required)
return
} | |
c25427 | true
}
if f.Type().Element().ProtoType() == pgs.StringT &&
strRulesNeeds(rules.GetMap().GetValues().GetString_(), wk) {
return true
}
case f.Type().ProtoType() == pgs.StringT:
if strRulesNeeds(rules.GetString_(), wk) {
return true
}
}
}
return false
} | |
c25428 | addrSubscribeAt(netns.None(), netns.None(), ch, done, nil, false)
} | |
c25429 | nil {
none := netns.None()
options.Namespace = &none
}
return addrSubscribeAt(*options.Namespace, netns.None(), ch, done, options.ErrorCallback, options.ListExisting)
} | |
c25430 | ip.To4() != nil {
return FAMILY_V4
}
return FAMILY_V6
} | |
c25431 | unix.IfInfomsg{
Family: uint8(family),
},
}
} | |
c25432 |
children: []NetlinkRequestData{},
Data: data,
}
} | |
c25433 | {
attr := NewRtAttr(attrType, data)
a.children = append(a.children, attr)
return attr
} | |
c25434 | {
a.children = append(a.children, attr)
} | |
c25435 | copy(b[0:next], hdr)
for _, data := range dataBytes {
for _, dataByte := range data {
b[next] = dataByte
next = next + 1
}
}
// Add the raw data if any
if len(req.RawData) > 0 {
copy(b[next:length], req.RawData)
}
return b
} | |
c25436 | = append(req.RawData, data...)
} | |
c25437 | fmt.Errorf("Wrong Seq nr %d, expected %d", m.Header.Seq, req.Seq)
}
if m.Header.Pid != pid {
return nil, fmt.Errorf("Wrong pid %d, expected %d", m.Header.Pid, pid)
}
if m.Header.Type == unix.NLMSG_DONE {
break done
}
if m.Header.Type == unix.NLMSG_ERROR {
native := NativeEndian()
erro... | |
c25438 | Len: uint32(unix.SizeofNlMsghdr),
Type: uint16(proto),
Flags: unix.NLM_F_REQUEST | uint16(flags),
Seq: atomic.AddUint32(&nextSeqNr, 1),
},
}
} | |
c25439 |
c, err := executeInNetns(newNs, curNs)
if err != nil {
return nil, err
}
defer c()
return getNetlinkSocket(protocol)
} | |
c25440 | a closed fd
return unix.SetsockoptTimeval(int(s.fd), unix.SOL_SOCKET, unix.SO_SNDTIMEO, timeout)
} | |
c25441 | a closed fd
return unix.SetsockoptTimeval(int(s.fd), unix.SOL_SOCKET, unix.SO_RCVTIMEO, timeout)
} | |
c25442 | msg.Index {
// Ignore messages from other interfaces
continue
}
neigh, err := NeighDeserialize(m)
if err != nil {
continue
}
res = append(res, *neigh)
}
return res, nil
} | |
c25443 | neighSubscribeAt(netns.None(), netns.None(), ch, done, nil, false)
} | |
c25444 | nil {
none := netns.None()
options.Namespace = &none
}
return neighSubscribeAt(*options.Namespace, netns.None(), ch, done, options.ErrorCallback, options.ListExisting)
} | |
c25445 | ok {
return errors.New("Filter attribute already present")
}
f.ipFilter[tp] = ip
return nil
} | |
c25446 | match = match && elem.Equal(flow.Reverse.SrcIP)
}
// -dst-nat ip Destination NAT ip
if elem, found := f.ipFilter[ConntrackReplyDstIP]; match && found {
match = match && elem.Equal(flow.Reverse.DstIP)
}
// Match source or destination reply IP
if elem, found := f.ipFilter[ConntrackReplyAnyIP]; match && foun... | |
c25447 | }
if prot.RootBlock {
boolStrings = append(boolStrings, "RootBlock")
}
if prot.Learning {
boolStrings = append(boolStrings, "Learning")
}
if prot.Flood {
boolStrings = append(boolStrings, "Flood")
}
if prot.ProxyArp {
boolStrings = append(boolStrings, "ProxyArp")
}
if prot.ProxyArpWiFi {
boolStrings... | |
c25448 | return c.m1, c.d, c.m2
} | |
c25449 | hfsc.Rsc = ServiceCurve{m1: m1 / 8, d: d, m2: m2 / 8}
} | |
c25450 | / 8}
hfsc.Fsc = ServiceCurve{m1: m1 / 8, d: d, m2: m2 / 8}
} | |
c25451 | hfsc.Usc = ServiceCurve{m1: m1 / 8, d: d, m2: m2 / 8}
} | |
c25452 | hfsc.Fsc = ServiceCurve{m1: m1 / 8, d: d, m2: m2 / 8}
} | |
c25453 |
Rsc: ServiceCurve{},
Fsc: ServiceCurve{},
Usc: ServiceCurve{},
}
} | |
c25454 | StringToBondModeMap[s]
if !ok {
return BOND_MODE_UNKNOWN
}
return mode
} | |
c25455 | := StringToBondXmitHashPolicyMap[s]
if !ok {
return BOND_XMIT_HASH_POLICY_UNKNOWN
}
return lacp
} | |
c25456 | := StringToBondLacpRateMap[s]
if !ok {
return BOND_LACP_RATE_UNKNOWN
}
return lacp
} | |
c25457 | err != nil {
return nil, err
}
devices, err := parseDevLinkDeviceList(msgs)
if err != nil {
return nil, err
}
for _, d := range devices {
h.getEswitchAttrs(f, d)
}
return devices, nil
} | |
c25458 | h.newNetlinkRequest(proto, unix.NLM_F_ACK|unix.NLM_F_DUMP)
return execRdmaGetLink(req, name)
} | |
c25459 | ip, Mask: net.CIDRMask(32, 32)}
}
return &net.IPNet{IP: ip, Mask: net.CIDRMask(128, 128)}
} | |
c25460 | data := nl.NewRtAttr(unix.IFLA_VFINFO_LIST, nil)
info := data.AddRtAttr(nl.IFLA_VF_INFO, nil)
vfmsg := nl.VfGUID{
Vf: uint32(vf),
GUID: guid,
}
info.AddRtAttr(guidType, vfmsg.Serialize())
req.AddData(data)
_, err = req.Execute(unix.NETLINK_ROUTE, 0)
return err
} | |
c25461 | if err == unix.EINVAL {
// older kernels don't support looking up via IFLA_IFNAME
// so fall back to dumping all links
h.lookupByDump = true
return h.linkByNameDump(name)
}
return link, err
} | |
c25462 | if err == unix.EINVAL {
// older kernels don't support looking up via IFLA_IFALIAS
// so fall back to dumping all links
h.lookupByDump = true
return h.linkByAliasDump(alias)
}
return link, err
} | |
c25463 | nl.NewRtAttr(unix.IFLA_EXT_MASK, nl.Uint32Attr(nl.RTEXT_FILTER_VF))
req.AddData(attr)
return execGetLink(req)
} | |
c25464 | linkSubscribeAt(netns.None(), netns.None(), ch, done, nil, false)
} | |
c25465 | nil {
none := netns.None()
options.Namespace = &none
}
return linkSubscribeAt(*options.Namespace, netns.None(), ch, done, options.ErrorCallback, options.ListExisting)
} | |
c25466 | unix.SIOCBONDENSLAVE, uintptr(unsafe.Pointer(ifreq)))
if errno != 0 {
return fmt.Errorf("Failed to enslave %q to %q, errno=%v", link.Attrs().Name, master.Attrs().Name, errno)
}
return nil
} | |
c25467 | %q failed, errno=%v", link.Attrs().Name, errno)
}
stats := ðtoolStats{
cmd: ETHTOOL_GSTATS,
nStats: gstrings.length,
}
ifreq.Data = uintptr(unsafe.Pointer(stats))
_, _, errno = syscall.Syscall(syscall.SYS_IOCTL, uintptr(fd), SIOCETHTOOL, uintptr(unsafe.Pointer(ifreq)))
if errno != 0 {
return -1, fmt... | |
c25468 | h.getNetNsId(NETNSA_FD, uint32(fd))
} | |
c25469 | h.setNetNsId(NETNSA_FD, uint32(fd), uint32(nsid))
} | |
c25470 | err := nl.ParseRouteAttr(m[msg.Len():])
if err != nil {
return 0, err
}
for _, attr := range attrs {
switch attr.Attr.Type {
case NETNSA_NSID:
return int(int32(native.Uint32(attr.Value))), nil
}
}
}
return 0, fmt.Errorf("unexpected empty result")
} | |
c25471 |
b1 := make([]byte, 4, 4)
native.PutUint32(b1, newnsid)
attr1 := nl.NewRtAttr(NETNSA_NSID, b1)
req.AddData(attr1)
_, err := req.Execute(unix.NETLINK_ROUTE, unix.RTM_NEWNSID)
return err
} | |
c25472 | ipn1.Mask.Size()
m2, _ := ipn2.Mask.Size()
return m1 == m2 && ipn1.IP.Equal(ipn2.IP)
} | |
c25473 | copy(ifreq.Slave[:unix.IFNAMSIZ-1], slave)
return ifreq
} | |
c25474 |
ifreq := &Ifreq{Data: uintptr(unsafe.Pointer(e))}
copy(ifreq.Name[:unix.IFNAMSIZ-1], linkName)
return ifreq, e
} | |
c25475 | _ := x.Mask.Size()
// ignore label for comparison
return a.IP.Equal(x.IP) && sizea == sizeb
} | |
c25476 | nl.TCPDIAG_NOCOOKIE},
},
})
s.Send(req)
msgs, err := s.Receive()
if err != nil {
return nil, err
}
if len(msgs) == 0 {
return nil, errors.New("no message nor error from netlink")
}
if len(msgs) > 2 {
return nil, fmt.Errorf("multiple (%d) matching sockets", len(msgs))
}
sock := &Socket{}
if err := so... | |
c25477 | routeSubscribeAt(netns.None(), netns.None(), ch, done, nil, false)
} | |
c25478 | nil {
none := netns.None()
options.Namespace = &none
}
return routeSubscribeAt(*options.Namespace, netns.None(), ch, done, options.ErrorCallback, options.ListExisting)
} | |
c25479 |
}
fd, _, errno := unix.Syscall(unix.SYS_BPF,
5, /* bpf cmd */
uintptr(unsafe.Pointer(&attr)),
unsafe.Sizeof(attr))
if errno != 0 {
return 0, errno
}
return int(fd), nil
} | |
c25480 | -1,
Goto: -1,
Flow: -1,
}
} | |
c25481 | if gap == 0 {
gap = 1
}
}
corruptProb = Percentage2u32(nattrs.CorruptProb)
corruptCorr = Percentage2u32(nattrs.CorruptCorr)
return &Netem{
QdiscAttrs: attrs,
Latency: latency,
DelayCorr: delayCorr,
Limit: limit,
Loss: loss,
LossCorr: lossCorr,
Gap: ... | |
c25482 | int) bool {
_, ok := h.sockets[nlFamily]
return ok
} | |
c25483 | {
return newHandle(netns.None(), netns.None(), nlFamilies...)
} | |
c25484 | := sh.Socket.SetSendTimeout(&tv); err != nil {
return err
}
if err := sh.Socket.SetReceiveTimeout(&tv); err != nil {
return err
}
}
return nil
} | |
c25485 | err := unix.GetsockoptInt(fd, unix.SOL_SOCKET, unix.SO_RCVBUF)
if err != nil {
return nil, err
}
results[i] = size
i++
}
return results, nil
} | |
c25486 | return newHandle(newNs, curNs)
} | |
c25487 |
sh.Close()
}
h.sockets = nil
} | |
c25488 | snapshot.Metadata.Name + "-" + string(snapshot.Metadata.UID)
} | |
c25489 | err != nil {
return nil, err
}
case "volumetype":
volumeType = strings.TrimSpace(v)
case "namespace":
namespace = strings.TrimSpace(v)
case "selector":
selector = strings.TrimSpace(v)
case "forcecreate":
v = strings.TrimSpace(v)
forceCreate = strings.ToLower(v) == "true"
}
}
config.B... | |
c25490 | fmt.Sprintf("export(path = %s)", path))
if call.Err != nil {
return fmt.Errorf("error calling org.ganesha.nfsd.exportmgr.AddExport: %v", call.Err)
}
return nil
} | |
c25491 | syncDuration,
disableReconciliationSync: disableReconciliationSync,
desiredStateOfWorld: desiredStateOfWorld,
actualStateOfWorld: actualStateOfWorld,
snapshotter: snapshotter,
timeOfLastSync: time.Now(),
}
} | |
c25492 | if !ok {
return
}
if awsError.Code() == "RequestLimitExceeded" {
c.backoff.ReportError()
glog.Warningf("Got RequestLimitExceeded error on AWS request (%s)",
describeRequest(r))
}
} | |
c25493 | cloud.(*openstack.OpenStack)
} | |
c25494 | := pv.Spec.Cinder.VolumeID
err := c.cloud.DeleteVolume(volumeID)
if err != nil {
return err
}
return nil
} | |
c25495 | tags: %#v", volumeID, snapshotName, *tags)
snapID, status, err := c.cloud.CreateSnapshot(volumeID, snapshotName, snapshotDescription, *tags)
if err != nil {
return nil, nil, err
}
return &crdv1.VolumeSnapshotDataSource{
CinderSnapshot: &crdv1.CinderVolumeSnapshotSource{
SnapshotID: snapID,
},
}, c.conve... | |
c25496 | nil {
return fmt.Errorf("invalid VolumeSnapshotDataSource: %v", src)
}
snapshotID := src.CinderSnapshot.SnapshotID
err := c.cloud.DeleteSnapshot(snapshotID)
if err != nil {
return err
}
return nil
} | |
c25497 | int64 in gophercloud?
volumeID, _, err := c.cloud.CreateVolume(volName, int(szGB), vType, zone, snapID, &tags)
if err != nil {
glog.Errorf("error create volume from snapshot: %v", err)
return nil, nil, err
}
glog.V(2).Infof("Successfully created Cinder Volume from Snapshot, Volume: %s", volumeID)
pv := &v1.Pe... | |
c25498 | snapshotData)
}
snapshotID := snapshotData.Spec.CinderSnapshot.SnapshotID
status, isComplete, err := c.cloud.DescribeSnapshot(snapshotID)
glog.Infof("DescribeSnapshot: Snapshot %s, Status %s, isComplete: %v", snapshotID, status, isComplete)
if err != nil {
return c.convertSnapshotStatus(status), false, err
}
... | |
c25499 | "Snapshot is being created",
LastTransitionTime: metav1.Now(),
},
}
} else {
snapConditions = []crdv1.VolumeSnapshotCondition{
{
Type: crdv1.VolumeSnapshotConditionError,
Status: v1.ConditionTrue,
Message: "Snapshot creation failed",
LastTransit... |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.