id stringlengths 2 7 | text stringlengths 17 51.2k | title stringclasses 1
value |
|---|---|---|
c7900 | // Perform Create callback
err = objCallbackHandler.PolicyCb.PolicyCreate(obj)
if err != nil {
log.Errorf("PolicyCreate retruned error for: %+v. Err: %v", obj, err)
collections.policyMutex.Lock()
delete(collections.policys, obj.Key)
collections.policyMutex.Unlock()
return err
}
}
// Write it t... | |
c7901 | := collections.policys[key]
if obj == nil {
return nil
}
return obj
} | |
c7902 | }
// delete it from modeldb
collections.policyMutex.Lock()
err = obj.Delete()
collections.policyMutex.Unlock()
if err != nil {
log.Errorf("Error deleting policy %s. Err: %v", obj.Key, err)
}
// delete it from cache
collections.policyMutex.Lock()
delete(collections.policys, key)
collections.policyMutex.Un... | |
c7903 |
}
if len(obj.TenantName) > 64 {
return errors.New("tenantName string too long")
}
tenantNameMatch := regexp.MustCompile("^(([a-zA-Z0-9]|[a-zA-Z0-9][a-zA-Z0-9\\-]*[a-zA-Z0-9])\\.)*([A-Za-z0-9]|[A-Za-z0-9][A-Za-z0-9\\-]*[A-Za-z0-9])$")
if tenantNameMatch.MatchString(obj.TenantName) == false {
return errors.Ne... | |
c7904 | // Perform Create callback
err = objCallbackHandler.RuleCb.RuleCreate(obj)
if err != nil {
log.Errorf("RuleCreate retruned error for: %+v. Err: %v", obj, err)
collections.ruleMutex.Lock()
delete(collections.rules, obj.Key)
collections.ruleMutex.Unlock()
return err
}
}
// Write it to modeldb
c... | |
c7905 | collections.rules[key]
if obj == nil {
return nil
}
return obj
} | |
c7906 | }
// delete it from modeldb
collections.ruleMutex.Lock()
err = obj.Delete()
collections.ruleMutex.Unlock()
if err != nil {
log.Errorf("Error deleting rule %s. Err: %v", obj.Key, err)
}
// delete it from cache
collections.ruleMutex.Lock()
delete(collections.rules, key)
collections.ruleMutex.Unlock()
ret... | |
c7907 | regexp.MustCompile("^(([a-zA-Z0-9]|[a-zA-Z0-9][a-zA-Z0-9\\-]*[a-zA-Z0-9])\\.)*([A-Za-z0-9]|[A-Za-z0-9][A-Za-z0-9\\-]*[A-Za-z0-9])$")
if ruleIdMatch.MatchString(obj.RuleID) == false {
return errors.New("ruleId string invalid format")
}
if len(obj.TenantName) > 64 {
return errors.New("tenantName string too long"... | |
c7908 |
return errors.New("Invalid object type")
}
// Perform callback
err := objCallbackHandler.ServiceLBCb.ServiceLBGetOper(obj)
if err != nil {
log.Errorf("ServiceLBDelete retruned error for: %+v. Err: %v", obj, err)
return err
}
return nil
} | |
c7909 | // Perform Create callback
err = objCallbackHandler.ServiceLBCb.ServiceLBCreate(obj)
if err != nil {
log.Errorf("ServiceLBCreate retruned error for: %+v. Err: %v", obj, err)
collections.serviceLBMutex.Lock()
delete(collections.serviceLBs, obj.Key)
collections.serviceLBMutex.Unlock()
return err
}
... | |
c7910 | := collections.serviceLBs[key]
if obj == nil {
return nil
}
return obj
} | |
c7911 | return err
}
// delete it from modeldb
collections.serviceLBMutex.Lock()
err = obj.Delete()
collections.serviceLBMutex.Unlock()
if err != nil {
log.Errorf("Error deleting serviceLB %s. Err: %v", obj.Key, err)
}
// delete it from cache
collections.serviceLBMutex.Lock()
delete(collections.serviceLBs, key)
... | |
c7912 | > 256 {
return errors.New("serviceName string too long")
}
serviceNameMatch := regexp.MustCompile("^(([a-zA-Z0-9]|[a-zA-Z0-9][a-zA-Z0-9\\-]*[a-zA-Z0-9])\\.)*([A-Za-z0-9]|[A-Za-z0-9][A-Za-z0-9\\-]*[A-Za-z0-9])$")
if serviceNameMatch.MatchString(obj.ServiceName) == false {
return errors.New("serviceName string i... | |
c7913 |
return errors.New("Invalid object type")
}
// Perform callback
err := objCallbackHandler.TenantCb.TenantGetOper(obj)
if err != nil {
log.Errorf("TenantDelete retruned error for: %+v. Err: %v", obj, err)
return err
}
return nil
} | |
c7914 | // Perform Create callback
err = objCallbackHandler.TenantCb.TenantCreate(obj)
if err != nil {
log.Errorf("TenantCreate retruned error for: %+v. Err: %v", obj, err)
collections.tenantMutex.Lock()
delete(collections.tenants, obj.Key)
collections.tenantMutex.Unlock()
return err
}
}
// Write it t... | |
c7915 | := collections.tenants[key]
if obj == nil {
return nil
}
return obj
} | |
c7916 | }
// delete it from modeldb
collections.tenantMutex.Lock()
err = obj.Delete()
collections.tenantMutex.Unlock()
if err != nil {
log.Errorf("Error deleting tenant %s. Err: %v", obj.Key, err)
}
// delete it from cache
collections.tenantMutex.Lock()
delete(collections.tenants, key)
collections.tenantMutex.Un... | |
c7917 |
if len(obj.TenantName) > 64 {
return errors.New("tenantName string too long")
}
tenantNameMatch := regexp.MustCompile("^(([a-zA-Z0-9]|[a-zA-Z0-9][a-zA-Z0-9\\-]*[a-zA-Z0-9])\\.)*([A-Za-z0-9]|[A-Za-z0-9][A-Za-z0-9\\-]*[A-Za-z0-9])$")
if tenantNameMatch.MatchString(obj.TenantName) == false {
return errors.New("t... | |
c7918 | // Perform Create callback
err = objCallbackHandler.VolumeCb.VolumeCreate(obj)
if err != nil {
log.Errorf("VolumeCreate retruned error for: %+v. Err: %v", obj, err)
collections.volumeMutex.Lock()
delete(collections.volumes, obj.Key)
collections.volumeMutex.Unlock()
return err
}
}
// Write it t... | |
c7919 | := collections.volumes[key]
if obj == nil {
return nil
}
return obj
} | |
c7920 | }
// delete it from modeldb
collections.volumeMutex.Lock()
err = obj.Delete()
collections.volumeMutex.Unlock()
if err != nil {
log.Errorf("Error deleting volume %s. Err: %v", obj.Key, err)
}
// delete it from cache
collections.volumeMutex.Lock()
delete(collections.volumes, key)
collections.volumeMutex.Un... | |
c7921 | obj.TenantName + ":" + obj.VolumeName
if obj.Key != keyStr {
log.Errorf("Expecting Volume Key: %s. Got: %s", keyStr, obj.Key)
return errors.New("Invalid Key")
}
// Validate each field
return nil
} | |
c7922 | // Perform Create callback
err = objCallbackHandler.VolumeProfileCb.VolumeProfileCreate(obj)
if err != nil {
log.Errorf("VolumeProfileCreate retruned error for: %+v. Err: %v", obj, err)
collections.volumeProfileMutex.Lock()
delete(collections.volumeProfiles, obj.Key)
collections.volumeProfileMutex.Unl... | |
c7923 |
defer collections.volumeProfileMutex.Unlock()
obj := collections.volumeProfiles[key]
if obj == nil {
return nil
}
return obj
} | |
c7924 | return err
}
// delete it from modeldb
collections.volumeProfileMutex.Lock()
err = obj.Delete()
collections.volumeProfileMutex.Unlock()
if err != nil {
log.Errorf("Error deleting volumeProfile %s. Err: %v", obj.Key, err)
}
// delete it from cache
collections.volumeProfileMutex.Lock()
delete(collections.v... | |
c7925 | VolumeProfile Key: %s. Got: %s", keyStr, obj.Key)
return errors.New("Invalid Key")
}
// Validate each field
return nil
} | |
c7926 |
case core.Test:
// nothing to do. internal mode for testing
default:
log.Fatalf("Unknown plugin mode -- should be %s | %s | %s",
core.Docker, core.SwarmMode, core.Kubernetes)
}
// init mesos plugin
mesosplugin.InitPlugin(netPlugin)
// create a new agent
agent := &Agent{
netPlugin: netPlugin,
plug... | |
c7927 | log.Infof("Read epg key[%d] %s, populating state \n", idx, epg.GroupName)
processEpgEvent(ag.netPlugin, opts, epg.ID, false)
}
}
readServiceLb := &mastercfg.CfgServiceLBState{}
readServiceLb.StateDriver = ag.netPlugin.StateDriver
serviceLbCfgs, err := readServiceLb.ReadAll()
if err == nil {
for idx, serv... | |
c7928 |
log.Errorf("Error starting cluster run loop")
}
// start service REST requests
ag.serveRequests()
return nil
} | |
c7929 |
go handleGlobalCfgEvents(ag.netPlugin, opts, recvErr)
go handlePolicyRuleEvents(ag.netPlugin, opts, recvErr)
if ag.pluginConfig.Instance.PluginMode == core.Docker ||
ag.pluginConfig.Instance.PluginMode == core.SwarmMode {
go ag.monitorDockerEvents(recvErr)
} else if ag.pluginConfig.Instance.PluginMode == co... | |
c7930 | ns, err := ag.netPlugin.NetworkDriver.InspectNameserver()
if err != nil {
log.Errorf("Error fetching nameserver state. Err: %v", err)
http.Error(w, "Error fetching nameserver state", http.StatusInternalServerError)
return
}
w.Write(ns)
})
s = router.Methods("Delete").Subrouter()
s.HandleFunc("/debu... | |
c7931 | epID, err)
http.Error(w, fmt.Sprintf("failed to delete endpoint: %+v", epID), 0)
return nil, err
}
return nil, nil
} | |
c7932 | err)
}
// add the token header we use to authenticate
if err := cl.SetAuthToken(nc.Token); err != nil {
return fmt.Errorf("failed to set auth token: %v", err)
}
return nil
} | |
c7933 |
}
// panic if we've failed to retrieve the home directory
if homeDir == "" {
panic(errHomeDirectoryNotSet)
}
return usr.HomeDir + "/.netctl/config.json"
} | |
c7934 | errExit(ctx, exitIO, err.Error(), false)
}
// only the user should be able to read the config file
if err := ioutil.WriteFile(configPath(), data, 0600); err != nil {
errExit(ctx, exitIO, err.Error(), false)
}
} | |
c7935 | // If we do not have a host, default to unix socket
dockerHost = fmt.Sprintf("unix://%s", DefaultUnixSocket)
}
}
return dockerHost
} | |
c7936 | mc := mastercfg.CfgServiceLBState{
Tenant: tenant,
ServiceName: name,
IPAddress: v4name,
}
ens.addService(&mc)
}
}
} | |
c7937 | == K8sDefaultTenant {
ens.k8sService.Remove(name)
} else {
mc := mastercfg.CfgServiceLBState{
Tenant: tenant,
ServiceName: name,
}
ens.delService(&mc)
}
} | |
c7938 | `json:"endpointQueue"`
Dtbl map[string]map[string]map[string][]string `json:"dnsRecords"`
Stats map[string]map[string]uint64 `json:"stats"`
}{SvcChan: len(ens.svcChan), EpChan: len(ens.epChan),
Dtbl: ens.inspectNameRecord(), Stats: ens.inspectStats()}
return &s, nil
} | |
c7939 | "invalidQuery")
return nil, errors.New("")
}
if req.IsTsig() != nil {
ens.incTenantStats(tenant, "invalidQuery")
return nil, errors.New("")
}
d, err := ens.serveNameRecord(tenant, req)
if err != nil {
logrus.Infof("no name record: %s", err)
ens.incTenantStats(tenant, "noNameRecord")
return nil, err
... | |
c7940 | = make([]tenantBucket, ens.bucketSize)
ens.k8sService = cmap.New()
for i := uint(0); i < ens.bucketSize; i++ {
ens.buckets[i].tenantTables = make(map[string]*dnsTables)
ens.stats.tenantStats = make(map[string]map[string]uint64)
}
ens.epKeyPath = mastercfg.StateConfigPath + "eps/"
ens.svcKeyPath = mastercfg.S... | |
c7941 | = bgpCfg.RouterIP
bgpState.As = bgpCfg.As
bgpState.NeighborAs = bgpCfg.NeighborAs
bgpState.Neighbor = bgpCfg.Neighbor
bgpState.StateDriver = stateDriver
bgpState.ID = bgpCfg.Hostname
return bgpState.Write()
} | |
c7942 | %s", hostname)
return err
}
err = bgpState.Clear()
if err != nil {
log.Errorf("Error deleing Bgp config for hostname %s", hostname)
return err
}
return nil
} | |
c7943 | ep.kapi,
eventChan: make(chan LockEvent, 1),
stopChan: make(chan bool, 1),
watchCh: make(chan *client.Response, 1),
watchCtx: watchCtx,
watchCancel: watchCancel,
mutex: new(sync.Mutex),
}, nil
} | |
c7944 | }
lk.mutex.Unlock()
case watchResp := <-lk.watchCh:
if watchResp != nil {
log.Debugf("Received watch notification(%s/%s): %+v", lk.name, lk.myID, watchResp)
if watchResp.Action == "expire" || watchResp.Action == "delete" ||
watchResp.Action == "compareAndDelete" {
log.Infof("Retrying to acqu... | |
c7945 | key %s, Err %v.", keyName, err)
} else {
log.Debugf("Got Watch Resp: %+v", resp)
// send the event to watch channel
lk.watchCh <- resp
}
lk.mutex.Lock()
// If the lock is released, we are done
if lk.isReleased {
lk.mutex.Unlock()
return
}
lk.mutex.Unlock()
}
} | |
c7946 | driver := reflect.New(driverType).Interface()
return driver, nil
}
return nil, core.Errorf("Failed to find a registered driver for: %s", driverName)
} | |
c7947 | initHelper(stateDriverRegistry, name)
if err != nil {
return nil, err
}
d := driver.(core.StateDriver)
err = d.Init(instInfo)
if err != nil {
return nil, err
}
gStateDriver = d
return d, nil
} | |
c7948 | nil {
return nil, core.Errorf("statedriver has not been not created.")
}
return gStateDriver, nil
} | |
c7949 | {
return nil, err
}
d := driver.(core.NetworkDriver)
err = d.Init(instInfo)
if err != nil {
return nil, err
}
return d, nil
} | |
c7950 | Usage: fmt.Sprintf("set %s forwarding network mode, options: [bridge, routing]", binLower),
},
/*
// only ovs is supported
// TODO: turn it on when having more than one backend supported
cli.StringFlag {
Name: "driver, net-driver",
Value: "ovs",
EnvVar: "CONTIV_NETPLUGIN_DRIVER",
Usage: ... | |
c7951 | "use-syslog, syslog",
EnvVar: fmt.Sprintf("CONTIV_%s_USE_SYSLOG", binUpper),
Usage: fmt.Sprintf("set %s send log to syslog if this flag is provided", binLower),
},
cli.StringFlag{
Name: "syslog-url",
Value: "udp://127.0.0.1:514",
EnvVar: fmt.Sprintf("CONTIV_%s_SYSLOG_URL", binUpper),
Usage: ... | |
c7952 | }
if ctx.Bool("use-json-log") {
logrus.SetFormatter(&logrus.JSONFormatter{})
logrus.Infof("Using %v log format: json", binary)
} else {
logrus.SetFormatter(&logrus.TextFormatter{FullTimestamp: true, TimestampFormat: time.StampNano})
logrus.Infof("Using %v log format: text", binary)
}
return nil
} | |
c7953 | %v endpoint: %v", binary, storeDriver, endpoint)
}
// TODO: support multi-endpoints
storeURL = endpoint
logrus.Infof("Using %s state db endpoints: %v: %v", binary, storeDriver, storeURL)
break
}
if storeURL == "" {
return nil, fmt.Errorf("invalid %s %s endpoints: empty", binary, storeDriver)
}
return... | |
c7954 |
return nil, fmt.Errorf("%s forwarding mode is not set", binary)
} else if networkMode == "vxlan" && forwardMode == "bridge" {
return nil, fmt.Errorf("invalid %s forwarding mode: %q (network mode: %q)", binary, forwardMode, networkMode)
}
// vxlan/vlan+routing, vlan+bridge are valid combinations
logrus.Infof("U... | |
c7955 |
flags = append(flags, slice...)
}
return flags
} | |
c7956 | _, str := range stringSlice {
if str != "" {
result = append(result, str)
}
}
return result
} | |
c7957 | if strings.Contains(strOutput, "Ubuntu") {
SysAttrs.OsType = "ubuntu"
} else {
SysAttrs.OsType = "unsupported"
}
// fetch the system memory, disk, and other attributes
return err
} | |
c7958 |
// Flush any old rules we might have added. They will get re-added
// if the service is still active
osexec.Command(ipTablesPath, "-w", iptablesWaitLock, "-t", "nat", "-F",
contivNPChain).CombinedOutput()
proxy := NodeSvcProxy{}
proxy.SvcMap = make(map[string]core.ServiceSpec)
proxy.ProvMap = make(map[string... | |
c7959 | p.Mutex.Lock()
defer p.Mutex.Unlock()
delete(p.LocalIP, globalIP)
} | |
c7960 | "/")[0]
localIP = strings.Split(localIP, "/")[0]
p.Mutex.Lock()
defer p.Mutex.Unlock()
p.LocalIP[globalIP] = localIP
} | |
c7961 | return nil
}
}
}
if !isNodeSvc {
p.deleteSvc(svcName) // delete it if it exists
return nil
}
p.SvcMap[svcName] = *spec
p.syncSvc(svcName)
return nil
} | |
c7962 | error {
p.Mutex.Lock()
defer p.Mutex.Unlock()
p.deleteSvc(svcName) // delete it if it exists
return nil
} | |
c7963 | typed
bytePassword, err := terminal.ReadPassword(0) // fd 0 = stdin
if err != nil {
errExit(ctx, exitIO, err.Error(), false)
}
password := string(bytePassword)
fmt.Println("")
return username, password
} | |
c7964 | format", true)
}
if routerip == "" || asid == "" || neighbor == "" || neighboras == "" {
errExit(ctx, exitHelp, "Missing attributes", true)
}
errCheck(ctx, getClient(ctx).BgpPost(&contivClient.Bgp{
As: asid,
Hostname: hostname,
Neighbor: neighbor,
NeighborAs: neighboras,
Routerip: route... | |
c7965 | fmt.Printf("Deleting Bgp router config: %s\n", hostname)
errCheck(ctx, getClient(ctx).BgpDelete(hostname))
} | |
c7966 |
}
os.Stdout.WriteString(bgpName)
} else {
writer := tabwriter.NewWriter(os.Stdout, 0, 2, 2, ' ', 0)
defer writer.Flush()
writer.Write([]byte("HostName\tRouterIP\tAS\tNeighbor\tNeighborAS\n"))
writer.Write([]byte("---------\t--------\t-------\t--------\t-------\n"))
for _, group := range *bgpList {
wr... | |
c7967 | := ctx.StringSlice("port")
ipAddress := ctx.String("preferred-ip")
service := &contivClient.ServiceLB{
ServiceName: serviceName,
TenantName: tenantName,
NetworkName: serviceSubnet,
IpAddress: ipAddress,
}
service.Selectors = append(service.Selectors, selectors...)
service.Ports = append(service.Ports, ... | |
c7968 | fmt.Printf("Deleting Service %s,%s\n", serviceName, tenantName)
errCheck(ctx, getClient(ctx).ServiceLBDelete(tenantName, serviceName))
} | |
c7969 | }
}
}
if ctx.Bool("json") {
dumpJSONList(ctx, filtered)
} else if ctx.Bool("quiet") {
services := ""
for _, service := range filtered {
services += service.ServiceName + "\n"
}
os.Stdout.WriteString(services)
} else {
writer := tabwriter.NewWriter(os.Stdout, 0, 2, 2, ' ', 0)
defer writer.Flush... | |
c7970 | err := cp.getServiceInstances(keyName, 0)
return srvList, err
} | |
c7971 | strconv.Itoa(srvInfo.Port)
// If the entry didnt exists previously, trigger add event
if _, ok := currSrvMap[srvKey]; !ok {
log.Debugf("Sending add event for srv: %v", srvInfo)
eventCh <- WatchServiceEvent{
EventType: WatchServiceEventAdd,
ServiceInfo: srvInfo,
}
... | |
c7972 |
close(srvState.stopChan)
delete(cp.serviceDb, keyName)
// Delete the service instance
_, err := cp.client.KV().Delete(keyName, nil)
if err != nil {
log.Errorf("Error deleting key %s. Err: %v", keyName, err)
return err
}
return nil
} | |
c7973 |
}
// Parse each node in the directory
for _, kv := range kvs {
var respSrvc ServiceInfo
// Parse JSON response
err = json.Unmarshal([]byte(kv.Value), &respSrvc)
if err != nil {
log.Errorf("Error parsing object %+v, Err %v", kv, err)
return nil, 0, err
}
srvcList = append(srvcList, respSrvc)
}
... | |
c7974 |
return aErr
}
if aciMode {
if epgCfg.PktTagType == "vlan" {
err = gCfg.FreeVLAN(uint(epgCfg.PktTag))
if err != nil {
return err
}
log.Debugf("Freed vlan %v\n", epgCfg.PktTag)
}
}
// mark it as unused
if len(epgCfg.IPPool) > 0 {
netutils.ClearIPAddrRange(&nwCfg.IPAllocMap, epgCfg.IPPool, ... | |
c7975 | != nil {
log.Errorf("Error finding endpointgroup %s. Err: %v", key, err)
return err
}
//update the epGroup state
epCfg.DSCP = Dscp
epCfg.Bandwidth = bandwidth
epCfg.Burst = burst
//Write to etcd
return epCfg.Write()
} | |
c7976 | provider list
svcProvider.Providers = append(svcProvider.Providers, providerList...)
svcProvider.ServiceName = serviceID
svcProvider.ID = serviceID
log.Infof("Updating service providers with {%v} on service %s", svcProvider.Providers, serviceID)
return svcProvider.Write()
} | |
c7977 | strings.Contains(err.Error(), "key not found") {
return nil
}
return err
} | |
c7978 | {
return r.StateDriver.ReadAllState(vLANResourceConfigPathPrefix, r,
json.Unmarshal)
} | |
c7979 | false
vlan, ok = oper.FreeVLANs.NextSet(0)
if !ok {
return nil, errors.New("no vlans available")
}
}
oper.FreeVLANs.Clear(vlan)
err = oper.Write()
if err != nil {
return nil, err
}
return vlan, nil
} | |
c7980 |
if !ok {
return core.Errorf("Invalid type for vlan value")
}
if oper.FreeVLANs.Test(vlan) {
return nil
}
oper.FreeVLANs.Set(vlan)
return oper.Write()
} | |
c7981 | {
return r.StateDriver.ReadAllState(vLANResourceOperPathPrefix, r,
json.Unmarshal)
} | |
c7982 | }
d.HostProxy.DeleteLocalIP(operEp.IPAddress)
portName := operEp.PortName
intfName := netutils.GetHostIntfName(portName)
return sw.DelHostPort(intfName, false)
}
return errors.New("host bridge not found")
} | |
c7983 | intfNum, err := strconv.Atoi(num)
if err != nil {
return "", err
}
hostIP, err := sw.AddHostPort(portName, intfNum, net, false)
if err == nil {
d.HostProxy.AddLocalIP(globalIP, hostIP)
return hostIP, nil
}
}
return "", errors.New("host bridge not found")
} | |
c7984 |
}
if d.switchDb["vxlan"] != nil {
d.switchDb["vxlan"].DelHostPort(hostPortName, true)
d.switchDb["vxlan"].Delete()
}
} | |
c7985 | d.switchDb["vxlan"]
} else {
sw = d.switchDb["vlan"]
}
return sw.CreateNetwork(uint16(cfgNw.PktTag), uint32(cfgNw.ExtPktTag), cfgNw.Gateway, cfgNw.Tenant)
} | |
c7986 | + hostName
epOper := drivers.OperEndpointState{}
epOper.StateDriver = d.oper.StateDriver
err := epOper.Read(epID)
if err == nil {
err = sw.DeletePort(&epOper, true)
if err != nil {
log.Errorf("Error deleting endpoint: %+v. Err: %v", epOper, err)
}
epOper.Clear()
}
}
return sw.DeleteNetwor... | |
c7987 | %s ", cfgEpGroup.Bandwidth, epInfo.Ovsportname)
// Find the switch based on network type
if epInfo.BridgeType == "vxlan" {
sw = d.switchDb["vxlan"]
} else {
sw = d.switchDb["vlan"]
}
// update the endpoint in ovs switch
err = sw.UpdateEndpoint(epInfo.Ovsportname, cfgEpGroup.Burst, cf... | |
c7988 | d.switchDb["vxlan"]
} else {
sw = d.switchDb["vlan"]
}
skipVethPair := (cfgNw.NwType == "infra")
err = sw.DeletePort(&epOper, skipVethPair)
if err != nil {
log.Errorf("Error deleting endpoint: %+v. Err: %v", epOper, err)
}
d.oper.localEpInfoMutex.Lock()
delete(d.oper.LocalEpInfo, id)
d.oper.localEpInfoM... | |
c7989 | d.switchDb["vxlan"].CreateVtep(node.HostAddr)
if err != nil {
log.Errorf("Error adding the VTEP %s. Err: %s", node.HostAddr, err)
return err
}
return nil
} | |
c7990 | d.switchDb["vxlan"].DeleteVtep(node.HostAddr)
if err != nil {
log.Errorf("Error deleting the VTEP %s. Err: %s", node.HostAddr, err)
return err
}
return nil
} | |
c7991 |
// Find the switch based on network type
sw = d.switchDb["vlan"]
return sw.AddBgp(cfg.Hostname, cfg.RouterIP, cfg.As, cfg.NeighborAs, cfg.Neighbor)
} | |
c7992 | oper state for Bgp
//Need to Revisit again
// Find the switch based on network type
var sw *OvsSwitch
sw = d.switchDb["vlan"]
return sw.DeleteBgp()
} | |
c7993 |
pSpec[ix].Protocol = p.Protocol
pSpec[ix].SvcPort = p.SvcPort
pSpec[ix].ProvPort = p.ProvPort
}
ofnetSS := ofnet.ServiceSpec{
IpAddress: spec.IPAddress,
Ports: pSpec,
}
return &ofnetSS
} | |
c7994 | {
errs += err.Error()
}
if errs != "" {
return errors.New(errs)
}
d.nameServer.AddLbService(nameserver.K8sDefaultTenant, svcName, spec.IPAddress)
return nil
} | |
c7995 | if err != nil {
errs += err.Error()
}
}
err := d.HostProxy.DelSvcSpec(svcName, spec)
if err != nil {
errs += err.Error()
}
if errs != "" {
return errors.New(errs)
}
d.nameServer.DelLbService(nameserver.K8sDefaultTenant, svcName)
return nil
} | |
c7996 |
vlanStats[key] = val
}
jsonStats, err := json.Marshal(vlanStats)
if err != nil {
log.Errorf("Error encoding epstats. Err: %v", err)
return jsonStats, err
}
return jsonStats, nil
} | |
c7997 | d.switchDb["vxlan"].InspectState()
if err != nil {
return []byte{}, err
}
// build the map
driverState["vlan"] = vlanState
driverState["vxlan"] = vxlanState
// json marshall the map
jsonState, err := json.Marshal(driverState)
if err != nil {
log.Errorf("Error encoding epstats. Err: %v", err)
return []b... | |
c7998 | json.Marshal(bgpState)
if err != nil {
log.Errorf("Error encoding epstats. Err: %v", err)
return []byte{}, err
}
return jsonState, nil
} | |
c7999 | cfg.ArpMode = ofnet.ArpFlood
default:
// set the default to proxy for graceful upgrade
cfg.ArpMode = ofnet.ArpProxy
}
errs := ""
for _, sw := range d.switchDb {
err := sw.GlobalConfigUpdate(cfg)
if err != nil {
errs += err.Error()
}
}
if errs != "" {
return errors.New(errs)
}
return nil
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.