_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, 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: log.Stream(niceHeader("daemon: ", dmn.Command)),
shell: sh,
indir: indir,
}
}
return &DaemonPen{daemons: d}, 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}, nil
} | 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) != 0) {
if !reflect.DeepEqual(c.variables, other.variables) {
return false
}
}
return true
} | 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 == nil {
return "pwsh", nil
} else {
return "", fmt.Errorf("powershell/pwsh not on path")
}
case "modd":
// 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)
}
} | 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, serviceInfo)
// if there is a previously registered service, stop refreshing it
if ep.serviceDb[keyName] != nil {
ep.serviceDb[keyName].stopChan <- true
}
// JSON format the object
jsonVal, err := json.Marshal(serviceInfo)
if err != nil {
log.Errorf("Json conversion error. Err %v", err)
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 background
go ep.refreshService(&srvState, string(jsonVal[:]))
// Store it in DB
ep.serviceDb[keyName] = &srvState
return nil
} | 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: %+v", srvInfo)
// Send Add event
eventCh <- WatchServiceEvent{
EventType: WatchServiceEventAdd,
ServiceInfo: srvInfo,
}
}
return mIndex, nil
} | 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 the service in db %s", keyName)
return errors.New("Service not found")
}
// stop the refresh thread and delete service
srvState.stopChan <- true
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
} | 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 forever
for {
select {
case <-time.After(srvState.TTL / 3):
log.Debugf("Refreshing key: %s", srvState.KeyName)
_, 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)
}
case <-srvState.stopChan:
log.Infof("Stop refreshing key: %s", srvState.KeyName)
return
}
}
} | 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.VtepIP
} | 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 a new client
ec.client, err = client.New(etcdConfig)
if err != nil {
log.Fatalf("Error creating etcd client. Err: %v", err)
return nil, err
}
// create keys api
ec.kapi = client.NewKeysAPI(ec.client)
// 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, nil
} | 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() == client.ErrClusterUnavailable.Error() {
for i := 0; i < maxEtcdRetries; i++ {
resp, err = ep.kapi.Get(context.Background(), keyName, &client.GetOptions{Quorum: true})
if err == nil {
break
}
// Retry after a delay
time.Sleep(time.Second)
}
}
if err != nil {
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
} | 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 {
// Retry few times if cluster is unavailable
if err.Error() == client.ErrClusterUnavailable.Error() {
for i := 0; i < maxEtcdRetries; i++ {
resp, err = ep.kapi.Get(context.Background(), keyName, &getOpts)
if err == nil {
break
}
// Retry after a delay
time.Sleep(time.Second)
}
}
if err != nil {
return nil, err
}
}
if !resp.Node.Dir {
log.Errorf("ListDir response is not 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
// Which means, caller has to derive the key from value :(
retList = recursAddNode(resp.Node, retList)
return retList, nil
} | 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.Background(), keyName, string(jsonVal[:]), nil)
if err != nil {
// Retry few times if cluster is unavailable
if err.Error() == client.ErrClusterUnavailable.Error() {
for i := 0; i < maxEtcdRetries; i++ {
_, 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
} | 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 < maxEtcdRetries; i++ {
_, err = ep.kapi.Delete(context.Background(), keyName, nil)
if err == nil {
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
} | 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.(*mastercfg.CfgNetworkState)
if net.NwType != "infra" && net.PktTagType == "vxlan" {
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 route [%s]", clusterNet)
if len(clusterNet) > 0 {
if err = netutils.AddIPRoute(clusterNet, gwIP); err != nil {
log.Errorf("Adding route [%s] --> %s: err: %v",
clusterNet, gwIP, err)
}
}
} | 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,
ConfigEP: intent.ConfigEP{
Container: pluginHost,
Host: pluginHost,
},
}
var mresp master.CreateEndpointResponse
err = cluster.MasterPostReq("/plugin/createEndpoint", &mreq, &mresp)
if err != nil {
log.Errorf("master failed to create endpoint %s", err)
return err
}
log.Infof("Got endpoint create resp from master: %+v", mresp)
// Take lock to ensure netPlugin processes only one cmd at a time
// Ask netplugin to create the endpoint
netID := nwCfg.NetworkName + "." + nwCfg.Tenant
err = netPlugin.CreateEndpoint(netID + "-" + pluginHost)
if err != nil {
log.Errorf("Endpoint creation failed. Error: %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
if nwCfg.NetworkName == contivVxGWName {
addVxGWRoutes(netPlugin, mresp.EndpointConfig.IPAddress)
}
return nil
} | 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)
}
}
// Build endpoint request
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)
return err
}
log.Infof("Got endpoint create resp from master: %+v", mresp)
// Network delete will take care of infra nw EP delete in plugin
return err
} | 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 netmaster,
// so we don't need to worry about that here
// read endpoint config
epCfg := &mastercfg.CfgEndpointState{}
epCfg.StateDriver = netPlugin.StateDriver
err := epCfg.Read(epID)
if err != nil {
log.Errorf("Failed to read config for ep '%s' \n", epID)
return err
}
eptype := "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: %s", err)
return err
}
log.Infof("Endpoint operation create succeeded")
return err
} | 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 {
// Delete remote endpoint
err := netPlugin.DeleteRemoteEndpoint(epCfg.ID)
if err != nil {
log.Errorf("Endpoint %s delete operation failed. Error: %s", epCfg.ID, err)
return err
}
log.Infof("Endpoint %s 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 nil
} | 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 list from state.
//Ports format: servicePort:ProviderPort:Protocol
for _, port := range svcLBCfg.Ports {
portInfo := strings.Split(port, ":")
if len(portInfo) != 3 {
return errors.New("invalid Port Format")
}
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 := &core.ServiceSpec{
IPAddress: svcLBCfg.IPAddress,
Ports: portSpecList,
}
operStr := ""
if isDelete {
err = netPlugin.DeleteServiceLB(serviceID, spec)
operStr = "delete"
} else {
err = netPlugin.AddServiceLB(serviceID, spec)
operStr = "create"
}
if err != nil {
log.Errorf("Service Load Balancer %s failed.Error:%s", operStr, err)
return err
}
log.Infof("Service Load Balancer %s succeeded", operStr)
return nil
} | 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 rule '%s' \n", ruleID)
return err
}
if isDelete {
// Delete endpoint
err = netPlugin.DelPolicyRule(ruleID)
if err != nil {
log.Errorf("PolicyRule %s delete operation failed. Error: %s", ruleID, err)
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 succeeded", ruleID)
}
return err
} | 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.Clear()
}
}()
oper := &AutoVXLANOperResource{FreeVXLANs: r.VXLANs, FreeLocalVLANs: r.LocalVLANs}
oper.StateDriver = r.StateDriver
oper.ID = r.ID
return oper.Write()
} | 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.FreeVXLANsStart
err := r.Write()
if err != nil {
return err
}
defer func() {
if err != nil {
r.Clear()
}
}()
oper := &AutoVXLANOperResource{}
oper.StateDriver = r.StateDriver
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)
}
oper.FreeLocalVLANs = oper.FreeLocalVLANs.Intersection(r.LocalVLANs)
return oper.Write()
} | 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.FreeVXLANs.Test(vxlan) {
return nil, fmt.Errorf("requested vxlan not available")
}
} else {
ok := false
vxlan, ok = oper.FreeVXLANs.NextSet(0)
if !ok {
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: vxlan, VLAN: vlan}, nil
} | 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
oper.FreeVXLANs.Set(vxlan)
vlan := pair.VLAN
oper.FreeLocalVLANs.Set(vlan)
return oper.Write()
} | 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(serviceName, tenantName)
mastercfg.SvcMutex.RLock()
err := serviceLBState.Read(serviceLBState.ID)
if err != nil {
mastercfg.SvcMutex.RUnlock()
log.Errorf("Error reading service lb config for service %s in tenant %s", serviceName, tenantName)
return err
}
mastercfg.SvcMutex.RUnlock()
// find the network from network id
nwCfg := &mastercfg.CfgNetworkState{}
nwCfg.StateDriver = stateDriver
networkID := serviceLBState.Network + "." + serviceLBState.Tenant
err = nwCfg.Read(networkID)
if err != nil {
log.Errorf("network %s is not operational. Service object deletion failed", networkID)
return err
}
err = networkReleaseAddress(nwCfg, nil, serviceLBState.IPAddress)
if err != nil {
log.Errorf("Network release address failed %s", err)
}
serviceID := GetServiceID(serviceLBState.ServiceName, serviceLBState.Tenant)
mastercfg.SvcMutex.Lock()
//Remove the service ID from the provider cache
for _, providerInfo := range mastercfg.ServiceLBDb[serviceID].Providers {
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:]...)
}
}
}
//Remove the service from the service cache
delete(mastercfg.ServiceLBDb, serviceID)
SvcProviderUpdate(serviceID, true)
err = serviceLBState.Clear()
if err != nil {
mastercfg.SvcMutex.Unlock()
log.Errorf("Error deleing service lb config for service %s in tenant %s", serviceName, tenantName)
return err
}
mastercfg.SvcMutex.Unlock()
return nil
} | 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
svcLBCfgs, err := svcLBState.ReadAll()
if err == nil {
mastercfg.SvcMutex.Lock()
for _, svcLBCfg := range svcLBCfgs {
svcLB := svcLBCfg.(*mastercfg.CfgServiceLBState)
//mastercfg.ServiceLBDb = make(map[string]*mastercfg.ServiceLBInfo)
serviceID := GetServiceID(svcLB.ServiceName, svcLB.Tenant)
mastercfg.ServiceLBDb[serviceID] = &mastercfg.ServiceLBInfo{
IPAddress: svcLB.IPAddress,
Tenant: svcLB.Tenant,
ServiceName: svcLB.ServiceName,
Network: svcLB.Network,
}
mastercfg.ServiceLBDb[serviceID].Ports = append(mastercfg.ServiceLBDb[serviceID].Ports, svcLB.Ports...)
mastercfg.ServiceLBDb[serviceID].Selectors = make(map[string]string)
mastercfg.ServiceLBDb[serviceID].Providers = make(map[string]*mastercfg.Provider)
for k, v := range svcLB.Selectors {
mastercfg.ServiceLBDb[serviceID].Selectors[k] = v
}
for providerID, providerInfo := range svcLB.Providers {
mastercfg.ServiceLBDb[serviceID].Providers[providerID] = providerInfo
providerDBId := providerInfo.ContainerID
mastercfg.ProviderDb[providerDBId] = providerInfo
}
}
mastercfg.SvcMutex.Unlock()
}
//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 && mastercfg.ProviderDb[providerDBId] == nil {
//Create provider info and store it in provider db
providerInfo := &mastercfg.Provider{}
providerInfo.ContainerID = ep.ContainerID
providerInfo.Network = strings.Split(ep.NetID, ".")[0]
providerInfo.Tenant = strings.Split(ep.NetID, ".")[1]
providerInfo.Labels = make(map[string]string)
providerInfo.IPAddress = ep.IPAddress
for k, v := range ep.Labels {
providerInfo.Labels[k] = v
}
mastercfg.SvcMutex.Lock()
mastercfg.ProviderDb[providerDBId] = providerInfo
mastercfg.SvcMutex.Unlock()
}
}
}
} | go | {
"resource": ""
} |
q7751 | IsOverlappingSubnetv6 | train | func IsOverlappingSubnetv6(inputIPv6Subnet string, existingIPv6Subnet string) bool {
inputIPv6StartRange, inputIPv6EndRange := getIPv6Range(inputIPv6Subnet)
existingIPv6StartRange, existingIPv6EndRange := getIPv6Range(existingIPv6Subnet)
inputStartRange := ipv6ToBigint(inputIPv6StartRange)
inputEndRange := ipv6ToBigint(inputIPv6EndRange)
existingStartRange := ipv6ToBigint(existingIPv6StartRange)
existingEndRange := ipv6ToBigint(existingIPv6EndRange)
if (existingStartRange.Cmp(inputStartRange) <= 0 && inputStartRange.Cmp(existingEndRange) <= 0) ||
(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
}
return false
} | 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(getLastAddrInRange(inputSubnetIP, inputSubnetLen))
existingStartRange, _ := ipv4ToUint32(getFirstAddrInRange(existingSubnetIP))
existingEndRange, _ := ipv4ToUint32(getLastAddrInRange(existingSubnetIP, existingSubnetLen))
if (existingStartRange <= inputStartRange && inputStartRange <= existingEndRange) ||
(existingStartRange <= inputEndRange && inputEndRange <= existingEndRange) {
return true
}
if (inputStartRange <= existingStartRange && existingStartRange <= inputEndRange) ||
(inputStartRange <= existingEndRange && existingEndRange <= inputEndRange) {
return true
}
return false
} | 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(ipRange, subnetLen))
if rangeMin < firstAddr || rangeMax > lastAddr || 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
} | 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], 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.Clear(uint(i))
}
return nil
} | 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))
if rangeMin < firstAddr {
rangeMin = firstAddr
}
if rangeMax > lastAddr {
rangeMax = lastAddr
}
minAddr, _ := ipv4Uint32ToString(rangeMin)
maxAddr, _ := ipv4Uint32ToString(rangeMax)
return minAddr + "-" + maxAddr
} | 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, _ := 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 - firstAddr); i++ {
ipAllocMap.Clear(uint(i))
}
} | 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 "", core.Errorf("subnet length %d is bigger than subnet alloc len %d",
subnetLen, allocSubnetLen)
}
maxHosts := uint(1 << (allocSubnetLen - subnetLen))
if hostID >= maxHosts {
return "", core.Errorf("host 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)
} | 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 %d",
subnetLen, allocSubnetLen)
}
hostIPUint32, err := ipv4ToUint32(hostIP)
if err != nil {
return 0, core.Errorf("unable to convert hostIP %s to uint32", hostIP)
}
subnetIPUint32, err := ipv4ToUint32(subnetIP)
if err != nil {
return 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, subnetIP, subnetLen, hostID)
}
return uint(hostID), nil
} | 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 next hostID
var carryOver = 1
var allocd = true
for allocd == true {
// Add 1 to hostID
for i := len(hostidIP) - 1; i >= 0; i-- {
var temp int
temp = int(hostidIP[i]) + carryOver
if temp > int(0xFF) {
hostidIP[i] = 0
carryOver = 1
} else {
hostidIP[i] = uint8(temp)
carryOver = 0
break
}
}
// Check if this hostID is already allocated
if _, allocd = IPv6AllocMap[hostidIP.String()]; allocd == true {
// Already allocated find the next hostID
carryOver = 1
} else {
// allocd == false. check if we 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 float64(len(IPv6AllocMap)) < maxHosts {
hostID = "::"
hostidIP = net.ParseIP(hostID)
carryOver = 1
allocd = true // continue the loop
} else {
return "", core.Errorf("Reached MaxHosts (%v). Cannot allocate more hosts", maxHosts)
}
}
}
}
return hostidIP.String(), nil
} | 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 := net.ParseIP(hostID)
hostIP := net.IPv6zero
var offset int
for offset = 0; offset < int(subnetLen/8); offset++ {
hostIP[offset] = subnetIP[offset]
}
// copy the overlapping byte in subnetIP and hostID
if subnetLen%8 != 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]
}
return hostIP.String(), nil
} | 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
subnetIP := net.ParseIP(subnetAddr)
if subnetIP == nil {
return "", core.Errorf("Invalid subnetAddr %s ", subnetAddr)
}
s := uint8(subnetIP[offset])
hostIP := net.ParseIP(hostAddr)
if hostIP == nil {
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
} | 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 && tagType == "vxlan" {
return nil, core.Errorf("do not support more than 2 vxlan tag ranges")
}
tagRanges := make([]TagRange, len(rangesStr), len(rangesStr))
for idx, oneRangeStr := range rangesStr {
oneRangeStr = strings.Trim(oneRangeStr, " ")
tagNums := strings.Split(oneRangeStr, "-")
if len(tagNums) > 2 {
return nil, core.Errorf("invalid tags %s, correct '10-50,70-100'",
oneRangeStr)
}
tagRanges[idx].Min, err = strconv.Atoi(tagNums[0])
if err != nil {
return nil, core.Errorf("invalid integer %d conversion error '%s'",
tagRanges[idx].Min, err)
}
tagRanges[idx].Max, err = strconv.Atoi(tagNums[1])
if err != nil {
return nil, core.Errorf("invalid integer %d conversion error '%s'",
tagRanges[idx].Max, err)
}
if tagRanges[idx].Min > tagRanges[idx].Max {
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 values exceed 4095 max allowed",
oneRangeStr)
}
if tagType == "vxlan" && tagRanges[idx].Max > 65535 {
return nil, core.Errorf("invalid range %s, vlan values exceed 65535 max allowed",
oneRangeStr)
}
if tagType == "vxlan" &&
(tagRanges[idx].Max-tagRanges[idx].Min > 16000) {
return nil, core.Errorf("does not allow vxlan range to exceed 16000 range %s",
oneRangeStr)
}
}
return tagRanges, nil
} | 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) && subnetLen > 32) {
return "", 0, core.Errorf("invalid mask in gateway/mask specification ")
}
return subnetStr, uint(subnetLen), nil
} | 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].IP.String()
}
err = core.Errorf("local ip not found")
if localIPAddr != "" {
err = nil
}
return localIPAddr, err
} | 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 linkList {
if strings.HasPrefix(link.Attrs().Name, "docker") || strings.HasPrefix(link.Attrs().Name, "veth") ||
strings.HasPrefix(link.Attrs().Name, "vport") || 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
} | 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 intfList {
if strings.HasPrefix(intf.Name, "docker") || strings.HasPrefix(intf.Name, "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
} | 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, "veth") ||
strings.HasPrefix(intf.Name, "vport") || strings.HasPrefix(intf.Name, "lo") {
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
} | 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 && !ipv4.IsLoopback() {
return ipv4.String(), nil
}
}
return "", errors.New("could not find ip addr")
} | 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 return
if err == nil {
return nil
}
out, err := osexec.Command(ipTablesPath, "-t", "nat", "-A", "POSTROUTING", "-s", netmask,
"!", "-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
} | 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)
if err == nil && len(match) != 0 {
if len(match) == 1 && match[0].Gw.Equal(gwIP) {
// the exact same route exists -- be idempotent
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)
} | 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 reqVxlan != 0 && reqVxlan <= g.FreeVXLANsStart {
return 0, 0, errors.New("requested vxlan is out of range")
}
if (reqVxlan != 0) && (reqVxlan >= g.FreeVXLANsStart) {
reqVxlan = 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
} | 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("global", resources.AutoVXLANResource,
resources.VXLANVLANPair{
VXLAN: vxlan - g.FreeVXLANsStart,
VLAN: localVLAN})
} | 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", err)
return 0, err
}
return vlan.(uint), err
} | 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. 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
} | 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 checks %s", err)
}
if res == "vlan" {
var vlanRsrcCfg *bitset.BitSet
vlanRsrcCfg, err = gc.initVLANBitset(gc.Auto.VLANs)
if err != nil {
return err
}
err = ra.RedefineResource("global", resources.AutoVLANResource, vlanRsrcCfg)
if err != nil {
log.Errorf("Error deleting vlan resource. Err: %v", err)
}
} else if res == "vxlan" {
var vxlanRsrcCfg *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: vxlanRsrcCfg.FreeVXLANsStart}
g.StateDriver = gc.StateDriver
err = g.Write()
if err != nil {
log.Errorf("error '%s' updating global oper state %v \n", err, g)
return err
}
}
return err
} | 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[0], "-")[1])
} else {
minUsed, _ = strconv.Atoi(tags[0])
maxUsed = minUsed
}
if len(inUse) > 1 {
if strings.Contains(tags[len(tags)-1], "-") {
maxUsed, _ = 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
} | 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.