_id stringlengths 2 7 | title stringlengths 1 118 | partition stringclasses 3 values | text stringlengths 52 85.5k | language stringclasses 1 value | meta_information dict |
|---|---|---|---|---|---|
q7800 | InitPolicyMgr | train | func InitPolicyMgr(stateDriver core.StateDriver, ofm *ofnet.OfnetMaster) error {
// save statestore and ofnet masters
stateStore = stateDriver
ofnetMaster = ofm
// restore all existing epg policies
err := restoreEpgPolicies(stateDriver)
if err != nil {
log.Errorf("Error restoring EPG policies. ")
}
return nil
} | go | {
"resource": ""
} |
q7801 | NewEpgPolicy | train | func NewEpgPolicy(epgpKey string, epgID int, policy *contivModel.Policy) (*EpgPolicy, error) {
gp := new(EpgPolicy)
gp.EpgPolicyKey = epgpKey
gp.ID = epgpKey
gp.EndpointGroupID = epgID
gp.StateDriver = stateStore
log.Infof("Creating new epg policy: %s", epgpKey)
// init the dbs
gp.RuleMaps = make(map[string]*RuleMap)
// Install all rules within the policy
for ruleKey := range policy.LinkSets.Rules {
// find the rule
rule := contivModel.FindRule(ruleKey)
if rule == nil {
log.Errorf("Error finding the rule %s", ruleKey)
return nil, core.Errorf("rule not found")
}
log.Infof("Adding Rule %s to epgp policy %s", ruleKey, epgpKey)
// Add the rule to epg Policy
err := gp.AddRule(rule)
if err != nil {
log.Errorf("Error adding rule %s to epg polict %s. Err: %v", ruleKey, epgpKey, err)
return nil, err
}
}
// Save the policy state
err := gp.Write()
if err != nil {
return nil, err
}
// Save it in local cache
epgPolicyDb[epgpKey] = gp
log.Info("Created epg policy {%+v}", gp)
return gp, nil
} | go | {
"resource": ""
} |
q7802 | restoreEpgPolicies | train | func restoreEpgPolicies(stateDriver core.StateDriver) error {
// read all epg policies
gp := new(EpgPolicy)
gp.StateDriver = stateDriver
gpCfgs, err := gp.ReadAll()
if err == nil {
for _, gpCfg := range gpCfgs {
epgp := gpCfg.(*EpgPolicy)
log.Infof("Restoring EpgPolicy: %+v", epgp)
// save it in cache
epgPolicyDb[epgp.EpgPolicyKey] = epgp
// Restore all rules within the policy
for ruleKey, ruleMap := range epgp.RuleMaps {
log.Infof("Restoring Rule %s, Rule: %+v", ruleKey, ruleMap.Rule)
// delete the entry from the map so that we can add it back
delete(epgp.RuleMaps, ruleKey)
// Add the rule to epg Policy
err := epgp.AddRule(ruleMap.Rule)
if err != nil {
log.Errorf("Error restoring rule %s. Err: %v", ruleKey, err)
return err
}
}
}
}
return nil
} | go | {
"resource": ""
} |
q7803 | Delete | train | func (gp *EpgPolicy) Delete() error {
// delete from the DB
delete(epgPolicyDb, gp.EpgPolicyKey)
return gp.Clear()
} | go | {
"resource": ""
} |
q7804 | AddRule | train | func (gp *EpgPolicy) AddRule(rule *contivModel.Rule) error {
var dirs []string
// check if the rule exists already
if gp.RuleMaps[rule.Key] != nil {
// FIXME: see if we can update the rule
return core.Errorf("Rule already exists")
}
// Figure out all the directional rules we need to install
switch rule.Direction {
case "in":
if (rule.Protocol == "udp" || rule.Protocol == "tcp") && rule.Port != 0 {
dirs = []string{"inRx", "inTx"}
} else {
dirs = []string{"inRx"}
}
case "out":
if (rule.Protocol == "udp" || rule.Protocol == "tcp") && rule.Port != 0 {
dirs = []string{"outRx", "outTx"}
} else {
dirs = []string{"outTx"}
}
case "both":
if (rule.Protocol == "udp" || rule.Protocol == "tcp") && rule.Port != 0 {
dirs = []string{"inRx", "inTx", "outRx", "outTx"}
} else {
dirs = []string{"inRx", "outTx"}
}
}
// create a ruleMap
ruleMap := new(RuleMap)
ruleMap.OfnetRules = make(map[string]*ofnet.OfnetPolicyRule)
ruleMap.Rule = rule
// Create ofnet rules
for _, dir := range dirs {
ofnetRule, err := gp.createOfnetRule(rule, dir)
if err != nil {
log.Errorf("Error creating %s ofnet rule for {%+v}. Err: %v", dir, rule, err)
return err
}
// add it to the rule map
ruleMap.OfnetRules[ofnetRule.RuleId] = ofnetRule
}
// save the rulemap
gp.RuleMaps[rule.Key] = ruleMap
return nil
} | go | {
"resource": ""
} |
q7805 | DelRule | train | func (gp *EpgPolicy) DelRule(rule *contivModel.Rule) error {
// check if the rule exists
ruleMap := gp.RuleMaps[rule.Key]
if ruleMap == nil {
return core.Errorf("Rule does not exists")
}
// Delete each ofnet rule under this policy rule
for _, ofnetRule := range ruleMap.OfnetRules {
log.Infof("Deleting rule {%+v} from policyDB", ofnetRule)
// Delete the rule from policyDB
err := ofnetMaster.DelRule(ofnetRule)
if err != nil {
log.Errorf("Error deleting the ofnet rule {%+v}. Err: %v", ofnetRule, err)
}
// Send DelRule to netplugin agents
err = delPolicyRuleState(ofnetRule)
if err != nil {
log.Errorf("Error deleting the ofnet rule {%+v}. Err: %v", ofnetRule, err)
}
}
// delete the cache
delete(gp.RuleMaps, rule.Key)
return nil
} | go | {
"resource": ""
} |
q7806 | parseEnv | train | func (cniApp *cniAppInfo) parseEnv() error {
cniApp.logFields = make(logger.Fields)
envVal := ""
for _, envName := range cniEnvList {
if envVal = os.Getenv(envName); envVal == "" {
return fmt.Errorf("failed to get env variable %s", envName)
}
logger.Infof("parsed env variable %s = [%s]", envName, envVal)
switch envName {
case envVarCniCommand:
cniApp.cniCmd = strings.ToUpper(envVal)
cniApp.logFields["CMD"] = envVal
if _, ok := map[string]int{cniapi.CniCmdAdd: 1,
cniapi.CniCmdDel: 2}[cniApp.cniCmd]; ok == false {
return fmt.Errorf("unknown CNI command %s", envName)
}
case envVarCniIfname:
cniApp.cniMesosAttr.CniIfname = envVal
case envVarCniNetns:
cniApp.cniMesosAttr.CniNetns = envVal
nsDir := filepath.Dir(envVal)
cniApp.netcfgFile = strings.Join([]string{nsDir, "netcontiv", "network.conf"}, "/")
logger.Infof("cni network config file location : %s", cniApp.netcfgFile)
case envVarCniContainerID:
cniApp.cniMesosAttr.CniContainerid = envVal
cniApp.logFields["CID"] = strings.Split(envVal, "-")[0]
logger.Debugf("added fields in logger CID: %s", cniApp.logFields["CID"])
default:
cniLog.Errorf("unknown CNI variable %s", envName)
}
}
// update logger
cniLog = logger.WithFields(cniApp.logFields)
return nil
} | go | {
"resource": ""
} |
q7807 | parseNwInfoLabels | train | func (cniApp *cniAppInfo) parseNwInfoLabels() {
var cniNetInfo struct {
Args struct {
Mesos struct {
NetworkInfo struct {
Labels struct {
NwLabel []cniapi.NetworkLabel `json:"labels"`
} `json:"labels"`
} `json:"network_info"`
} `json:"org.apache.mesos"`
} `json:"args"`
}
cniLog.Infof("parse config file %s ", cniApp.netcfgFile)
cfgFile, err := ioutil.ReadFile(cniApp.netcfgFile)
if err != nil {
cniLog.Warnf("%s", err)
return
}
if err := json.Unmarshal(cfgFile, &cniNetInfo); err != nil {
cniLog.Errorf("failed to parse %s, %s", cniApp.netcfgFile, err)
return
}
for idx, elem := range cniNetInfo.Args.Mesos.NetworkInfo.Labels.NwLabel {
cniLog.Infof("configured labels [%d] {key: %s, val: %s}", idx,
elem.Key, elem.Value)
// copy netplugin related labels
switch elem.Key {
case cniapi.LabelTenantName:
cniApp.cniMesosAttr.Labels.TenantName = elem.Value
case cniapi.LabelNetworkName:
cniApp.cniMesosAttr.Labels.NetworkName = elem.Value
case cniapi.LabelNetworkGroup:
cniApp.cniMesosAttr.Labels.NetworkGroup = elem.Value
}
}
} | go | {
"resource": ""
} |
q7808 | sendCniResp | train | func (cniApp *cniAppInfo) sendCniResp(cniResp []byte, retCode int) int {
cniLog.Infof("sent CNI response: %s ", cniResp)
fmt.Printf("%s\n", string(cniResp))
return retCode
} | go | {
"resource": ""
} |
q7809 | sendCniErrorResp | train | func (cniApp *cniAppInfo) sendCniErrorResp(errorMsg string) int {
cniLog.Infof("prepare CNI error response: %s ", errorMsg)
// CNI_ERROR_UNSUPPORTED is sent for all errors
cniResp := cniapi.CniCmdErrorResp{CniVersion: cniapi.CniDefaultVersion,
ErrCode: cniapi.CniStatusErrorUnsupportedField,
ErrMsg: "contiv: " + errorMsg}
jsonResp, err := json.Marshal(cniResp)
if err == nil {
fmt.Printf("%s\n", string(jsonResp))
cniLog.Infof("CNI error response: %s", string(jsonResp))
} else {
cniLog.Errorf("failed to convert CNI error response to JSON, %s ", err)
// send minimal response to stdout
fmt.Printf("{ \n")
fmt.Printf("\"cniVersion\": \"%s\" \n", cniResp.CniVersion)
fmt.Printf("\"code\": \"%d\" \n", cniResp.ErrCode)
fmt.Printf("\"msg\": \"%s %s\" \n", "contiv", cniResp.ErrMsg)
fmt.Printf("} \n")
}
return int(cniResp.ErrCode)
} | go | {
"resource": ""
} |
q7810 | handleHTTP | train | func (cniApp *cniAppInfo) handleHTTP(url string, jsonReq *bytes.Buffer) int {
cniLog.Infof("http POST url: %s data: %v", url, jsonReq)
httpResp, err := cniApp.httpClient.Post(url, "application/json", jsonReq)
if err != nil {
return cniApp.sendCniErrorResp("failed to get response from netplugin :" + err.Error())
}
defer httpResp.Body.Close()
switch httpResp.StatusCode {
case http.StatusOK:
cniLog.Infof("received http OK response from netplugin")
info, err := ioutil.ReadAll(httpResp.Body)
if err != nil {
return cniApp.sendCniErrorResp("failed to read success response from netplugin :" + err.Error())
}
return cniApp.sendCniResp(info, cniapi.CniStatusSuccess)
case http.StatusInternalServerError:
cniLog.Infof("received http error response from netplugin")
info, err := ioutil.ReadAll(httpResp.Body)
if err != nil {
return cniApp.sendCniErrorResp("failed to read error response from netplugin :" + err.Error())
}
return cniApp.sendCniResp(info, cniapi.CniStatusErrorUnsupportedField)
default:
cniLog.Infof("received unknown error from netplugin")
return cniApp.sendCniErrorResp("error response from netplugin: " + http.StatusText(httpResp.StatusCode))
}
} | go | {
"resource": ""
} |
q7811 | init | train | func (cniApp *cniAppInfo) init() {
cniApp.serverURL = "http://localhost"
trans := &http.Transport{Dial: func(network, addr string) (net.Conn,
error) {
return net.Dial("unix", cniapi.ContivMesosSocket)
}}
cniApp.httpClient = &http.Client{Transport: trans}
} | go | {
"resource": ""
} |
q7812 | Get | train | func Get() *Info {
ver := Info{}
ver.GitCommit = gitCommit
ver.Version = version
ver.BuildTime = buildTime
return &ver
} | go | {
"resource": ""
} |
q7813 | StringFromInfo | train | func StringFromInfo(ver *Info) string {
return fmt.Sprintf("Version: %s\n", ver.Version) +
fmt.Sprintf("GitCommit: %s\n", ver.GitCommit) +
fmt.Sprintf("BuildTime: %s\n", ver.BuildTime)
} | go | {
"resource": ""
} |
q7814 | InitDockPlugin | train | func InitDockPlugin(np *plugin.NetPlugin, mode string) error {
// Save state
netPlugin = np
pluginMode = mode
// Get local hostname
hostname, err := os.Hostname()
if err != nil {
log.Fatalf("Could not retrieve hostname: %v", err)
}
log.Debugf("Configuring router")
router := mux.NewRouter()
s := router.Methods("POST").Subrouter()
dispatchMap := map[string]func(http.ResponseWriter, *http.Request){
"/Plugin.Activate": activate(hostname),
"/Plugin.Deactivate": deactivate(hostname),
"/NetworkDriver.GetCapabilities": getCapability,
"/NetworkDriver.CreateNetwork": createNetwork,
"/NetworkDriver.DeleteNetwork": deleteNetwork,
"/NetworkDriver.CreateEndpoint": createEndpoint(hostname),
"/NetworkDriver.DeleteEndpoint": deleteEndpoint(hostname),
"/NetworkDriver.EndpointOperInfo": endpointInfo,
"/NetworkDriver.Join": join,
"/NetworkDriver.Leave": leave,
"/NetworkDriver.AllocateNetwork": allocateNetwork,
"/NetworkDriver.FreeNetwork": freeNetwork,
"/NetworkDriver.ProgramExternalConnectivity": programExternalConnectivity,
"/NetworkDriver.RevokeExternalConnectivity": revokeExternalConnectivity,
"/NetworkDriver.DiscoverNew": discoverNew,
"/NetworkDriver.DiscoverDelete": discoverDelete,
"/IpamDriver.GetDefaultAddressSpaces": getDefaultAddressSpaces,
"/IpamDriver.RequestPool": requestPool,
"/IpamDriver.ReleasePool": releasePool,
"/IpamDriver.RequestAddress": requestAddress,
"/IpamDriver.ReleaseAddress": releaseAddress,
"/IpamDriver.GetCapabilities": getIpamCapability,
}
for dispatchPath, dispatchFunc := range dispatchMap {
s.HandleFunc(dispatchPath, logHandler(dispatchPath, dispatchFunc))
}
s.HandleFunc("/NetworkDriver.{*}", unknownAction)
s.HandleFunc("/IpamDriver.{*}", unknownAction)
driverPath := path.Join(pluginPath, driverName) + ".sock"
os.Remove(driverPath)
os.MkdirAll(pluginPath, 0700)
go func() {
l, err := net.ListenUnix("unix", &net.UnixAddr{Name: driverPath, Net: "unix"})
if err != nil {
panic(err)
}
log.Infof("docker plugin listening on %s", driverPath)
server := &http.Server{Handler: router}
server.SetKeepAlivesEnabled(false)
server.Serve(l)
l.Close()
log.Infof("docker plugin closing %s", driverPath)
}()
return nil
} | go | {
"resource": ""
} |
q7815 | deactivate | train | func deactivate(hostname string) func(http.ResponseWriter, *http.Request) {
return func(w http.ResponseWriter, r *http.Request) {
logEvent("deactivate")
}
} | go | {
"resource": ""
} |
q7816 | activate | train | func activate(hostname string) func(http.ResponseWriter, *http.Request) {
return func(w http.ResponseWriter, r *http.Request) {
logEvent("activate")
content, err := json.Marshal(plugins.Manifest{Implements: []string{"NetworkDriver", "IpamDriver"}})
if err != nil {
httpError(w, "Could not generate bootstrap response", err)
return
}
w.Write(content)
}
} | go | {
"resource": ""
} |
q7817 | GetDockerNetworkName | train | func GetDockerNetworkName(nwID string) (string, string, string, error) {
// first see if we can find the network in docknet oper state
dnetOper, err := docknet.FindDocknetByUUID(nwID)
if err == nil {
return dnetOper.TenantName, dnetOper.NetworkName, dnetOper.ServiceName, nil
}
if pluginMode == core.SwarmMode {
log.Errorf("Unable to find docknet info in objstore")
return "", "", "", err
}
// create docker client
docker, err := dockerclient.NewClient("unix:///var/run/docker.sock", "", nil, nil)
if err != nil {
log.Errorf("Unable to connect to docker. Error %v", err)
return "", "", "", errors.New("unable to connect to docker")
}
nwIDFilter := filters.NewArgs()
nwIDFilter.Add("id", nwID)
nwList, err := docker.NetworkList(context.Background(), types.NetworkListOptions{Filters: nwIDFilter})
if err != nil {
log.Infof("Error: %v", err)
return "", "", "", err
}
if len(nwList) != 1 {
if len(nwList) == 0 {
err = errors.New("network UUID not found")
} else {
err = errors.New("more than one network found with the same ID")
}
return "", "", "", err
}
nw := nwList[0]
log.Infof("Returning network name %s for ID %s", nw.Name, nwID)
// parse the network name
var tenantName, netName, serviceName string
names := strings.Split(nw.Name, "/")
if len(names) == 2 {
// has service.network/tenant format.
tenantName = names[1]
// parse service and network names
sNames := strings.Split(names[0], ".")
if len(sNames) == 2 {
// has service.network format
netName = sNames[1]
serviceName = sNames[0]
} else {
netName = sNames[0]
}
} else if len(names) == 1 {
// has service.network in default tenant
tenantName = defaultTenantName
// parse service and network names
sNames := strings.Split(names[0], ".")
if len(sNames) == 2 {
// has service.network format
netName = sNames[1]
serviceName = sNames[0]
} else {
netName = sNames[0]
}
} else {
log.Errorf("Invalid network name format for network %s", nw.Name)
return "", "", "", errors.New("invalid format")
}
return tenantName, netName, serviceName, nil
} | go | {
"resource": ""
} |
q7818 | FindGroupFromTag | train | func FindGroupFromTag(epgTag string) (*mastercfg.EndpointGroupState, error) {
stateDriver, err := utils.GetStateDriver()
if err != nil {
return nil, err
}
epgCfg := &mastercfg.EndpointGroupState{}
epgCfg.StateDriver = stateDriver
epgList, err := epgCfg.ReadAll()
if err != nil {
return nil, err
}
var epg *mastercfg.EndpointGroupState
found := false
for _, epgP := range epgList {
epg = epgP.(*mastercfg.EndpointGroupState)
if epg.GroupTag == epgTag {
found = true
break
}
}
if !found {
return nil, fmt.Errorf("Couldn't find group matching the tag %s", epgTag)
}
return epg, nil
} | go | {
"resource": ""
} |
q7819 | FindNetworkFromTag | train | func FindNetworkFromTag(nwTag string) (*mastercfg.CfgNetworkState, error) {
stateDriver, err := utils.GetStateDriver()
if err != nil {
return nil, err
}
nwCfg := &mastercfg.CfgNetworkState{}
nwCfg.StateDriver = stateDriver
nwList, err := nwCfg.ReadAll()
if err != nil {
return nil, err
}
var nw *mastercfg.CfgNetworkState
found := false
for _, nwP := range nwList {
nw = nwP.(*mastercfg.CfgNetworkState)
if nw.NetworkTag == nwTag {
found = true
break
}
}
if !found {
return nil, fmt.Errorf("Couldn't find network matching the tag %s", nwTag)
}
return nw, nil
} | go | {
"resource": ""
} |
q7820 | createNetworkHelper | train | func createNetworkHelper(networkID string, tag string, IPv4Data, IPv6Data []driverapi.IPAMData) error {
var tenantName, networkName, serviceName string
var err error
if tag != "" {
// we need to map docker network to policy group or network using the tag
log.Infof("Received tag %s", tag)
var nw *mastercfg.CfgNetworkState
epg, err := FindGroupFromTag(tag)
if err != nil {
nw, err = FindNetworkFromTag(tag)
if err != nil {
return errors.New("failed to lookup tag")
}
}
if epg != nil {
tenantName = epg.TenantName
networkName = epg.NetworkName
serviceName = epg.GroupName
} else if nw != nil {
tenantName = nw.Tenant
networkName = nw.NetworkName
serviceName = ""
}
} else if len(IPv4Data) > 0 {
// if subnet is specified in docker command, we create a contiv network
subnetPool := ""
gateway := ""
if IPv4Data[0].Pool != nil {
subnetPool = IPv4Data[0].Pool.String()
}
if IPv4Data[0].Gateway != nil {
gateway = strings.Split(IPv4Data[0].Gateway.String(), "/")[0]
}
subnetv6 := ""
gatewayv6 := ""
if len(IPv6Data) > 0 {
if IPv6Data[0].Pool != nil {
subnetv6 = IPv6Data[0].Pool.String()
}
if IPv6Data[0].Gateway != nil {
gatewayv6 = strings.Split(IPv6Data[0].Gateway.String(), "/")[0]
}
}
// build key and URL
keyStr := "default" + ":" + networkID
url := "/api/v1/networks/" + keyStr + "/"
tenantName = "default"
networkName = networkID
serviceName = ""
req := client.Network{
TenantName: tenantName,
NetworkName: networkName,
Subnet: subnetPool,
Gateway: gateway,
Ipv6Subnet: subnetv6,
Ipv6Gateway: gatewayv6,
Encap: "vxlan",
}
var resp client.Network
err = cluster.MasterPostReq(url, &req, &resp)
if err != nil {
log.Errorf("failed to create network in netmaster: %s", err.Error())
return errors.New("failed to create network in netmaster")
}
log.Infof("Created contiv network %+v", req)
}
// Create docknet oper state to map the docker network to contiv network
// We do not create a network in docker as it is created explicitly by user
err = docknet.CreateDockNetState(tenantName, networkName, serviceName, networkID)
if err != nil {
log.Errorf("Error creating docknet state: %s", err.Error())
return errors.New("Error creating docknet state")
}
return nil
} | go | {
"resource": ""
} |
q7821 | deleteNetworkHelper | train | func deleteNetworkHelper(networkID string) error {
dnet, err := docknet.FindDocknetByUUID(networkID)
if err == nil {
// delete the dnet oper state
err = docknet.DeleteDockNetState(dnet.TenantName, dnet.NetworkName, dnet.ServiceName)
if err != nil {
msg := fmt.Sprintf("Could not delete docknet for nwID %s: %s", networkID, err.Error())
log.Errorf(msg)
return errors.New(msg)
}
log.Infof("Deleted docker network mapping for %v", networkID)
} else {
msg := fmt.Sprintf("Could not find Docker network %s: %s", networkID, err.Error())
log.Errorf(msg)
}
netID := networkID + ".default"
_, err = utils.GetNetwork(netID)
if err == nil {
// if we find a contiv network with the ID hash, then it must be
// a docker created network (from the libnetwork create api).
// build key and URL
keyStr := "default" + ":" + networkID
url := "/api/v1/networks/" + keyStr + "/"
err = cluster.MasterDelReq(url)
if err != nil {
msg := fmt.Sprintf("Failed to delete network: %s", err.Error())
log.Errorf(msg)
return errors.New(msg)
}
log.Infof("Deleted contiv network %v", networkID)
} else {
log.Infof("Could not find contiv network %v", networkID)
}
return nil
} | go | {
"resource": ""
} |
q7822 | handleDockerEvents | train | func (ag *Agent) handleDockerEvents(events <-chan events.Message, errs <-chan error) {
for {
select {
case err := <-errs:
if err != nil && err == io.EOF {
log.Errorf("Closing the events channel. Err: %+v", err)
return
}
if err != nil && err != io.EOF {
log.Errorf("Received error from docker events. Err: %+v", err)
}
case event := <-events:
log.Debugf("Received Docker event: {%#v}\n", event)
// process events only when LB services exist.
if !ag.lbServiceExist() {
continue
}
switch event.Status {
case "start":
endpointUpdReq := &master.UpdateEndpointRequest{}
defaultHeaders := map[string]string{"User-Agent": "Docker-Client/" + dockerversion.Version + " (" + runtime.GOOS + ")"}
cli, err := dockerclient.NewClient("unix:///var/run/docker.sock", "v1.21", nil, defaultHeaders)
if err != nil {
panic(err)
}
containerInfo, err := cli.ContainerInspect(context.Background(), event.ID)
if err != nil {
log.Errorf("Container Inspect failed :%s", err)
break
}
if event.ID != "" {
labelMap := getLabelsFromContainerInspect(&containerInfo)
containerTenant := getTenantFromContainerInspect(&containerInfo)
networkName, ipAddress, err := getEpNetworkInfoFromContainerInspect(&containerInfo)
if err != nil {
log.Errorf("Error getting container network info for %v.Err:%s", event.ID, err)
}
endpoint := getEndpointFromContainerInspect(&containerInfo)
if ipAddress != "" {
//Create provider info
endpointUpdReq.IPAddress = ipAddress
endpointUpdReq.ContainerID = event.ID
endpointUpdReq.Tenant = containerTenant
endpointUpdReq.Network = networkName
endpointUpdReq.Event = "start"
endpointUpdReq.EndpointID = endpoint
endpointUpdReq.EPCommonName = containerInfo.Name
endpointUpdReq.Labels = make(map[string]string)
for k, v := range labelMap {
endpointUpdReq.Labels[k] = v
}
}
var epUpdResp master.UpdateEndpointResponse
log.Infof("Sending Endpoint update request to master: {%+v}", endpointUpdReq)
err = cluster.MasterPostReq("/plugin/updateEndpoint", endpointUpdReq, &epUpdResp)
if err != nil {
log.Errorf("Event: 'start' , Http error posting endpoint update, Error:%s", err)
}
} else {
log.Errorf("Unable to fetch container labels for container %s ", event.ID)
}
case "die":
endpointUpdReq := &master.UpdateEndpointRequest{}
endpointUpdReq.ContainerID = event.ID
endpointUpdReq.Event = "die"
var epUpdResp master.UpdateEndpointResponse
log.Infof("Sending Endpoint update request to master: {%+v} on container delete", endpointUpdReq)
err := cluster.MasterPostReq("/plugin/updateEndpoint", endpointUpdReq, &epUpdResp)
if err != nil {
log.Errorf("Event:'die' Http error posting endpoint update, Error:%s", err)
}
}
}
}
} | go | {
"resource": ""
} |
q7823 | getLabelsFromContainerInspect | train | func getLabelsFromContainerInspect(containerInfo *types.ContainerJSON) map[string]string {
if containerInfo != nil && containerInfo.Config != nil {
return containerInfo.Config.Labels
}
return nil
} | go | {
"resource": ""
} |
q7824 | getTenantFromContainerInspect | train | func getTenantFromContainerInspect(containerInfo *types.ContainerJSON) string {
tenant := "default"
if containerInfo != nil && containerInfo.NetworkSettings != nil {
for network := range containerInfo.NetworkSettings.Networks {
if strings.Contains(network, "/") {
//network name is of the form networkname/tenantname for non default tenant
tenant = strings.Split(network, "/")[1]
}
}
}
return tenant
} | go | {
"resource": ""
} |
q7825 | Init | train | func (d *VppDriver) Init(info *core.InstanceInfo) error {
log.Infof("Initializing vppdriver")
return nil
} | go | {
"resource": ""
} |
q7826 | DeleteEndpoint | train | func (d *VppDriver) DeleteEndpoint(id string) (err error) {
log.Infof("Not implemented")
return nil
} | go | {
"resource": ""
} |
q7827 | AddPeerHost | train | func (d *VppDriver) AddPeerHost(node core.ServiceInfo) error {
log.Infof("Not implemented")
return nil
} | go | {
"resource": ""
} |
q7828 | GlobalConfigUpdate | train | func (d *VppDriver) GlobalConfigUpdate(inst core.InstanceInfo) error {
log.Infof("Not implemented")
return nil
} | go | {
"resource": ""
} |
q7829 | ReleaseAddressHandler | train | func ReleaseAddressHandler(w http.ResponseWriter, r *http.Request, vars map[string]string) (interface{}, error) {
var relReq AddressReleaseRequest
var networkID string
var epgName string
var epgCfg *mastercfg.EndpointGroupState
// Get object from the request
err := json.NewDecoder(r.Body).Decode(&relReq)
if err != nil {
log.Errorf("Error decoding ReleaseAddressHandler. Err %v", err)
return nil, err
}
log.Infof("Received AddressReleaseRequest: %+v", relReq)
stateDriver, err := utils.GetStateDriver()
if err != nil {
return nil, err
}
networkID, epgName = getNwAndEpgFromAddrReq(relReq.NetworkID)
if len(epgName) > 0 {
epgCfg = &mastercfg.EndpointGroupState{}
epgCfg.StateDriver = stateDriver
if err = epgCfg.Read(epgName); err != nil {
log.Errorf("failed to read epg %s, %s", epgName, err)
return nil, err
}
log.Infof("AddressReleaseRequest for network: %s epg: %s", networkID, epgName)
}
// find the network from network id
nwCfg := &mastercfg.CfgNetworkState{}
nwCfg.StateDriver = stateDriver
err = nwCfg.Read(networkID)
if err != nil {
log.Errorf("network %s is not operational", relReq.NetworkID)
return nil, err
}
// release addresses
err = networkReleaseAddress(nwCfg, epgCfg, relReq.IPv4Address)
if err != nil {
log.Errorf("Failed to release address. Err: %v", err)
return nil, err
}
return "success", nil
} | go | {
"resource": ""
} |
q7830 | CreateEndpointHandler | train | func CreateEndpointHandler(w http.ResponseWriter, r *http.Request, vars map[string]string) (interface{}, error) {
var epReq CreateEndpointRequest
// Get object from the request
err := json.NewDecoder(r.Body).Decode(&epReq)
if err != nil {
log.Errorf("Error decoding AllocAddressHandler. Err %v", err)
return nil, err
}
log.Infof("Received CreateEndpointRequest: %+v", epReq)
// Take a global lock for address allocation
addrMutex.Lock()
defer addrMutex.Unlock()
// Gte the state driver
stateDriver, err := utils.GetStateDriver()
if err != nil {
return nil, err
}
// find the network from network id
netID := epReq.NetworkName + "." + epReq.TenantName
nwCfg := &mastercfg.CfgNetworkState{}
nwCfg.StateDriver = stateDriver
err = nwCfg.Read(netID)
if err != nil {
log.Errorf("network %s is not operational", netID)
return nil, err
}
// Create the endpoint
epCfg, err := CreateEndpoint(stateDriver, nwCfg, &epReq)
if err != nil {
log.Errorf("CreateEndpoint failure for ep: %v. Err: %v", epReq.ConfigEP, err)
return nil, err
}
// build ep create response
epResp := CreateEndpointResponse{
EndpointConfig: *epCfg,
}
// return the response
return epResp, nil
} | go | {
"resource": ""
} |
q7831 | DeleteEndpointHandler | train | func DeleteEndpointHandler(w http.ResponseWriter, r *http.Request, vars map[string]string) (interface{}, error) {
var epdelReq DeleteEndpointRequest
// Get object from the request
err := json.NewDecoder(r.Body).Decode(&epdelReq)
if err != nil {
log.Errorf("Error decoding AllocAddressHandler. Err %v", err)
return nil, err
}
log.Infof("Received DeleteEndpointRequest: %+v", epdelReq)
// Get the state driver
stateDriver, err := utils.GetStateDriver()
if err != nil {
return nil, err
}
// Take a global lock for address release
addrMutex.Lock()
defer addrMutex.Unlock()
// build the endpoint ID
netID := epdelReq.NetworkName + "." + epdelReq.TenantName
epID := getEpName(netID, &intent.ConfigEP{Container: epdelReq.EndpointID})
// delete the endpoint
epCfg, err := DeleteEndpointID(stateDriver, epID)
if err != nil {
log.Errorf("Error deleting endpoint: %v", epID)
return nil, err
}
// build the response
delResp := DeleteEndpointResponse{
EndpointConfig: *epCfg,
}
// done. return resp
return delResp, nil
} | go | {
"resource": ""
} |
q7832 | parseCniArgs | train | func (cniReq *cniServer) parseCniArgs(httpBody []byte) error {
if err := json.Unmarshal(httpBody, &cniReq.pluginArgs); err != nil {
return fmt.Errorf("failed to parse JSON req: %s", err.Error())
}
cniLog.Debugf("parsed ifname: %s, netns: %s, container-id: %s,"+
"tenant: %s, network-name: %s, network-group: %s",
cniReq.pluginArgs.CniIfname, cniReq.pluginArgs.CniNetns,
cniReq.pluginArgs.CniContainerid,
cniReq.pluginArgs.Labels.TenantName,
cniReq.pluginArgs.Labels.NetworkName,
cniReq.pluginArgs.Labels.NetworkGroup)
// set defaults
cniReq.endPointLabels = map[string]string{cniapi.LabelNetworkName: "default-net",
cniapi.LabelTenantName: "default"}
for _, label := range []string{cniapi.LabelTenantName, cniapi.LabelNetworkName,
cniapi.LabelNetworkGroup} {
switch label {
case cniapi.LabelTenantName:
if len(cniReq.pluginArgs.Labels.TenantName) > 0 {
cniReq.endPointLabels[label] = cniReq.pluginArgs.Labels.TenantName
}
cniLog.Infof("netplugin label %s = %s", cniapi.LabelTenantName,
cniReq.endPointLabels[label])
case cniapi.LabelNetworkName:
if len(cniReq.pluginArgs.Labels.NetworkName) > 0 {
cniReq.endPointLabels[label] = cniReq.pluginArgs.Labels.NetworkName
}
cniLog.Infof("netplugin label %s = %s", cniapi.LabelNetworkName,
cniReq.endPointLabels[label])
case cniapi.LabelNetworkGroup:
if len(cniReq.pluginArgs.Labels.NetworkGroup) > 0 {
cniReq.endPointLabels[label] = cniReq.pluginArgs.Labels.NetworkGroup
}
cniLog.Infof("netplugin label %s = %s", cniapi.LabelNetworkGroup,
cniReq.endPointLabels[label])
}
}
cniReq.networkID = cniReq.endPointLabels[cniapi.LabelNetworkName] + "." +
cniReq.endPointLabels[cniapi.LabelTenantName]
cniLog.Infof("network fdn %s", cniReq.networkID)
cniReq.endpointID = cniReq.networkID + "-" +
cniReq.pluginArgs.CniContainerid
cniLog.Infof("endpoint fdn %s", cniReq.endpointID)
return nil
} | go | {
"resource": ""
} |
q7833 | InitPlugin | train | func InitPlugin(netPlugin *plugin.NetPlugin) {
cniLog = log.WithField("plugin", "mesos")
cniLog.Infof("starting Mesos CNI server")
router := mux.NewRouter()
// register handlers for cni plugin
subRtr := router.Headers("Content-Type", "application/json").Subrouter()
subRtr.HandleFunc(cniapi.MesosNwIntfAdd, httpWrapper(mesosNwIntfAdd)).Methods("POST")
subRtr.HandleFunc(cniapi.MesosNwIntfDel, httpWrapper(mesosNwIntfDel)).Methods("POST")
router.HandleFunc("/{*}", unknownReq)
sockFile := cniapi.ContivMesosSocket
os.Remove(sockFile)
os.MkdirAll(cniapi.PluginPath, 0700)
cniDriverInit(netPlugin)
go func() {
lsock, err := net.ListenUnix("unix", &net.UnixAddr{Name: sockFile, Net: "unix"})
if err != nil {
cniLog.Errorf("Mesos CNI server failed: %s", err)
return
}
cniLog.Infof("Mesos CNI server is listening on %s", sockFile)
http.Serve(lsock, router)
lsock.Close()
cniLog.Infof("Mesos CNI server socket %s closed ", sockFile)
}()
} | go | {
"resource": ""
} |
q7834 | RegisterPlugin | train | func RegisterPlugin(name string, plugin Plugin) error {
pluginMutex.Lock()
defer pluginMutex.Unlock()
pluginList[name] = plugin
return nil
} | go | {
"resource": ""
} |
q7835 | GetPlugin | train | func GetPlugin(name string) Plugin {
// Find the conf store
pluginMutex.Lock()
defer pluginMutex.Unlock()
if pluginList[name] == nil {
log.Errorf("Objdb Plugin %s not registered", name)
return nil
}
return pluginList[name]
} | go | {
"resource": ""
} |
q7836 | InitClient | train | func InitClient(storeName string, storeURLs []string) (API, error) {
plugin := GetPlugin(storeName)
if plugin == nil {
log.Errorf("Invalid DB type %s", storeName)
return nil, errors.New("unsupported DB type")
}
cl, err := plugin.NewClient(storeURLs)
if err != nil {
log.Errorf("Error creating client %s to url %v. Err: %v", storeName, storeURLs, err)
return nil, err
}
return cl, nil
} | go | {
"resource": ""
} |
q7837 | NewClient | train | func NewClient(dbURL string) (API, error) {
// check if we should use default db
if dbURL == "" {
dbURL = defaultDbURL
}
parts := strings.Split(dbURL, "://")
if len(parts) < 2 {
log.Errorf("Invalid DB URL format %s", dbURL)
return nil, errors.New("invalid DB URL")
}
clientName := parts[0]
clientURL := parts[1]
return InitClient(clientName, []string{"http://" + clientURL})
} | go | {
"resource": ""
} |
q7838 | GetDocknetName | train | func GetDocknetName(tenantName, networkName, epgName string) string {
netName := ""
// if epg is specified, always use that, else use nw
if epgName == "" {
netName = networkName
} else {
netName = epgName
}
// add tenant suffix if not the default tenant
if tenantName != defaultTenantName {
netName = netName + "/" + tenantName
}
return netName
} | go | {
"resource": ""
} |
q7839 | UpdateDockerV2PluginName | train | func UpdateDockerV2PluginName(netDriver string, ipamDriver string) {
log.Infof("docker v2plugin (%s) updated to %s and ipam (%s) updated to %s",
netDriverName, netDriver, ipamDriverName, ipamDriver)
netDriverName = netDriver
ipamDriverName = ipamDriver
} | go | {
"resource": ""
} |
q7840 | DeleteDockNet | train | func DeleteDockNet(tenantName, networkName, serviceName string) error {
// Trim default tenant name
docknetName := GetDocknetName(tenantName, networkName, serviceName)
// connect to docker
defaultHeaders := map[string]string{"User-Agent": "Docker-Client/" + dockerversion.Version + " (" + runtime.GOOS + ")"}
docker, err := dockerclient.NewClient("unix:///var/run/docker.sock", "v1.23", nil, defaultHeaders)
if err != nil {
log.Errorf("Unable to connect to docker. Error %v", err)
return errors.New("unable to connect to docker")
}
// check whether the network is present in docker
_, err = docker.NetworkInspect(context.Background(), docknetName)
if err != nil {
log.Warnf("Couldnt find network %s in docker", docknetName)
}
docknetDeleted := (err != nil)
log.Infof("Deleting docker network: %+v", docknetName)
// Delete network
err = docker.NetworkRemove(context.Background(), docknetName)
if err != nil {
if !docknetDeleted {
log.Errorf("Error deleting network %s. Err: %v", docknetName, err)
return err
}
// since it was already deleted from docker ignore the error
log.Infof("Ignoring error in deleting docker network %s. Err: %v", docknetName, err)
}
err = DeleteDockNetState(tenantName, networkName, serviceName)
if docknetDeleted && strings.Contains(err.Error(), "key not found") {
// Ignore the error as docknet was already deleted
err = nil
}
return err
} | go | {
"resource": ""
} |
q7841 | CreateDockNetState | train | func CreateDockNetState(tenantName, networkName, serviceName, docknetID string) error {
log.Infof("Adding DockNetState for %s.%s.%s --> %s", tenantName, networkName, serviceName, docknetID)
// Get the state driver
stateDriver, err := utils.GetStateDriver()
if err != nil {
log.Warnf("Couldn't get state driver for docknet add %v", err)
return err
}
// save docknet oper state
dnetOper := DnetOperState{
TenantName: tenantName,
NetworkName: networkName,
ServiceName: serviceName,
DocknetUUID: docknetID,
}
dnetOper.ID = fmt.Sprintf("%s.%s.%s", tenantName, networkName, serviceName)
dnetOper.StateDriver = stateDriver
// write the dnet oper state
return dnetOper.Write()
} | go | {
"resource": ""
} |
q7842 | DeleteDockNetState | train | func DeleteDockNetState(tenantName, networkName, serviceName string) error {
log.Infof("Deleting DockNetState for %s.%s.%s", tenantName, networkName, serviceName)
// Get the state driver
stateDriver, err := utils.GetStateDriver()
if err != nil {
log.Warnf("Couldn't get state driver for docknet del %v", err)
return err
}
// save docknet oper state
dnetOper := DnetOperState{}
dnetOper.ID = fmt.Sprintf("%s.%s.%s", tenantName, networkName, serviceName)
dnetOper.StateDriver = stateDriver
// write the dnet oper state
return dnetOper.Clear()
} | go | {
"resource": ""
} |
q7843 | GetDocknetState | train | func GetDocknetState(tenantName, networkName, serviceName string) (*DnetOperState, error) {
log.Infof("GetDocknetState for %s.%s.%s", tenantName, networkName, serviceName)
// Get the state driver
stateDriver, err := utils.GetStateDriver()
if err != nil {
log.Warnf("Couldn't get state driver for docknet %v", err)
return nil, err
}
// save docknet oper state
dnetOper := DnetOperState{}
dnetOper.ID = fmt.Sprintf("%s.%s.%s", tenantName, networkName, serviceName)
dnetOper.StateDriver = stateDriver
// Read the dnet oper state
err = dnetOper.Read(dnetOper.ID)
if err == nil {
return &dnetOper, nil
}
return nil, err
} | go | {
"resource": ""
} |
q7844 | FindDocknetByUUID | train | func FindDocknetByUUID(dnetID string) (*DnetOperState, error) {
log.Infof("find docker network '%s' ", dnetID)
// Get the state driver
stateDriver, err := utils.GetStateDriver()
if err != nil {
log.Warnf("Couldn't read global config %v", err)
return nil, err
}
tmpDnet := DnetOperState{}
tmpDnet.StateDriver = stateDriver
dnetOperList, err := tmpDnet.ReadAll()
if err != nil {
log.Errorf("Error getting docknet list. Err: %v", err)
return nil, err
}
// Walk all dnets and find the matching UUID
for _, dnet := range dnetOperList {
if dnet.(*DnetOperState).DocknetUUID == dnetID {
return dnet.(*DnetOperState), nil
}
}
return nil, errors.New("docknet UUID not found")
} | go | {
"resource": ""
} |
q7845 | GetK8SConfig | train | func GetK8SConfig(pCfg *ContivConfig) error {
bytes, err := ioutil.ReadFile(contivKubeCfgFile)
if err != nil {
return err
}
pCfg.SvcSubnet = defSvcSubnet
err = json.Unmarshal(bytes, pCfg)
if err != nil {
return fmt.Errorf("Error parsing config file: %s", err)
}
// If no client certs or token is specified, get the default token
if len(strings.TrimSpace(pCfg.K8sCert)) == 0 && len(strings.TrimSpace(pCfg.K8sToken)) == 0 {
pCfg.K8sToken, err = getDefaultToken()
if err != nil {
log.Errorf("Failed: %v", err)
return err
}
}
return nil
} | go | {
"resource": ""
} |
q7846 | SetUpK8SClient | train | func SetUpK8SClient() (*kubernetes.Clientset, error) {
var contivK8sCfg ContivConfig
err := GetK8SConfig(&contivK8sCfg)
if err != nil {
log.Errorf("Failed to get K8S config: %v", err)
return nil, err
}
// init k8s client
restCfg := &k8sRest.Config{
Host: contivK8sCfg.K8sAPIServer,
BearerToken: contivK8sCfg.K8sToken,
TLSClientConfig: k8sRest.TLSClientConfig{CAFile: contivK8sCfg.K8sCa},
}
clientSet, err := kubernetes.NewForConfig(restCfg)
if err != nil {
log.Errorf("failed to create kubernetes client instance %s, %+v", err, restCfg)
return nil, err
}
return clientSet, nil
} | go | {
"resource": ""
} |
q7847 | getDefaultToken | train | func getDefaultToken() (string, error) {
bytes, err := ioutil.ReadFile(tokenFile)
if err != nil {
log.Errorf("Failed: %v", err)
return "", err
}
return string(bytes), nil
} | go | {
"resource": ""
} |
q7848 | CreateNetworks | train | func CreateNetworks(stateDriver core.StateDriver, tenant *intent.ConfigTenant) error {
// Validate the config
err := validateNetworkConfig(tenant)
if err != nil {
log.Errorf("error validating network config. Error: %s", err)
return err
}
for _, network := range tenant.Networks {
err = CreateNetwork(network, stateDriver, tenant.Name)
if err != nil {
log.Errorf("Error creating network {%+v}. Err: %v", network, err)
return err
}
}
return err
} | go | {
"resource": ""
} |
q7849 | DeleteNetworkID | train | func DeleteNetworkID(stateDriver core.StateDriver, netID string) error {
nwCfg := &mastercfg.CfgNetworkState{}
nwCfg.StateDriver = stateDriver
err := nwCfg.Read(netID)
if err != nil {
log.Errorf("network %s is not operational", netID)
return err
}
// Will Skip docker network deletion for ACI fabric mode.
aci, _ := IsAciConfigured()
if nwCfg.NwType != "infra" {
// For Infra nw, endpoint delete initiated by netplugin
// Check if there are any active endpoints
if hasActiveEndpoints(nwCfg) {
return core.Errorf("Error: Network has active endpoints")
}
if GetClusterMode() == core.Docker && aci == false {
// Delete the docker network
err = docknet.DeleteDockNet(nwCfg.Tenant, nwCfg.NetworkName, "")
if err != nil {
log.Errorf("Error deleting network %s. Err: %v", netID, err)
// DeleteDockNet will fail when network has active endpoints.
// No damage is done yet. It is safe to fail.
return err
}
}
}
gstate.GlobalMutex.Lock()
defer gstate.GlobalMutex.Unlock()
gCfg := &gstate.Cfg{}
gCfg.StateDriver = stateDriver
err = gCfg.Read("")
if err != nil {
log.Errorf("error reading tenant info for %q. Error: %s", nwCfg.Tenant, err)
return err
}
// Free resource associated with the network
err = freeNetworkResources(stateDriver, nwCfg, gCfg)
if err != nil {
// Error while freeing up vlan/vxlan/subnet/gateway resources
// This can only happen because of defects in code
// No need of any corrective handling here
return err
}
err = nwCfg.Clear()
if err != nil {
log.Errorf("error writing nw config. Error: %s", err)
return err
}
return err
} | go | {
"resource": ""
} |
q7850 | DeleteNetworks | train | func DeleteNetworks(stateDriver core.StateDriver, tenant *intent.ConfigTenant) error {
gCfg := &gstate.Cfg{}
gCfg.StateDriver = stateDriver
err := gCfg.Read("")
if err != nil {
log.Errorf("error reading tenant state. Error: %s", err)
return err
}
err = validateNetworkConfig(tenant)
if err != nil {
log.Errorf("error validating network config. Error: %s", err)
return err
}
for _, network := range tenant.Networks {
networkID := network.Name + "." + tenant.Name
err = DeleteNetworkID(stateDriver, networkID)
if err != nil {
return err
}
}
return err
} | go | {
"resource": ""
} |
q7851 | networkReleaseAddress | train | func networkReleaseAddress(nwCfg *mastercfg.CfgNetworkState, epgCfg *mastercfg.EndpointGroupState, ipAddress string) error {
isIPv6 := netutils.IsIPv6(ipAddress)
if isIPv6 {
hostID, err := netutils.GetIPv6HostID(nwCfg.SubnetIP, nwCfg.SubnetLen, ipAddress)
if err != nil {
log.Errorf("error getting host id from hostIP %s Subnet %s/%d. Error: %s",
ipAddress, nwCfg.SubnetIP, nwCfg.SubnetLen, err)
return err
}
// networkReleaseAddress is called from multiple places
// Make sure we decrement the EpCount only if the IPAddress
// was not already freed earlier
if _, found := nwCfg.IPv6AllocMap[hostID]; found {
nwCfg.EpAddrCount--
}
delete(nwCfg.IPv6AllocMap, hostID)
} else {
if epgCfg != nil && len(epgCfg.IPPool) > 0 {
log.Infof("releasing epg ip: %s", ipAddress)
ipAddrValue, err := netutils.GetIPNumber(nwCfg.SubnetIP, nwCfg.SubnetLen, 32, ipAddress)
if err != nil {
log.Errorf("error getting host id from hostIP %s pool %s. Error: %s",
ipAddress, epgCfg.IPPool, err)
return err
}
// networkReleaseAddress is called from multiple places
// Make sure we decrement the EpCount only if the IPAddress
// was not already freed earlier
if epgCfg.EPGIPAllocMap.Test(ipAddrValue) {
nwCfg.EpAddrCount--
}
epgCfg.EPGIPAllocMap.Clear(ipAddrValue)
if err := epgCfg.Write(); err != nil {
log.Errorf("error writing epg config. Error: %s", err)
return err
}
} else {
ipAddrValue, err := netutils.GetIPNumber(nwCfg.SubnetIP, nwCfg.SubnetLen, 32, ipAddress)
if err != nil {
log.Errorf("error getting host id from hostIP %s Subnet %s/%d. Error: %s",
ipAddress, nwCfg.SubnetIP, nwCfg.SubnetLen, err)
return err
}
// networkReleaseAddress is called from multiple places
// Make sure we decrement the EpCount only if the IPAddress
// was not already freed earlier
if nwCfg.IPAllocMap.Test(ipAddrValue) {
nwCfg.EpAddrCount--
}
nwCfg.IPAllocMap.Clear(ipAddrValue)
log.Infof("Releasing IP Address: %v"+
"from networkId:%+v", ipAddrValue,
nwCfg.NetworkName)
}
}
err := nwCfg.Write()
if err != nil {
log.Errorf("error writing nw config. Error: %s", err)
return err
}
return nil
} | go | {
"resource": ""
} |
q7852 | addMaster | train | func addMaster(netplugin *plugin.NetPlugin, srvInfo objdb.ServiceInfo) error {
// save it in db
MasterDB[masterKey(srvInfo)] = &srvInfo
// tell the plugin about the master
return netplugin.AddMaster(core.ServiceInfo{
HostAddr: srvInfo.HostAddr,
Port: netmasterRPCPort,
})
} | go | {
"resource": ""
} |
q7853 | deleteMaster | train | func deleteMaster(netplugin *plugin.NetPlugin, srvInfo objdb.ServiceInfo) error {
// delete from the db
delete(MasterDB, masterKey(srvInfo))
// tel plugin about it
return netplugin.DeleteMaster(core.ServiceInfo{
HostAddr: srvInfo.HostAddr,
Port: netmasterRPCPort,
})
} | go | {
"resource": ""
} |
q7854 | getMasterLockHolder | train | func getMasterLockHolder() (string, error) {
// Create the lock
leaderLock, err := ObjdbClient.NewLock("netmaster/leader", "", 0)
if err != nil {
log.Fatalf("Could not create leader lock. Err: %v", err)
}
// get current holder of leader lock
masterNode := leaderLock.GetHolder()
if masterNode == "" {
log.Errorf("No leader node found")
return "", errors.New("no leader node")
}
return masterNode, nil
} | go | {
"resource": ""
} |
q7855 | MasterPostReq | train | func MasterPostReq(path string, req interface{}, resp interface{}) error {
return masterReq(path, req, resp, false)
} | go | {
"resource": ""
} |
q7856 | registerService | train | func registerService(objClient objdb.API, ctrlIP, vtepIP, hostname string, vxlanUDPPort int) error {
// netplugin service info
srvInfo := objdb.ServiceInfo{
ServiceName: "netplugin",
TTL: 10,
HostAddr: ctrlIP,
Port: netpluginRPCPort1,
Hostname: hostname,
}
// Register the node with service registry
err := objClient.RegisterService(srvInfo)
if err != nil {
log.Fatalf("Error registering service. Err: %v", err)
return err
}
srvInfo = objdb.ServiceInfo{
ServiceName: "netplugin",
TTL: 10,
HostAddr: ctrlIP,
Port: netpluginRPCPort2,
Hostname: hostname,
}
// Register the node with service registry
err = objClient.RegisterService(srvInfo)
if err != nil {
log.Fatalf("Error registering service. Err: %v", err)
return err
}
// netplugn VTEP service info
srvInfo = objdb.ServiceInfo{
ServiceName: "netplugin.vtep",
TTL: 10,
HostAddr: vtepIP,
Port: vxlanUDPPort,
Hostname: hostname,
}
// Register the node with service registry
err = objClient.RegisterService(srvInfo)
if err != nil {
log.Fatalf("Error registering service. Err: %v", err)
return err
}
log.Infof("Registered netplugin service with registry")
return nil
} | go | {
"resource": ""
} |
q7857 | peerDiscoveryLoop | train | func peerDiscoveryLoop(netplugin *plugin.NetPlugin, objClient objdb.API, ctrlIP, vtepIP string) {
// Create channels for watch thread
nodeEventCh := make(chan objdb.WatchServiceEvent, 1)
watchStopCh := make(chan bool, 1)
masterEventCh := make(chan objdb.WatchServiceEvent, 1)
masterWatchStopCh := make(chan bool, 1)
// Start a watch on netmaster
err := objClient.WatchService("netmaster.rpc", masterEventCh, masterWatchStopCh)
if err != nil {
log.Fatalf("Could not start a watch on netmaster service. Err: %v", err)
}
// Start a watch on netplugin service
err = objClient.WatchService("netplugin.vtep", nodeEventCh, watchStopCh)
if err != nil {
log.Fatalf("Could not start a watch on netplugin service. Err: %v", err)
}
for {
select {
case srvEvent := <-nodeEventCh:
log.Debugf("Received netplugin service watch event: %+v", srvEvent)
// collect the info about the node
nodeInfo := srvEvent.ServiceInfo
// check if its our own info coming back to us
if nodeInfo.HostAddr == vtepIP {
break
}
// Handle based on event type
if srvEvent.EventType == objdb.WatchServiceEventAdd {
log.Infof("Node add event for {%+v}", nodeInfo)
// add the node
err := netplugin.AddPeerHost(core.ServiceInfo{
HostAddr: nodeInfo.HostAddr,
Port: netplugin.PluginConfig.Instance.VxlanUDPPort,
})
if err != nil {
log.Errorf("Error adding node {%+v}. Err: %v", nodeInfo, err)
}
} else if srvEvent.EventType == objdb.WatchServiceEventDel {
log.Infof("Node delete event for {%+v}", nodeInfo)
// remove the node
err := netplugin.DeletePeerHost(core.ServiceInfo{
HostAddr: nodeInfo.HostAddr,
Port: netplugin.PluginConfig.Instance.VxlanUDPPort,
})
if err != nil {
log.Errorf("Error deleting node {%+v}. Err: %v", nodeInfo, err)
}
}
case srvEvent := <-masterEventCh:
log.Infof("Received netmaster service watch event: %+v", srvEvent)
// collect the info about the node
nodeInfo := srvEvent.ServiceInfo
// Handle based on event type
if srvEvent.EventType == objdb.WatchServiceEventAdd {
log.Infof("Master add event for {%+v}", nodeInfo)
// Add the master
err := addMaster(netplugin, nodeInfo)
if err != nil {
log.Errorf("Error adding master {%+v}. Err: %v", nodeInfo, err)
}
} else if srvEvent.EventType == objdb.WatchServiceEventDel {
log.Infof("Master delete event for {%+v}", nodeInfo)
// Delete the master
err := deleteMaster(netplugin, nodeInfo)
if err != nil {
log.Errorf("Error deleting master {%+v}. Err: %v", nodeInfo, err)
}
}
}
// Dont process next peer event for another 100ms
time.Sleep(100 * time.Millisecond)
}
} | go | {
"resource": ""
} |
q7858 | Init | train | func Init(storeDriver string, storeURLs []string) error {
var err error
// Create an objdb client
ObjdbClient, err = objdb.InitClient(storeDriver, storeURLs)
return err
} | go | {
"resource": ""
} |
q7859 | RunLoop | train | func RunLoop(netplugin *plugin.NetPlugin, ctrlIP, vtepIP, hostname string) error {
// Register ourselves
err := registerService(ObjdbClient, ctrlIP, vtepIP, hostname, netplugin.PluginConfig.Instance.VxlanUDPPort)
// Start peer discovery loop
go peerDiscoveryLoop(netplugin, ObjdbClient, ctrlIP, vtepIP)
return err
} | go | {
"resource": ""
} |
q7860 | makeHttpHandler | train | func makeHttpHandler(handlerFunc HttpApiFunc) http.HandlerFunc {
// Create a closure and return an anonymous function
return func(w http.ResponseWriter, r *http.Request) {
// Call the handler
resp, err := handlerFunc(w, r, mux.Vars(r))
if err != nil {
// Log error
log.Errorf("Handler for %s %s returned error: %s", r.Method, r.URL, err)
// Send HTTP response
http.Error(w, err.Error(), http.StatusInternalServerError)
} else {
// Send HTTP response as Json
err = writeJSON(w, http.StatusOK, resp)
if err != nil {
log.Errorf("Error generating json. Err: %v", err)
}
}
}
} | go | {
"resource": ""
} |
q7861 | GetOperAciGw | train | func GetOperAciGw(obj *AciGwInspect) error {
// Check if we handle this object
if objCallbackHandler.AciGwCb == nil {
log.Errorf("No callback registered for aciGw object")
return errors.New("Invalid object type")
}
// Perform callback
err := objCallbackHandler.AciGwCb.AciGwGetOper(obj)
if err != nil {
log.Errorf("AciGwDelete retruned error for: %+v. Err: %v", obj, err)
return err
}
return nil
} | go | {
"resource": ""
} |
q7862 | CreateAciGw | train | func CreateAciGw(obj *AciGw) error {
// Validate parameters
err := ValidateAciGw(obj)
if err != nil {
log.Errorf("ValidateAciGw retruned error for: %+v. Err: %v", obj, err)
return err
}
// Check if we handle this object
if objCallbackHandler.AciGwCb == nil {
log.Errorf("No callback registered for aciGw object")
return errors.New("Invalid object type")
}
saveObj := obj
collections.aciGwMutex.Lock()
key := collections.aciGws[obj.Key]
collections.aciGwMutex.Unlock()
// Check if object already exists
if key != nil {
// Perform Update callback
err = objCallbackHandler.AciGwCb.AciGwUpdate(collections.aciGws[obj.Key], obj)
if err != nil {
log.Errorf("AciGwUpdate retruned error for: %+v. Err: %v", obj, err)
return err
}
// save the original object after update
collections.aciGwMutex.Lock()
saveObj = collections.aciGws[obj.Key]
collections.aciGwMutex.Unlock()
} else {
// save it in cache
collections.aciGwMutex.Lock()
collections.aciGws[obj.Key] = obj
collections.aciGwMutex.Unlock()
// Perform Create callback
err = objCallbackHandler.AciGwCb.AciGwCreate(obj)
if err != nil {
log.Errorf("AciGwCreate retruned error for: %+v. Err: %v", obj, err)
collections.aciGwMutex.Lock()
delete(collections.aciGws, obj.Key)
collections.aciGwMutex.Unlock()
return err
}
}
// Write it to modeldb
collections.aciGwMutex.Lock()
err = saveObj.Write()
collections.aciGwMutex.Unlock()
if err != nil {
log.Errorf("Error saving aciGw %s to db. Err: %v", saveObj.Key, err)
return err
}
return nil
} | go | {
"resource": ""
} |
q7863 | FindAciGw | train | func FindAciGw(key string) *AciGw {
collections.aciGwMutex.Lock()
defer collections.aciGwMutex.Unlock()
obj := collections.aciGws[key]
if obj == nil {
return nil
}
return obj
} | go | {
"resource": ""
} |
q7864 | DeleteAciGw | train | func DeleteAciGw(key string) error {
collections.aciGwMutex.Lock()
obj := collections.aciGws[key]
collections.aciGwMutex.Unlock()
if obj == nil {
log.Errorf("aciGw %s not found", key)
return errors.New("aciGw not found")
}
// Check if we handle this object
if objCallbackHandler.AciGwCb == nil {
log.Errorf("No callback registered for aciGw object")
return errors.New("Invalid object type")
}
// Perform callback
err := objCallbackHandler.AciGwCb.AciGwDelete(obj)
if err != nil {
log.Errorf("AciGwDelete retruned error for: %+v. Err: %v", obj, err)
return err
}
// delete it from modeldb
collections.aciGwMutex.Lock()
err = obj.Delete()
collections.aciGwMutex.Unlock()
if err != nil {
log.Errorf("Error deleting aciGw %s. Err: %v", obj.Key, err)
}
// delete it from cache
collections.aciGwMutex.Lock()
delete(collections.aciGws, key)
collections.aciGwMutex.Unlock()
return nil
} | go | {
"resource": ""
} |
q7865 | ValidateAciGw | train | func ValidateAciGw(obj *AciGw) error {
collections.aciGwMutex.Lock()
defer collections.aciGwMutex.Unlock()
// Validate key is correct
keyStr := obj.Name
if obj.Key != keyStr {
log.Errorf("Expecting AciGw Key: %s. Got: %s", keyStr, obj.Key)
return errors.New("Invalid Key")
}
// Validate each field
if len(obj.EnforcePolicies) > 64 {
return errors.New("enforcePolicies string too long")
}
enforcePoliciesMatch := regexp.MustCompile("^(yes|no){1}$")
if enforcePoliciesMatch.MatchString(obj.EnforcePolicies) == false {
return errors.New("enforcePolicies string invalid format")
}
if len(obj.IncludeCommonTenant) > 64 {
return errors.New("includeCommonTenant string too long")
}
includeCommonTenantMatch := regexp.MustCompile("^(yes|no){1}$")
if includeCommonTenantMatch.MatchString(obj.IncludeCommonTenant) == false {
return errors.New("includeCommonTenant string invalid format")
}
if len(obj.Name) > 64 {
return errors.New("name string too long")
}
nameMatch := regexp.MustCompile("^(aciGw)$")
if nameMatch.MatchString(obj.Name) == false {
return errors.New("name string invalid format")
}
if len(obj.NodeBindings) > 2048 {
return errors.New("nodeBindings string too long")
}
nodeBindingsMatch := regexp.MustCompile("^$|^(topology/pod-[0-9]{1,4}/node-[0-9]{1,4}){1}(,topology/pod-[0-9]{1,4}/node-[0-9]{1,4})*$")
if nodeBindingsMatch.MatchString(obj.NodeBindings) == false {
return errors.New("nodeBindings string invalid format")
}
if len(obj.PathBindings) > 2048 {
return errors.New("pathBindings string too long")
}
pathBindingsMatch := regexp.MustCompile("^$|^(topology/pod-[0-9]{1,4}/paths-[0-9]{1,4}/pathep-\\[eth[0-9]{1,2}/[0-9]{1,2}\\]){1}(,topology/pod-[0-9]{1,4}/paths-[0-9]{1,4}/pathep-\\[eth[0-9]{1,2}/[0-9]{1,2}\\])*$")
if pathBindingsMatch.MatchString(obj.PathBindings) == false {
return errors.New("pathBindings string invalid format")
}
if len(obj.PhysicalDomain) > 128 {
return errors.New("physicalDomain string too long")
}
physicalDomainMatch := 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 physicalDomainMatch.MatchString(obj.PhysicalDomain) == false {
return errors.New("physicalDomain string invalid format")
}
return nil
} | go | {
"resource": ""
} |
q7866 | CreateAppProfile | train | func CreateAppProfile(obj *AppProfile) error {
// Validate parameters
err := ValidateAppProfile(obj)
if err != nil {
log.Errorf("ValidateAppProfile retruned error for: %+v. Err: %v", obj, err)
return err
}
// Check if we handle this object
if objCallbackHandler.AppProfileCb == nil {
log.Errorf("No callback registered for appProfile object")
return errors.New("Invalid object type")
}
saveObj := obj
collections.appProfileMutex.Lock()
key := collections.appProfiles[obj.Key]
collections.appProfileMutex.Unlock()
// Check if object already exists
if key != nil {
// Perform Update callback
err = objCallbackHandler.AppProfileCb.AppProfileUpdate(collections.appProfiles[obj.Key], obj)
if err != nil {
log.Errorf("AppProfileUpdate retruned error for: %+v. Err: %v", obj, err)
return err
}
// save the original object after update
collections.appProfileMutex.Lock()
saveObj = collections.appProfiles[obj.Key]
collections.appProfileMutex.Unlock()
} else {
// save it in cache
collections.appProfileMutex.Lock()
collections.appProfiles[obj.Key] = obj
collections.appProfileMutex.Unlock()
// Perform Create callback
err = objCallbackHandler.AppProfileCb.AppProfileCreate(obj)
if err != nil {
log.Errorf("AppProfileCreate retruned error for: %+v. Err: %v", obj, err)
collections.appProfileMutex.Lock()
delete(collections.appProfiles, obj.Key)
collections.appProfileMutex.Unlock()
return err
}
}
// Write it to modeldb
collections.appProfileMutex.Lock()
err = saveObj.Write()
collections.appProfileMutex.Unlock()
if err != nil {
log.Errorf("Error saving appProfile %s to db. Err: %v", saveObj.Key, err)
return err
}
return nil
} | go | {
"resource": ""
} |
q7867 | FindAppProfile | train | func FindAppProfile(key string) *AppProfile {
collections.appProfileMutex.Lock()
defer collections.appProfileMutex.Unlock()
obj := collections.appProfiles[key]
if obj == nil {
return nil
}
return obj
} | go | {
"resource": ""
} |
q7868 | DeleteAppProfile | train | func DeleteAppProfile(key string) error {
collections.appProfileMutex.Lock()
obj := collections.appProfiles[key]
collections.appProfileMutex.Unlock()
if obj == nil {
log.Errorf("appProfile %s not found", key)
return errors.New("appProfile not found")
}
// Check if we handle this object
if objCallbackHandler.AppProfileCb == nil {
log.Errorf("No callback registered for appProfile object")
return errors.New("Invalid object type")
}
// Perform callback
err := objCallbackHandler.AppProfileCb.AppProfileDelete(obj)
if err != nil {
log.Errorf("AppProfileDelete retruned error for: %+v. Err: %v", obj, err)
return err
}
// delete it from modeldb
collections.appProfileMutex.Lock()
err = obj.Delete()
collections.appProfileMutex.Unlock()
if err != nil {
log.Errorf("Error deleting appProfile %s. Err: %v", obj.Key, err)
}
// delete it from cache
collections.appProfileMutex.Lock()
delete(collections.appProfiles, key)
collections.appProfileMutex.Unlock()
return nil
} | go | {
"resource": ""
} |
q7869 | ValidateAppProfile | train | func ValidateAppProfile(obj *AppProfile) error {
collections.appProfileMutex.Lock()
defer collections.appProfileMutex.Unlock()
// Validate key is correct
keyStr := obj.TenantName + ":" + obj.AppProfileName
if obj.Key != keyStr {
log.Errorf("Expecting AppProfile Key: %s. Got: %s", keyStr, obj.Key)
return errors.New("Invalid Key")
}
// Validate each field
if len(obj.AppProfileName) > 64 {
return errors.New("appProfileName string too long")
}
appProfileNameMatch := 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 appProfileNameMatch.MatchString(obj.AppProfileName) == false {
return errors.New("appProfileName string invalid format")
}
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("tenantName string invalid format")
}
return nil
} | go | {
"resource": ""
} |
q7870 | GetOperBgp | train | func GetOperBgp(obj *BgpInspect) error {
// Check if we handle this object
if objCallbackHandler.BgpCb == nil {
log.Errorf("No callback registered for Bgp object")
return errors.New("Invalid object type")
}
// Perform callback
err := objCallbackHandler.BgpCb.BgpGetOper(obj)
if err != nil {
log.Errorf("BgpDelete retruned error for: %+v. Err: %v", obj, err)
return err
}
return nil
} | go | {
"resource": ""
} |
q7871 | CreateBgp | train | func CreateBgp(obj *Bgp) error {
// Validate parameters
err := ValidateBgp(obj)
if err != nil {
log.Errorf("ValidateBgp retruned error for: %+v. Err: %v", obj, err)
return err
}
// Check if we handle this object
if objCallbackHandler.BgpCb == nil {
log.Errorf("No callback registered for Bgp object")
return errors.New("Invalid object type")
}
saveObj := obj
collections.BgpMutex.Lock()
key := collections.Bgps[obj.Key]
collections.BgpMutex.Unlock()
// Check if object already exists
if key != nil {
// Perform Update callback
err = objCallbackHandler.BgpCb.BgpUpdate(collections.Bgps[obj.Key], obj)
if err != nil {
log.Errorf("BgpUpdate retruned error for: %+v. Err: %v", obj, err)
return err
}
// save the original object after update
collections.BgpMutex.Lock()
saveObj = collections.Bgps[obj.Key]
collections.BgpMutex.Unlock()
} else {
// save it in cache
collections.BgpMutex.Lock()
collections.Bgps[obj.Key] = obj
collections.BgpMutex.Unlock()
// Perform Create callback
err = objCallbackHandler.BgpCb.BgpCreate(obj)
if err != nil {
log.Errorf("BgpCreate retruned error for: %+v. Err: %v", obj, err)
collections.BgpMutex.Lock()
delete(collections.Bgps, obj.Key)
collections.BgpMutex.Unlock()
return err
}
}
// Write it to modeldb
collections.BgpMutex.Lock()
err = saveObj.Write()
collections.BgpMutex.Unlock()
if err != nil {
log.Errorf("Error saving Bgp %s to db. Err: %v", saveObj.Key, err)
return err
}
return nil
} | go | {
"resource": ""
} |
q7872 | FindBgp | train | func FindBgp(key string) *Bgp {
collections.BgpMutex.Lock()
defer collections.BgpMutex.Unlock()
obj := collections.Bgps[key]
if obj == nil {
return nil
}
return obj
} | go | {
"resource": ""
} |
q7873 | DeleteBgp | train | func DeleteBgp(key string) error {
collections.BgpMutex.Lock()
obj := collections.Bgps[key]
collections.BgpMutex.Unlock()
if obj == nil {
log.Errorf("Bgp %s not found", key)
return errors.New("Bgp not found")
}
// Check if we handle this object
if objCallbackHandler.BgpCb == nil {
log.Errorf("No callback registered for Bgp object")
return errors.New("Invalid object type")
}
// Perform callback
err := objCallbackHandler.BgpCb.BgpDelete(obj)
if err != nil {
log.Errorf("BgpDelete retruned error for: %+v. Err: %v", obj, err)
return err
}
// delete it from modeldb
collections.BgpMutex.Lock()
err = obj.Delete()
collections.BgpMutex.Unlock()
if err != nil {
log.Errorf("Error deleting Bgp %s. Err: %v", obj.Key, err)
}
// delete it from cache
collections.BgpMutex.Lock()
delete(collections.Bgps, key)
collections.BgpMutex.Unlock()
return nil
} | go | {
"resource": ""
} |
q7874 | ValidateBgp | train | func ValidateBgp(obj *Bgp) error {
collections.BgpMutex.Lock()
defer collections.BgpMutex.Unlock()
// Validate key is correct
keyStr := obj.Hostname
if obj.Key != keyStr {
log.Errorf("Expecting Bgp Key: %s. Got: %s", keyStr, obj.Key)
return errors.New("Invalid Key")
}
// Validate each field
if len(obj.As) > 64 {
return errors.New("as string too long")
}
if len(obj.Hostname) > 256 {
return errors.New("hostname string too long")
}
hostnameMatch := 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 hostnameMatch.MatchString(obj.Hostname) == false {
return errors.New("hostname string invalid format")
}
if len(obj.Neighbor) > 15 {
return errors.New("neighbor string too long")
}
neighborMatch := regexp.MustCompile("^((25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9]?[0-9])(\\.(25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9]?[0-9])){3})?$")
if neighborMatch.MatchString(obj.Neighbor) == false {
return errors.New("neighbor string invalid format")
}
if len(obj.NeighborAs) > 64 {
return errors.New("neighbor-as string too long")
}
routeripMatch := regexp.MustCompile("^((25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9]?[0-9])(\\.(25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9]?[0-9])){3})(\\-(25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9]?[0-9]))?/(3[0-1]|2[0-9]|1[0-9]|[1-9])$")
if routeripMatch.MatchString(obj.Routerip) == false {
return errors.New("routerip string invalid format")
}
return nil
} | go | {
"resource": ""
} |
q7875 | GetOperEndpoint | train | func GetOperEndpoint(obj *EndpointInspect) error {
// Check if we handle this object
if objCallbackHandler.EndpointCb == nil {
log.Errorf("No callback registered for endpoint object")
return errors.New("Invalid object type")
}
// Perform callback
err := objCallbackHandler.EndpointCb.EndpointGetOper(obj)
if err != nil {
log.Errorf("EndpointDelete retruned error for: %+v. Err: %v", obj, err)
return err
}
return nil
} | go | {
"resource": ""
} |
q7876 | GetOperEndpointGroup | train | func GetOperEndpointGroup(obj *EndpointGroupInspect) error {
// Check if we handle this object
if objCallbackHandler.EndpointGroupCb == nil {
log.Errorf("No callback registered for endpointGroup object")
return errors.New("Invalid object type")
}
// Perform callback
err := objCallbackHandler.EndpointGroupCb.EndpointGroupGetOper(obj)
if err != nil {
log.Errorf("EndpointGroupDelete retruned error for: %+v. Err: %v", obj, err)
return err
}
return nil
} | go | {
"resource": ""
} |
q7877 | CreateEndpointGroup | train | func CreateEndpointGroup(obj *EndpointGroup) error {
// Validate parameters
err := ValidateEndpointGroup(obj)
if err != nil {
log.Errorf("ValidateEndpointGroup retruned error for: %+v. Err: %v", obj, err)
return err
}
// Check if we handle this object
if objCallbackHandler.EndpointGroupCb == nil {
log.Errorf("No callback registered for endpointGroup object")
return errors.New("Invalid object type")
}
saveObj := obj
collections.endpointGroupMutex.Lock()
key := collections.endpointGroups[obj.Key]
collections.endpointGroupMutex.Unlock()
// Check if object already exists
if key != nil {
// Perform Update callback
err = objCallbackHandler.EndpointGroupCb.EndpointGroupUpdate(collections.endpointGroups[obj.Key], obj)
if err != nil {
log.Errorf("EndpointGroupUpdate retruned error for: %+v. Err: %v", obj, err)
return err
}
// save the original object after update
collections.endpointGroupMutex.Lock()
saveObj = collections.endpointGroups[obj.Key]
collections.endpointGroupMutex.Unlock()
} else {
// save it in cache
collections.endpointGroupMutex.Lock()
collections.endpointGroups[obj.Key] = obj
collections.endpointGroupMutex.Unlock()
// Perform Create callback
err = objCallbackHandler.EndpointGroupCb.EndpointGroupCreate(obj)
if err != nil {
log.Errorf("EndpointGroupCreate retruned error for: %+v. Err: %v", obj, err)
collections.endpointGroupMutex.Lock()
delete(collections.endpointGroups, obj.Key)
collections.endpointGroupMutex.Unlock()
return err
}
}
// Write it to modeldb
collections.endpointGroupMutex.Lock()
err = saveObj.Write()
collections.endpointGroupMutex.Unlock()
if err != nil {
log.Errorf("Error saving endpointGroup %s to db. Err: %v", saveObj.Key, err)
return err
}
return nil
} | go | {
"resource": ""
} |
q7878 | FindEndpointGroup | train | func FindEndpointGroup(key string) *EndpointGroup {
collections.endpointGroupMutex.Lock()
defer collections.endpointGroupMutex.Unlock()
obj := collections.endpointGroups[key]
if obj == nil {
return nil
}
return obj
} | go | {
"resource": ""
} |
q7879 | DeleteEndpointGroup | train | func DeleteEndpointGroup(key string) error {
collections.endpointGroupMutex.Lock()
obj := collections.endpointGroups[key]
collections.endpointGroupMutex.Unlock()
if obj == nil {
log.Errorf("endpointGroup %s not found", key)
return errors.New("endpointGroup not found")
}
// Check if we handle this object
if objCallbackHandler.EndpointGroupCb == nil {
log.Errorf("No callback registered for endpointGroup object")
return errors.New("Invalid object type")
}
// Perform callback
err := objCallbackHandler.EndpointGroupCb.EndpointGroupDelete(obj)
if err != nil {
log.Errorf("EndpointGroupDelete retruned error for: %+v. Err: %v", obj, err)
return err
}
// delete it from modeldb
collections.endpointGroupMutex.Lock()
err = obj.Delete()
collections.endpointGroupMutex.Unlock()
if err != nil {
log.Errorf("Error deleting endpointGroup %s. Err: %v", obj.Key, err)
}
// delete it from cache
collections.endpointGroupMutex.Lock()
delete(collections.endpointGroups, key)
collections.endpointGroupMutex.Unlock()
return nil
} | go | {
"resource": ""
} |
q7880 | ValidateEndpointGroup | train | func ValidateEndpointGroup(obj *EndpointGroup) error {
collections.endpointGroupMutex.Lock()
defer collections.endpointGroupMutex.Unlock()
// Validate key is correct
keyStr := obj.TenantName + ":" + obj.GroupName
if obj.Key != keyStr {
log.Errorf("Expecting EndpointGroup Key: %s. Got: %s", keyStr, obj.Key)
return errors.New("Invalid Key")
}
// Validate each field
if len(obj.CfgdTag) > 128 {
return errors.New("cfgdTag string too long")
}
cfgdTagMatch := 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 cfgdTagMatch.MatchString(obj.CfgdTag) == false {
return errors.New("cfgdTag string invalid format")
}
if len(obj.GroupName) > 64 {
return errors.New("groupName string too long")
}
groupNameMatch := 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 groupNameMatch.MatchString(obj.GroupName) == false {
return errors.New("groupName string invalid format")
}
ipPoolMatch := regexp.MustCompile("^$|^((25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9]?[0-9])(\\.(25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9]?[0-9])){3})(\\-((25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9]?[0-9])(\\.(25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9]?[0-9])){3}))?$")
if ipPoolMatch.MatchString(obj.IpPool) == false {
return errors.New("ipPool string invalid format")
}
if len(obj.NetProfile) > 64 {
return errors.New("netProfile string too long")
}
if len(obj.NetworkName) > 64 {
return errors.New("networkName string too long")
}
networkNameMatch := 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 networkNameMatch.MatchString(obj.NetworkName) == false {
return errors.New("networkName string invalid format")
}
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("tenantName string invalid format")
}
return nil
} | go | {
"resource": ""
} |
q7881 | CreateExtContractsGroup | train | func CreateExtContractsGroup(obj *ExtContractsGroup) error {
// Validate parameters
err := ValidateExtContractsGroup(obj)
if err != nil {
log.Errorf("ValidateExtContractsGroup retruned error for: %+v. Err: %v", obj, err)
return err
}
// Check if we handle this object
if objCallbackHandler.ExtContractsGroupCb == nil {
log.Errorf("No callback registered for extContractsGroup object")
return errors.New("Invalid object type")
}
saveObj := obj
collections.extContractsGroupMutex.Lock()
key := collections.extContractsGroups[obj.Key]
collections.extContractsGroupMutex.Unlock()
// Check if object already exists
if key != nil {
// Perform Update callback
err = objCallbackHandler.ExtContractsGroupCb.ExtContractsGroupUpdate(collections.extContractsGroups[obj.Key], obj)
if err != nil {
log.Errorf("ExtContractsGroupUpdate retruned error for: %+v. Err: %v", obj, err)
return err
}
// save the original object after update
collections.extContractsGroupMutex.Lock()
saveObj = collections.extContractsGroups[obj.Key]
collections.extContractsGroupMutex.Unlock()
} else {
// save it in cache
collections.extContractsGroupMutex.Lock()
collections.extContractsGroups[obj.Key] = obj
collections.extContractsGroupMutex.Unlock()
// Perform Create callback
err = objCallbackHandler.ExtContractsGroupCb.ExtContractsGroupCreate(obj)
if err != nil {
log.Errorf("ExtContractsGroupCreate retruned error for: %+v. Err: %v", obj, err)
collections.extContractsGroupMutex.Lock()
delete(collections.extContractsGroups, obj.Key)
collections.extContractsGroupMutex.Unlock()
return err
}
}
// Write it to modeldb
collections.extContractsGroupMutex.Lock()
err = saveObj.Write()
collections.extContractsGroupMutex.Unlock()
if err != nil {
log.Errorf("Error saving extContractsGroup %s to db. Err: %v", saveObj.Key, err)
return err
}
return nil
} | go | {
"resource": ""
} |
q7882 | FindExtContractsGroup | train | func FindExtContractsGroup(key string) *ExtContractsGroup {
collections.extContractsGroupMutex.Lock()
defer collections.extContractsGroupMutex.Unlock()
obj := collections.extContractsGroups[key]
if obj == nil {
return nil
}
return obj
} | go | {
"resource": ""
} |
q7883 | DeleteExtContractsGroup | train | func DeleteExtContractsGroup(key string) error {
collections.extContractsGroupMutex.Lock()
obj := collections.extContractsGroups[key]
collections.extContractsGroupMutex.Unlock()
if obj == nil {
log.Errorf("extContractsGroup %s not found", key)
return errors.New("extContractsGroup not found")
}
// Check if we handle this object
if objCallbackHandler.ExtContractsGroupCb == nil {
log.Errorf("No callback registered for extContractsGroup object")
return errors.New("Invalid object type")
}
// Perform callback
err := objCallbackHandler.ExtContractsGroupCb.ExtContractsGroupDelete(obj)
if err != nil {
log.Errorf("ExtContractsGroupDelete retruned error for: %+v. Err: %v", obj, err)
return err
}
// delete it from modeldb
collections.extContractsGroupMutex.Lock()
err = obj.Delete()
collections.extContractsGroupMutex.Unlock()
if err != nil {
log.Errorf("Error deleting extContractsGroup %s. Err: %v", obj.Key, err)
}
// delete it from cache
collections.extContractsGroupMutex.Lock()
delete(collections.extContractsGroups, key)
collections.extContractsGroupMutex.Unlock()
return nil
} | go | {
"resource": ""
} |
q7884 | ValidateExtContractsGroup | train | func ValidateExtContractsGroup(obj *ExtContractsGroup) error {
collections.extContractsGroupMutex.Lock()
defer collections.extContractsGroupMutex.Unlock()
// Validate key is correct
keyStr := obj.TenantName + ":" + obj.ContractsGroupName
if obj.Key != keyStr {
log.Errorf("Expecting ExtContractsGroup Key: %s. Got: %s", keyStr, obj.Key)
return errors.New("Invalid Key")
}
// Validate each field
if len(obj.ContractsGroupName) > 64 {
return errors.New("contractsGroupName string too long")
}
contractsGroupNameMatch := 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 contractsGroupNameMatch.MatchString(obj.ContractsGroupName) == false {
return errors.New("contractsGroupName string invalid format")
}
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("tenantName string invalid format")
}
return nil
} | go | {
"resource": ""
} |
q7885 | GetOperGlobal | train | func GetOperGlobal(obj *GlobalInspect) error {
// Check if we handle this object
if objCallbackHandler.GlobalCb == nil {
log.Errorf("No callback registered for global object")
return errors.New("Invalid object type")
}
// Perform callback
err := objCallbackHandler.GlobalCb.GlobalGetOper(obj)
if err != nil {
log.Errorf("GlobalDelete retruned error for: %+v. Err: %v", obj, err)
return err
}
return nil
} | go | {
"resource": ""
} |
q7886 | CreateGlobal | train | func CreateGlobal(obj *Global) error {
// Validate parameters
err := ValidateGlobal(obj)
if err != nil {
log.Errorf("ValidateGlobal retruned error for: %+v. Err: %v", obj, err)
return err
}
// Check if we handle this object
if objCallbackHandler.GlobalCb == nil {
log.Errorf("No callback registered for global object")
return errors.New("Invalid object type")
}
saveObj := obj
collections.globalMutex.Lock()
key := collections.globals[obj.Key]
collections.globalMutex.Unlock()
// Check if object already exists
if key != nil {
// Perform Update callback
err = objCallbackHandler.GlobalCb.GlobalUpdate(collections.globals[obj.Key], obj)
if err != nil {
log.Errorf("GlobalUpdate retruned error for: %+v. Err: %v", obj, err)
return err
}
// save the original object after update
collections.globalMutex.Lock()
saveObj = collections.globals[obj.Key]
collections.globalMutex.Unlock()
} else {
// save it in cache
collections.globalMutex.Lock()
collections.globals[obj.Key] = obj
collections.globalMutex.Unlock()
// Perform Create callback
err = objCallbackHandler.GlobalCb.GlobalCreate(obj)
if err != nil {
log.Errorf("GlobalCreate retruned error for: %+v. Err: %v", obj, err)
collections.globalMutex.Lock()
delete(collections.globals, obj.Key)
collections.globalMutex.Unlock()
return err
}
}
// Write it to modeldb
collections.globalMutex.Lock()
err = saveObj.Write()
collections.globalMutex.Unlock()
if err != nil {
log.Errorf("Error saving global %s to db. Err: %v", saveObj.Key, err)
return err
}
return nil
} | go | {
"resource": ""
} |
q7887 | FindGlobal | train | func FindGlobal(key string) *Global {
collections.globalMutex.Lock()
defer collections.globalMutex.Unlock()
obj := collections.globals[key]
if obj == nil {
return nil
}
return obj
} | go | {
"resource": ""
} |
q7888 | DeleteGlobal | train | func DeleteGlobal(key string) error {
collections.globalMutex.Lock()
obj := collections.globals[key]
collections.globalMutex.Unlock()
if obj == nil {
log.Errorf("global %s not found", key)
return errors.New("global not found")
}
// Check if we handle this object
if objCallbackHandler.GlobalCb == nil {
log.Errorf("No callback registered for global object")
return errors.New("Invalid object type")
}
// Perform callback
err := objCallbackHandler.GlobalCb.GlobalDelete(obj)
if err != nil {
log.Errorf("GlobalDelete retruned error for: %+v. Err: %v", obj, err)
return err
}
// delete it from modeldb
collections.globalMutex.Lock()
err = obj.Delete()
collections.globalMutex.Unlock()
if err != nil {
log.Errorf("Error deleting global %s. Err: %v", obj.Key, err)
}
// delete it from cache
collections.globalMutex.Lock()
delete(collections.globals, key)
collections.globalMutex.Unlock()
return nil
} | go | {
"resource": ""
} |
q7889 | ValidateGlobal | train | func ValidateGlobal(obj *Global) error {
collections.globalMutex.Lock()
defer collections.globalMutex.Unlock()
// Validate key is correct
keyStr := obj.Name
if obj.Key != keyStr {
log.Errorf("Expecting Global Key: %s. Got: %s", keyStr, obj.Key)
return errors.New("Invalid Key")
}
// Validate each field
if len(obj.ArpMode) > 64 {
return errors.New("arpMode string too long")
}
arpModeMatch := regexp.MustCompile("^(proxy|flood)?$")
if arpModeMatch.MatchString(obj.ArpMode) == false {
return errors.New("arpMode string invalid format")
}
if len(obj.FwdMode) > 64 {
return errors.New("fwdMode string too long")
}
fwdModeMatch := regexp.MustCompile("^(bridge|routing)?$")
if fwdModeMatch.MatchString(obj.FwdMode) == false {
return errors.New("fwdMode string invalid format")
}
if len(obj.Name) > 64 {
return errors.New("name string too long")
}
nameMatch := regexp.MustCompile("^(global)$")
if nameMatch.MatchString(obj.Name) == false {
return errors.New("name string invalid format")
}
if len(obj.NetworkInfraType) > 64 {
return errors.New("networkInfraType string too long")
}
networkInfraTypeMatch := regexp.MustCompile("^(aci|aci-opflex|default)?$")
if networkInfraTypeMatch.MatchString(obj.NetworkInfraType) == false {
return errors.New("networkInfraType string invalid format")
}
pvtSubnetMatch := regexp.MustCompile("^((25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9]?[0-9])(\\.(25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9]?[0-9])){3})/16$")
if pvtSubnetMatch.MatchString(obj.PvtSubnet) == false {
return errors.New("pvtSubnet string invalid format")
}
vlansMatch := regexp.MustCompile("^([0-9]{1,4}?-[0-9]{1,4}?)$")
if vlansMatch.MatchString(obj.Vlans) == false {
return errors.New("vlans string invalid format")
}
vxlansMatch := regexp.MustCompile("^([0-9]{1,8}?-[0-9]{1,8}?)$")
if vxlansMatch.MatchString(obj.Vxlans) == false {
return errors.New("vxlans string invalid format")
}
return nil
} | go | {
"resource": ""
} |
q7890 | CreateNetprofile | train | func CreateNetprofile(obj *Netprofile) error {
// Validate parameters
err := ValidateNetprofile(obj)
if err != nil {
log.Errorf("ValidateNetprofile retruned error for: %+v. Err: %v", obj, err)
return err
}
// Check if we handle this object
if objCallbackHandler.NetprofileCb == nil {
log.Errorf("No callback registered for netprofile object")
return errors.New("Invalid object type")
}
saveObj := obj
collections.netprofileMutex.Lock()
key := collections.netprofiles[obj.Key]
collections.netprofileMutex.Unlock()
// Check if object already exists
if key != nil {
// Perform Update callback
err = objCallbackHandler.NetprofileCb.NetprofileUpdate(collections.netprofiles[obj.Key], obj)
if err != nil {
log.Errorf("NetprofileUpdate retruned error for: %+v. Err: %v", obj, err)
return err
}
// save the original object after update
collections.netprofileMutex.Lock()
saveObj = collections.netprofiles[obj.Key]
collections.netprofileMutex.Unlock()
} else {
// save it in cache
collections.netprofileMutex.Lock()
collections.netprofiles[obj.Key] = obj
collections.netprofileMutex.Unlock()
// Perform Create callback
err = objCallbackHandler.NetprofileCb.NetprofileCreate(obj)
if err != nil {
log.Errorf("NetprofileCreate retruned error for: %+v. Err: %v", obj, err)
collections.netprofileMutex.Lock()
delete(collections.netprofiles, obj.Key)
collections.netprofileMutex.Unlock()
return err
}
}
// Write it to modeldb
collections.netprofileMutex.Lock()
err = saveObj.Write()
collections.netprofileMutex.Unlock()
if err != nil {
log.Errorf("Error saving netprofile %s to db. Err: %v", saveObj.Key, err)
return err
}
return nil
} | go | {
"resource": ""
} |
q7891 | FindNetprofile | train | func FindNetprofile(key string) *Netprofile {
collections.netprofileMutex.Lock()
defer collections.netprofileMutex.Unlock()
obj := collections.netprofiles[key]
if obj == nil {
return nil
}
return obj
} | go | {
"resource": ""
} |
q7892 | DeleteNetprofile | train | func DeleteNetprofile(key string) error {
collections.netprofileMutex.Lock()
obj := collections.netprofiles[key]
collections.netprofileMutex.Unlock()
if obj == nil {
log.Errorf("netprofile %s not found", key)
return errors.New("netprofile not found")
}
// Check if we handle this object
if objCallbackHandler.NetprofileCb == nil {
log.Errorf("No callback registered for netprofile object")
return errors.New("Invalid object type")
}
// Perform callback
err := objCallbackHandler.NetprofileCb.NetprofileDelete(obj)
if err != nil {
log.Errorf("NetprofileDelete retruned error for: %+v. Err: %v", obj, err)
return err
}
// delete it from modeldb
collections.netprofileMutex.Lock()
err = obj.Delete()
collections.netprofileMutex.Unlock()
if err != nil {
log.Errorf("Error deleting netprofile %s. Err: %v", obj.Key, err)
}
// delete it from cache
collections.netprofileMutex.Lock()
delete(collections.netprofiles, key)
collections.netprofileMutex.Unlock()
return nil
} | go | {
"resource": ""
} |
q7893 | ValidateNetprofile | train | func ValidateNetprofile(obj *Netprofile) error {
collections.netprofileMutex.Lock()
defer collections.netprofileMutex.Unlock()
// Validate key is correct
keyStr := obj.TenantName + ":" + obj.ProfileName
if obj.Key != keyStr {
log.Errorf("Expecting Netprofile Key: %s. Got: %s", keyStr, obj.Key)
return errors.New("Invalid Key")
}
// Validate each field
if obj.DSCP == 0 {
obj.DSCP = 0
}
if obj.DSCP > 63 {
return errors.New("DSCP Value Out of bound")
}
if len(obj.Bandwidth) > 64 {
return errors.New("bandwidth string too long")
}
bandwidthMatch := regexp.MustCompile("^([1-9][0-9]* (([kmgKMG{1}]bps)|[kmgKMG{1}]|(kb|Kb|Gb|gb|Mb|mb)))?$|^([1-9][0-9]*(((k|m|g|K|G|M)bps)|(k|m|g|K|M|G)|(kb|Kb|Gb|gb|Mb|mb)))?$")
if bandwidthMatch.MatchString(obj.Bandwidth) == false {
return errors.New("bandwidth string invalid format")
}
if obj.Burst > 10486 {
return errors.New("burst Value Out of bound")
}
if len(obj.ProfileName) > 64 {
return errors.New("profileName string too long")
}
return nil
} | go | {
"resource": ""
} |
q7894 | GetOperNetwork | train | func GetOperNetwork(obj *NetworkInspect) error {
// Check if we handle this object
if objCallbackHandler.NetworkCb == nil {
log.Errorf("No callback registered for network object")
return errors.New("Invalid object type")
}
// Perform callback
err := objCallbackHandler.NetworkCb.NetworkGetOper(obj)
if err != nil {
log.Errorf("NetworkDelete retruned error for: %+v. Err: %v", obj, err)
return err
}
return nil
} | go | {
"resource": ""
} |
q7895 | CreateNetwork | train | func CreateNetwork(obj *Network) error {
// Validate parameters
err := ValidateNetwork(obj)
if err != nil {
log.Errorf("ValidateNetwork retruned error for: %+v. Err: %v", obj, err)
return err
}
// Check if we handle this object
if objCallbackHandler.NetworkCb == nil {
log.Errorf("No callback registered for network object")
return errors.New("Invalid object type")
}
saveObj := obj
collections.networkMutex.Lock()
key := collections.networks[obj.Key]
collections.networkMutex.Unlock()
// Check if object already exists
if key != nil {
// Perform Update callback
err = objCallbackHandler.NetworkCb.NetworkUpdate(collections.networks[obj.Key], obj)
if err != nil {
log.Errorf("NetworkUpdate retruned error for: %+v. Err: %v", obj, err)
return err
}
// save the original object after update
collections.networkMutex.Lock()
saveObj = collections.networks[obj.Key]
collections.networkMutex.Unlock()
} else {
// save it in cache
collections.networkMutex.Lock()
collections.networks[obj.Key] = obj
collections.networkMutex.Unlock()
// Perform Create callback
err = objCallbackHandler.NetworkCb.NetworkCreate(obj)
if err != nil {
log.Errorf("NetworkCreate retruned error for: %+v. Err: %v", obj, err)
collections.networkMutex.Lock()
delete(collections.networks, obj.Key)
collections.networkMutex.Unlock()
return err
}
}
// Write it to modeldb
collections.networkMutex.Lock()
err = saveObj.Write()
collections.networkMutex.Unlock()
if err != nil {
log.Errorf("Error saving network %s to db. Err: %v", saveObj.Key, err)
return err
}
return nil
} | go | {
"resource": ""
} |
q7896 | FindNetwork | train | func FindNetwork(key string) *Network {
collections.networkMutex.Lock()
defer collections.networkMutex.Unlock()
obj := collections.networks[key]
if obj == nil {
return nil
}
return obj
} | go | {
"resource": ""
} |
q7897 | DeleteNetwork | train | func DeleteNetwork(key string) error {
collections.networkMutex.Lock()
obj := collections.networks[key]
collections.networkMutex.Unlock()
if obj == nil {
log.Errorf("network %s not found", key)
return errors.New("network not found")
}
// Check if we handle this object
if objCallbackHandler.NetworkCb == nil {
log.Errorf("No callback registered for network object")
return errors.New("Invalid object type")
}
// Perform callback
err := objCallbackHandler.NetworkCb.NetworkDelete(obj)
if err != nil {
log.Errorf("NetworkDelete retruned error for: %+v. Err: %v", obj, err)
return err
}
// delete it from modeldb
collections.networkMutex.Lock()
err = obj.Delete()
collections.networkMutex.Unlock()
if err != nil {
log.Errorf("Error deleting network %s. Err: %v", obj.Key, err)
}
// delete it from cache
collections.networkMutex.Lock()
delete(collections.networks, key)
collections.networkMutex.Unlock()
return nil
} | go | {
"resource": ""
} |
q7898 | ValidateNetwork | train | func ValidateNetwork(obj *Network) error {
collections.networkMutex.Lock()
defer collections.networkMutex.Unlock()
// Validate key is correct
keyStr := obj.TenantName + ":" + obj.NetworkName
if obj.Key != keyStr {
log.Errorf("Expecting Network Key: %s. Got: %s", keyStr, obj.Key)
return errors.New("Invalid Key")
}
// Validate each field
if len(obj.CfgdTag) > 128 {
return errors.New("cfgdTag string too long")
}
cfgdTagMatch := 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 cfgdTagMatch.MatchString(obj.CfgdTag) == false {
return errors.New("cfgdTag string invalid format")
}
encapMatch := regexp.MustCompile("^(vlan|vxlan)$")
if encapMatch.MatchString(obj.Encap) == false {
return errors.New("encap string invalid format")
}
gatewayMatch := regexp.MustCompile("^((25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9]?[0-9])(\\.(25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9]?[0-9])){3})?$")
if gatewayMatch.MatchString(obj.Gateway) == false {
return errors.New("gateway string invalid format")
}
ipv6GatewayMatch := regexp.MustCompile("^(((([0-9]|[a-f]|[A-F]){1,4})((\\:([0-9]|[a-f]|[A-F]){1,4}){7}))|(((([0-9]|[a-f]|[A-F]){1,4}\\:){0,6}|\\:)((\\:([0-9]|[a-f]|[A-F]){1,4}){0,6}|\\:)))?$")
if ipv6GatewayMatch.MatchString(obj.Ipv6Gateway) == false {
return errors.New("ipv6Gateway string invalid format")
}
ipv6SubnetMatch := regexp.MustCompile("^((((([0-9]|[a-f]|[A-F]){1,4})((\\:([0-9]|[a-f]|[A-F]){1,4}){7}))|(((([0-9]|[a-f]|[A-F]){1,4}\\:){0,6}|\\:)((\\:([0-9]|[a-f]|[A-F]){1,4}){0,6}|\\:)))/(1[0-2][0-7]|[1-9][0-9]|[1-9]))?$")
if ipv6SubnetMatch.MatchString(obj.Ipv6Subnet) == false {
return errors.New("ipv6Subnet string invalid format")
}
if len(obj.NetworkName) > 64 {
return errors.New("networkName string too long")
}
networkNameMatch := 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 networkNameMatch.MatchString(obj.NetworkName) == false {
return errors.New("networkName string invalid format")
}
if obj.NwType == "" {
obj.NwType = "data"
}
nwTypeMatch := regexp.MustCompile("^(infra|data)$")
if nwTypeMatch.MatchString(obj.NwType) == false {
return errors.New("nwType string invalid format")
}
if obj.PktTag > 1.6777216e+07 {
return errors.New("pktTag Value Out of bound")
}
subnetMatch := regexp.MustCompile("^((25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9]?[0-9])(\\.(25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9]?[0-9])){3})(\\-((25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9]?[0-9])(\\.(25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9]?[0-9])){3}))?/(3[0-1]|2[0-9]|1[0-9]|[1-9])$")
if subnetMatch.MatchString(obj.Subnet) == false {
return errors.New("subnet string invalid format")
}
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("tenantName string invalid format")
}
return nil
} | go | {
"resource": ""
} |
q7899 | GetOperPolicy | train | func GetOperPolicy(obj *PolicyInspect) error {
// Check if we handle this object
if objCallbackHandler.PolicyCb == nil {
log.Errorf("No callback registered for policy object")
return errors.New("Invalid object type")
}
// Perform callback
err := objCallbackHandler.PolicyCb.PolicyGetOper(obj)
if err != nil {
log.Errorf("PolicyDelete retruned error for: %+v. Err: %v", obj, err)
return err
}
return nil
} | go | {
"resource": ""
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.