_id stringlengths 2 7 | title stringlengths 1 118 | partition stringclasses 3 values | text stringlengths 52 85.5k | language stringclasses 1 value | meta_information dict |
|---|---|---|---|---|---|
q8100 | AciGwInspect | train | func (c *ContivClient) AciGwInspect(name string) (*AciGwInspect, error) {
// build key and URL
keyStr := name
url := c.baseURL + "/api/v1/inspect/aciGws/" + keyStr + "/"
// http get the object
var obj AciGwInspect
err := c.httpGet(url, &obj)
if err != nil {
log.Debugf("Error getting aciGw %+v. Err: %v", keyStr, err)
return nil, err
}
return &obj, nil
} | go | {
"resource": ""
} |
q8101 | AppProfilePost | train | func (c *ContivClient) AppProfilePost(obj *AppProfile) error {
// build key and URL
keyStr := obj.TenantName + ":" + obj.AppProfileName
url := c.baseURL + "/api/v1/appProfiles/" + keyStr + "/"
// http post the object
err := c.httpPost(url, obj)
if err != nil {
log.Debugf("Error creating appProfile %+v. Err: %v", obj, err)
return err
}
return nil
} | go | {
"resource": ""
} |
q8102 | AppProfileList | train | func (c *ContivClient) AppProfileList() (*[]*AppProfile, error) {
// build key and URL
url := c.baseURL + "/api/v1/appProfiles/"
// http get the object
var objList []*AppProfile
err := c.httpGet(url, &objList)
if err != nil {
log.Debugf("Error getting appProfiles. Err: %v", err)
return nil, err
}
return &objList, nil
} | go | {
"resource": ""
} |
q8103 | BgpPost | train | func (c *ContivClient) BgpPost(obj *Bgp) error {
// build key and URL
keyStr := obj.Hostname
url := c.baseURL + "/api/v1/Bgps/" + keyStr + "/"
// http post the object
err := c.httpPost(url, obj)
if err != nil {
log.Debugf("Error creating Bgp %+v. Err: %v", obj, err)
return err
}
return nil
} | go | {
"resource": ""
} |
q8104 | BgpList | train | func (c *ContivClient) BgpList() (*[]*Bgp, error) {
// build key and URL
url := c.baseURL + "/api/v1/Bgps/"
// http get the object
var objList []*Bgp
err := c.httpGet(url, &objList)
if err != nil {
log.Debugf("Error getting Bgps. Err: %v", err)
return nil, err
}
return &objList, nil
} | go | {
"resource": ""
} |
q8105 | BgpGet | train | func (c *ContivClient) BgpGet(hostname string) (*Bgp, error) {
// build key and URL
keyStr := hostname
url := c.baseURL + "/api/v1/Bgps/" + keyStr + "/"
// http get the object
var obj Bgp
err := c.httpGet(url, &obj)
if err != nil {
log.Debugf("Error getting Bgp %+v. Err: %v", keyStr, err)
return nil, err
}
return &obj, nil
} | go | {
"resource": ""
} |
q8106 | BgpDelete | train | func (c *ContivClient) BgpDelete(hostname string) error {
// build key and URL
keyStr := hostname
url := c.baseURL + "/api/v1/Bgps/" + keyStr + "/"
// http get the object
err := c.httpDelete(url)
if err != nil {
log.Debugf("Error deleting Bgp %s. Err: %v", keyStr, err)
return err
}
return nil
} | go | {
"resource": ""
} |
q8107 | EndpointInspect | train | func (c *ContivClient) EndpointInspect(endpointID string) (*EndpointInspect, error) {
// build key and URL
keyStr := endpointID
url := c.baseURL + "/api/v1/inspect/endpoints/" + keyStr + "/"
// http get the object
var obj EndpointInspect
err := c.httpGet(url, &obj)
if err != nil {
log.Debugf("Error getting endpoint %+v. Err: %v", keyStr, err)
return nil, err
}
return &obj, nil
} | go | {
"resource": ""
} |
q8108 | EndpointGroupPost | train | func (c *ContivClient) EndpointGroupPost(obj *EndpointGroup) error {
// build key and URL
keyStr := obj.TenantName + ":" + obj.GroupName
url := c.baseURL + "/api/v1/endpointGroups/" + keyStr + "/"
// http post the object
err := c.httpPost(url, obj)
if err != nil {
log.Debugf("Error creating endpointGroup %+v. Err: %v", obj, err)
return err
}
return nil
} | go | {
"resource": ""
} |
q8109 | EndpointGroupList | train | func (c *ContivClient) EndpointGroupList() (*[]*EndpointGroup, error) {
// build key and URL
url := c.baseURL + "/api/v1/endpointGroups/"
// http get the object
var objList []*EndpointGroup
err := c.httpGet(url, &objList)
if err != nil {
log.Debugf("Error getting endpointGroups. Err: %v", err)
return nil, err
}
return &objList, nil
} | go | {
"resource": ""
} |
q8110 | ExtContractsGroupPost | train | func (c *ContivClient) ExtContractsGroupPost(obj *ExtContractsGroup) error {
// build key and URL
keyStr := obj.TenantName + ":" + obj.ContractsGroupName
url := c.baseURL + "/api/v1/extContractsGroups/" + keyStr + "/"
// http post the object
err := c.httpPost(url, obj)
if err != nil {
log.Debugf("Error creating extContractsGroup %+v. Err: %v", obj, err)
return err
}
return nil
} | go | {
"resource": ""
} |
q8111 | ExtContractsGroupList | train | func (c *ContivClient) ExtContractsGroupList() (*[]*ExtContractsGroup, error) {
// build key and URL
url := c.baseURL + "/api/v1/extContractsGroups/"
// http get the object
var objList []*ExtContractsGroup
err := c.httpGet(url, &objList)
if err != nil {
log.Debugf("Error getting extContractsGroups. Err: %v", err)
return nil, err
}
return &objList, nil
} | go | {
"resource": ""
} |
q8112 | GlobalPost | train | func (c *ContivClient) GlobalPost(obj *Global) error {
// build key and URL
keyStr := obj.Name
url := c.baseURL + "/api/v1/globals/" + keyStr + "/"
// http post the object
err := c.httpPost(url, obj)
if err != nil {
log.Debugf("Error creating global %+v. Err: %v", obj, err)
return err
}
return nil
} | go | {
"resource": ""
} |
q8113 | GlobalList | train | func (c *ContivClient) GlobalList() (*[]*Global, error) {
// build key and URL
url := c.baseURL + "/api/v1/globals/"
// http get the object
var objList []*Global
err := c.httpGet(url, &objList)
if err != nil {
log.Debugf("Error getting globals. Err: %v", err)
return nil, err
}
return &objList, nil
} | go | {
"resource": ""
} |
q8114 | NetprofilePost | train | func (c *ContivClient) NetprofilePost(obj *Netprofile) error {
// build key and URL
keyStr := obj.TenantName + ":" + obj.ProfileName
url := c.baseURL + "/api/v1/netprofiles/" + keyStr + "/"
// http post the object
err := c.httpPost(url, obj)
if err != nil {
log.Debugf("Error creating netprofile %+v. Err: %v", obj, err)
return err
}
return nil
} | go | {
"resource": ""
} |
q8115 | NetprofileList | train | func (c *ContivClient) NetprofileList() (*[]*Netprofile, error) {
// build key and URL
url := c.baseURL + "/api/v1/netprofiles/"
// http get the object
var objList []*Netprofile
err := c.httpGet(url, &objList)
if err != nil {
log.Debugf("Error getting netprofiles. Err: %v", err)
return nil, err
}
return &objList, nil
} | go | {
"resource": ""
} |
q8116 | NetworkPost | train | func (c *ContivClient) NetworkPost(obj *Network) error {
// build key and URL
keyStr := obj.TenantName + ":" + obj.NetworkName
url := c.baseURL + "/api/v1/networks/" + keyStr + "/"
// http post the object
err := c.httpPost(url, obj)
if err != nil {
log.Debugf("Error creating network %+v. Err: %v", obj, err)
return err
}
return nil
} | go | {
"resource": ""
} |
q8117 | NetworkList | train | func (c *ContivClient) NetworkList() (*[]*Network, error) {
// build key and URL
url := c.baseURL + "/api/v1/networks/"
// http get the object
var objList []*Network
err := c.httpGet(url, &objList)
if err != nil {
log.Debugf("Error getting networks. Err: %v", err)
return nil, err
}
return &objList, nil
} | go | {
"resource": ""
} |
q8118 | PolicyPost | train | func (c *ContivClient) PolicyPost(obj *Policy) error {
// build key and URL
keyStr := obj.TenantName + ":" + obj.PolicyName
url := c.baseURL + "/api/v1/policys/" + keyStr + "/"
// http post the object
err := c.httpPost(url, obj)
if err != nil {
log.Debugf("Error creating policy %+v. Err: %v", obj, err)
return err
}
return nil
} | go | {
"resource": ""
} |
q8119 | PolicyList | train | func (c *ContivClient) PolicyList() (*[]*Policy, error) {
// build key and URL
url := c.baseURL + "/api/v1/policys/"
// http get the object
var objList []*Policy
err := c.httpGet(url, &objList)
if err != nil {
log.Debugf("Error getting policys. Err: %v", err)
return nil, err
}
return &objList, nil
} | go | {
"resource": ""
} |
q8120 | RulePost | train | func (c *ContivClient) RulePost(obj *Rule) error {
// build key and URL
keyStr := obj.TenantName + ":" + obj.PolicyName + ":" + obj.RuleID
url := c.baseURL + "/api/v1/rules/" + keyStr + "/"
// http post the object
err := c.httpPost(url, obj)
if err != nil {
log.Debugf("Error creating rule %+v. Err: %v", obj, err)
return err
}
return nil
} | go | {
"resource": ""
} |
q8121 | RuleList | train | func (c *ContivClient) RuleList() (*[]*Rule, error) {
// build key and URL
url := c.baseURL + "/api/v1/rules/"
// http get the object
var objList []*Rule
err := c.httpGet(url, &objList)
if err != nil {
log.Debugf("Error getting rules. Err: %v", err)
return nil, err
}
return &objList, nil
} | go | {
"resource": ""
} |
q8122 | ServiceLBPost | train | func (c *ContivClient) ServiceLBPost(obj *ServiceLB) error {
// build key and URL
keyStr := obj.TenantName + ":" + obj.ServiceName
url := c.baseURL + "/api/v1/serviceLBs/" + keyStr + "/"
// http post the object
err := c.httpPost(url, obj)
if err != nil {
log.Debugf("Error creating serviceLB %+v. Err: %v", obj, err)
return err
}
return nil
} | go | {
"resource": ""
} |
q8123 | ServiceLBList | train | func (c *ContivClient) ServiceLBList() (*[]*ServiceLB, error) {
// build key and URL
url := c.baseURL + "/api/v1/serviceLBs/"
// http get the object
var objList []*ServiceLB
err := c.httpGet(url, &objList)
if err != nil {
log.Debugf("Error getting serviceLBs. Err: %v", err)
return nil, err
}
return &objList, nil
} | go | {
"resource": ""
} |
q8124 | TenantPost | train | func (c *ContivClient) TenantPost(obj *Tenant) error {
// build key and URL
keyStr := obj.TenantName
url := c.baseURL + "/api/v1/tenants/" + keyStr + "/"
// http post the object
err := c.httpPost(url, obj)
if err != nil {
log.Debugf("Error creating tenant %+v. Err: %v", obj, err)
return err
}
return nil
} | go | {
"resource": ""
} |
q8125 | TenantList | train | func (c *ContivClient) TenantList() (*[]*Tenant, error) {
// build key and URL
url := c.baseURL + "/api/v1/tenants/"
// http get the object
var objList []*Tenant
err := c.httpGet(url, &objList)
if err != nil {
log.Debugf("Error getting tenants. Err: %v", err)
return nil, err
}
return &objList, nil
} | go | {
"resource": ""
} |
q8126 | VolumePost | train | func (c *ContivClient) VolumePost(obj *Volume) error {
// build key and URL
keyStr := obj.TenantName + ":" + obj.VolumeName
url := c.baseURL + "/api/v1/volumes/" + keyStr + "/"
// http post the object
err := c.httpPost(url, obj)
if err != nil {
log.Debugf("Error creating volume %+v. Err: %v", obj, err)
return err
}
return nil
} | go | {
"resource": ""
} |
q8127 | VolumeList | train | func (c *ContivClient) VolumeList() (*[]*Volume, error) {
// build key and URL
url := c.baseURL + "/api/v1/volumes/"
// http get the object
var objList []*Volume
err := c.httpGet(url, &objList)
if err != nil {
log.Debugf("Error getting volumes. Err: %v", err)
return nil, err
}
return &objList, nil
} | go | {
"resource": ""
} |
q8128 | VolumeProfilePost | train | func (c *ContivClient) VolumeProfilePost(obj *VolumeProfile) error {
// build key and URL
keyStr := obj.TenantName + ":" + obj.VolumeProfileName
url := c.baseURL + "/api/v1/volumeProfiles/" + keyStr + "/"
// http post the object
err := c.httpPost(url, obj)
if err != nil {
log.Debugf("Error creating volumeProfile %+v. Err: %v", obj, err)
return err
}
return nil
} | go | {
"resource": ""
} |
q8129 | VolumeProfileList | train | func (c *ContivClient) VolumeProfileList() (*[]*VolumeProfile, error) {
// build key and URL
url := c.baseURL + "/api/v1/volumeProfiles/"
// http get the object
var objList []*VolumeProfile
err := c.httpGet(url, &objList)
if err != nil {
log.Debugf("Error getting volumeProfiles. Err: %v", err)
return nil, err
}
return &objList, nil
} | go | {
"resource": ""
} |
q8130 | VolumeProfileGet | train | func (c *ContivClient) VolumeProfileGet(tenantName string, volumeProfileName string) (*VolumeProfile, error) {
// build key and URL
keyStr := tenantName + ":" + volumeProfileName
url := c.baseURL + "/api/v1/volumeProfiles/" + keyStr + "/"
// http get the object
var obj VolumeProfile
err := c.httpGet(url, &obj)
if err != nil {
log.Debugf("Error getting volumeProfile %+v. Err: %v", keyStr, err)
return nil, err
}
return &obj, nil
} | go | {
"resource": ""
} |
q8131 | VolumeProfileDelete | train | func (c *ContivClient) VolumeProfileDelete(tenantName string, volumeProfileName string) error {
// build key and URL
keyStr := tenantName + ":" + volumeProfileName
url := c.baseURL + "/api/v1/volumeProfiles/" + keyStr + "/"
// http get the object
err := c.httpDelete(url)
if err != nil {
log.Debugf("Error deleting volumeProfile %s. Err: %v", keyStr, err)
return err
}
return nil
} | go | {
"resource": ""
} |
q8132 | NewStateResourceManager | train | func NewStateResourceManager(sd core.StateDriver) (*StateResourceManager, error) {
if gStateResourceManager != nil {
return nil, core.Errorf("state-based resource manager instance already exists.")
}
gStateResourceManager = &StateResourceManager{stateDriver: sd}
err := gStateResourceManager.Init()
if err != nil {
return nil, err
}
return gStateResourceManager, nil
} | go | {
"resource": ""
} |
q8133 | GetStateResourceManager | train | func GetStateResourceManager() (*StateResourceManager, error) {
if gStateResourceManager == nil {
return nil, core.Errorf("state-based resource manager has not been not created.")
}
return gStateResourceManager, nil
} | go | {
"resource": ""
} |
q8134 | DefineResource | train | func (rm *StateResourceManager) DefineResource(id, desc string,
rsrcCfg interface{}) error {
// XXX: need to take care of distibuted updates, locks etc here
rsrc, alreadyExists, err := rm.findResource(id, desc)
if err != nil {
return err
}
if alreadyExists {
return core.Errorf("Resource with id: %q already exists", id)
}
return rsrc.Init(rsrcCfg)
} | go | {
"resource": ""
} |
q8135 | UndefineResource | train | func (rm *StateResourceManager) UndefineResource(id, desc string) error {
// XXX: need to take care of distibuted updates, locks etc here
rsrc, alreadyExists, err := rm.findResource(id, desc)
if err != nil {
return err
}
if !alreadyExists {
return core.Errorf("No resource found for description: %q and id: %q",
desc, id)
}
rsrc.Deinit()
return nil
} | go | {
"resource": ""
} |
q8136 | RedefineResource | train | func (rm *StateResourceManager) RedefineResource(id, desc string, rsrcCfg interface{}) error {
rsrc, alreadyExists, err := rm.findResource(id, desc)
if err != nil {
return err
}
if !alreadyExists {
return core.Errorf("No resource found for description: %q and id: %q",
desc, id)
}
rsrc.Reinit(rsrcCfg)
return nil
} | go | {
"resource": ""
} |
q8137 | GetResourceList | train | func (rm *StateResourceManager) GetResourceList(id, desc string) (uint, string) {
// XXX: need to take care of distibuted updates, locks etc here
rsrc, _, err := rm.findResource(id, desc)
if err != nil {
log.Errorf("unable to find resource %s desc %s", id, desc)
return 0, ""
}
return rsrc.GetList()
} | go | {
"resource": ""
} |
q8138 | AllocateResourceVal | train | func (rm *StateResourceManager) AllocateResourceVal(id, desc string, reqValue interface{}) (interface{},
error) {
// XXX: need to take care of distibuted updates, locks etc here
rsrc, alreadyExists, err := rm.findResource(id, desc)
if err != nil {
return nil, err
}
if !alreadyExists {
return nil, core.Errorf("No resource found for description: %q and id: %q",
desc, id)
}
return rsrc.Allocate(reqValue)
} | go | {
"resource": ""
} |
q8139 | DeallocateResourceVal | train | func (rm *StateResourceManager) DeallocateResourceVal(id, desc string,
value interface{}) error {
// XXX: need to take care of distibuted updates, locks etc here
rsrc, alreadyExists, err := rm.findResource(id, desc)
if err != nil {
return err
}
if !alreadyExists {
return core.Errorf("No resource found for description: %q and id: %q",
desc, id)
}
return rsrc.Deallocate(value)
} | go | {
"resource": ""
} |
q8140 | ReadAll | train | func (s *GlobConfig) ReadAll() ([]core.State, error) {
return s.StateDriver.ReadAllState(globalConfigPathPrefix, s, json.Unmarshal)
} | go | {
"resource": ""
} |
q8141 | getPvtIP | train | func (sw *OvsSwitch) getPvtIP(portName string) net.IP {
if strings.Contains(portName, "vport") {
port := strings.Replace(portName, "vvport", "", 1)
portNum, err := strconv.Atoi(port)
if err == nil {
ipStr, _ := netutils.PortToHostIPMAC(portNum, sw.hostPvtNW)
log.Infof("PvtIP: %s", ipStr)
ips := strings.Split(ipStr, "/")
if len(ips) > 0 {
return net.ParseIP(ips[0])
}
}
log.Errorf("Error getting port number from %s - %v", port, err)
}
log.Infof("No pvt IP for port %s", portName)
return nil
} | go | {
"resource": ""
} |
q8142 | GetUplinkInterfaces | train | func (sw *OvsSwitch) GetUplinkInterfaces(uplinkID string) []string {
uplink, _ := sw.uplinkDb.Get(uplinkID)
if uplink == nil {
return nil
}
return uplink.([]string)
} | go | {
"resource": ""
} |
q8143 | NewOvsSwitch | train | func NewOvsSwitch(bridgeName, netType, localIP, fwdMode string,
vlanIntf []string, hostPvtNW int, vxlanUDPPort int) (*OvsSwitch, error) {
var err error
var datapath string
var ofnetPort, ctrlrPort uint16
log.Infof("Received request to create new ovs switch bridge:%s, localIP:%s, fwdMode:%s", bridgeName, localIP, fwdMode)
sw := new(OvsSwitch)
sw.bridgeName = bridgeName
sw.netType = netType
sw.uplinkDb = cmap.New()
sw.hostPvtNW = hostPvtNW
sw.vxlanEncapMtu, err = netutils.GetHostLowestLinkMtu()
if err != nil {
log.Fatalf("Failed to get Host Node MTU. Err: %v", err)
}
// Create OVS db driver
sw.ovsdbDriver, err = NewOvsdbDriver(bridgeName, "secure", vxlanUDPPort)
if err != nil {
log.Fatalf("Error creating ovsdb driver. Err: %v", err)
}
sw.ovsdbDriver.ovsSwitch = sw
if netType == "vxlan" {
ofnetPort = vxlanOfnetPort
ctrlrPort = vxlanCtrlerPort
switch fwdMode {
case "bridge":
datapath = "vxlan"
case "routing":
datapath = "vrouter"
default:
log.Errorf("Invalid datapath mode")
return nil, errors.New("invalid forwarding mode. Expects 'bridge' or 'routing'")
}
// Create an ofnet agent
sw.ofnetAgent, err = ofnet.NewOfnetAgent(bridgeName, datapath, net.ParseIP(localIP),
ofnetPort, ctrlrPort, vlanIntf)
if err != nil {
log.Fatalf("Error initializing ofnet")
return nil, err
}
} else if netType == "vlan" {
ofnetPort = vlanOfnetPort
ctrlrPort = vlanCtrlerPort
switch fwdMode {
case "bridge":
datapath = "vlan"
case "routing":
datapath = "vlrouter"
default:
log.Errorf("Invalid datapath mode")
return nil, errors.New("invalid forwarding mode. Expects 'bridge' or 'routing'")
}
// Create an ofnet agent
sw.ofnetAgent, err = ofnet.NewOfnetAgent(bridgeName, datapath, net.ParseIP(localIP),
ofnetPort, ctrlrPort, vlanIntf)
if err != nil {
log.Fatalf("Error initializing ofnet")
return nil, err
}
} else if netType == "host" {
err = fmt.Errorf("Explicit host-net not supported")
return nil, err
}
// Add controller to the OVS
ctrlerIP := "127.0.0.1"
target := fmt.Sprintf("tcp:%s:%d", ctrlerIP, ctrlrPort)
if !sw.ovsdbDriver.IsControllerPresent(target) {
err = sw.ovsdbDriver.AddController(ctrlerIP, ctrlrPort)
if err != nil {
log.Errorf("Error adding controller to switch: %s. Err: %v", bridgeName, err)
return nil, err
}
}
log.Infof("Waiting for OVS switch(%s) to connect..", netType)
// Wait for a while for OVS switch to connect to agent
if sw.ofnetAgent != nil {
sw.ofnetAgent.WaitForSwitchConnection()
}
log.Infof("Switch (%s) connected.", netType)
return sw, nil
} | go | {
"resource": ""
} |
q8144 | Delete | train | func (sw *OvsSwitch) Delete() {
if sw.ofnetAgent != nil {
sw.ofnetAgent.Delete()
}
if sw.ovsdbDriver != nil {
sw.ovsdbDriver.Delete()
// Wait a little for OVS switch to be deleted
time.Sleep(300 * time.Millisecond)
}
} | go | {
"resource": ""
} |
q8145 | createVethPair | train | func createVethPair(name1, name2 string) error {
log.Infof("Creating Veth pairs with name: %s, %s", name1, name2)
// Veth pair params
veth := &netlink.Veth{
LinkAttrs: netlink.LinkAttrs{
Name: name1,
TxQLen: 0,
},
PeerName: name2,
}
// Create the veth pair
if err := netlink.LinkAdd(veth); err != nil {
log.Errorf("error creating veth pair: %v", err)
return err
}
return nil
} | go | {
"resource": ""
} |
q8146 | setLinkMtu | train | func setLinkMtu(name string, mtu int) error {
iface, err := netlink.LinkByName(name)
if err != nil {
return err
}
return netlink.LinkSetMTU(iface, mtu)
} | go | {
"resource": ""
} |
q8147 | getOvsPortName | train | func getOvsPortName(intfName string, skipVethPair bool) string {
var ovsPortName string
if useVethPair && !skipVethPair {
ovsPortName = strings.Replace(intfName, "port", "vport", 1)
} else {
ovsPortName = intfName
}
return ovsPortName
} | go | {
"resource": ""
} |
q8148 | UpdateEndpoint | train | func (sw *OvsSwitch) UpdateEndpoint(ovsPortName string, burst, dscp int, epgBandwidth int64) error {
// update bandwidth
err := sw.ovsdbDriver.UpdatePolicingRate(ovsPortName, burst, epgBandwidth)
if err != nil {
return err
}
// Get the openflow port number for the interface
ofpPort, err := sw.ovsdbDriver.GetOfpPortNo(ovsPortName)
if err != nil {
log.Errorf("Could not find the OVS port %s. Err: %v", ovsPortName, err)
return err
}
// Build the updated endpoint info
endpoint := ofnet.EndpointInfo{
PortNo: ofpPort,
Dscp: dscp,
}
// update endpoint state in ofnet
err = sw.ofnetAgent.UpdateLocalEndpoint(endpoint)
if err != nil {
log.Errorf("Error updating local port %s to ofnet. Err: %v", ovsPortName, err)
return err
}
return nil
} | go | {
"resource": ""
} |
q8149 | UpdatePort | train | func (sw *OvsSwitch) UpdatePort(intfName string, cfgEp *mastercfg.CfgEndpointState, pktTag, nwPktTag, dscp int, skipVethPair bool) error {
// Get OVS port name
ovsPortName := getOvsPortName(intfName, skipVethPair)
// Add the endpoint to ofnet
// Get the openflow port number for the interface
ofpPort, err := sw.ovsdbDriver.GetOfpPortNo(ovsPortName)
if err != nil {
log.Errorf("Could not find the OVS port %s. Err: %v", ovsPortName, err)
return err
}
macAddr, _ := net.ParseMAC(cfgEp.MacAddress)
// Build the endpoint info
endpoint := ofnet.EndpointInfo{
PortNo: ofpPort,
MacAddr: macAddr,
Vlan: uint16(nwPktTag),
IpAddr: net.ParseIP(cfgEp.IPAddress),
Ipv6Addr: net.ParseIP(cfgEp.IPv6Address),
EndpointGroup: cfgEp.EndpointGroupID,
EndpointGroupVlan: uint16(pktTag),
Dscp: dscp,
}
// Add the local port to ofnet
if sw.ofnetAgent == nil {
log.Infof("Skipping adding localport to ofnet")
return nil
}
err = sw.ofnetAgent.AddLocalEndpoint(endpoint)
if err != nil {
log.Errorf("Error adding local port %s to ofnet. Err: %v", ovsPortName, err)
return err
}
return nil
} | go | {
"resource": ""
} |
q8150 | DeletePort | train | func (sw *OvsSwitch) DeletePort(epOper *drivers.OperEndpointState, skipVethPair bool) error {
if epOper.VtepIP != "" {
return nil
}
// Get the OVS port name
ovsPortName := getOvsPortName(epOper.PortName, skipVethPair)
// Get the openflow port number for the interface and remove from ofnet
ofpPort, err := sw.ovsdbDriver.GetOfpPortNo(ovsPortName)
if err == nil {
if sw.ofnetAgent != nil {
err = sw.ofnetAgent.RemoveLocalEndpoint(ofpPort)
}
} else {
if sw.ofnetAgent != nil {
var tenantName string
netParts := strings.Split(epOper.NetID, ".")
if len(netParts) == 2 {
tenantName = netParts[1]
} else {
tenantName = "default"
}
epID := sw.ofnetAgent.GetEndpointIdByIpVrf(net.ParseIP(epOper.IPAddress), tenantName)
err = sw.ofnetAgent.RemoveLocalEndpointByID(epID)
}
}
if err != nil {
log.Errorf("Error removing endpoint %+v from ofnet. Err: %v", epOper, err)
// continue with further cleanup
}
// Delete it from ovsdb
err = sw.ovsdbDriver.DeletePort(ovsPortName)
if err != nil {
log.Errorf("Error deleting port %s from OVS. Err: %v", ovsPortName, err)
// continue with further cleanup
}
// Delete the Veth pairs if required
if useVethPair && !skipVethPair {
// Delete a Veth pair
verr := deleteVethPair(ovsPortName, epOper.PortName)
if verr != nil {
log.Errorf("Error deleting veth pairs. Err: %v", verr)
return verr
}
}
return err
} | go | {
"resource": ""
} |
q8151 | vxlanIfName | train | func vxlanIfName(vtepIP string) string {
return fmt.Sprintf(vxlanIfNameFmt, strings.Replace(vtepIP, ".", "", -1))
} | go | {
"resource": ""
} |
q8152 | CreateVtep | train | func (sw *OvsSwitch) CreateVtep(vtepIP string) error {
// Create interface name for VTEP
intfName := vxlanIfName(vtepIP)
log.Infof("Creating VTEP intf %s for IP %s", intfName, vtepIP)
// Check if it already exists
isPresent, vsifName := sw.ovsdbDriver.IsVtepPresent(vtepIP)
if !isPresent || (vsifName != intfName) {
// Ask ovsdb to create it
err := sw.ovsdbDriver.CreateVtep(intfName, vtepIP)
if err != nil {
log.Errorf("Error creating VTEP port %s. Err: %v", intfName, err)
}
}
// Wait a little for OVS to create the interface
time.Sleep(300 * time.Millisecond)
// Get the openflow port number for the interface
ofpPort, err := sw.ovsdbDriver.GetOfpPortNo(intfName)
if err != nil {
log.Errorf("Could not find the OVS port %s. Err: %v", intfName, err)
return err
}
// Add info about VTEP port to ofnet
if sw.ofnetAgent != nil {
err = sw.ofnetAgent.AddVtepPort(ofpPort, net.ParseIP(vtepIP))
if err != nil {
log.Errorf("Error adding VTEP port %s to ofnet. Err: %v", intfName, err)
return err
}
}
return nil
} | go | {
"resource": ""
} |
q8153 | DeleteVtep | train | func (sw *OvsSwitch) DeleteVtep(vtepIP string) error {
// Build vtep interface name
intfName := vxlanIfName(vtepIP)
log.Infof("Deleting VTEP intf %s for IP %s", intfName, vtepIP)
// Get the openflow port number for the interface
ofpPort, err := sw.ovsdbDriver.GetOfpPortNo(intfName)
if err != nil {
log.Errorf("Could not find the OVS port %s. Err: %v", intfName, err)
return err
}
// Add info about VTEP port to ofnet
if sw.ofnetAgent != nil {
err = sw.ofnetAgent.RemoveVtepPort(ofpPort, net.ParseIP(vtepIP))
if err != nil {
log.Errorf("Error deleting VTEP port %s to ofnet. Err: %v", intfName, err)
return err
}
}
// ask ovsdb to delete the VTEP
return sw.ovsdbDriver.DeleteVtep(intfName)
} | go | {
"resource": ""
} |
q8154 | HandleLinkUpdates | train | func (sw *OvsSwitch) HandleLinkUpdates(linkUpd ofnet.LinkUpdateInfo) {
for intfListObj := range sw.uplinkDb.IterBuffered() {
intfList := intfListObj.Val.([]string)
for _, intf := range intfList {
if intf == linkUpd.LinkName {
portName := intfListObj.Key
portUpds := ofnet.PortUpdates{
PortName: portName,
Updates: []ofnet.PortUpdate{
{
UpdateType: ofnet.LacpUpdate,
UpdateInfo: linkUpd,
},
},
}
err := sw.ofnetAgent.UpdateUplink(portName, portUpds)
if err != nil {
log.Errorf("Update uplink failed. Err: %+v", err)
}
return
}
}
}
} | go | {
"resource": ""
} |
q8155 | RemoveUplinks | train | func (sw *OvsSwitch) RemoveUplinks() error {
var err error
// some error checking
if sw.netType != "vlan" {
log.Fatalf("Can not remove uplink from OVS type %s.", sw.netType)
}
for intfListObj := range sw.uplinkDb.IterBuffered() {
intfList := intfListObj.Val.([]string)
portName := intfListObj.Key
// Remove uplink from agent
err = sw.ofnetAgent.RemoveUplink(portName)
if err != nil {
log.Errorf("Error removing uplink %s. Err: %v", portName, err)
return err
}
log.Infof("Removed uplink %s from ofnet", portName)
isPortPresent := sw.ovsdbDriver.IsPortNamePresent(portName)
if len(intfList) == 1 {
isPortPresent = sw.ovsdbDriver.IsPortNamePresent(intfList[0])
}
if isPortPresent {
if len(intfList) == 1 {
err = sw.ovsdbDriver.DeletePort(intfList[0])
} else {
err = sw.ovsdbDriver.DeletePortBond(portName, intfList)
}
if err != nil {
log.Errorf("Error deleting uplink %s from OVS. Err: %v", portName, err)
return err
}
}
time.Sleep(time.Second)
sw.uplinkDb.Remove(portName)
log.Infof("Removed uplink %s(%+v) from OVS switch %s.", portName, intfList, sw.bridgeName)
}
return nil
} | go | {
"resource": ""
} |
q8156 | AddHostPort | train | func (sw *OvsSwitch) AddHostPort(intfName string, intfNum, network int, isHostNS bool) (string, error) {
var err error
// some error checking
if sw.netType != "vxlan" {
log.Fatalf("Can not add host port to OVS type %s.", sw.netType)
}
ovsPortType := ""
ovsPortName := getOvsPortName(intfName, isHostNS)
if isHostNS {
ovsPortType = "internal"
} else {
log.Infof("Host port in container name space -- ignore")
return "", nil
}
portID := "host" + intfName
// If the port already exists in OVS, remove it first
if sw.ovsdbDriver.IsPortNamePresent(ovsPortName) {
log.Infof("Removing existing interface entry %s from OVS", ovsPortName)
// Delete it from ovsdb
err := sw.ovsdbDriver.DeletePort(ovsPortName)
if err != nil {
log.Errorf("Error deleting port %s from OVS. Err: %v", ovsPortName, err)
}
}
// Ask OVSDB driver to add the port as an access port
err = sw.ovsdbDriver.CreatePort(ovsPortName, ovsPortType, portID, hostVLAN, 0, 0)
if err != nil {
log.Errorf("Error adding hostport %s to OVS. Err: %v", intfName, err)
return "", err
}
// Get the openflow port number for the interface
ofpPort, err := sw.ovsdbDriver.GetOfpPortNo(ovsPortName)
if err != nil {
log.Errorf("Could not find the OVS port %s. Err: %v", intfName, err)
return "", err
}
// Assign an IP based on the intfnumber
ipStr, macStr := netutils.PortToHostIPMAC(intfNum, network)
mac, _ := net.ParseMAC(macStr)
portInfo := ofnet.HostPortInfo{
PortNo: ofpPort,
MacAddr: mac,
IpAddr: ipStr,
Kind: "NAT",
}
// Add to ofnet if this is the hostNS port.
netutils.SetInterfaceMac(intfName, macStr)
netutils.SetInterfaceIP(intfName, ipStr)
err = setLinkUp(intfName)
if sw.ofnetAgent != nil {
err = sw.ofnetAgent.AddHostPort(portInfo)
if err != nil {
log.Errorf("Error adding host port %s. Err: %v", intfName, err)
return "", err
}
}
log.Infof("Added host port %s to OVS switch %s.", intfName, sw.bridgeName)
defer func() {
if err != nil {
sw.ovsdbDriver.DeletePort(intfName)
}
}()
return ipStr, nil
} | go | {
"resource": ""
} |
q8157 | DelHostPort | train | func (sw *OvsSwitch) DelHostPort(intfName string, isHostNS bool) error {
var err error
ovsPortName := getOvsPortName(intfName, isHostNS)
// Get the openflow port number for the interface
ofpPort, err := sw.ovsdbDriver.GetOfpPortNo(ovsPortName)
if err != nil {
log.Errorf("Could not find the OVS port %s. Err: %v", intfName, err)
}
// If the port already exists in OVS, remove it first
if sw.ovsdbDriver.IsPortNamePresent(ovsPortName) {
log.Debugf("Removing interface entry %s from OVS", ovsPortName)
// Delete it from ovsdb
err := sw.ovsdbDriver.DeletePort(ovsPortName)
if err != nil {
log.Errorf("Error deleting port %s from OVS. Err: %v", ovsPortName, err)
}
}
if isHostNS && sw.ofnetAgent != nil {
err = sw.ofnetAgent.RemoveHostPort(ofpPort)
if err != nil {
log.Errorf("Error deleting host port %s. Err: %v", intfName, err)
return err
}
}
return nil
} | go | {
"resource": ""
} |
q8158 | DeleteMaster | train | func (sw *OvsSwitch) DeleteMaster(node core.ServiceInfo) error {
// Build master info
masterInfo := ofnet.OfnetNode{
HostAddr: node.HostAddr,
HostPort: uint16(node.Port),
}
// remove the master
if sw.ofnetAgent != nil {
err := sw.ofnetAgent.RemoveMaster(&masterInfo)
if err != nil {
log.Errorf("Error deleting ofnet master %+v. Err: %v", masterInfo, err)
return err
}
}
return nil
} | go | {
"resource": ""
} |
q8159 | AddBgp | train | func (sw *OvsSwitch) AddBgp(hostname string, routerIP string,
As string, neighborAs, neighbor string) error {
if sw.netType == "vlan" && sw.ofnetAgent != nil {
err := sw.ofnetAgent.AddBgp(routerIP, As, neighborAs, neighbor)
if err != nil {
log.Errorf("Error adding BGP server")
return err
}
}
return nil
} | go | {
"resource": ""
} |
q8160 | DeleteBgp | train | func (sw *OvsSwitch) DeleteBgp() error {
if sw.netType == "vlan" && sw.ofnetAgent != nil {
// Delete vlan/vni mapping
err := sw.ofnetAgent.DeleteBgp()
if err != nil {
log.Errorf("Error removing bgp server Err: %v", err)
return err
}
}
return nil
} | go | {
"resource": ""
} |
q8161 | AddSvcSpec | train | func (sw *OvsSwitch) AddSvcSpec(svcName string, spec *ofnet.ServiceSpec) error {
log.Infof("OvsSwitch AddSvcSpec %s", svcName)
if sw.ofnetAgent != nil {
return sw.ofnetAgent.AddSvcSpec(svcName, spec)
}
return nil
} | go | {
"resource": ""
} |
q8162 | DelSvcSpec | train | func (sw *OvsSwitch) DelSvcSpec(svcName string, spec *ofnet.ServiceSpec) error {
if sw.ofnetAgent != nil {
return sw.ofnetAgent.DelSvcSpec(svcName, spec)
}
return nil
} | go | {
"resource": ""
} |
q8163 | SvcProviderUpdate | train | func (sw *OvsSwitch) SvcProviderUpdate(svcName string, providers []string) {
if sw.ofnetAgent != nil {
sw.ofnetAgent.SvcProviderUpdate(svcName, providers)
}
} | go | {
"resource": ""
} |
q8164 | GetEndpointStats | train | func (sw *OvsSwitch) GetEndpointStats() (map[string]*ofnet.OfnetEndpointStats, error) {
if sw.ofnetAgent == nil {
return nil, errors.New("no ofnet agent")
}
stats, err := sw.ofnetAgent.GetEndpointStats()
if err != nil {
log.Errorf("Error: %v", err)
return nil, err
}
log.Debugf("stats: %+v", stats)
return stats, nil
} | go | {
"resource": ""
} |
q8165 | InspectState | train | func (sw *OvsSwitch) InspectState() (interface{}, error) {
if sw.ofnetAgent == nil {
return nil, errors.New("no ofnet agent")
}
return sw.ofnetAgent.InspectState()
} | go | {
"resource": ""
} |
q8166 | InspectBgp | train | func (sw *OvsSwitch) InspectBgp() (interface{}, error) {
if sw.ofnetAgent == nil {
return nil, errors.New("no ofnet agent")
}
return sw.ofnetAgent.InspectBgp()
} | go | {
"resource": ""
} |
q8167 | GlobalConfigUpdate | train | func (sw *OvsSwitch) GlobalConfigUpdate(cfg ofnet.OfnetGlobalConfig) error {
if sw.ofnetAgent == nil {
return errors.New("no ofnet agent")
}
return sw.ofnetAgent.GlobalConfigUpdate(cfg)
} | go | {
"resource": ""
} |
q8168 | AddNameServer | train | func (sw *OvsSwitch) AddNameServer(ns ofnet.NameServer) {
if sw.ofnetAgent != nil {
sw.ofnetAgent.AddNameServer(ns)
}
} | go | {
"resource": ""
} |
q8169 | NewAPIClient | train | func NewAPIClient(serverURL, caFile, keyFile, certFile, authToken string) *APIClient {
useClientCerts := true
c := APIClient{}
c.apiServerPort = 6443 // default
port := strings.Split(serverURL, ":")
if len(port) > 0 {
if v, err := strconv.ParseUint(port[len(port)-1], 10, 16); err == nil {
c.apiServerPort = uint16(v)
} else {
log.Warnf("parse failed: %s, use default api server port: %d", err, c.apiServerPort)
}
}
c.baseURL = serverURL + "/api/v1/namespaces/"
c.watchBase = serverURL + "/api/v1/watch/"
// Read CA cert
ca, err := ioutil.ReadFile(caFile)
if err != nil {
log.Fatal(err)
return nil
}
caPool := x509.NewCertPool()
caPool.AppendCertsFromPEM(ca)
// Read client cert
cert, err := tls.LoadX509KeyPair(certFile, keyFile)
// We need either the client certs or a non-empty authToken to proceed
if err != nil {
// We cannot use client certs now
useClientCerts = false
// Check for a non-empty token
if len(strings.TrimSpace(authToken)) == 0 {
log.Fatalf("Error %s loading the client certificates and missing auth token", err)
return nil
}
}
// Setup HTTPS client
tlsCfg := &tls.Config{
RootCAs: caPool,
}
// Setup client cert based authentication
if useClientCerts {
tlsCfg.Certificates = []tls.Certificate{cert}
tlsCfg.BuildNameToCertificate()
}
transport := &http.Transport{TLSClientConfig: tlsCfg}
c.client = &http.Client{Transport: transport}
c.authToken = authToken
p := &c.podCache
p.labels = make(map[string]string)
p.nameSpace = ""
p.name = ""
return &c
} | go | {
"resource": ""
} |
q8170 | fetchPodLabels | train | func (c *APIClient) fetchPodLabels(ns, name string) error {
var data interface{}
// initiate a get request to the api server
podURL := c.baseURL + ns + "/pods/" + name
req, err := http.NewRequest("GET", podURL, nil)
if err != nil {
return err
}
if len(strings.TrimSpace(c.authToken)) > 0 {
req.Header.Set("Authorization", fmt.Sprintf("Bearer %s", c.authToken))
}
r, err := c.client.Do(req)
if err != nil {
return err
}
defer r.Body.Close()
switch {
case r.StatusCode == int(404):
return fmt.Errorf("page not found")
case r.StatusCode == int(403):
return fmt.Errorf("access denied")
case r.StatusCode != int(200):
log.Errorf("GET Status '%s' status code %d \n", r.Status, r.StatusCode)
return fmt.Errorf("%s", r.Status)
}
response, err := ioutil.ReadAll(r.Body)
if err != nil {
return err
}
err = json.Unmarshal(response, &data)
if err != nil {
return err
}
podSpec := data.(map[string]interface{})
m, ok := podSpec["metadata"]
// Treat missing metadata as a fatal error
if !ok {
return fmt.Errorf("metadata not found in podSpec")
}
p := &c.podCache
p.labelsMutex.Lock()
defer p.labelsMutex.Unlock()
p.setDefaults(ns, name)
meta := m.(map[string]interface{})
l, ok := meta["labels"]
if ok {
labels := l.(map[string]interface{})
for key, val := range labels {
switch valType := val.(type) {
case string:
p.labels[key] = val.(string)
default:
log.Infof("Label %s type %v in pod %s.%s ignored",
key, valType, ns, name)
}
}
} else {
log.Infof("labels not found in podSpec metadata, using defaults")
}
return nil
} | go | {
"resource": ""
} |
q8171 | GetPodLabel | train | func (c *APIClient) GetPodLabel(ns, name, label string) (string, error) {
// If cache does not match, fetch
if c.podCache.nameSpace != ns || c.podCache.name != name {
err := c.fetchPodLabels(ns, name)
if err != nil {
return "", err
}
}
c.podCache.labelsMutex.Lock()
defer c.podCache.labelsMutex.Unlock()
res, found := c.podCache.labels[label]
if found {
return res, nil
}
log.Infof("label %s not found in podSpec for %s.%s", label, ns, name)
return "", nil
} | go | {
"resource": ""
} |
q8172 | WatchSvcEps | train | func (c *APIClient) WatchSvcEps(respCh chan EpWatchResp) {
ctx, _ := context.WithCancel(context.Background())
go func() {
// Make request to Kubernetes API
getURL := c.watchBase + "endpoints"
req, err := http.NewRequest("GET", getURL, nil)
if err != nil {
respCh <- EpWatchResp{opcode: "FATAL", errStr: fmt.Sprintf("Req %v", err)}
return
}
req.Header.Set("Authorization", fmt.Sprintf("Bearer %s", c.authToken))
res, err := ctxhttp.Do(ctx, c.client, req)
if err != nil {
log.Errorf("EP Watch error: %v", err)
respCh <- EpWatchResp{opcode: "FATAL", errStr: fmt.Sprintf("Do %v", err)}
return
}
defer res.Body.Close()
var weps watchSvcEpStatus
reader := bufio.NewReader(res.Body)
// bufio.Reader.ReadBytes is blocking, so we watch for
// context timeout or cancellation in a goroutine
// and close the response body when see see it. The
// response body is also closed via defer when the
// request is made, but closing twice is OK.
go func() {
<-ctx.Done()
res.Body.Close()
}()
for {
line, err := reader.ReadBytes('\n')
if ctx.Err() != nil {
respCh <- EpWatchResp{opcode: "ERROR", errStr: fmt.Sprintf("ctx %v", err)}
return
}
if err != nil {
respCh <- EpWatchResp{opcode: "ERROR", errStr: fmt.Sprintf("read %v", err)}
return
}
if err := json.Unmarshal(line, &weps); err != nil {
respCh <- EpWatchResp{opcode: "WARN", errStr: fmt.Sprintf("unmarshal %v", err)}
continue
}
if weps.Object.ObjectMeta.Namespace == "kube-system" && (weps.Object.ObjectMeta.Name == "kube-scheduler" || weps.Object.ObjectMeta.Name == "kube-controller-manager") {
// Ignoring these frequent updates
continue
}
resp := EpWatchResp{opcode: weps.Type}
resp.svcName = weps.Object.ObjectMeta.Name
resp.providers = make([]string, 0, 1)
for _, subset := range weps.Object.Subsets {
// TODO: handle partially ready providers
for _, addr := range subset.Addresses {
resp.providers = append(resp.providers, addr.IP)
}
}
log.Infof("kube ep watch: %v", resp)
respCh <- resp
}
}()
} | go | {
"resource": ""
} |
q8173 | ReadAll | train | func (s *CfgPolicyRule) ReadAll() ([]core.State, error) {
return s.StateDriver.ReadAllState(policyRuleConfigPathPrefix, s, json.Unmarshal)
} | go | {
"resource": ""
} |
q8174 | WatchAll | train | func (s *CfgPolicyRule) WatchAll(rsps chan core.WatchState) error {
return s.StateDriver.WatchAllState(policyRuleConfigPathPrefix, s, json.Unmarshal,
rsps)
} | go | {
"resource": ""
} |
q8175 | addPolicyRuleState | train | func addPolicyRuleState(ofnetRule *ofnet.OfnetPolicyRule) error {
ruleCfg := &CfgPolicyRule{}
ruleCfg.StateDriver = stateStore
ruleCfg.OfnetPolicyRule = (*ofnetRule)
// Save the rule
return ruleCfg.Write()
} | go | {
"resource": ""
} |
q8176 | delPolicyRuleState | train | func delPolicyRuleState(ofnetRule *ofnet.OfnetPolicyRule) error {
ruleCfg := &CfgPolicyRule{}
ruleCfg.StateDriver = stateStore
ruleCfg.OfnetPolicyRule = (*ofnetRule)
// Delete the rule
return ruleCfg.Clear()
} | go | {
"resource": ""
} |
q8177 | ListenWrapper | train | func ListenWrapper(l net.Listener) net.Listener {
return &contivListener{
Listener: l,
cond: sync.NewCond(&sync.Mutex{})}
} | go | {
"resource": ""
} |
q8178 | Accept | train | func (s *contivListener) Accept() (net.Conn, error) {
s.incrementRef()
defer s.decrementRef()
return s.Listener.Accept()
} | go | {
"resource": ""
} |
q8179 | Close | train | func (s *contivListener) Close() error {
if err := s.Listener.Close(); err != nil {
return err
}
s.cond.L.Lock()
for s.refCnt > 0 {
s.cond.Wait()
}
s.cond.L.Unlock()
return nil
} | go | {
"resource": ""
} |
q8180 | NewNWClient | train | func NewNWClient() *NWClient {
c := NWClient{}
c.baseURL = nwURL
transport := &http.Transport{Dial: unixDial}
c.client = &http.Client{Transport: transport}
return &c
} | go | {
"resource": ""
} |
q8181 | AddPod | train | func (c *NWClient) AddPod(podInfo interface{}) (*cniapi.RspAddPod, error) {
data := cniapi.RspAddPod{}
buf, err := json.Marshal(podInfo)
if err != nil {
return nil, err
}
body := bytes.NewBuffer(buf)
url := c.baseURL + cniapi.EPAddURL
r, err := c.client.Post(url, "application/json", body)
if err != nil {
return nil, err
}
defer r.Body.Close()
switch {
case r.StatusCode == int(404):
return nil, fmt.Errorf("page not found")
case r.StatusCode == int(403):
return nil, fmt.Errorf("access denied")
case r.StatusCode == int(500):
info, err := ioutil.ReadAll(r.Body)
if err != nil {
return nil, err
}
err = json.Unmarshal(info, &data)
if err != nil {
return nil, err
}
return &data, fmt.Errorf("internal server error")
case r.StatusCode != int(200):
log.Errorf("POST Status '%s' status code %d \n", r.Status, r.StatusCode)
return nil, fmt.Errorf("%s", r.Status)
}
response, err := ioutil.ReadAll(r.Body)
if err != nil {
return nil, err
}
err = json.Unmarshal(response, &data)
if err != nil {
return nil, err
}
return &data, nil
} | go | {
"resource": ""
} |
q8182 | DelPod | train | func (c *NWClient) DelPod(podInfo interface{}) error {
buf, err := json.Marshal(podInfo)
if err != nil {
return err
}
body := bytes.NewBuffer(buf)
url := c.baseURL + cniapi.EPDelURL
r, err := c.client.Post(url, "application/json", body)
if err != nil {
return err
}
defer r.Body.Close()
switch {
case r.StatusCode == int(404):
return fmt.Errorf("page not found")
case r.StatusCode == int(403):
return fmt.Errorf("access denied")
case r.StatusCode != int(200):
log.Errorf("GET Status '%s' status code %d \n", r.Status, r.StatusCode)
return fmt.Errorf("%s", r.Status)
}
return nil
} | go | {
"resource": ""
} |
q8183 | NewAPIController | train | func NewAPIController(router *mux.Router, objdbClient objdb.API, configs *APIControllerConfig) *APIController {
ctrler := new(APIController)
ctrler.router = router
ctrler.objdbClient = objdbClient
// init modeldb
modeldb.Init(&objdbClient)
// initialize the model objects
contivModel.Init()
// Register Callbacks
contivModel.RegisterGlobalCallbacks(ctrler)
contivModel.RegisterAppProfileCallbacks(ctrler)
contivModel.RegisterEndpointGroupCallbacks(ctrler)
contivModel.RegisterNetworkCallbacks(ctrler)
contivModel.RegisterPolicyCallbacks(ctrler)
contivModel.RegisterRuleCallbacks(ctrler)
contivModel.RegisterTenantCallbacks(ctrler)
contivModel.RegisterBgpCallbacks(ctrler)
contivModel.RegisterServiceLBCallbacks(ctrler)
contivModel.RegisterExtContractsGroupCallbacks(ctrler)
contivModel.RegisterEndpointCallbacks(ctrler)
contivModel.RegisterNetprofileCallbacks(ctrler)
contivModel.RegisterAciGwCallbacks(ctrler)
// Register routes
contivModel.AddRoutes(router)
// Init global state from config
initGlobalConfigs(configs)
// Add default tenant if it doesnt exist
tenant := contivModel.FindTenant("default")
if tenant == nil {
log.Infof("Creating default tenant")
err := contivModel.CreateTenant(&contivModel.Tenant{
Key: "default",
TenantName: "default",
})
if err != nil {
log.Fatalf("Error creating default tenant. Err: %v", err)
}
}
return ctrler
} | go | {
"resource": ""
} |
q8184 | GlobalGetOper | train | func (ac *APIController) GlobalGetOper(global *contivModel.GlobalInspect) error {
log.Infof("Received GlobalInspect: %+v", global)
stateDriver, err := utils.GetStateDriver()
if err != nil {
return err
}
gOper := &gstate.Oper{}
gOper.StateDriver = stateDriver
err = gOper.Read("")
if err != nil {
log.Errorf("Error obtaining global operational state")
return err
}
global.Oper.DefaultNetwork = gOper.DefaultNetwork
global.Oper.FreeVXLANsStart = int(gOper.FreeVXLANsStart)
gCfg := &gstate.Cfg{}
gCfg.StateDriver = stateDriver
numVlans, vlansInUse := gCfg.GetVlansInUse()
numVxlans, vxlansInUse := gCfg.GetVxlansInUse()
global.Oper.NumNetworks = int(numVlans + numVxlans)
global.Oper.VlansInUse = vlansInUse
global.Oper.VxlansInUse = vxlansInUse
global.Oper.ClusterMode = master.GetClusterMode()
return nil
} | go | {
"resource": ""
} |
q8185 | GlobalCreate | train | func (ac *APIController) GlobalCreate(global *contivModel.Global) error {
log.Infof("Received GlobalCreate: %+v", global)
// Get the state driver
stateDriver, err := utils.GetStateDriver()
if err != nil {
return err
}
// Build global config
gCfg := intent.ConfigGlobal{
NwInfraType: global.NetworkInfraType,
VLANs: global.Vlans,
VXLANs: global.Vxlans,
FwdMode: global.FwdMode,
ArpMode: global.ArpMode,
PvtSubnet: global.PvtSubnet,
}
// Create the object
err = master.CreateGlobal(stateDriver, &gCfg)
if err != nil {
log.Errorf("Error creating global config {%+v}. Err: %v", global, err)
return err
}
return nil
} | go | {
"resource": ""
} |
q8186 | GlobalUpdate | train | func (ac *APIController) GlobalUpdate(global, params *contivModel.Global) error {
log.Infof("Received GlobalUpdate: %+v. Old: %+v", params, global)
// Get the state driver
stateDriver, err := utils.GetStateDriver()
if err != nil {
return err
}
gCfg := &gstate.Cfg{}
gCfg.StateDriver = stateDriver
numVlans, _ := gCfg.GetVlansInUse()
numVxlans, _ := gCfg.GetVxlansInUse()
// Build global config
globalCfg := intent.ConfigGlobal{}
// Generate helpful error message when networks exist
errExistingNetworks := func(optionLabel string) error {
msgs := []string{}
if numVlans > 0 {
msgs = append(msgs, fmt.Sprintf("%d vlans", numVlans))
}
if numVxlans > 0 {
msgs = append(msgs, fmt.Sprintf("%d vxlans", numVxlans))
}
msg := fmt.Sprintf("Unable to update %s due to existing %s",
optionLabel, strings.Join(msgs, " and "))
log.Errorf(msg)
return fmt.Errorf(msg)
}
//check for change in forwarding mode
if global.FwdMode != params.FwdMode {
//check if there exists any non default network and tenants
if numVlans+numVxlans > 0 {
return errExistingNetworks("forwarding mode")
}
if global.FwdMode == "routing" {
//check if any bgp configurations exists.
bgpCfgs := &mastercfg.CfgBgpState{}
bgpCfgs.StateDriver = stateDriver
cfgs, _ := bgpCfgs.ReadAll()
if len(cfgs) != 0 {
log.Errorf("Unable to change the forwarding mode due to existing bgp configs")
return fmt.Errorf("please delete existing Bgp configs")
}
}
globalCfg.FwdMode = params.FwdMode
}
if global.ArpMode != params.ArpMode {
globalCfg.ArpMode = params.ArpMode
}
if global.Vlans != params.Vlans {
globalCfg.VLANs = params.Vlans
}
if global.Vxlans != params.Vxlans {
globalCfg.VXLANs = params.Vxlans
}
if global.NetworkInfraType != params.NetworkInfraType {
globalCfg.NwInfraType = params.NetworkInfraType
}
if global.PvtSubnet != params.PvtSubnet {
if (global.PvtSubnet != "" || params.PvtSubnet != defaultHostPvtNet) && numVlans+numVxlans > 0 {
return errExistingNetworks("private subnet")
}
globalCfg.PvtSubnet = params.PvtSubnet
}
// Create the object
err = master.UpdateGlobal(stateDriver, &globalCfg)
if err != nil {
log.Errorf("Error creating global config {%+v}. Err: %v", global, err)
return err
}
global.NetworkInfraType = params.NetworkInfraType
global.Vlans = params.Vlans
global.Vxlans = params.Vxlans
global.FwdMode = params.FwdMode
global.ArpMode = params.ArpMode
global.PvtSubnet = params.PvtSubnet
return nil
} | go | {
"resource": ""
} |
q8187 | GlobalDelete | train | func (ac *APIController) GlobalDelete(global *contivModel.Global) error {
log.Infof("Received GlobalDelete: %+v", global)
// Get the state driver
stateDriver, err := utils.GetStateDriver()
if err != nil {
return err
}
// Delete global state
err = master.DeleteGlobal(stateDriver)
if err != nil {
log.Errorf("Error deleting global config. Err: %v", err)
return err
}
return nil
} | go | {
"resource": ""
} |
q8188 | AciGwCreate | train | func (ac *APIController) AciGwCreate(aci *contivModel.AciGw) error {
log.Infof("Received AciGwCreate: %+v", aci)
// Fail the create if app profiles exist
profCount := contivModel.GetAppProfileCount()
if profCount != 0 {
log.Warnf("AciGwCreate: %d existing App-Profiles found.",
profCount)
}
return nil
} | go | {
"resource": ""
} |
q8189 | AciGwUpdate | train | func (ac *APIController) AciGwUpdate(aci, params *contivModel.AciGw) error {
log.Infof("Received AciGwUpdate: %+v", params)
// Fail the update if app profiles exist
profCount := contivModel.GetAppProfileCount()
if profCount != 0 {
log.Warnf("AciGwUpdate: %d existing App-Profiles found.",
profCount)
}
aci.EnforcePolicies = params.EnforcePolicies
aci.IncludeCommonTenant = params.IncludeCommonTenant
aci.NodeBindings = params.NodeBindings
aci.PathBindings = params.PathBindings
aci.PhysicalDomain = params.PhysicalDomain
return nil
} | go | {
"resource": ""
} |
q8190 | AciGwDelete | train | func (ac *APIController) AciGwDelete(aci *contivModel.AciGw) error {
log.Infof("Received AciGwDelete")
// Fail the delete if app profiles exist
profCount := contivModel.GetAppProfileCount()
if profCount != 0 {
return core.Errorf("%d App-Profiles found. Delete them first",
profCount)
}
return nil
} | go | {
"resource": ""
} |
q8191 | AciGwGetOper | train | func (ac *APIController) AciGwGetOper(op *contivModel.AciGwInspect) error {
op.Oper.NumAppProfiles = contivModel.GetAppProfileCount()
return nil
} | go | {
"resource": ""
} |
q8192 | AppProfileCreate | train | func (ac *APIController) AppProfileCreate(prof *contivModel.AppProfile) error {
log.Infof("Received AppProfileCreate: %+v", prof)
// Make sure tenant exists
if prof.TenantName == "" {
return core.Errorf("Invalid tenant name")
}
tenant := contivModel.FindTenant(prof.TenantName)
if tenant == nil {
return core.Errorf("Tenant %s not found", prof.TenantName)
}
for _, epg := range prof.EndpointGroups {
epgKey := prof.TenantName + ":" + epg
epgObj := contivModel.FindEndpointGroup(epgKey)
if epgObj == nil {
return core.Errorf("EndpointGroup %s not found", epgKey)
}
modeldb.AddLinkSet(&prof.LinkSets.EndpointGroups, epgObj)
modeldb.AddLink(&epgObj.Links.AppProfile, prof)
err := epgObj.Write()
if err != nil {
log.Errorf("Error updating epg state(%+v). Err: %v", epgObj, err)
return err
}
}
// Setup links
modeldb.AddLink(&prof.Links.Tenant, tenant)
modeldb.AddLinkSet(&tenant.LinkSets.AppProfiles, prof)
err := tenant.Write()
if err != nil {
log.Errorf("Error updating tenant state(%+v). Err: %v", tenant, err)
return err
}
err = CreateAppNw(prof)
return err
} | go | {
"resource": ""
} |
q8193 | AppProfileUpdate | train | func (ac *APIController) AppProfileUpdate(oldProf, newProf *contivModel.AppProfile) error {
log.Infof("Received AppProfileUpdate: %+v, newProf: %+v", oldProf, newProf)
// handle any epg addition
for _, epg := range newProf.EndpointGroups {
epgKey := newProf.TenantName + ":" + epg
log.Infof("Add %s to %s", epgKey, newProf.AppProfileName)
epgObj := contivModel.FindEndpointGroup(epgKey)
if epgObj == nil {
return core.Errorf("EndpointGroup %s not found", epgKey)
}
modeldb.AddLinkSet(&newProf.LinkSets.EndpointGroups, epgObj)
// workaround for objdb update problem
modeldb.AddLinkSet(&oldProf.LinkSets.EndpointGroups, epgObj)
modeldb.AddLink(&epgObj.Links.AppProfile, newProf)
err := epgObj.Write()
if err != nil {
log.Errorf("Error updating epg state(%+v). Err: %v", epgObj, err)
return err
}
}
// handle any epg removal
for _, epg := range oldProf.EndpointGroups {
if !stringInSlice(epg, newProf.EndpointGroups) {
epgKey := newProf.TenantName + ":" + epg
log.Infof("Remove %s from %s", epgKey, newProf.AppProfileName)
epgObj := contivModel.FindEndpointGroup(epgKey)
if epgObj == nil {
return core.Errorf("EndpointGroup %s not found", epgKey)
}
modeldb.RemoveLink(&epgObj.Links.AppProfile, oldProf)
err := epgObj.Write()
if err != nil {
log.Errorf("Error updating epg state(%+v). Err: %v",
epgObj, err)
return err
}
// workaround for objdb update problem
modeldb.RemoveLinkSet(&oldProf.LinkSets.EndpointGroups, epgObj)
}
}
// workaround for objdb update problem -- should fix model
oldProf.EndpointGroups = newProf.EndpointGroups
// update the app nw
DeleteAppNw(oldProf)
lErr := CreateAppNw(oldProf)
return lErr
} | go | {
"resource": ""
} |
q8194 | AppProfileDelete | train | func (ac *APIController) AppProfileDelete(prof *contivModel.AppProfile) error {
log.Infof("Received AppProfileDelete: %+v", prof)
tenant := contivModel.FindTenant(prof.TenantName)
if tenant == nil {
return core.Errorf("Tenant %s not found", prof.TenantName)
}
DeleteAppNw(prof)
// remove all links
for _, epg := range prof.EndpointGroups {
epgKey := prof.TenantName + ":" + epg
epgObj := contivModel.FindEndpointGroup(epgKey)
if epgObj == nil {
log.Errorf("EndpointGroup %s not found", epgKey)
continue
}
modeldb.RemoveLink(&epgObj.Links.AppProfile, prof)
err := epgObj.Write()
if err != nil {
log.Errorf("Error updating epg state(%+v). Err: %v", epgObj, err)
}
}
modeldb.RemoveLinkSet(&tenant.LinkSets.AppProfiles, prof)
tenant.Write()
return nil
} | go | {
"resource": ""
} |
q8195 | EndpointGetOper | train | func (ac *APIController) EndpointGetOper(endpoint *contivModel.EndpointInspect) error {
log.Infof("Received EndpointInspect: %+v", endpoint)
stateDriver, err := utils.GetStateDriver()
if err != nil {
return err
}
readEp := &mastercfg.CfgEndpointState{}
readEp.StateDriver = stateDriver
// TODO avoid linear read
epCfgs, err := readEp.ReadAll()
if err == nil {
for _, epCfg := range epCfgs {
ep := epCfg.(*mastercfg.CfgEndpointState)
if strings.Contains(ep.EndpointID, endpoint.Oper.Key) ||
strings.Contains(ep.ContainerID, endpoint.Oper.Key) ||
strings.Contains(ep.EPCommonName, endpoint.Oper.Key) {
endpoint.Oper.Network = ep.NetID
endpoint.Oper.EndpointID = ep.EndpointID
endpoint.Oper.ServiceName = ep.ServiceName
endpoint.Oper.EndpointGroupID = ep.EndpointGroupID
endpoint.Oper.EndpointGroupKey = ep.EndpointGroupKey
endpoint.Oper.IpAddress = []string{ep.IPAddress, ep.IPv6Address}
endpoint.Oper.MacAddress = ep.MacAddress
endpoint.Oper.HomingHost = ep.HomingHost
endpoint.Oper.IntfName = ep.IntfName
endpoint.Oper.VtepIP = ep.VtepIP
endpoint.Oper.Labels = fmt.Sprintf("%s", ep.Labels)
endpoint.Oper.ContainerID = ep.ContainerID
endpoint.Oper.ContainerName = ep.EPCommonName
epOper := &drivers.OperEndpointState{}
epOper.StateDriver = stateDriver
err := epOper.Read(ep.NetID + "-" + ep.EndpointID)
if err == nil {
endpoint.Oper.VirtualPort = "v" + epOper.PortName
}
return nil
}
}
}
return fmt.Errorf("endpoint not found")
} | go | {
"resource": ""
} |
q8196 | endpointGroupCleanup | train | func endpointGroupCleanup(endpointGroup *contivModel.EndpointGroup) error {
// delete the endpoint group state
err := master.DeleteEndpointGroup(endpointGroup.TenantName, endpointGroup.GroupName)
if err != nil {
log.Errorf("Error deleting endpoint group %+v. Err: %v", endpointGroup, err)
return err
}
// Detach the endpoint group from the Policies
for _, policyName := range endpointGroup.Policies {
policyKey := GetpolicyKey(endpointGroup.TenantName, policyName)
// find the policy
policy := contivModel.FindPolicy(policyKey)
if policy == nil {
log.Errorf("Could not find policy %s", policyName)
continue
}
// detach policy to epg
err := master.PolicyDetach(endpointGroup, policy)
if err != nil && err != master.EpgPolicyExists {
log.Errorf("Error detaching policy %s from epg %s", policyName, endpointGroup.Key)
}
// Remove links
modeldb.RemoveLinkSet(&policy.LinkSets.EndpointGroups, endpointGroup)
modeldb.RemoveLinkSet(&endpointGroup.LinkSets.Policies, policy)
policy.Write()
}
// Cleanup any external contracts
err = cleanupExternalContracts(endpointGroup)
if err != nil {
log.Errorf("Error cleaning up external contracts for epg %s", endpointGroup.Key)
}
// Remove the endpoint group from network and tenant link sets.
nwObjKey := endpointGroup.TenantName + ":" + endpointGroup.NetworkName
network := contivModel.FindNetwork(nwObjKey)
if network != nil {
modeldb.RemoveLinkSet(&network.LinkSets.EndpointGroups, endpointGroup)
network.Write()
}
tenant := contivModel.FindTenant(endpointGroup.TenantName)
if tenant != nil {
modeldb.RemoveLinkSet(&tenant.LinkSets.EndpointGroups, endpointGroup)
tenant.Write()
}
return nil
} | go | {
"resource": ""
} |
q8197 | EndpointGroupGetOper | train | func (ac *APIController) EndpointGroupGetOper(endpointGroup *contivModel.EndpointGroupInspect) error {
log.Infof("Received EndpointGroupInspect: %+v", endpointGroup)
// Get the state driver
stateDriver, err := utils.GetStateDriver()
if err != nil {
return err
}
epgCfg := &mastercfg.EndpointGroupState{}
epgCfg.StateDriver = stateDriver
epgID := endpointGroup.Config.GroupName + ":" + endpointGroup.Config.TenantName
if err := epgCfg.Read(epgID); err != nil {
log.Errorf("Error fetching endpointGroup from mastercfg: %s", epgID)
return err
}
nwName := epgCfg.NetworkName + "." + epgCfg.TenantName
nwCfg := &mastercfg.CfgNetworkState{}
nwCfg.StateDriver = stateDriver
if err := nwCfg.Read(nwName); err != nil {
log.Errorf("Error fetching network config %s", nwName)
return err
}
endpointGroup.Oper.ExternalPktTag = epgCfg.ExtPktTag
endpointGroup.Oper.PktTag = epgCfg.PktTag
endpointGroup.Oper.NumEndpoints = epgCfg.EpCount
endpointGroup.Oper.AvailableIPAddresses = netutils.ListAvailableIPs(epgCfg.EPGIPAllocMap,
nwCfg.SubnetIP, nwCfg.SubnetLen)
endpointGroup.Oper.AllocatedIPAddresses = netutils.ListAllocatedIPs(epgCfg.EPGIPAllocMap,
epgCfg.IPPool, nwCfg.SubnetIP, nwCfg.SubnetLen)
endpointGroup.Oper.GroupTag = epgCfg.GroupTag
readEp := &mastercfg.CfgEndpointState{}
readEp.StateDriver = stateDriver
epCfgs, err := readEp.ReadAll()
if err == nil {
for _, epCfg := range epCfgs {
ep := epCfg.(*mastercfg.CfgEndpointState)
if ep.EndpointGroupKey == epgID {
epOper := contivModel.EndpointOper{}
epOper.Network = ep.NetID
epOper.EndpointID = ep.EndpointID
epOper.ServiceName = ep.ServiceName
epOper.EndpointGroupID = ep.EndpointGroupID
epOper.EndpointGroupKey = ep.EndpointGroupKey
epOper.IpAddress = []string{ep.IPAddress, ep.IPv6Address}
epOper.MacAddress = ep.MacAddress
epOper.HomingHost = ep.HomingHost
epOper.IntfName = ep.IntfName
epOper.VtepIP = ep.VtepIP
epOper.Labels = fmt.Sprintf("%s", ep.Labels)
epOper.ContainerID = ep.ContainerID
epOper.ContainerName = ep.EPCommonName
endpointGroup.Oper.Endpoints = append(endpointGroup.Oper.Endpoints, epOper)
}
}
}
return nil
} | go | {
"resource": ""
} |
q8198 | EndpointGroupDelete | train | func (ac *APIController) EndpointGroupDelete(endpointGroup *contivModel.EndpointGroup) error {
log.Infof("Received EndpointGroupDelete: %+v", endpointGroup)
// if this is associated with an app profile, reject the delete
if endpointGroup.Links.AppProfile.ObjKey != "" {
return core.Errorf("Cannot delete %s, associated to appProfile %s",
endpointGroup.GroupName, endpointGroup.Links.AppProfile.ObjKey)
}
// In swarm-mode work-flow, if epg is mapped to a docker network, reject the delete
if master.GetClusterMode() == core.SwarmMode {
dnet, err := docknet.GetDocknetState(endpointGroup.TenantName, endpointGroup.NetworkName, endpointGroup.GroupName)
if err == nil {
return fmt.Errorf("cannot delete group %s mapped to docker network %s",
endpointGroup.GroupName, dnet.DocknetUUID)
}
if !strings.Contains(strings.ToLower(err.Error()), "key not found") {
log.Errorf("Error getting docknet state for %s.%s. (retval = %s)",
endpointGroup.TenantName, endpointGroup.GroupName, err.Error())
return err
}
log.Infof("No docknet state for %s.%s. (retval = %s)",
endpointGroup.TenantName, endpointGroup.GroupName, err.Error())
}
// get the netprofile structure by finding the netprofile
profileKey := GetNetprofileKey(endpointGroup.TenantName, endpointGroup.NetProfile)
netprofile := contivModel.FindNetprofile(profileKey)
if netprofile != nil {
// Remove linksets from netprofile.
modeldb.RemoveLinkSet(&netprofile.LinkSets.EndpointGroups, endpointGroup)
}
err := endpointGroupCleanup(endpointGroup)
if err != nil {
log.Errorf("EPG cleanup failed: %+v", err)
}
return err
} | go | {
"resource": ""
} |
q8199 | NetworkCreate | train | func (ac *APIController) NetworkCreate(network *contivModel.Network) error {
log.Infof("Received NetworkCreate: %+v", network)
// Make sure global settings is valid
if err := validateGlobalConfig(network.Encap); err != nil {
return fmt.Errorf("Global configuration is not ready: %v", err.Error())
}
// Make sure tenant exists
if network.TenantName == "" {
return core.Errorf("Invalid tenant name")
}
tenant := contivModel.FindTenant(network.TenantName)
if tenant == nil {
return core.Errorf("Tenant not found")
}
for key := range tenant.LinkSets.Networks {
networkDetail := contivModel.FindNetwork(key)
if networkDetail == nil {
log.Errorf("Network key %s not found", key)
return fmt.Errorf("network key %s not found", key)
}
// Check for overlapping subnetv6 if existing and current subnetv6 is non-empty
if network.Ipv6Subnet != "" && networkDetail.Ipv6Subnet != "" {
flagv6 := netutils.IsOverlappingSubnetv6(network.Ipv6Subnet, networkDetail.Ipv6Subnet)
if flagv6 == true {
log.Errorf("Overlapping of Subnetv6 Networks")
return errors.New("network " + networkDetail.NetworkName + " conflicts with subnetv6 " + network.Ipv6Subnet)
}
}
// Check for overlapping subnet if existing and current subnet is non-empty
if network.Subnet != "" && networkDetail.Subnet != "" {
flag := netutils.IsOverlappingSubnet(network.Subnet, networkDetail.Subnet)
if flag == true {
log.Errorf("Overlapping of Networks")
return errors.New("network " + networkDetail.NetworkName + " conflicts with subnet " + network.Subnet)
}
}
}
// If there is an EndpointGroup with the same name as this network, reject.
nameClash := contivModel.FindEndpointGroup(network.Key)
if nameClash != nil {
return core.Errorf("EndpointGroup %s conflicts with the network name",
nameClash.GroupName)
}
// Get the state driver
stateDriver, err := utils.GetStateDriver()
if err != nil {
return err
}
// Build network config
networkCfg := intent.ConfigNetwork{
Name: network.NetworkName,
NwType: network.NwType,
PktTagType: network.Encap,
PktTag: network.PktTag,
SubnetCIDR: network.Subnet,
Gateway: network.Gateway,
IPv6SubnetCIDR: network.Ipv6Subnet,
IPv6Gateway: network.Ipv6Gateway,
CfgdTag: network.CfgdTag,
}
// Create the network
err = master.CreateNetwork(networkCfg, stateDriver, network.TenantName)
if err != nil {
log.Errorf("Error creating network {%+v}. Err: %v", network, err)
return err
}
// Setup links
modeldb.AddLink(&network.Links.Tenant, tenant)
modeldb.AddLinkSet(&tenant.LinkSets.Networks, network)
// Save the tenant too since we added the links
err = tenant.Write()
if err != nil {
log.Errorf("Error updating tenant state(%+v). Err: %v", tenant, 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.