_id stringlengths 2 7 | title stringlengths 1 118 | partition stringclasses 3
values | text stringlengths 52 85.5k | language stringclasses 1
value | meta_information dict |
|---|---|---|---|---|---|
q7700 | NewDaemonPen | train | func NewDaemonPen(block conf.Block, vars map[string]string, log termlog.TermLog) (*DaemonPen, error) {
d := make([]*daemon, len(block.Daemons))
for i, dmn := range block.Daemons {
vcmd := varcmd.VarCmd{Block: nil, Modified: nil, Vars: vars}
finalcmd, err := vcmd.Render(dmn.Command)
if err != nil {
return nil... | go | {
"resource": ""
} |
q7701 | Restart | train | func (dp *DaemonPen) Restart() {
dp.Lock()
defer dp.Unlock()
if dp.daemons != nil {
for _, d := range dp.daemons {
d.Restart()
}
}
} | go | {
"resource": ""
} |
q7702 | Shutdown | train | func (dp *DaemonPen) Shutdown(sig os.Signal) {
dp.Lock()
defer dp.Unlock()
if dp.daemons != nil {
for _, d := range dp.daemons {
d.Shutdown(sig)
}
}
} | go | {
"resource": ""
} |
q7703 | NewDaemonWorld | train | func NewDaemonWorld(cnf *conf.Config, log termlog.TermLog) (*DaemonWorld, error) {
daemonPens := make([]*DaemonPen, len(cnf.Blocks))
for i, b := range cnf.Blocks {
d, err := NewDaemonPen(b, cnf.GetVariables(), log)
if err != nil {
return nil, err
}
daemonPens[i] = d
}
return &DaemonWorld{daemonPens}, ni... | go | {
"resource": ""
} |
q7704 | Shutdown | train | func (dw *DaemonWorld) Shutdown(s os.Signal) {
for _, dp := range dw.DaemonPens {
dp.Shutdown(s)
}
} | go | {
"resource": ""
} |
q7705 | shortCommand | train | func shortCommand(command string) string {
ret := command
parts := strings.Split(command, "\n")
for _, i := range parts {
i = strings.TrimLeft(i, " \t#")
i = strings.TrimRight(i, " \t\\")
if i != "" {
ret = i
break
}
}
return ret
} | go | {
"resource": ""
} |
q7706 | niceHeader | train | func niceHeader(preamble string, command string) string {
pre := termlog.DefaultPalette.Timestamp.SprintFunc()(preamble)
command = termlog.DefaultPalette.Header.SprintFunc()(shortCommand(command))
return pre + command
} | go | {
"resource": ""
} |
q7707 | unquote | train | func unquote(s string) string {
quote := s[0:1]
s = s[1 : len(s)-1]
s = strings.Replace(s, `\`+quote, quote, -1)
return s
} | go | {
"resource": ""
} |
q7708 | Parse | train | func Parse(name string, text string) (*Config, error) {
p := &parser{name: name, text: text}
err := p.parse()
if err != nil {
return nil, err
}
return p.config, nil
} | go | {
"resource": ""
} |
q7709 | Equals | train | func (c *Config) Equals(other *Config) bool {
if (c.Blocks != nil || len(c.Blocks) != 0) || (other.Blocks != nil || len(other.Blocks) != 0) {
if !reflect.DeepEqual(c.Blocks, other.Blocks) {
return false
}
}
if (c.variables != nil || len(c.variables) != 0) || (other.variables != nil || len(other.variables) != ... | go | {
"resource": ""
} |
q7710 | IncludePatterns | train | func (c *Config) IncludePatterns() []string {
pmap := map[string]bool{}
for _, b := range c.Blocks {
for _, p := range b.Include {
pmap[p] = true
}
}
paths := make([]string, len(pmap))
i := 0
for k := range pmap {
paths[i] = k
i++
}
sort.Strings(paths)
return paths
} | go | {
"resource": ""
} |
q7711 | GetVariables | train | func (c *Config) GetVariables() map[string]string {
n := map[string]string{}
for k, v := range c.variables {
n[k] = v
}
return n
} | go | {
"resource": ""
} |
q7712 | CommonExcludes | train | func (c *Config) CommonExcludes(excludes []string) {
for i, b := range c.Blocks {
if !b.NoCommonFilter {
b.Exclude = append(b.Exclude, excludes...)
}
c.Blocks[i] = b
}
} | go | {
"resource": ""
} |
q7713 | CheckShell | train | func CheckShell(shell string) (string, error) {
if _, ok := ValidShells[shell]; !ok {
return "", fmt.Errorf("unsupported shell: %q", shell)
}
switch shell {
case "powershell":
if _, err := exec.LookPath("powershell"); err == nil {
return "powershell", nil
} else if _, err := exec.LookPath("pwsh"); err == n... | go | {
"resource": ""
} |
q7714 | RegisterService | train | func (ep *EtcdClient) RegisterService(serviceInfo ServiceInfo) error {
keyName := "/contiv.io/service/" + serviceInfo.ServiceName + "/" +
serviceInfo.HostAddr + ":" + strconv.Itoa(serviceInfo.Port)
ttl := time.Duration(serviceInfo.TTL) * time.Second
log.Infof("Registering service key: %s, value: %+v", keyName, se... | go | {
"resource": ""
} |
q7715 | GetService | train | func (ep *EtcdClient) GetService(name string) ([]ServiceInfo, error) {
keyName := "/contiv.io/service/" + name + "/"
_, srvcList, err := ep.getServiceState(keyName)
return srvcList, err
} | go | {
"resource": ""
} |
q7716 | initServiceState | train | func (ep *EtcdClient) initServiceState(key string, eventCh chan WatchServiceEvent) (uint64, error) {
mIndex, srvcList, err := ep.getServiceState(key)
if err != nil {
return mIndex, err
}
// walk each service and inject it as an add event
for _, srvInfo := range srvcList {
log.Debugf("Sending service add event... | go | {
"resource": ""
} |
q7717 | DeregisterService | train | func (ep *EtcdClient) DeregisterService(serviceInfo ServiceInfo) error {
keyName := "/contiv.io/service/" + serviceInfo.ServiceName + "/" +
serviceInfo.HostAddr + ":" + strconv.Itoa(serviceInfo.Port)
// Find it in the database
srvState := ep.serviceDb[keyName]
if srvState == nil {
log.Errorf("Could not find th... | go | {
"resource": ""
} |
q7718 | refreshService | train | func (ep *EtcdClient) refreshService(srvState *etcdServiceState, keyVal string) {
// Set it via etcd client
_, err := ep.kapi.Set(context.Background(), srvState.KeyName, keyVal, &client.SetOptions{TTL: srvState.TTL})
if err != nil {
log.Errorf("Error setting key %s, Err: %v", srvState.KeyName, err)
}
// Loop fo... | go | {
"resource": ""
} |
q7719 | Matches | train | func (s *OperEndpointState) Matches(c *mastercfg.CfgEndpointState) bool {
return s.NetID == c.NetID &&
s.EndpointID == c.EndpointID &&
s.IPAddress == c.IPAddress &&
s.IPv6Address == c.IPv6Address &&
s.MacAddress == c.MacAddress &&
s.HomingHost == c.HomingHost &&
s.IntfName == c.IntfName &&
s.VtepIP == c.... | go | {
"resource": ""
} |
q7720 | ReadAll | train | func (s *OperEndpointState) ReadAll() ([]core.State, error) {
return s.StateDriver.ReadAllState(endpointOperPathPrefix, s, json.Unmarshal)
} | go | {
"resource": ""
} |
q7721 | NewClient | train | func (ep *etcdPlugin) NewClient(endpoints []string) (API, error) {
var err error
var ec = new(EtcdClient)
ep.mutex.Lock()
defer ep.mutex.Unlock()
// Setup default url
if len(endpoints) == 0 {
endpoints = []string{"http://127.0.0.1:2379"}
}
etcdConfig := client.Config{
Endpoints: endpoints,
}
// Create... | go | {
"resource": ""
} |
q7722 | GetObj | train | func (ep *EtcdClient) GetObj(key string, retVal interface{}) error {
keyName := "/contiv.io/obj/" + key
// Get the object from etcd client
resp, err := ep.kapi.Get(context.Background(), keyName, &client.GetOptions{Quorum: true})
if err != nil {
// Retry few times if cluster is unavailable
if err.Error() == cli... | go | {
"resource": ""
} |
q7723 | recursAddNode | train | func recursAddNode(node *client.Node, list []string) []string {
for _, innerNode := range node.Nodes {
// add only the files.
if !innerNode.Dir {
list = append(list, innerNode.Value)
} else {
list = recursAddNode(innerNode, list)
}
}
return list
} | go | {
"resource": ""
} |
q7724 | ListDir | train | func (ep *EtcdClient) ListDir(key string) ([]string, error) {
keyName := "/contiv.io/obj/" + key
getOpts := client.GetOptions{
Recursive: true,
Sort: true,
Quorum: true,
}
// Get the object from etcd client
resp, err := ep.kapi.Get(context.Background(), keyName, &getOpts)
if err != nil {
// Retr... | go | {
"resource": ""
} |
q7725 | SetObj | train | func (ep *EtcdClient) SetObj(key string, value interface{}) error {
keyName := "/contiv.io/obj/" + key
// JSON format the object
jsonVal, err := json.Marshal(value)
if err != nil {
log.Errorf("Json conversion error. Err %v", err)
return err
}
// Set it via etcd client
_, err = ep.kapi.Set(context.Backgroun... | go | {
"resource": ""
} |
q7726 | DelObj | train | func (ep *EtcdClient) DelObj(key string) error {
keyName := "/contiv.io/obj/" + key
// Remove it via etcd client
_, err := ep.kapi.Delete(context.Background(), keyName, nil)
if err != nil {
// Retry few times if cluster is unavailable
if err.Error() == client.ErrClusterUnavailable.Error() {
for i := 0; i < ... | go | {
"resource": ""
} |
q7727 | addVxGWRoutes | train | func addVxGWRoutes(netPlugin *plugin.NetPlugin, gwIP string) {
readNet := &mastercfg.CfgNetworkState{}
readNet.StateDriver = netPlugin.StateDriver
netCfgs, err := readNet.ReadAll()
if err != nil {
log.Errorf("Error reading netCfgs: %v", err)
return
}
for _, netCfg := range netCfgs {
net := netCfg.(*mastercf... | go | {
"resource": ""
} |
q7728 | processInfraNwCreate | train | func processInfraNwCreate(netPlugin *plugin.NetPlugin, nwCfg *mastercfg.CfgNetworkState, opts core.InstanceInfo) (err error) {
pluginHost := opts.HostLabel
// Build endpoint request
mreq := master.CreateEndpointRequest{
TenantName: nwCfg.Tenant,
NetworkName: nwCfg.NetworkName,
EndpointID: pluginHost,
Conf... | go | {
"resource": ""
} |
q7729 | processInfraNwDelete | train | func processInfraNwDelete(netPlugin *plugin.NetPlugin, nwCfg *mastercfg.CfgNetworkState, opts core.InstanceInfo) (err error) {
pluginHost := opts.HostLabel
if nwCfg.NetworkName == contivVxGWName {
gwIP, err := getVxGWIP(netPlugin, nwCfg.Tenant, pluginHost)
if err == nil {
delVxGWRoutes(netPlugin, gwIP)
}
}... | go | {
"resource": ""
} |
q7730 | processEpState | train | func processEpState(netPlugin *plugin.NetPlugin, opts core.InstanceInfo, epID string) error {
// take a lock in netplugin to ensure we are programming one event at a time.
// Also network create events need to be processed before endpoint creates
// and reverse shall happen for deletes. That order is ensured by netm... | go | {
"resource": ""
} |
q7731 | processRemoteEpState | train | func processRemoteEpState(netPlugin *plugin.NetPlugin, opts core.InstanceInfo, epCfg *mastercfg.CfgEndpointState, isDelete bool) error {
if !checkRemoteHost(epCfg.VtepIP, epCfg.HomingHost, opts.HostLabel) {
// Skip local endpoint update, as they are handled directly in dockplugin
return nil
}
if isDelete {
//... | go | {
"resource": ""
} |
q7732 | processServiceLBEvent | train | func processServiceLBEvent(netPlugin *plugin.NetPlugin, svcLBCfg *mastercfg.CfgServiceLBState, isDelete bool) error {
var err error
portSpecList := []core.PortSpec{}
portSpec := core.PortSpec{}
serviceID := svcLBCfg.ID
log.Infof("Recevied Process Service load balancer event {%v}", svcLBCfg)
//create portspect ... | go | {
"resource": ""
} |
q7733 | processSvcProviderUpdEvent | train | func processSvcProviderUpdEvent(netPlugin *plugin.NetPlugin, svcProvider *mastercfg.SvcProvider, isDelete bool) error {
if isDelete {
//ignore delete event since servicelb delete will take care of this.
return nil
}
netPlugin.SvcProviderUpdate(svcProvider.ServiceName, svcProvider.Providers)
return nil
} | go | {
"resource": ""
} |
q7734 | processPolicyRuleState | train | func processPolicyRuleState(netPlugin *plugin.NetPlugin, opts core.InstanceInfo, ruleID string, isDelete bool) error {
// read policy config
ruleCfg := &mastercfg.CfgPolicyRule{}
ruleCfg.StateDriver = netPlugin.StateDriver
err := ruleCfg.Read(ruleID)
if err != nil {
log.Errorf("Failed to read config for policy ... | go | {
"resource": ""
} |
q7735 | ReadAll | train | func (r *AutoVXLANCfgResource) ReadAll() ([]core.State, error) {
return r.StateDriver.ReadAllState(vXLANResourceConfigPathPrefix, r,
json.Unmarshal)
} | go | {
"resource": ""
} |
q7736 | Init | train | func (r *AutoVXLANCfgResource) Init(rsrcCfg interface{}) error {
cfg, ok := rsrcCfg.(*AutoVXLANCfgResource)
if !ok {
return core.Errorf("Invalid vxlan resource config.")
}
r.VXLANs = cfg.VXLANs
r.LocalVLANs = cfg.LocalVLANs
err := r.Write()
if err != nil {
return err
}
defer func() {
if err != nil {
r... | go | {
"resource": ""
} |
q7737 | Reinit | train | func (r *AutoVXLANCfgResource) Reinit(rsrcCfg interface{}) error {
cfg, ok := rsrcCfg.(*AutoVXLANCfgResource)
if !ok {
return core.Errorf("Invalid vxlan resource config.")
}
prevVXLANs := r.VXLANs
prevFreeStart := r.FreeVXLANsStart
r.VXLANs = cfg.VXLANs
r.LocalVLANs = cfg.LocalVLANs
r.FreeVXLANsStart = cfg... | go | {
"resource": ""
} |
q7738 | Allocate | train | func (r *AutoVXLANCfgResource) Allocate(reqVal interface{}) (interface{}, error) {
oper := &AutoVXLANOperResource{}
oper.StateDriver = r.StateDriver
err := oper.Read(r.ID)
if err != nil {
return nil, err
}
var vxlan uint
if (reqVal != nil) && (reqVal.(uint) != 0) {
vxlan = reqVal.(uint)
if !oper.FreeVXLAN... | go | {
"resource": ""
} |
q7739 | Deallocate | train | func (r *AutoVXLANCfgResource) Deallocate(value interface{}) error {
oper := &AutoVXLANOperResource{}
oper.StateDriver = r.StateDriver
err := oper.Read(r.ID)
if err != nil {
return err
}
pair, ok := value.(VXLANVLANPair)
if !ok {
return core.Errorf("Invalid type for vxlan-vlan pair")
}
vxlan := pair.VXLAN... | go | {
"resource": ""
} |
q7740 | ReadAll | train | func (r *AutoVXLANOperResource) ReadAll() ([]core.State, error) {
return r.StateDriver.ReadAllState(vXLANResourceOperPathPrefix, r,
json.Unmarshal)
} | go | {
"resource": ""
} |
q7741 | Init | train | func (d *FakeStateDriver) Init(instInfo *core.InstanceInfo) error {
d.TestState = make(map[string]valueData)
return nil
} | go | {
"resource": ""
} |
q7742 | Write | train | func (d *FakeStateDriver) Write(key string, value []byte) error {
val := valueData{value: value}
d.TestState[key] = val
return nil
} | go | {
"resource": ""
} |
q7743 | Read | train | func (d *FakeStateDriver) Read(key string) ([]byte, error) {
if val, ok := d.TestState[key]; ok {
return val.value, nil
}
return []byte{}, core.Errorf("key not found! key: %v", key)
} | go | {
"resource": ""
} |
q7744 | ReadAll | train | func (d *FakeStateDriver) ReadAll(baseKey string) ([][]byte, error) {
values := [][]byte{}
for key, val := range d.TestState {
if strings.Contains(key, baseKey) {
values = append(values, val.value)
}
}
return values, nil
} | go | {
"resource": ""
} |
q7745 | WatchAll | train | func (d *FakeStateDriver) WatchAll(baseKey string, rsps chan [2][]byte) error {
log.Warnf("watchall not supported")
select {} // block forever
} | go | {
"resource": ""
} |
q7746 | ClearState | train | func (d *FakeStateDriver) ClearState(key string) error {
if _, ok := d.TestState[key]; ok {
delete(d.TestState, key)
}
return nil
} | go | {
"resource": ""
} |
q7747 | ReadAllState | train | func (d *FakeStateDriver) ReadAllState(baseKey string, sType core.State,
unmarshal func([]byte, interface{}) error) ([]core.State, error) {
return readAllStateCommon(d, baseKey, sType, unmarshal)
} | go | {
"resource": ""
} |
q7748 | WatchAllState | train | func (d *FakeStateDriver) WatchAllState(baseKey string, sType core.State,
unmarshal func([]byte, interface{}) error, rsps chan core.WatchState) error {
return core.Errorf("not supported")
} | go | {
"resource": ""
} |
q7749 | DeleteServiceLB | train | func DeleteServiceLB(stateDriver core.StateDriver, serviceName string, tenantName string) error {
log.Infof("Received Delete Service Load Balancer %s on %s", serviceName, tenantName)
serviceLBState := &mastercfg.CfgServiceLBState{}
serviceLBState.StateDriver = stateDriver
serviceLBState.ID = GetServiceID(serviceNa... | go | {
"resource": ""
} |
q7750 | RestoreServiceProviderLBDb | train | func RestoreServiceProviderLBDb() {
log.Infof("Restoring ProviderDb and ServiceDB cache")
svcLBState := &mastercfg.CfgServiceLBState{}
stateDriver, err := utils.GetStateDriver()
if err != nil {
log.Errorf("Error Restoring Service and ProviderDb Err:%s", err)
return
}
svcLBState.StateDriver = stateDriver
sv... | go | {
"resource": ""
} |
q7751 | IsOverlappingSubnetv6 | train | func IsOverlappingSubnetv6(inputIPv6Subnet string, existingIPv6Subnet string) bool {
inputIPv6StartRange, inputIPv6EndRange := getIPv6Range(inputIPv6Subnet)
existingIPv6StartRange, existingIPv6EndRange := getIPv6Range(existingIPv6Subnet)
inputStartRange := ipv6ToBigint(inputIPv6StartRange)
inputEndRange := ipv6ToB... | go | {
"resource": ""
} |
q7752 | IsOverlappingSubnet | train | func IsOverlappingSubnet(inputSubnet string, existingSubnet string) bool {
inputSubnetIP, inputSubnetLen, _ := ParseCIDR(inputSubnet)
existingSubnetIP, existingSubnetLen, _ := ParseCIDR(existingSubnet)
inputStartRange, _ := ipv4ToUint32(getFirstAddrInRange(inputSubnetIP))
inputEndRange, _ := ipv4ToUint32(getLastAd... | go | {
"resource": ""
} |
q7753 | ValidateNetworkRangeParams | train | func ValidateNetworkRangeParams(ipRange string, subnetLen uint) error {
rangeMin, _ := ipv4ToUint32(getFirstAddrInRange(ipRange))
rangeMax, _ := ipv4ToUint32(getLastAddrInRange(ipRange, subnetLen))
firstAddr, _ := ipv4ToUint32(GetSubnetAddr(ipRange, subnetLen))
lastAddr, _ := ipv4ToUint32(getLastAddrInSubnet(ipRang... | go | {
"resource": ""
} |
q7754 | ClearReservedEntries | train | func ClearReservedEntries(b *bitset.BitSet, subnetLen uint) {
maxSize := (1 << (32 - subnetLen)) - 1
b.Clear(uint(maxSize))
b.Clear(uint(0))
} | go | {
"resource": ""
} |
q7755 | ClearIPAddrRange | train | func ClearIPAddrRange(ipAllocMap *bitset.BitSet, ipPool string, nwSubnetIP string, nwSubnetLen uint) error {
addrRangeList := strings.Split(ipPool, "-")
hostMin, err := GetIPNumber(nwSubnetIP, nwSubnetLen, 32, addrRangeList[0])
if err != nil {
log.Errorf("Error parsing first address %s. Err: %v", addrRangeList[0... | go | {
"resource": ""
} |
q7756 | GetIPAddrRange | train | func GetIPAddrRange(ipCIDR string, subnetLen uint) string {
rangeMin, _ := ipv4ToUint32(getFirstAddrInRange(ipCIDR))
rangeMax, _ := ipv4ToUint32(getLastAddrInRange(ipCIDR, subnetLen))
firstAddr, _ := ipv4ToUint32(GetSubnetAddr(ipCIDR, subnetLen))
lastAddr, _ := ipv4ToUint32(getLastAddrInSubnet(ipCIDR, subnetLen))
... | go | {
"resource": ""
} |
q7757 | ClearBitsOutsideRange | train | func ClearBitsOutsideRange(ipAllocMap *bitset.BitSet, ipRange string, subnetLen uint) {
var i uint32
rangeMin, _ := ipv4ToUint32(getFirstAddrInRange(ipRange))
rangeMax, _ := ipv4ToUint32(getLastAddrInRange(ipRange, subnetLen))
firstAddr, _ := ipv4ToUint32(GetSubnetAddr(ipRange, subnetLen))
lastAddr, _ := ipv4ToUin... | go | {
"resource": ""
} |
q7758 | CreateBitset | train | func CreateBitset(numBitsWide uint) *bitset.BitSet {
maxSize := 1 << numBitsWide
return bitset.New(uint(maxSize))
} | go | {
"resource": ""
} |
q7759 | GetSubnetIP | train | func GetSubnetIP(subnetIP string, subnetLen uint, allocSubnetLen, hostID uint) (string, error) {
if subnetIP == "" {
return "", core.Errorf("null subnet")
}
if subnetLen > 32 || subnetLen < 8 {
return "", core.Errorf("subnet length %d not supported", subnetLen)
}
if subnetLen > allocSubnetLen {
return "", c... | go | {
"resource": ""
} |
q7760 | GetIPNumber | train | func GetIPNumber(subnetIP string, subnetLen uint, allocSubnetLen uint, hostIP string) (uint, error) {
if subnetLen > 32 || subnetLen < 8 {
return 0, core.Errorf("subnet length %d not supported", subnetLen)
}
if subnetLen > allocSubnetLen {
return 0, core.Errorf("subnet length %d is bigger than subnet alloc len %... | go | {
"resource": ""
} |
q7761 | ReserveIPv6HostID | train | func ReserveIPv6HostID(hostID string, IPv6AllocMap *map[string]bool) {
if hostID == "" {
return
}
if *IPv6AllocMap == nil {
*IPv6AllocMap = make(map[string]bool)
}
(*IPv6AllocMap)[hostID] = true
} | go | {
"resource": ""
} |
q7762 | GetNextIPv6HostID | train | func GetNextIPv6HostID(hostID, subnetAddr string, subnetLen uint, IPv6AllocMap map[string]bool) (string, error) {
if hostID == "" {
hostID = "::"
}
if subnetLen == 0 {
return "", core.Errorf("subnet length %d is invalid", subnetLen)
}
hostidIP := net.ParseIP(hostID)
// start with the carryOver 1 to get the ... | go | {
"resource": ""
} |
q7763 | GetSubnetIPv6 | train | func GetSubnetIPv6(subnetAddr string, subnetLen uint, hostID string) (string, error) {
if subnetAddr == "" {
return "", core.Errorf("null subnet")
}
if subnetLen > 128 || subnetLen < 16 {
return "", core.Errorf("subnet length %d not supported", subnetLen)
}
subnetIP := net.ParseIP(subnetAddr)
hostidIP := ne... | go | {
"resource": ""
} |
q7764 | GetIPv6HostID | train | func GetIPv6HostID(subnetAddr string, subnetLen uint, hostAddr string) (string, error) {
if subnetLen > 128 || subnetLen < 16 {
return "", core.Errorf("subnet length %d not supported", subnetLen)
}
// Initialize hostID
hostID := net.IPv6zero
var offset uint
// get the overlapping byte
offset = subnetLen / 8
... | go | {
"resource": ""
} |
q7765 | ParseTagRanges | train | func ParseTagRanges(ranges string, tagType string) ([]TagRange, error) {
var err error
if ranges == "" {
return []TagRange{{0, 0}}, nil
}
if tagType != "vlan" && tagType != "vxlan" {
return nil, core.Errorf("invalid tag type %s", tagType)
}
rangesStr := strings.Split(ranges, ",")
if len(rangesStr) > 1 && ... | go | {
"resource": ""
} |
q7766 | ParseCIDR | train | func ParseCIDR(cidrStr string) (string, uint, error) {
strs := strings.Split(cidrStr, "/")
if len(strs) != 2 {
return "", 0, core.Errorf("invalid cidr format")
}
subnetStr := strs[0]
subnetLen, err := strconv.Atoi(strs[1])
if (IsIPv6(subnetStr) && subnetLen > 128) || err != nil || (!IsIPv6(subnetStr) && subnet... | go | {
"resource": ""
} |
q7767 | GetInterfaceIP | train | func GetInterfaceIP(linkName string) (string, error) {
var addrs []netlink.Addr
localIPAddr := ""
link, err := netlink.LinkByName(linkName)
if err != nil {
return "", err
}
addrs, err = netlink.AddrList(link, netlink.FAMILY_V4)
if err != nil {
return "", err
}
if len(addrs) > 0 {
localIPAddr = addrs[0].... | go | {
"resource": ""
} |
q7768 | GetNetlinkAddrList | train | func GetNetlinkAddrList() ([]string, error) {
var addrList []string
// get the link list
linkList, err := netlink.LinkList()
if err != nil {
return addrList, err
}
log.Debugf("Got link list(%d): %+v", len(linkList), linkList)
// Loop thru each interface and add its ip addr to list
for _, link := range linkL... | go | {
"resource": ""
} |
q7769 | GetLocalAddrList | train | func GetLocalAddrList() ([]string, error) {
var addrList []string
// get the link list
intfList, err := net.Interfaces()
if err != nil {
return addrList, err
}
log.Debugf("Got address list(%d): %+v", len(intfList), intfList)
// Loop thru each interface and add its ip addr to list
for _, intf := range intfLi... | go | {
"resource": ""
} |
q7770 | GetHostLowestLinkMtu | train | func GetHostLowestLinkMtu() (int, error) {
lowestMTU := 9000 //Jumbo frame MTU
intfList, err := net.Interfaces()
if err != nil {
return 0, err
}
// Loop thru each interface and add its ip addr to list
for _, intf := range intfList {
if strings.HasPrefix(intf.Name, "docker") || strings.HasPrefix(intf.Name, "v... | go | {
"resource": ""
} |
q7771 | IsAddrLocal | train | func IsAddrLocal(findAddr string) bool {
// get the local addr list
addrList, err := GetNetlinkAddrList()
if err != nil {
return false
}
// find the address
for _, addr := range addrList {
if addr == findAddr {
return true
}
}
return false
} | go | {
"resource": ""
} |
q7772 | GetFirstLocalAddr | train | func GetFirstLocalAddr() (string, error) {
// get the local addr list
addrList, err := GetNetlinkAddrList()
if err != nil {
return "", err
}
if len(addrList) > 0 {
return addrList[0], nil
}
return "", errors.New("no address was found")
} | go | {
"resource": ""
} |
q7773 | GetDefaultAddr | train | func GetDefaultAddr() (string, error) {
// get the ip address by local hostname
localIP, err := GetMyAddr()
if err == nil && IsAddrLocal(localIP) {
return localIP, nil
}
// Return first available address if we could not find by hostname
return GetFirstLocalAddr()
} | go | {
"resource": ""
} |
q7774 | GetSubnetAddr | train | func GetSubnetAddr(ipStr string, length uint) string {
subnetStr := ipStr
if isSubnetIPRange(ipStr) {
subnetStr = strings.Split(ipStr, "-")[0]
}
subnet, _ := ipv4ToUint32(subnetStr)
subnetMask := -1 << (32 - length)
ipSubnet, _ := ipv4Uint32ToString(uint32(subnetMask) & subnet)
return ipSubnet
} | go | {
"resource": ""
} |
q7775 | getLastAddrInSubnet | train | func getLastAddrInSubnet(ipStr string, length uint) string {
subnetStr := ipStr
if isSubnetIPRange(ipStr) {
subnetStr = strings.Split(ipStr, "-")[0]
}
subnet, _ := ipv4ToUint32(subnetStr)
subnetMask := -1 << (32 - length)
lastIP, _ := ipv4Uint32ToString(uint32(^subnetMask) | subnet)
return lastIP
} | go | {
"resource": ""
} |
q7776 | getFirstAddrInRange | train | func getFirstAddrInRange(ipRange string) string {
firstIP := ipRange
if isSubnetIPRange(ipRange) {
firstIP = strings.Split(ipRange, "-")[0]
}
return firstIP
} | go | {
"resource": ""
} |
q7777 | getLastAddrInRange | train | func getLastAddrInRange(ipRange string, subnetLen uint) string {
var lastIP string
if isSubnetIPRange(ipRange) {
lastIP = strings.Split(ipRange, "-")[1]
} else {
lastIP = getLastAddrInSubnet(ipRange, subnetLen)
}
return lastIP
} | go | {
"resource": ""
} |
q7778 | GetMyAddr | train | func GetMyAddr() (string, error) {
host, err := os.Hostname()
if err != nil {
return "", err
}
if host == "localhost" {
return "", errors.New("could not get hostname")
}
addrs, err := net.LookupIP(host)
if err != nil {
return "", err
}
for _, addr := range addrs {
if ipv4 := addr.To4(); ipv4 != nil ... | go | {
"resource": ""
} |
q7779 | PortToHostIPMAC | train | func PortToHostIPMAC(port, subnet int) (string, string) {
b0 := subnet >> 24
b1 := (subnet >> 16) & 0xff
b2 := (port >> 8) & 0xff
b3 := port & 0xff
ipStr := fmt.Sprintf("%d.%d.%d.%d/16", b0, b1, b2, b3)
macStr := fmt.Sprintf("02:02:%02x:%02x:%02x:%02x", b0, b1, b2, b3)
return ipStr, macStr
} | go | {
"resource": ""
} |
q7780 | SetIPMasquerade | train | func SetIPMasquerade(intf, netmask string) error {
ipTablesPath, err := osexec.LookPath("iptables")
if err != nil {
return err
}
_, err = osexec.Command(ipTablesPath, "-t", "nat", "-C", "POSTROUTING", "-s", netmask,
"!", "-o", intf, "-j", "MASQUERADE").CombinedOutput()
// If the rule already exists, just retu... | go | {
"resource": ""
} |
q7781 | HostIPToGateway | train | func HostIPToGateway(hostIP string) (string, error) {
ip := strings.Split(hostIP, ".")
if len(ip) != 4 {
return "", errors.New("bad host IP")
}
return ip[0] + "." + ip[1] + ".255.254", nil
} | go | {
"resource": ""
} |
q7782 | CIDRToMask | train | func CIDRToMask(cidr string) (int, error) {
_, net, err := net.ParseCIDR(cidr)
if err != nil {
return -1, err
}
ip := net.IP
if len(ip) == 16 {
return int(binary.BigEndian.Uint32(ip[12:16])), nil
}
return int(binary.BigEndian.Uint32(ip)), nil
} | go | {
"resource": ""
} |
q7783 | NextClear | train | func NextClear(allocMap bitset.BitSet, idx uint, subnetLen uint) (uint, bool) {
maxHosts := uint(1 << (32 - subnetLen))
value, found := allocMap.NextClear(idx)
if found && value >= maxHosts {
return 0, false
}
return value, found
} | go | {
"resource": ""
} |
q7784 | AddIPRoute | train | func AddIPRoute(cidr, gw string) error {
_, dst, err := net.ParseCIDR(cidr)
if err != nil {
return err
}
gwIP := net.ParseIP(gw)
if gwIP == nil {
return fmt.Errorf("Unable to parse gw %s", gw)
}
match, err := netlink.RouteListFiltered(netlink.FAMILY_V4,
&netlink.Route{Dst: dst}, netlink.RT_FILTER_DST)
... | go | {
"resource": ""
} |
q7785 | DelIPRoute | train | func DelIPRoute(cidr, gw string) error {
_, dst, err := net.ParseCIDR(cidr)
if err != nil {
return err
}
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})
} | go | {
"resource": ""
} |
q7786 | ReadAll | train | func (gc *Cfg) ReadAll() ([]core.State, error) {
return gc.StateDriver.ReadAllState(cfgGlobalPrefix, gc, json.Unmarshal)
} | go | {
"resource": ""
} |
q7787 | Clear | train | func (gc *Cfg) Clear() error {
key := cfgGlobalPath
return gc.StateDriver.ClearState(key)
} | go | {
"resource": ""
} |
q7788 | ReadAll | train | func (g *Oper) ReadAll() ([]core.State, error) {
return g.StateDriver.ReadAllState(operGlobalPrefix, g, json.Unmarshal)
} | go | {
"resource": ""
} |
q7789 | GetVxlansInUse | train | func (gc *Cfg) GetVxlansInUse() (uint, string) {
tempRm, err := resources.GetStateResourceManager()
if err != nil {
log.Errorf("error getting resource manager: %s", err)
return 0, ""
}
ra := core.ResourceManager(tempRm)
return ra.GetResourceList("global", resources.AutoVXLANResource)
} | go | {
"resource": ""
} |
q7790 | AllocVXLAN | train | func (gc *Cfg) AllocVXLAN(reqVxlan uint) (vxlan uint, localVLAN uint, err error) {
tempRm, err := resources.GetStateResourceManager()
if err != nil {
return 0, 0, err
}
ra := core.ResourceManager(tempRm)
g := &Oper{}
g.StateDriver = gc.StateDriver
err = g.Read("")
if err != nil {
return 0, 0, err
}
if ... | go | {
"resource": ""
} |
q7791 | FreeVXLAN | train | func (gc *Cfg) FreeVXLAN(vxlan uint, localVLAN uint) error {
tempRm, err := resources.GetStateResourceManager()
if err != nil {
return err
}
ra := core.ResourceManager(tempRm)
g := &Oper{}
g.StateDriver = gc.StateDriver
err = g.Read("")
if err != nil {
return nil
}
return ra.DeallocateResourceVal("globa... | go | {
"resource": ""
} |
q7792 | GetVlansInUse | train | func (gc *Cfg) GetVlansInUse() (uint, string) {
tempRm, err := resources.GetStateResourceManager()
if err != nil {
log.Errorf("error getting resource manager: %s", err)
return 0, ""
}
ra := core.ResourceManager(tempRm)
return ra.GetResourceList("global", resources.AutoVLANResource)
} | go | {
"resource": ""
} |
q7793 | AllocVLAN | train | func (gc *Cfg) AllocVLAN(reqVlan uint) (uint, error) {
tempRm, err := resources.GetStateResourceManager()
if err != nil {
return 0, err
}
ra := core.ResourceManager(tempRm)
vlan, err := ra.AllocateResourceVal("global", resources.AutoVLANResource, reqVlan)
if err != nil {
log.Errorf("alloc vlan failed: %q", e... | go | {
"resource": ""
} |
q7794 | FreeVLAN | train | func (gc *Cfg) FreeVLAN(vlan uint) error {
tempRm, err := resources.GetStateResourceManager()
if err != nil {
return err
}
ra := core.ResourceManager(tempRm)
return ra.DeallocateResourceVal("global", resources.AutoVLANResource, vlan)
} | go | {
"resource": ""
} |
q7795 | DeleteResources | train | func (gc *Cfg) DeleteResources(res string) error {
tempRm, err := resources.GetStateResourceManager()
if err != nil {
return err
}
ra := core.ResourceManager(tempRm)
if res == "vlan" {
err = ra.UndefineResource("global", resources.AutoVLANResource)
if err != nil {
log.Errorf("Error deleting vlan resource... | go | {
"resource": ""
} |
q7796 | UpdateResources | train | func (gc *Cfg) UpdateResources(res string) error {
log.Infof("Received update resource for res %s", res)
tempRm, err := resources.GetStateResourceManager()
if err != nil {
return err
}
ra := core.ResourceManager(tempRm)
err = gc.checkErrors(res)
if err != nil {
return core.Errorf("process failed on error c... | go | {
"resource": ""
} |
q7797 | CheckInBitRange | train | func (gc *Cfg) CheckInBitRange(ranges, inUse, pktTagType string) bool {
tags := strings.Split(inUse, ",")
if len(inUse) == 0 {
return true
}
minUsed := 0
maxUsed := 0
if strings.Contains(tags[0], "-") {
minUsed, _ = strconv.Atoi(strings.Split(tags[0], "-")[0])
maxUsed, _ = strconv.Atoi(strings.Split(tags[... | go | {
"resource": ""
} |
q7798 | ClearState | train | func (d *EtcdStateDriver) ClearState(key string) error {
ctx, cancel := context.WithTimeout(context.Background(), ctxTimeout)
defer cancel()
_, err := d.KeysAPI.Delete(ctx, key, nil)
return err
} | go | {
"resource": ""
} |
q7799 | WriteState | train | func (d *EtcdStateDriver) WriteState(key string, value core.State,
marshal func(interface{}) ([]byte, error)) error {
encodedState, err := marshal(value)
if err != nil {
return err
}
return d.Write(key, encodedState)
} | go | {
"resource": ""
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.