id stringlengths 2 7 | text stringlengths 17 51.2k | title stringclasses 1
value |
|---|---|---|
c7700 | err
}
dmn.Command = finalcmd
var indir string
if block.InDir != "" {
indir = block.InDir
} else {
indir, err = os.Getwd()
if err != nil {
return nil, err
}
}
sh, err := shell.GetShellName(vars[shellVarName])
if err != nil {
return nil, err
}
d[i] = &daemon{
conf: dmn,
log... | |
c7701 | _, d := range dp.daemons {
d.Restart()
}
}
} | |
c7702 | for _, d := range dp.daemons {
d.Shutdown(sig)
}
}
} | |
c7703 | if err != nil {
return nil, err
}
daemonPens[i] = d
}
return &DaemonWorld{daemonPens}, nil
} | |
c7704 | {
for _, dp := range dw.DaemonPens {
dp.Shutdown(s)
}
} | |
c7705 | i := range parts {
i = strings.TrimLeft(i, " \t#")
i = strings.TrimRight(i, " \t\\")
if i != "" {
ret = i
break
}
}
return ret
} | |
c7706 |
command = termlog.DefaultPalette.Header.SprintFunc()(shortCommand(command))
return pre + command
} | |
c7707 | = s[1 : len(s)-1]
s = strings.Replace(s, `\`+quote, quote, -1)
return s
} | |
c7708 | err != nil {
return nil, err
}
return p.config, nil
} | |
c7709 | len(c.variables) != 0) || (other.variables != nil || len(other.variables) != 0) {
if !reflect.DeepEqual(c.variables, other.variables) {
return false
}
}
return true
} | |
c7710 | len(pmap))
i := 0
for k := range pmap {
paths[i] = k
i++
}
sort.Strings(paths)
return paths
} | |
c7711 | := map[string]string{}
for k, v := range c.variables {
n[k] = v
}
return n
} | |
c7712 | b.Exclude = append(b.Exclude, excludes...)
}
c.Blocks[i] = b
}
} | |
c7713 | // When testing, we're running under a special compiled test executable,
// so we look for an instance of modd on our path.
if shellTesting {
return exec.LookPath("modd")
}
return os.Executable()
default:
return exec.LookPath(shell)
}
} | |
c7714 | return err
}
// create service state
srvState := etcdServiceState{
ServiceName: serviceInfo.ServiceName,
KeyName: keyName,
TTL: ttl,
HostAddr: serviceInfo.HostAddr,
Port: serviceInfo.Port,
stopChan: make(chan bool, 1),
Hostname: serviceInfo.Hostname,
}
// Run refresh in... | |
c7715 | srvcList, err := ep.getServiceState(keyName)
return srvcList, err
} | |
c7716 | srvcList {
log.Debugf("Sending service add event: %+v", srvInfo)
// Send Add event
eventCh <- WatchServiceEvent{
EventType: WatchServiceEventAdd,
ServiceInfo: srvInfo,
}
}
return mIndex, nil
} | |
c7717 | delete(ep.serviceDb, keyName)
// Delete the service instance
_, err := ep.kapi.Delete(context.Background(), keyName, nil)
if err != nil {
log.Errorf("Error deleting key %s. Err: %v", keyName, err)
return err
}
return nil
} | |
c7718 | keyVal, &client.SetOptions{TTL: srvState.TTL})
if err != nil {
log.Errorf("Error setting key %s, Err: %v", srvState.KeyName, err)
}
case <-srvState.stopChan:
log.Infof("Stop refreshing key: %s", srvState.KeyName)
return
}
}
} | |
c7719 |
s.IPAddress == c.IPAddress &&
s.IPv6Address == c.IPv6Address &&
s.MacAddress == c.MacAddress &&
s.HomingHost == c.HomingHost &&
s.IntfName == c.IntfName &&
s.VtepIP == c.VtepIP
} | |
c7720 | {
return s.StateDriver.ReadAllState(endpointOperPathPrefix, s, json.Unmarshal)
} | |
c7721 |
// Initialize service DB
ec.serviceDb = make(map[string]*etcdServiceState)
// Make sure we can read from etcd
_, err = ec.kapi.Get(context.Background(), "/", &client.GetOptions{Recursive: true, Sort: true})
if err != nil {
log.Errorf("Failed to connect to etcd. Err: %v", err)
return nil, err
}
return ec, ... | |
c7722 | log.Errorf("Error getting key %s. Err: %v", keyName, err)
return err
}
}
// Parse JSON response
if err := json.Unmarshal([]byte(resp.Node.Value), retVal); err != nil {
log.Errorf("Error parsing object %s, Err %v", resp.Node.Value, err)
return err
}
return nil
} | |
c7723 | only the files.
if !innerNode.Dir {
list = append(list, innerNode.Value)
} else {
list = recursAddNode(innerNode, list)
}
}
return list
} | |
c7724 | a directory")
return nil, errors.New("Response is not directory")
}
var retList []string
// Call a recursive function to recurse thru each directory and get all files
// Warning: assumes directory itep is not interesting to the caller
// Warning2: there is also an assumption that keynames are not required
// ... | |
c7725 | {
_, err = ep.kapi.Set(context.Background(), keyName, string(jsonVal[:]), nil)
if err == nil {
break
}
// Retry after a delay
time.Sleep(time.Second)
}
}
if err != nil {
log.Errorf("Error setting key %s, Err: %v", keyName, err)
return err
}
}
return nil
} | |
c7726 | break
}
// Retry after a delay
time.Sleep(time.Second)
}
}
if err != nil {
log.Errorf("Error removing key %s, Err: %v", keyName, err)
return err
}
}
return nil
} | |
c7727 | {
route := fmt.Sprintf("%s/%d", net.SubnetIP, net.SubnetLen)
err = netutils.AddIPRoute(route, gwIP)
if err != nil {
log.Errorf("Adding route %s --> %s: err: %v",
route, gwIP, err)
}
}
}
// route add cluster-ip
clusterNet := k8splugin.GetK8sClusterIPRange()
log.Infof("configuring cluster-ip ... | |
c7728 | %s", err)
return err
}
// Assign IP to interface
ipCIDR := fmt.Sprintf("%s/%d", mresp.EndpointConfig.IPAddress, nwCfg.SubnetLen)
err = netutils.SetInterfaceIP(nwCfg.NetworkName, ipCIDR)
if err != nil {
log.Errorf("Could not assign ip: %s", err)
return err
}
// add host access routes for vxlan networks
... | |
c7729 |
mreq := master.DeleteEndpointRequest{
TenantName: nwCfg.Tenant,
NetworkName: nwCfg.NetworkName,
EndpointID: pluginHost,
}
var mresp master.DeleteEndpointResponse
err = cluster.MasterPostReq("/plugin/deleteEndpoint", &mreq, &mresp)
if err != nil {
log.Errorf("master failed to delete endpoint %s", err)
... | |
c7730 | "local"
if checkRemoteHost(epCfg.VtepIP, epCfg.HomingHost, opts.HostLabel) {
eptype = "remote"
}
// Create the endpoint
if eptype == "local" {
err = netPlugin.CreateEndpoint(epID)
} else {
err = netPlugin.CreateRemoteEndpoint(epID)
}
if err != nil {
log.Errorf("Endpoint operation create failed. Error: ... | |
c7731 | delete operation succeeded", epCfg.ID)
} else {
// Create remote endpoint
err := netPlugin.CreateRemoteEndpoint(epCfg.ID)
if err != nil {
log.Errorf("Endpoint %s create operation failed. Error: %s", epCfg.ID, err)
return err
}
log.Infof("Endpoint %s create operation succeeded", epCfg.ID)
}
return n... | |
c7732 | }
svcPort := portInfo[0]
provPort := portInfo[1]
portSpec.Protocol = portInfo[2]
sPort, _ := strconv.ParseUint(svcPort, 10, 16)
portSpec.SvcPort = uint16(sPort)
pPort, _ := strconv.ParseUint(provPort, 10, 16)
portSpec.ProvPort = uint16(pPort)
portSpecList = append(portSpecList, portSpec)
}
spec :... | |
c7733 |
}
netPlugin.SvcProviderUpdate(svcProvider.ServiceName, svcProvider.Providers)
return nil
} | |
c7734 | return err
}
log.Infof("PolicyRule %s delete operation succeeded", ruleID)
} else {
// Create endpoint
err = netPlugin.AddPolicyRule(ruleID)
if err != nil {
log.Errorf("PolicyRule %s create operation failed. Error: %s", ruleID, err)
return err
}
log.Infof("PolicyRule %s create operation succeede... | |
c7735 | {
return r.StateDriver.ReadAllState(vXLANResourceConfigPathPrefix, r,
json.Unmarshal)
} | |
c7736 | }
}()
oper := &AutoVXLANOperResource{FreeVXLANs: r.VXLANs, FreeLocalVLANs: r.LocalVLANs}
oper.StateDriver = r.StateDriver
oper.ID = r.ID
return oper.Write()
} | |
c7737 |
oper.ID = r.ID
err = oper.Read(r.ID)
if err != nil {
return err
}
prevVXLANs.InPlaceSymmetricDifference(oper.FreeVXLANs)
oper.FreeVXLANs = r.VXLANs
for i, e := prevVXLANs.NextSet(0); e; i, e = prevVXLANs.NextSet(i + 1) {
vxlan := i + prevFreeStart
oper.FreeVXLANs.Clear(vxlan - r.FreeVXLANsStart)
}
o... | |
c7738 | return nil, errors.New("no vxlans available")
}
}
vlan, ok := oper.FreeLocalVLANs.NextSet(0)
if !ok {
return nil, errors.New("no local vlans available")
}
oper.FreeVXLANs.Clear(vxlan)
oper.FreeLocalVLANs.Clear(vlan)
err = oper.Write()
if err != nil {
return nil, err
}
return VXLANVLANPair{VXLAN: vxl... | |
c7739 | {
return core.Errorf("Invalid type for vxlan-vlan pair")
}
vxlan := pair.VXLAN
oper.FreeVXLANs.Set(vxlan)
vlan := pair.VLAN
oper.FreeLocalVLANs.Set(vlan)
return oper.Write()
} | |
c7740 | {
return r.StateDriver.ReadAllState(vXLANResourceOperPathPrefix, r,
json.Unmarshal)
} | |
c7741 | = make(map[string]valueData)
return nil
} | |
c7742 | := valueData{value: value}
d.TestState[key] = val
return nil
} | |
c7743 | }
return []byte{}, core.Errorf("key not found! key: %v", key)
} | |
c7744 | if strings.Contains(key, baseKey) {
values = append(values, val.value)
}
}
return values, nil
} | |
c7745 | log.Warnf("watchall not supported")
select {} // block forever
} | |
c7746 |
delete(d.TestState, key)
}
return nil
} | |
c7747 | error) {
return readAllStateCommon(d, baseKey, sType, unmarshal)
} | |
c7748 | chan core.WatchState) error {
return core.Errorf("not supported")
} | |
c7749 |
containerID := providerInfo.ContainerID
for i, service := range mastercfg.ProviderDb[containerID].Services {
if service == serviceID {
mastercfg.ProviderDb[containerID].Services =
append(mastercfg.ProviderDb[containerID].Services[:i],
mastercfg.ProviderDb[containerID].Services[i+1:]...)
}
}
... | |
c7750 | }
//Recover from endpoint state as well .
epCfgState := mastercfg.CfgEndpointState{}
epCfgState.StateDriver = stateDriver
epCfgs, err := epCfgState.ReadAll()
if err == nil {
for _, epCfg := range epCfgs {
ep := epCfg.(*mastercfg.CfgEndpointState)
providerDBId := ep.ContainerID
if ep.Labels != nil && m... | |
c7751 | (existingStartRange.Cmp(inputEndRange) <= 0 && inputEndRange.Cmp(existingEndRange) <= 0) {
return true
}
if (inputStartRange.Cmp(existingStartRange) <= 0 && existingStartRange.Cmp(inputEndRange) <= 0) ||
(inputStartRange.Cmp(existingEndRange) <= 0 && existingEndRange.Cmp(inputEndRange) <= 0) {
return true
}... | |
c7752 | existingEndRange) ||
(existingStartRange <= inputEndRange && inputEndRange <= existingEndRange) {
return true
}
if (inputStartRange <= existingStartRange && existingStartRange <= inputEndRange) ||
(inputStartRange <= existingEndRange && existingEndRange <= inputEndRange) {
return true
}
return false
} | |
c7753 | rangeMin > rangeMax {
return core.Errorf("Network subnet format not valid")
}
if subnetLen > 32 || subnetLen < 8 {
return core.Errorf("subnet length %d not supported", subnetLen)
}
return nil
} | |
c7754 | - 1
b.Clear(uint(maxSize))
b.Clear(uint(0))
} | |
c7755 | address %s. Err: %v", addrRangeList[0], err)
return err
}
hostMax, err := GetIPNumber(nwSubnetIP, nwSubnetLen, 32, addrRangeList[1])
if err != nil {
log.Errorf("Error parsing last address %s. Err: %v", addrRangeList[1], err)
return err
}
// Clear a range
for i := hostMin; i <= hostMax; i++ {
ipAllocMap... | |
c7756 | firstAddr
}
if rangeMax > lastAddr {
rangeMax = lastAddr
}
minAddr, _ := ipv4Uint32ToString(rangeMin)
maxAddr, _ := ipv4Uint32ToString(rangeMax)
return minAddr + "-" + maxAddr
} | |
c7757 | lastAddr, _ := ipv4ToUint32(getLastAddrInSubnet(ipRange, subnetLen))
// Set bits lower than rangeMin as used
for i = 0; i < (rangeMin - firstAddr); i++ {
ipAllocMap.Clear(uint(i))
}
// Set bits greater than the rangeMax as used
for i = ((rangeMin - firstAddr) + ((rangeMax - rangeMin) + 1)); i < (lastAddr - fi... | |
c7758 | {
maxSize := 1 << numBitsWide
return bitset.New(uint(maxSize))
} | |
c7759 | id %d is beyond subnet's capacity %d",
hostID, maxHosts)
}
hostIPUint32, err := ipv4ToUint32(subnetIP)
if err != nil {
return "", core.Errorf("unable to convert subnet %s to uint32", subnetIP)
}
hostIPUint32 += uint32(hostID << (32 - allocSubnetLen))
return ipv4Uint32ToString(hostIPUint32)
} | |
c7760 | 0, core.Errorf("unable to convert subnetIP %s to uint32", subnetIP)
}
hostID := uint((hostIPUint32 - subnetIPUint32) >> (32 - allocSubnetLen))
maxHosts := uint(1 << (allocSubnetLen - subnetLen))
if hostID >= maxHosts {
return 0, core.Errorf("hostIP %s is exceeding beyond subnet %s/%d, hostID %d",
hostIP, sub... | |
c7761 | {
return
}
if *IPv6AllocMap == nil {
*IPv6AllocMap = make(map[string]bool)
}
(*IPv6AllocMap)[hostID] = true
} | |
c7762 | reached MaxHosts
offset := (subnetLen - 1) / 8
masklen := subnetLen % 8
mask := ((1 << masklen) - 1) << (8 - masklen)
if (hostidIP[offset] & byte(mask)) != 0 {
// if hostID is outside subnet range,
// check if we have reached MaxHosts
maxHosts := math.Pow(2, float64(128-subnetLen)) - 1
if f... | |
c7763 | 0 && subnetIP[offset] != 0 {
if hostidIP[offset]&subnetIP[offset] != 0 {
return "", core.Errorf("host id %s exceeds subnet %s capacity ",
hostID, subnetAddr)
}
hostIP[offset] = hostidIP[offset] | subnetIP[offset]
offset++
}
for ; offset < len(hostidIP); offset++ {
hostIP[offset] = hostidIP[offset]
... | |
c7764 | {
return "", core.Errorf("Invalid hostAddr %s ", hostAddr)
}
h := uint8(hostIP[offset])
hostID[offset] = byte(h - s)
// Copy the rest of the bytes
for i := (offset + 1); i < 16; i++ {
hostID[i] = hostIP[i]
offset++
}
return hostID.String(), nil
} | |
c7765 | return nil, core.Errorf("invalid range %s, min is greater than max",
oneRangeStr)
}
if tagRanges[idx].Min < 1 {
return nil, core.Errorf("invalid range %s, values less than 1",
oneRangeStr)
}
if tagType == "vlan" && tagRanges[idx].Max > 4095 {
return nil, core.Errorf("invalid range %s, vlan value... | |
c7766 | (!IsIPv6(subnetStr) && subnetLen > 32) {
return "", 0, core.Errorf("invalid mask in gateway/mask specification ")
}
return subnetStr, uint(subnetLen), nil
} | |
c7767 |
addrs, err = netlink.AddrList(link, netlink.FAMILY_V4)
if err != nil {
return "", err
}
if len(addrs) > 0 {
localIPAddr = addrs[0].IP.String()
}
err = core.Errorf("local ip not found")
if localIPAddr != "" {
err = nil
}
return localIPAddr, err
} | |
c7768 | || strings.HasPrefix(link.Attrs().Name, "lo") {
continue
}
addrs, err := netlink.AddrList(link, netlink.FAMILY_V4)
if err != nil {
return addrList, err
}
for _, addr := range addrs {
addrList = append(addrList, addr.IP.String())
}
}
return addrList, err
} | |
c7769 | "veth") ||
strings.HasPrefix(intf.Name, "vport") || strings.HasPrefix(intf.Name, "lo") {
continue
}
addrs, err := intf.Addrs()
if err != nil {
return addrList, err
}
for _, addr := range addrs {
addrList = append(addrList, addr.String())
}
}
return addrList, err
} | |
c7770 | {
continue
}
lowestMTU = int(math.Min(float64(lowestMTU), float64(intf.MTU)))
}
if lowestMTU == 0 {
return 0, errors.New("Failed to find minimum MTU")
}
return lowestMTU, nil
} | |
c7771 |
for _, addr := range addrList {
if addr == findAddr {
return true
}
}
return false
} | |
c7772 | 0 {
return addrList[0], nil
}
return "", errors.New("no address was found")
} | |
c7773 | Return first available address if we could not find by hostname
return GetFirstLocalAddr()
} | |
c7774 |
}
subnet, _ := ipv4ToUint32(subnetStr)
subnetMask := -1 << (32 - length)
ipSubnet, _ := ipv4Uint32ToString(uint32(subnetMask) & subnet)
return ipSubnet
} | |
c7775 |
subnetMask := -1 << (32 - length)
lastIP, _ := ipv4Uint32ToString(uint32(^subnetMask) | subnet)
return lastIP
} | |
c7776 |
if isSubnetIPRange(ipRange) {
firstIP = strings.Split(ipRange, "-")[0]
}
return firstIP
} | |
c7777 | else {
lastIP = getLastAddrInSubnet(ipRange, subnetLen)
}
return lastIP
} | |
c7778 |
addrs, err := net.LookupIP(host)
if err != nil {
return "", err
}
for _, addr := range addrs {
if ipv4 := addr.To4(); ipv4 != nil && !ipv4.IsLoopback() {
return ipv4.String(), nil
}
}
return "", errors.New("could not find ip addr")
} | |
c7779 | macStr := fmt.Sprintf("02:02:%02x:%02x:%02x:%02x", b0, b1, b2, b3)
return ipStr, macStr
} | |
c7780 | "!", "-o", intf, "-j", "MASQUERADE").CombinedOutput()
if err != nil {
log.Errorf("Setting ip tables failed: %v %s", err, out)
} else {
log.Infof("####Set ip tables success: %s", out)
}
return err
} | |
c7781 | return "", errors.New("bad host IP")
}
return ip[0] + "." + ip[1] + ".255.254", nil
} | |
c7782 | err
}
ip := net.IP
if len(ip) == 16 {
return int(binary.BigEndian.Uint32(ip[12:16])), nil
}
return int(binary.BigEndian.Uint32(ip)), nil
} | |
c7783 | allocMap.NextClear(idx)
if found && value >= maxHosts {
return 0, false
}
return value, found
} | |
c7784 | log.Infof("Route %s --> %s present", cidr, gw)
return nil
}
log.Errorf("AddIPRoute(%s, %s): exists %+v", cidr, gw, match)
return fmt.Errorf("Route exists")
}
newRoute := netlink.Route{
Dst: dst,
Gw: gwIP,
}
return netlink.RouteAdd(&newRoute)
} | |
c7785 |
gwIP := net.ParseIP(gw)
if gwIP == nil {
return fmt.Errorf("Unable to parse gw %s", gw)
}
return netlink.RouteDel(&netlink.Route{Dst: dst, Gw: gwIP})
} | |
c7786 | return gc.StateDriver.ReadAllState(cfgGlobalPrefix, gc, json.Unmarshal)
} | |
c7787 | cfgGlobalPath
return gc.StateDriver.ClearState(key)
} | |
c7788 | g.StateDriver.ReadAllState(operGlobalPrefix, g, json.Unmarshal)
} | |
c7789 | log.Errorf("error getting resource manager: %s", err)
return 0, ""
}
ra := core.ResourceManager(tempRm)
return ra.GetResourceList("global", resources.AutoVXLANResource)
} | |
c7790 | = reqVxlan - g.FreeVXLANsStart
}
pair, err1 := ra.AllocateResourceVal("global", resources.AutoVXLANResource, reqVxlan)
if err1 != nil {
return 0, 0, err1
}
vxlan = pair.(resources.VXLANVLANPair).VXLAN + g.FreeVXLANsStart
localVLAN = pair.(resources.VXLANVLANPair).VLAN
return
} | |
c7791 | {
return nil
}
return ra.DeallocateResourceVal("global", resources.AutoVXLANResource,
resources.VXLANVLANPair{
VXLAN: vxlan - g.FreeVXLANsStart,
VLAN: localVLAN})
} | |
c7792 | log.Errorf("error getting resource manager: %s", err)
return 0, ""
}
ra := core.ResourceManager(tempRm)
return ra.GetResourceList("global", resources.AutoVLANResource)
} | |
c7793 | core.ResourceManager(tempRm)
vlan, err := ra.AllocateResourceVal("global", resources.AutoVLANResource, reqVlan)
if err != nil {
log.Errorf("alloc vlan failed: %q", err)
return 0, err
}
return vlan.(uint), err
} | |
c7794 | != nil {
return err
}
ra := core.ResourceManager(tempRm)
return ra.DeallocateResourceVal("global", resources.AutoVLANResource, vlan)
} | |
c7795 | if err != nil {
log.Errorf("Error deleting vlan resource. Err: %v", err)
}
} else if res == "vxlan" {
err = ra.UndefineResource("global", resources.AutoVXLANResource)
if err != nil {
log.Errorf("Error deleting vxlan resource. Err: %v", err)
}
}
return err
} | |
c7796 | *resources.AutoVXLANCfgResource
vxlanRsrcCfg, err = gc.initVXLANBitset(gc.Auto.VXLANs)
if err != nil {
return err
}
err = ra.RedefineResource("global", resources.AutoVXLANResource, vxlanRsrcCfg)
if err != nil {
log.Errorf("Error deleting vxlan resource. Err: %v", err)
}
g := &Oper{FreeVXLANsStart: ... | |
c7797 | = strconv.Atoi(strings.Split(tags[len(tags)-1], "-")[1])
} else {
maxUsed, _ = strconv.Atoi(strings.TrimSpace(tags[len(tags)-1]))
}
}
r, err := netutils.ParseTagRanges(ranges, pktTagType)
if err != nil {
return false
}
if r[0].Min > minUsed || r[0].Max < maxUsed {
return false
}
return true
} | |
c7798 | ctxTimeout)
defer cancel()
_, err := d.KeysAPI.Delete(ctx, key, nil)
return err
} | |
c7799 |
if err != nil {
return err
}
return d.Write(key, encodedState)
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.