_id stringlengths 2 7 | title stringlengths 1 118 | partition stringclasses 3
values | text stringlengths 52 85.5k | language stringclasses 1
value | meta_information dict |
|---|---|---|---|---|---|
q7900 | CreatePolicy | train | func CreatePolicy(obj *Policy) error {
// Validate parameters
err := ValidatePolicy(obj)
if err != nil {
log.Errorf("ValidatePolicy retruned error for: %+v. Err: %v", obj, err)
return err
}
// Check if we handle this object
if objCallbackHandler.PolicyCb == nil {
log.Errorf("No callback registered for poli... | go | {
"resource": ""
} |
q7901 | FindPolicy | train | func FindPolicy(key string) *Policy {
collections.policyMutex.Lock()
defer collections.policyMutex.Unlock()
obj := collections.policys[key]
if obj == nil {
return nil
}
return obj
} | go | {
"resource": ""
} |
q7902 | DeletePolicy | train | func DeletePolicy(key string) error {
collections.policyMutex.Lock()
obj := collections.policys[key]
collections.policyMutex.Unlock()
if obj == nil {
log.Errorf("policy %s not found", key)
return errors.New("policy not found")
}
// Check if we handle this object
if objCallbackHandler.PolicyCb == nil {
log... | go | {
"resource": ""
} |
q7903 | ValidatePolicy | train | func ValidatePolicy(obj *Policy) error {
collections.policyMutex.Lock()
defer collections.policyMutex.Unlock()
// Validate key is correct
keyStr := obj.TenantName + ":" + obj.PolicyName
if obj.Key != keyStr {
log.Errorf("Expecting Policy Key: %s. Got: %s", keyStr, obj.Key)
return errors.New("Invalid Key")
}
... | go | {
"resource": ""
} |
q7904 | CreateRule | train | func CreateRule(obj *Rule) error {
// Validate parameters
err := ValidateRule(obj)
if err != nil {
log.Errorf("ValidateRule retruned error for: %+v. Err: %v", obj, err)
return err
}
// Check if we handle this object
if objCallbackHandler.RuleCb == nil {
log.Errorf("No callback registered for rule object")
... | go | {
"resource": ""
} |
q7905 | FindRule | train | func FindRule(key string) *Rule {
collections.ruleMutex.Lock()
defer collections.ruleMutex.Unlock()
obj := collections.rules[key]
if obj == nil {
return nil
}
return obj
} | go | {
"resource": ""
} |
q7906 | DeleteRule | train | func DeleteRule(key string) error {
collections.ruleMutex.Lock()
obj := collections.rules[key]
collections.ruleMutex.Unlock()
if obj == nil {
log.Errorf("rule %s not found", key)
return errors.New("rule not found")
}
// Check if we handle this object
if objCallbackHandler.RuleCb == nil {
log.Errorf("No ca... | go | {
"resource": ""
} |
q7907 | ValidateRule | train | func ValidateRule(obj *Rule) error {
collections.ruleMutex.Lock()
defer collections.ruleMutex.Unlock()
// Validate key is correct
keyStr := obj.TenantName + ":" + obj.PolicyName + ":" + obj.RuleID
if obj.Key != keyStr {
log.Errorf("Expecting Rule Key: %s. Got: %s", keyStr, obj.Key)
return errors.New("Invalid ... | go | {
"resource": ""
} |
q7908 | GetOperServiceLB | train | func GetOperServiceLB(obj *ServiceLBInspect) error {
// Check if we handle this object
if objCallbackHandler.ServiceLBCb == nil {
log.Errorf("No callback registered for serviceLB object")
return errors.New("Invalid object type")
}
// Perform callback
err := objCallbackHandler.ServiceLBCb.ServiceLBGetOper(obj)... | go | {
"resource": ""
} |
q7909 | CreateServiceLB | train | func CreateServiceLB(obj *ServiceLB) error {
// Validate parameters
err := ValidateServiceLB(obj)
if err != nil {
log.Errorf("ValidateServiceLB retruned error for: %+v. Err: %v", obj, err)
return err
}
// Check if we handle this object
if objCallbackHandler.ServiceLBCb == nil {
log.Errorf("No callback regi... | go | {
"resource": ""
} |
q7910 | FindServiceLB | train | func FindServiceLB(key string) *ServiceLB {
collections.serviceLBMutex.Lock()
defer collections.serviceLBMutex.Unlock()
obj := collections.serviceLBs[key]
if obj == nil {
return nil
}
return obj
} | go | {
"resource": ""
} |
q7911 | DeleteServiceLB | train | func DeleteServiceLB(key string) error {
collections.serviceLBMutex.Lock()
obj := collections.serviceLBs[key]
collections.serviceLBMutex.Unlock()
if obj == nil {
log.Errorf("serviceLB %s not found", key)
return errors.New("serviceLB not found")
}
// Check if we handle this object
if objCallbackHandler.Servi... | go | {
"resource": ""
} |
q7912 | ValidateServiceLB | train | func ValidateServiceLB(obj *ServiceLB) error {
collections.serviceLBMutex.Lock()
defer collections.serviceLBMutex.Unlock()
// Validate key is correct
keyStr := obj.TenantName + ":" + obj.ServiceName
if obj.Key != keyStr {
log.Errorf("Expecting ServiceLB Key: %s. Got: %s", keyStr, obj.Key)
return errors.New("I... | go | {
"resource": ""
} |
q7913 | GetOperTenant | train | func GetOperTenant(obj *TenantInspect) error {
// Check if we handle this object
if objCallbackHandler.TenantCb == nil {
log.Errorf("No callback registered for tenant object")
return errors.New("Invalid object type")
}
// Perform callback
err := objCallbackHandler.TenantCb.TenantGetOper(obj)
if err != nil {
... | go | {
"resource": ""
} |
q7914 | CreateTenant | train | func CreateTenant(obj *Tenant) error {
// Validate parameters
err := ValidateTenant(obj)
if err != nil {
log.Errorf("ValidateTenant retruned error for: %+v. Err: %v", obj, err)
return err
}
// Check if we handle this object
if objCallbackHandler.TenantCb == nil {
log.Errorf("No callback registered for tena... | go | {
"resource": ""
} |
q7915 | FindTenant | train | func FindTenant(key string) *Tenant {
collections.tenantMutex.Lock()
defer collections.tenantMutex.Unlock()
obj := collections.tenants[key]
if obj == nil {
return nil
}
return obj
} | go | {
"resource": ""
} |
q7916 | DeleteTenant | train | func DeleteTenant(key string) error {
collections.tenantMutex.Lock()
obj := collections.tenants[key]
collections.tenantMutex.Unlock()
if obj == nil {
log.Errorf("tenant %s not found", key)
return errors.New("tenant not found")
}
// Check if we handle this object
if objCallbackHandler.TenantCb == nil {
log... | go | {
"resource": ""
} |
q7917 | ValidateTenant | train | func ValidateTenant(obj *Tenant) error {
collections.tenantMutex.Lock()
defer collections.tenantMutex.Unlock()
// Validate key is correct
keyStr := obj.TenantName
if obj.Key != keyStr {
log.Errorf("Expecting Tenant Key: %s. Got: %s", keyStr, obj.Key)
return errors.New("Invalid Key")
}
// Validate each fiel... | go | {
"resource": ""
} |
q7918 | CreateVolume | train | func CreateVolume(obj *Volume) error {
// Validate parameters
err := ValidateVolume(obj)
if err != nil {
log.Errorf("ValidateVolume retruned error for: %+v. Err: %v", obj, err)
return err
}
// Check if we handle this object
if objCallbackHandler.VolumeCb == nil {
log.Errorf("No callback registered for volu... | go | {
"resource": ""
} |
q7919 | FindVolume | train | func FindVolume(key string) *Volume {
collections.volumeMutex.Lock()
defer collections.volumeMutex.Unlock()
obj := collections.volumes[key]
if obj == nil {
return nil
}
return obj
} | go | {
"resource": ""
} |
q7920 | DeleteVolume | train | func DeleteVolume(key string) error {
collections.volumeMutex.Lock()
obj := collections.volumes[key]
collections.volumeMutex.Unlock()
if obj == nil {
log.Errorf("volume %s not found", key)
return errors.New("volume not found")
}
// Check if we handle this object
if objCallbackHandler.VolumeCb == nil {
log... | go | {
"resource": ""
} |
q7921 | ValidateVolume | train | func ValidateVolume(obj *Volume) error {
collections.volumeMutex.Lock()
defer collections.volumeMutex.Unlock()
// Validate key is correct
keyStr := obj.TenantName + ":" + obj.VolumeName
if obj.Key != keyStr {
log.Errorf("Expecting Volume Key: %s. Got: %s", keyStr, obj.Key)
return errors.New("Invalid Key")
}
... | go | {
"resource": ""
} |
q7922 | CreateVolumeProfile | train | func CreateVolumeProfile(obj *VolumeProfile) error {
// Validate parameters
err := ValidateVolumeProfile(obj)
if err != nil {
log.Errorf("ValidateVolumeProfile retruned error for: %+v. Err: %v", obj, err)
return err
}
// Check if we handle this object
if objCallbackHandler.VolumeProfileCb == nil {
log.Erro... | go | {
"resource": ""
} |
q7923 | FindVolumeProfile | train | func FindVolumeProfile(key string) *VolumeProfile {
collections.volumeProfileMutex.Lock()
defer collections.volumeProfileMutex.Unlock()
obj := collections.volumeProfiles[key]
if obj == nil {
return nil
}
return obj
} | go | {
"resource": ""
} |
q7924 | DeleteVolumeProfile | train | func DeleteVolumeProfile(key string) error {
collections.volumeProfileMutex.Lock()
obj := collections.volumeProfiles[key]
collections.volumeProfileMutex.Unlock()
if obj == nil {
log.Errorf("volumeProfile %s not found", key)
return errors.New("volumeProfile not found")
}
// Check if we handle this object
if ... | go | {
"resource": ""
} |
q7925 | ValidateVolumeProfile | train | func ValidateVolumeProfile(obj *VolumeProfile) error {
collections.volumeProfileMutex.Lock()
defer collections.volumeProfileMutex.Unlock()
// Validate key is correct
keyStr := obj.TenantName + ":" + obj.VolumeProfileName
if obj.Key != keyStr {
log.Errorf("Expecting VolumeProfile Key: %s. Got: %s", keyStr, obj.K... | go | {
"resource": ""
} |
q7926 | NewAgent | train | func NewAgent(pluginConfig *plugin.Config) *Agent {
opts := pluginConfig.Instance
netPlugin := &plugin.NetPlugin{}
// init cluster state
err := cluster.Init(pluginConfig.Drivers.State, []string{opts.DbURL})
if err != nil {
log.Fatalf("Error initializing cluster. Err: %v", err)
}
// Init the driver plugins..
... | go | {
"resource": ""
} |
q7927 | ProcessCurrentState | train | func (ag *Agent) ProcessCurrentState() error {
opts := ag.pluginConfig.Instance
readNet := &mastercfg.CfgNetworkState{}
readNet.StateDriver = ag.netPlugin.StateDriver
netCfgs, err := readNet.ReadAll()
if err == nil {
for idx, netCfg := range netCfgs {
net := netCfg.(*mastercfg.CfgNetworkState)
log.Debugf("... | go | {
"resource": ""
} |
q7928 | PostInit | train | func (ag *Agent) PostInit() error {
opts := ag.pluginConfig.Instance
// Initialize clustering
err := cluster.RunLoop(ag.netPlugin, opts.CtrlIP, opts.VtepIP, opts.HostLabel)
if err != nil {
log.Errorf("Error starting cluster run loop")
}
// start service REST requests
ag.serveRequests()
return nil
} | go | {
"resource": ""
} |
q7929 | HandleEvents | train | func (ag *Agent) HandleEvents() error {
opts := ag.pluginConfig.Instance
recvErr := make(chan error, 1)
go handleNetworkEvents(ag.netPlugin, opts, recvErr)
go handleBgpEvents(ag.netPlugin, opts, recvErr)
go handleEndpointEvents(ag.netPlugin, opts, recvErr)
go handleEpgEvents(ag.netPlugin, opts, recvErr)
go ... | go | {
"resource": ""
} |
q7930 | serveRequests | train | func (ag *Agent) serveRequests() {
listenURL := ":9090"
router := mux.NewRouter()
// Add REST routes
s := router.Methods("GET").Subrouter()
s.HandleFunc("/svcstats", func(w http.ResponseWriter, r *http.Request) {
stats, err := ag.netPlugin.GetEndpointStats()
if err != nil {
log.Errorf("Error fetching stats... | go | {
"resource": ""
} |
q7931 | ReclaimEndpointHandler | train | func (ag *Agent) ReclaimEndpointHandler(w http.ResponseWriter, r *http.Request, vars map[string]string) (interface{}, error) {
epID := vars["id"]
// delete the endpoint
err := ag.netPlugin.DeleteEndpoint(epID)
if err != nil {
log.Errorf("Error deleting endpoint %v. Err: %v", epID, err)
http.Error(w, fmt.Sprintf... | go | {
"resource": ""
} |
q7932 | applyConfig | train | func applyConfig(cl *contivClient.ContivClient) error {
data, err := ioutil.ReadFile(configPath())
if err != nil {
return fmt.Errorf("failed to read config file: %v", err)
}
nc := Config{}
if err := json.Unmarshal(data, &nc); err != nil {
return fmt.Errorf("failed to unmarshal JSON: %v", err)
}
// add the ... | go | {
"resource": ""
} |
q7933 | configPath | train | func configPath() string {
var homeDir string
// this fails for static binaries
usr, err := user.Current()
if err == nil {
homeDir = usr.HomeDir
}
// this should work where we don't have static binaries
if err != nil {
homeDir = os.Getenv("HOME")
}
// panic if we've failed to retrieve the home directory
i... | go | {
"resource": ""
} |
q7934 | writeConfig | train | func writeConfig(ctx *cli.Context, data []byte) {
dir := filepath.Dir(configPath())
// try to create the netctl config directory but ignore "already exists" errors.
// only the user should be able to read the contents of this directory
if err := os.Mkdir(dir, 0700); err != nil && !os.IsExist(err) {
errExit(ctx, ... | go | {
"resource": ""
} |
q7935 | getDockerHost | train | func getDockerHost() string {
dockerHost := os.Getenv("DOCKER_HOST")
if dockerHost == "" {
if runtime.GOOS == "windows" {
// If we do not have a host, default to TCP socket on Windows
dockerHost = fmt.Sprintf("tcp://%s:%d", DefaultHTTPHost, DefaultHTTPPort)
} else {
// If we do not have a host, default t... | go | {
"resource": ""
} |
q7936 | AddLbService | train | func (ens *NetpluginNameServer) AddLbService(tenant string, name string, v4name string) {
if len(v4name) > 0 {
dnsLog.Infof("add k8s service %s ip %s", name, v4name)
if tenant == K8sDefaultTenant {
ens.k8sService.Set(name, nameRecord{v4Record: net.ParseIP(v4name)})
} else {
mc := mastercfg.CfgServiceLBStat... | go | {
"resource": ""
} |
q7937 | DelLbService | train | func (ens *NetpluginNameServer) DelLbService(tenant string, name string) {
dnsLog.Infof("delete k8s service %s ", name)
if tenant == K8sDefaultTenant {
ens.k8sService.Remove(name)
} else {
mc := mastercfg.CfgServiceLBState{
Tenant: tenant,
ServiceName: name,
}
ens.delService(&mc)
}
} | go | {
"resource": ""
} |
q7938 | InspectState | train | func (ens *NetpluginNameServer) InspectState() (interface{}, error) {
s := struct {
SvcChan int `json:"serviceQueue"`
EpChan int `json:"endpointQueue"`
Dtbl map[string]map[string]map[string][]string `json:"dnsRecords"`
Stats map... | go | {
"resource": ""
} |
q7939 | NsLookup | train | func (ens *NetpluginNameServer) NsLookup(nsq []byte, vrfPtr *string) ([]byte, error) {
tenant := *vrfPtr
req := new(dns.Msg)
err := req.Unpack(nsq)
if err != nil {
ens.incTenantStats(tenant, "invalidQuery")
return nil, err
}
// no fancy requests
if req.Response {
ens.incTenantStats(tenant, "invalidQuery")... | go | {
"resource": ""
} |
q7940 | Init | train | func (ens *NetpluginNameServer) Init(sd core.StateDriver) error {
dnsLog = logrus.WithField("module", "nameserver")
ens.bucketSize = 64
ens.stateDriver = sd
// don't change buffering
ens.epChan = make(chan core.WatchState, 64)
ens.epErrChan = make(chan error)
ens.svcChan = make(chan core.WatchState, 8)
ens.svc... | go | {
"resource": ""
} |
q7941 | AddBgp | train | func AddBgp(stateDriver core.StateDriver, bgpCfg *intent.ConfigBgp) error {
log.Infof("Adding bgp neighbor {%v}", bgpCfg)
aci, _ := IsAciConfigured()
if aci {
log.Errorf("Invalid configuration. Not supported in ACI fabric mode.")
return errors.New("not supported in ACI fabric mode")
}
bgpState := &mastercfg.C... | go | {
"resource": ""
} |
q7942 | DeleteBgp | train | func DeleteBgp(stateDriver core.StateDriver, hostname string) error {
log.Infof("Deleting bgp neighbor for {%v}", hostname)
bgpState := &mastercfg.CfgBgpState{}
bgpState.StateDriver = stateDriver
err := bgpState.Read(hostname)
if err != nil {
log.Errorf("Error reading bgp config for hostname %s", hostname)
ret... | go | {
"resource": ""
} |
q7943 | NewLock | train | func (ep *EtcdClient) NewLock(name string, myID string, ttl uint64) (LockInterface, error) {
watchCtx, watchCancel := context.WithCancel(context.Background())
// Create a lock
return &etcdLock{
name: name,
myID: myID,
ttl: time.Duration(ttl) * time.Second,
kapi: ep.kapi,
eventC... | go | {
"resource": ""
} |
q7944 | waitForLock | train | func (lk *etcdLock) waitForLock() {
// If timeout is not specified, set it to high value
timeoutIntvl := time.Second * time.Duration(20000)
if lk.timeout != 0 {
timeoutIntvl = time.Second * time.Duration(lk.timeout)
}
log.Infof("Waiting to acquire lock (%s/%s)", lk.name, lk.myID)
// Create a timer
timer := t... | go | {
"resource": ""
} |
q7945 | watchLock | train | func (lk *etcdLock) watchLock() {
keyName := "/contiv.io/lock/" + lk.name
watcher := lk.kapi.Watcher(keyName, nil)
if watcher == nil {
log.Errorf("Error creating the watcher")
return
}
for {
resp, err := watcher.Next(lk.watchCtx)
if err != nil && (err.Error() == client.ErrClusterUnavailable.Error() ||
... | go | {
"resource": ""
} |
q7946 | initHelper | train | func initHelper(driverRegistry map[string]driverConfigTypes, driverName string) (core.Driver, error) {
if _, ok := driverRegistry[driverName]; ok {
driverType := driverRegistry[driverName].DriverType
driver := reflect.New(driverType).Interface()
return driver, nil
}
return nil, core.Errorf("Failed to find a ... | go | {
"resource": ""
} |
q7947 | NewStateDriver | train | func NewStateDriver(name string, instInfo *core.InstanceInfo) (core.StateDriver, error) {
if name == "" || instInfo == nil {
return nil, core.Errorf("invalid driver name or configuration passed.")
}
if gStateDriver != nil {
return nil, core.Errorf("statedriver instance already exists.")
}
driver, err := init... | go | {
"resource": ""
} |
q7948 | GetStateDriver | train | func GetStateDriver() (core.StateDriver, error) {
if gStateDriver == nil {
return nil, core.Errorf("statedriver has not been not created.")
}
return gStateDriver, nil
} | go | {
"resource": ""
} |
q7949 | NewNetworkDriver | train | func NewNetworkDriver(name string, instInfo *core.InstanceInfo) (core.NetworkDriver, error) {
if name == "" || instInfo == nil {
return nil, core.Errorf("invalid driver name or configuration passed.")
}
driver, err := initHelper(networkDriverRegistry, name)
if err != nil {
return nil, err
}
d := driver.(cor... | go | {
"resource": ""
} |
q7950 | BuildNetworkFlags | train | func BuildNetworkFlags(binary string) []cli.Flag {
binUpper := strings.ToUpper(binary)
binLower := strings.ToLower(binary)
return []cli.Flag{
cli.StringFlag{
Name: "mode, plugin-mode, cluster-mode",
EnvVar: fmt.Sprintf("CONTIV_%s_MODE", binUpper),
Usage: fmt.Sprintf("set %s mode, options: [docker, kube... | go | {
"resource": ""
} |
q7951 | BuildLogFlags | train | func BuildLogFlags(binary string) []cli.Flag {
binUpper := strings.ToUpper(binary)
binLower := strings.ToLower(binary)
return []cli.Flag{
cli.StringFlag{
Name: "log-level",
Value: "INFO",
EnvVar: fmt.Sprintf("CONTIV_%s_LOG_LEVEL", binUpper),
Usage: fmt.Sprintf("set %s log level, options: [DEBUG, IN... | go | {
"resource": ""
} |
q7952 | InitLogging | train | func InitLogging(binary string, ctx *cli.Context) error {
logLevel, err := logrus.ParseLevel(ctx.String("log-level"))
if err != nil {
return err
}
logrus.SetLevel(logLevel)
logrus.Infof("Using %v log level: %v", binary, logLevel)
if ctx.Bool("use-syslog") {
syslogURL := ctx.String("syslog-url")
if err := c... | go | {
"resource": ""
} |
q7953 | ValidateDBOptions | train | func ValidateDBOptions(binary string, ctx *cli.Context) (*DBConfigs, error) {
var storeDriver string
var storeURL string
var storeURLs string
etcdURLs := ctx.String("etcd")
consulURLs := ctx.String("consul")
if etcdURLs != "" && consulURLs != "" {
return nil, fmt.Errorf("ambiguous %s db endpoints, both etcd an... | go | {
"resource": ""
} |
q7954 | ValidateNetworkOptions | train | func ValidateNetworkOptions(binary string, ctx *cli.Context) (*NetworkConfigs, error) {
// 1. validate and set plugin mode
pluginMode := strings.ToLower(ctx.String("mode"))
switch pluginMode {
case core.Docker, core.Kubernetes, core.SwarmMode, core.Test:
logrus.Infof("Using %s mode: %v", binary, pluginMode)
case... | go | {
"resource": ""
} |
q7955 | FlattenFlags | train | func FlattenFlags(flagSlices ...[]cli.Flag) []cli.Flag {
var flags []cli.Flag
for _, slice := range flagSlices {
flags = append(flags, slice...)
}
return flags
} | go | {
"resource": ""
} |
q7956 | FilterEmpty | train | func FilterEmpty(stringSlice []string) []string {
var result []string
for _, str := range stringSlice {
if str != "" {
result = append(result, str)
}
}
return result
} | go | {
"resource": ""
} |
q7957 | FetchSysAttrs | train | func FetchSysAttrs() error {
output, err := ioutil.ReadFile("/etc/os-release")
if err != nil {
log.Errorf("Error reading the /etc/os-release Error: %s Output: \n%s\n", err, output)
return err
}
strOutput := string(output)
if strings.Contains(strOutput, "CentOS") {
SysAttrs.OsType = "centos"
} else if strin... | go | {
"resource": ""
} |
q7958 | NewNodeProxy | train | func NewNodeProxy() (*NodeSvcProxy, error) {
ipTablesPath, err := osexec.LookPath("iptables")
if err != nil {
return nil, err
}
// Install contiv chain and jump
out, err := osexec.Command(ipTablesPath, "-w", iptablesWaitLock,
"-t", "nat", "-N", contivNPChain).CombinedOutput()
if err != nil {
if !strings.Co... | go | {
"resource": ""
} |
q7959 | DeleteLocalIP | train | func (p *NodeSvcProxy) DeleteLocalIP(globalIP string) {
// strip cidr
globalIP = strings.Split(globalIP, "/")[0]
p.Mutex.Lock()
defer p.Mutex.Unlock()
delete(p.LocalIP, globalIP)
} | go | {
"resource": ""
} |
q7960 | AddLocalIP | train | func (p *NodeSvcProxy) AddLocalIP(globalIP, localIP string) {
// strip cidr
globalIP = strings.Split(globalIP, "/")[0]
localIP = strings.Split(localIP, "/")[0]
p.Mutex.Lock()
defer p.Mutex.Unlock()
p.LocalIP[globalIP] = localIP
} | go | {
"resource": ""
} |
q7961 | AddSvcSpec | train | func (p *NodeSvcProxy) AddSvcSpec(svcName string, spec *core.ServiceSpec) error {
p.Mutex.Lock()
defer p.Mutex.Unlock()
log.Infof("Node proxy AddSvcSpec: %s", svcName)
// Determine if this is a node service
isNodeSvc := false
for _, port := range spec.Ports {
if port.NodePort != 0 && port.Protocol == "TCP" {
... | go | {
"resource": ""
} |
q7962 | DelSvcSpec | train | func (p *NodeSvcProxy) DelSvcSpec(svcName string, spec *core.ServiceSpec) error {
p.Mutex.Lock()
defer p.Mutex.Unlock()
p.deleteSvc(svcName) // delete it if it exists
return nil
} | go | {
"resource": ""
} |
q7963 | readLoginCredentials | train | func readLoginCredentials(ctx *cli.Context) (string, string) {
fmt.Print("Username: ")
reader := bufio.NewReader(os.Stdin)
username, err := reader.ReadString('\n')
if err != nil {
errExit(ctx, exitIO, err.Error(), false)
}
username = strings.TrimSpace(username) // ReadString includes the newline
if len(usern... | go | {
"resource": ""
} |
q7964 | addBgp | train | func addBgp(ctx *cli.Context) {
if len(ctx.Args()) < 1 {
errExit(ctx, exitHelp, "Host name required", true)
}
hostname := ctx.Args()[0]
routerip := ctx.String("router-ip")
asid := ctx.String("as")
neighboras := ctx.String("neighbor-as")
neighbor := ctx.String("neighbor")
//Error checks
_, _, err := net.Par... | go | {
"resource": ""
} |
q7965 | deleteBgp | train | func deleteBgp(ctx *cli.Context) {
if len(ctx.Args()) != 1 {
errExit(ctx, exitHelp, "Host name required", true)
}
hostname := ctx.Args()[0]
fmt.Printf("Deleting Bgp router config: %s\n", hostname)
errCheck(ctx, getClient(ctx).BgpDelete(hostname))
} | go | {
"resource": ""
} |
q7966 | listBgp | train | func listBgp(ctx *cli.Context) {
if len(ctx.Args()) != 0 {
errExit(ctx, exitHelp, "More arguments than required", true)
}
bgpList, err := getClient(ctx).BgpList()
errCheck(ctx, err)
if ctx.Bool("json") {
dumpJSONList(ctx, bgpList)
} else if ctx.Bool("quite") {
bgpName := ""
for _, bgp := range *bgpList ... | go | {
"resource": ""
} |
q7967 | createServiceLB | train | func createServiceLB(ctx *cli.Context) {
if len(ctx.Args()) != 1 {
errExit(ctx, exitHelp, "Service name required", true)
}
serviceName := ctx.Args()[0]
serviceSubnet := ctx.String("network")
tenantName := ctx.String("tenant")
if len(tenantName) == 0 {
tenantName = "default"
}
selectors := ctx.StringSlice("... | go | {
"resource": ""
} |
q7968 | deleteServiceLB | train | func deleteServiceLB(ctx *cli.Context) {
if len(ctx.Args()) != 1 {
errExit(ctx, exitHelp, "Service name required", true)
}
serviceName := ctx.Args()[0]
tenantName := ctx.String("tenant")
if len(tenantName) == 0 {
tenantName = "default"
}
fmt.Printf("Deleting Service %s,%s\n", serviceName, tenantName)
err... | go | {
"resource": ""
} |
q7969 | listServiceLB | train | func listServiceLB(ctx *cli.Context) {
tenantName := ctx.String("tenant")
if len(tenantName) == 0 {
tenantName = "default"
}
_, err := getClient(ctx).TenantGet(tenantName)
errCheck(ctx, err)
svcList, err := getClient(ctx).ServiceLBList()
errCheck(ctx, err)
filtered := []*contivClient.ServiceLB{}
if ctx.B... | go | {
"resource": ""
} |
q7970 | GetService | train | func (cp *ConsulClient) GetService(srvName string) ([]ServiceInfo, error) {
keyName := "contiv.io/service/" + srvName + "/"
srvList, _, err := cp.getServiceInstances(keyName, 0)
return srvList, err
} | go | {
"resource": ""
} |
q7971 | WatchService | train | func (cp *ConsulClient) WatchService(srvName string, eventCh chan WatchServiceEvent, stopCh chan bool) error {
keyName := "contiv.io/service/" + srvName + "/"
// Run in background
go func() {
var currSrvMap = make(map[string]ServiceInfo)
// Get current list of services
srvList, lastIdx, err := cp.getServiceI... | go | {
"resource": ""
} |
q7972 | DeregisterService | train | func (cp *ConsulClient) DeregisterService(serviceInfo ServiceInfo) error {
keyName := "contiv.io/service/" + serviceInfo.ServiceName + "/" +
serviceInfo.HostAddr + ":" + strconv.Itoa(serviceInfo.Port)
// Find it in the database
srvState := cp.serviceDb[keyName]
if srvState == nil {
log.Errorf("Could not find t... | go | {
"resource": ""
} |
q7973 | getServiceInstances | train | func (cp *ConsulClient) getServiceInstances(key string, waitIdx uint64) ([]ServiceInfo, uint64, error) {
var srvcList []ServiceInfo
// Get the object from consul client
kvs, meta, err := cp.client.KV().List(key, &api.QueryOptions{WaitIndex: waitIdx})
if err != nil {
log.Errorf("Error getting key %s. Err: %v", ke... | go | {
"resource": ""
} |
q7974 | DeleteEndpointGroup | train | func DeleteEndpointGroup(tenantName, groupName string) error {
// Get the state driver
stateDriver, err := utils.GetStateDriver()
if err != nil {
return err
}
epgKey := mastercfg.GetEndpointGroupKey(groupName, tenantName)
epgCfg := &mastercfg.EndpointGroupState{}
epgCfg.StateDriver = stateDriver
err = epgCfg... | go | {
"resource": ""
} |
q7975 | UpdateEndpointGroup | train | func UpdateEndpointGroup(bandwidth, groupName, tenantName string, Dscp, burst int) error {
// Get the state driver - get the etcd driver state
stateDriver, err := utils.GetStateDriver()
if err != nil {
return err
}
key := mastercfg.GetEndpointGroupKey(groupName, tenantName)
if key == "" {
return errors.New(... | go | {
"resource": ""
} |
q7976 | SvcProviderUpdate | train | func SvcProviderUpdate(serviceID string, isDelete bool) error {
providerList := []string{}
stateDriver, err := utils.GetStateDriver()
if err != nil {
return err
}
svcProvider := &mastercfg.SvcProvider{}
svcProvider.StateDriver = stateDriver
if _, present := mastercfg.ServiceLBDb[serviceID]; !present {
svc... | go | {
"resource": ""
} |
q7977 | ErrIfKeyExists | train | func ErrIfKeyExists(err error) error {
if err == nil || strings.Contains(err.Error(), "key not found") {
return nil
}
return err
} | go | {
"resource": ""
} |
q7978 | ReadAll | train | func (r *AutoVLANCfgResource) ReadAll() ([]core.State, error) {
return r.StateDriver.ReadAllState(vLANResourceConfigPathPrefix, r,
json.Unmarshal)
} | go | {
"resource": ""
} |
q7979 | Allocate | train | func (r *AutoVLANCfgResource) Allocate(reqVal interface{}) (interface{}, error) {
oper := &AutoVLANOperResource{}
oper.StateDriver = r.StateDriver
err := oper.Read(r.ID)
if err != nil {
return nil, err
}
var vlan uint
if (reqVal != nil) && (reqVal.(uint) != 0) {
vlan = reqVal.(uint)
if !oper.FreeVLANs.Tes... | go | {
"resource": ""
} |
q7980 | Deallocate | train | func (r *AutoVLANCfgResource) Deallocate(value interface{}) error {
oper := &AutoVLANOperResource{}
oper.StateDriver = r.StateDriver
err := oper.Read(r.ID)
if err != nil {
return err
}
vlan, ok := value.(uint)
if !ok {
return core.Errorf("Invalid type for vlan value")
}
if oper.FreeVLANs.Test(vlan) {
re... | go | {
"resource": ""
} |
q7981 | ReadAll | train | func (r *AutoVLANOperResource) ReadAll() ([]core.State, error) {
return r.StateDriver.ReadAllState(vLANResourceOperPathPrefix, r,
json.Unmarshal)
} | go | {
"resource": ""
} |
q7982 | DeleteHostAccPort | train | func (d *OvsDriver) DeleteHostAccPort(id string) error {
sw, found := d.switchDb["host"]
if found {
operEp := &drivers.OperEndpointState{}
operEp.StateDriver = d.oper.StateDriver
err := operEp.Read(id)
if err != nil {
return err
}
d.HostProxy.DeleteLocalIP(operEp.IPAddress)
portName := operEp.PortNam... | go | {
"resource": ""
} |
q7983 | CreateHostAccPort | train | func (d *OvsDriver) CreateHostAccPort(portName, globalIP string, net int) (string, error) {
sw, found := d.switchDb["host"]
if found {
num := strings.Replace(portName, "hport", "", 1)
intfNum, err := strconv.Atoi(num)
if err != nil {
return "", err
}
hostIP, err := sw.AddHostPort(portName, intfNum, net,... | go | {
"resource": ""
} |
q7984 | Deinit | train | func (d *OvsDriver) Deinit() {
log.Infof("Cleaning up ovsdriver")
// cleanup both vlan and vxlan OVS instances
if d.switchDb["vlan"] != nil {
d.switchDb["vlan"].RemoveUplinks()
d.switchDb["vlan"].Delete()
}
if d.switchDb["vxlan"] != nil {
d.switchDb["vxlan"].DelHostPort(hostPortName, true)
d.switchDb["vxl... | go | {
"resource": ""
} |
q7985 | CreateNetwork | train | func (d *OvsDriver) CreateNetwork(id string) error {
cfgNw := mastercfg.CfgNetworkState{}
cfgNw.StateDriver = d.oper.StateDriver
err := cfgNw.Read(id)
if err != nil {
log.Errorf("Failed to read net %s \n", cfgNw.ID)
return err
}
log.Infof("create net %+v \n", cfgNw)
// Find the switch based on network type
... | go | {
"resource": ""
} |
q7986 | DeleteNetwork | train | func (d *OvsDriver) DeleteNetwork(id, subnet, nwType, encap string, pktTag, extPktTag int, gateway string, tenant string) error {
log.Infof("delete net %s, nwType %s, encap %s, tags: %d/%d", id, nwType, encap, pktTag, extPktTag)
// Find the switch based on network type
var sw *OvsSwitch
if encap == "vxlan" {
sw ... | go | {
"resource": ""
} |
q7987 | UpdateEndpointGroup | train | func (d *OvsDriver) UpdateEndpointGroup(id string) error {
log.Infof("Received endpoint group update for %s", id)
var (
err error
epgBandwidth int64
sw *OvsSwitch
)
//gets the EndpointGroupState object
cfgEpGroup := &mastercfg.EndpointGroupState{}
cfgEpGroup.StateDriver = d.oper.StateDriv... | go | {
"resource": ""
} |
q7988 | DeleteEndpoint | train | func (d *OvsDriver) DeleteEndpoint(id string) error {
epOper := drivers.OperEndpointState{}
epOper.StateDriver = d.oper.StateDriver
err := epOper.Read(id)
if err != nil {
return err
}
defer func() {
epOper.Clear()
}()
// Get the network state
cfgNw := mastercfg.CfgNetworkState{}
cfgNw.StateDriver = d.ope... | go | {
"resource": ""
} |
q7989 | AddPeerHost | train | func (d *OvsDriver) AddPeerHost(node core.ServiceInfo) error {
// Nothing to do if this is our own IP
if node.HostAddr == d.localIP {
return nil
}
log.Infof("CreatePeerHost for %+v", node)
// Add the VTEP for the peer in vxlan switch.
err := d.switchDb["vxlan"].CreateVtep(node.HostAddr)
if err != nil {
log... | go | {
"resource": ""
} |
q7990 | DeletePeerHost | train | func (d *OvsDriver) DeletePeerHost(node core.ServiceInfo) error {
// Nothing to do if this is our own IP
if node.HostAddr == d.localIP {
return nil
}
log.Infof("DeletePeerHost for %+v", node)
// Remove the VTEP for the peer in vxlan switch.
err := d.switchDb["vxlan"].DeleteVtep(node.HostAddr)
if err != nil {... | go | {
"resource": ""
} |
q7991 | AddBgp | train | func (d *OvsDriver) AddBgp(id string) error {
var sw *OvsSwitch
cfg := mastercfg.CfgBgpState{}
cfg.StateDriver = d.oper.StateDriver
err := cfg.Read(id)
if err != nil {
log.Errorf("Failed to read router state %s \n", cfg.Hostname)
return err
}
log.Infof("Create Bgp :%+v", cfg)
// Find the switch based on n... | go | {
"resource": ""
} |
q7992 | DeleteBgp | train | func (d *OvsDriver) DeleteBgp(id string) error {
log.Infof("Delete Bgp Neighbor %s \n", id)
//FixME: We are not maintaining 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()
} | go | {
"resource": ""
} |
q7993 | convSvcSpec | train | func convSvcSpec(spec *core.ServiceSpec) *ofnet.ServiceSpec {
pSpec := make([]ofnet.PortSpec, len(spec.Ports))
for ix, p := range spec.Ports {
pSpec[ix].Protocol = p.Protocol
pSpec[ix].SvcPort = p.SvcPort
pSpec[ix].ProvPort = p.ProvPort
}
ofnetSS := ofnet.ServiceSpec{
IpAddress: spec.IPAddress,
Ports: ... | go | {
"resource": ""
} |
q7994 | AddSvcSpec | train | func (d *OvsDriver) AddSvcSpec(svcName string, spec *core.ServiceSpec) error {
log.Infof("AddSvcSpec: %s", svcName)
ss := convSvcSpec(spec)
errs := ""
for _, sw := range d.switchDb {
log.Infof("sw AddSvcSpec: %s", svcName)
err := sw.AddSvcSpec(svcName, ss)
if err != nil {
errs += err.Error()
}
}
err :... | go | {
"resource": ""
} |
q7995 | DelSvcSpec | train | func (d *OvsDriver) DelSvcSpec(svcName string, spec *core.ServiceSpec) error {
ss := convSvcSpec(spec)
errs := ""
for _, sw := range d.switchDb {
err := sw.DelSvcSpec(svcName, ss)
if err != nil {
errs += err.Error()
}
}
err := d.HostProxy.DelSvcSpec(svcName, spec)
if err != nil {
errs += err.Error()
... | go | {
"resource": ""
} |
q7996 | GetEndpointStats | train | func (d *OvsDriver) GetEndpointStats() ([]byte, error) {
vxlanStats, err := d.switchDb["vxlan"].GetEndpointStats()
if err != nil {
log.Errorf("Error getting vxlan stats. Err: %v", err)
return []byte{}, err
}
vlanStats, err := d.switchDb["vlan"].GetEndpointStats()
if err != nil {
log.Errorf("Error getting vl... | go | {
"resource": ""
} |
q7997 | InspectState | train | func (d *OvsDriver) InspectState() ([]byte, error) {
driverState := make(map[string]interface{})
// get vlan switch state
vlanState, err := d.switchDb["vlan"].InspectState()
if err != nil {
return []byte{}, err
}
// get vxlan switch state
vxlanState, err := d.switchDb["vxlan"].InspectState()
if err != nil {... | go | {
"resource": ""
} |
q7998 | InspectBgp | train | func (d *OvsDriver) InspectBgp() ([]byte, error) {
// get vlan switch state
bgpState, err := d.switchDb["vlan"].InspectBgp()
if err != nil {
return []byte{}, err
}
// json marshall the map
jsonState, err := json.Marshal(bgpState)
if err != nil {
log.Errorf("Error encoding epstats. Err: %v", err)
return [... | go | {
"resource": ""
} |
q7999 | GlobalConfigUpdate | train | func (d *OvsDriver) GlobalConfigUpdate(inst core.InstanceInfo) error {
// convert the netplugin config to ofnet config
// currently, its only ArpMode
var cfg ofnet.OfnetGlobalConfig
switch inst.ArpMode {
case "flood":
cfg.ArpMode = ofnet.ArpFlood
default:
// set the default to proxy for graceful upgrade
cfg... | go | {
"resource": ""
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.