// requestAddress
func requestAddress() func(http.ResponseWriter, *http.Request) {
return func(w http.ResponseWriter, r *http.Request) {
var (
content []byte
err error
areq = api.RequestAddressRequest{}
decoder = json.NewDecoder(r.Body)
)
logEvent("requestAddress")
// Decode the JSON message
err = decoder.Decode(&areq)
if err != nil {
httpError(w, "Could not read and parse requestAddress request", err)
return
}
log.Infof("Received RequestAddressRequest: %+v", areq)
// Build an alloc request to be sent to master
allocReq := master.AddressAllocRequest{
NetworkID: areq.PoolID,
PreferredIPv4Address: areq.Address,
}
subnetLen := strings.Split(areq.PoolID, "/")[1]
var addr string
if areq.Address != "" {
addr = areq.Address + "/" + subnetLen
} else {
// Make a REST call to master
var allocResp master.AddressAllocResponse
err = cluster.MasterPostReq("/plugin/allocAddress", &allocReq, &allocResp)
if err != nil {
httpError(w, "master failed to allocate address", err)
return
}
addr = allocResp.IPv4Address
}
// build response
aresp := api.RequestAddressResponse{
Address: addr,
}
log.Infof("Sending RequestAddressResponse: %+v", aresp)
// build json
content, err = json.Marshal(aresp)
if err != nil {
httpError(w, "Could not generate requestAddress response", err)
return
}
w.Write(content)
}
}
// createEP creates the specified EP in contiv
func createEP(req *epSpec) (*epAttr, error) {
// if the ep already exists, treat as error for now.
netID := req.Network + "." + req.Tenant
ep, err := netdGetEndpoint(netID + "-" + req.EndpointID)
if err == nil {
return nil, fmt.Errorf("EP %s already exists", req.EndpointID)
}
// Build endpoint request
mreq := master.CreateEndpointRequest{
TenantName: req.Tenant,
NetworkName: req.Network,
ServiceName: req.Group,
EndpointID: req.EndpointID,
EPCommonName: req.Name,
ConfigEP: intent.ConfigEP{
Container: req.EndpointID,
Host: pluginHost,
ServiceName: req.Group,
},
}
var mresp master.CreateEndpointResponse
err = cluster.MasterPostReq("/plugin/createEndpoint", &mreq, &mresp)
if err != nil {
epCleanUp(req)
return nil, err
}
log.Infof("Got endpoint create resp from master: %+v", mresp)
// Ask netplugin to create the endpoint
err = netPlugin.CreateEndpoint(netID + "-" + req.EndpointID)
if err != nil {
log.Errorf("Endpoint creation failed. Error: %s", err)
epCleanUp(req)
return nil, err
}
ep, err = netdGetEndpoint(netID + "-" + req.EndpointID)
if err != nil {
epCleanUp(req)
return nil, err
}
log.Debug(ep)
// need to get the subnetlen from nw state.
nw, err := netdGetNetwork(netID)
if err != nil {
return nil, err
}
epResponse := epAttr{}
epResponse.PortName = ep.PortName
epResponse.IPAddress = ep.IPAddress + "/" + strconv.Itoa(int(nw.SubnetLen))
epResponse.Gateway = nw.Gateway
return &epResponse, nil
}
// deleteEndpoint deletes an endpoint using netplugin api
func (its *integTestSuite) deleteEndpoint(tenantName, netName, epgName string, epCfg *mastercfg.CfgEndpointState) error {
// Build endpoint delete request
delreq := master.DeleteEndpointRequest{
TenantName: tenantName,
NetworkName: netName,
ServiceName: epgName,
EndpointID: epCfg.EndpointID,
}
var delResp master.DeleteEndpointResponse
err := cluster.MasterPostReq("/plugin/deleteEndpoint", &delreq, &delResp)
if err != nil {
log.Errorf("master failed to delete endpoint. Err: %v", err)
return err
}
// delete the endpoint
err = its.npcluster.PluginAgent.Plugin().DeleteEndpoint(epCfg.ID)
if err != nil {
log.Errorf("Error deleting endpoint %s. Err: %v", epCfg.ID, err)
return err
}
return nil
}
func (cniReq *cniServer) deleteMasterEndPoint() error {
// delete from master
delReq := master.DeleteEndpointRequest{
TenantName: cniReq.endPointLabels[cniapi.LabelTenantName],
NetworkName: cniReq.endPointLabels[cniapi.LabelNetworkName],
ServiceName: cniReq.endPointLabels[cniapi.LabelNetworkGroup],
EndpointID: cniReq.pluginArgs.CniContainerid,
}
delResp := master.DeleteEndpointResponse{}
if err := cluster.MasterPostReq("/plugin/deleteEndpoint", &delReq, &delResp); err != nil {
cniLog.Errorf("failed to delete endpoint %s from master %s ", cniReq.endpointID, err.Error())
return err
}
return nil
}
// Process Infra Nw Create
// Auto allocate an endpoint for this node
func processInfraNwCreate(netPlugin *plugin.NetPlugin, nwCfg *mastercfg.CfgNetworkState, opts cliOpts) (err error) {
pluginHost := opts.hostLabel
// Build endpoint request
mreq := master.CreateEndpointRequest{
TenantName: nwCfg.Tenant,
NetworkName: nwCfg.NetworkName,
EndpointID: pluginHost,
ConfigEP: intent.ConfigEP{
Container: pluginHost,
Host: pluginHost,
},
}
var mresp master.CreateEndpointResponse
err = cluster.MasterPostReq("/plugin/createEndpoint", &mreq, &mresp)
if err != nil {
log.Errorf("master failed to create endpoint %s", err)
return err
}
log.Infof("Got endpoint create resp from master: %+v", mresp)
// Take lock to ensure netPlugin processes only one cmd at a time
netPlugin.Lock()
defer func() { netPlugin.Unlock() }()
// Ask netplugin to create the endpoint
netID := nwCfg.NetworkName + "." + nwCfg.Tenant
err = netPlugin.CreateEndpoint(netID + "-" + pluginHost)
if err != nil {
log.Errorf("Endpoint creation failed. Error: %s", err)
return err
}
// Assign IP to interface
ipCIDR := fmt.Sprintf("%s/%d", mresp.EndpointConfig.IPAddress, nwCfg.SubnetLen)
err = netutils.SetInterfaceIP(nwCfg.NetworkName, ipCIDR)
if err != nil {
log.Errorf("Could not assign ip: %s", err)
return err
}
return nil
}
// allocAddress gets an address from the master
func (its *integTestSuite) allocAddress(addrPool, networkID, prefAddress string) (string, error) {
// Build an alloc request to be sent to master
allocReq := master.AddressAllocRequest{
AddressPool: addrPool,
NetworkID: networkID,
PreferredIPv4Address: prefAddress,
}
// Make a REST call to master
var allocResp master.AddressAllocResponse
err := cluster.MasterPostReq("/plugin/allocAddress", &allocReq, &allocResp)
if err != nil {
log.Errorf("master failed to allocate address. Err: %v", err)
return "", err
}
return strings.Split(allocResp.IPv4Address, "/")[0], nil
}
// epCleanUp deletes the ep from netplugin and netmaster
func epCleanUp(req *epSpec) error {
// first delete from netplugin
// ignore any errors as this is best effort
netID := req.Network + "." + req.Tenant
err1 := netPlugin.DeleteEndpoint(netID + "-" + req.EndpointID)
// now delete from master
delReq := master.DeleteEndpointRequest{
TenantName: req.Tenant,
NetworkName: req.Network,
ServiceName: req.Group,
EndpointID: req.EndpointID,
}
var delResp master.DeleteEndpointResponse
err2 := cluster.MasterPostReq("/plugin/deleteEndpoint", &delReq, &delResp)
if err1 != nil {
return err1
}
return err2
}
// Process Infra Nw Delete
// Delete the auto allocated endpoint
func processInfraNwDelete(netPlugin *plugin.NetPlugin, nwCfg *mastercfg.CfgNetworkState, opts cliOpts) (err error) {
pluginHost := opts.hostLabel
// Build endpoint request
mreq := master.DeleteEndpointRequest{
TenantName: nwCfg.Tenant,
NetworkName: nwCfg.NetworkName,
EndpointID: pluginHost,
}
var mresp master.DeleteEndpointResponse
err = cluster.MasterPostReq("/plugin/deleteEndpoint", &mreq, &mresp)
if err != nil {
log.Errorf("master failed to delete endpoint %s", err)
return err
}
log.Infof("Got endpoint create resp from master: %+v", mresp)
// Network delete will take care of infra nw EP delete in plugin
return
}
// createEndpoint creates an endpoint using netplugin api
func (its *integTestSuite) createEndpoint(tenantName, netName, epgName, v4Addr, v6Addr string) (*mastercfg.CfgEndpointState, error) {
its.uniqEPID++
epID := fmt.Sprintf("%s-%s-%s-%d", tenantName, netName, epgName, its.uniqEPID)
// Build endpoint request
mreq := master.CreateEndpointRequest{
TenantName: tenantName,
NetworkName: netName,
ServiceName: epgName,
EndpointID: epID,
ConfigEP: intent.ConfigEP{
Container: epID,
Host: its.npcluster.HostLabel,
IPAddress: v4Addr,
IPv6Address: v6Addr,
ServiceName: epgName,
},
}
var mresp master.CreateEndpointResponse
err := cluster.MasterPostReq("/plugin/createEndpoint", &mreq, &mresp)
if err != nil {
log.Errorf("master failed to create endpoint. Err: %v", err)
return nil, err
}
log.Infof("Got endpoint create resp from master: %+v", mresp)
netID := netName + "." + tenantName
// Ask netplugin to create the endpoint
err = its.npcluster.PluginAgent.Plugin().CreateEndpoint(netID + "-" + epID)
if err != nil {
log.Errorf("Endpoint creation failed. Error: %s", err)
return nil, err
}
return &mresp.EndpointConfig, nil
}
/***
Copyright 2014 Cisco Systems Inc. All rights reserved.
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*/
package agent
import (
"strings"
log "github.com/Sirupsen/logrus"
"github.com/contiv/netplugin/mgmtfn/dockplugin"
"github.com/contiv/netplugin/netmaster/master"
"github.com/contiv/netplugin/netplugin/cluster"
"github.com/docker/engine-api/client"
"github.com/docker/engine-api/types"
"github.com/samalba/dockerclient"
"golang.org/x/net/context"
)
// Handles docker events monitored by dockerclient. Currently we only handle
// container start and die event*/
func handleDockerEvents(event *dockerclient.Event, ec chan error, args ...interface{}) {
log.Debugf("Received Docker event: {%#v}\n", *event)
endpointUpdReq := &master.UpdateEndpointRequest{}
switch event.Status {
case "start":
defaultHeaders := map[string]string{"User-Agent": "engine-api-cli-1.0"}
cli, err := client.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)
return
}
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.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)
}
}
}
// requestAddress
func requestAddress(w http.ResponseWriter, r *http.Request) {
var (
content []byte
err error
areq = api.RequestAddressRequest{}
decoder = json.NewDecoder(r.Body)
)
logEvent("requestAddress")
// Decode the JSON message
err = decoder.Decode(&areq)
if err != nil {
httpError(w, "Could not read and parse requestAddress request", err)
return
}
log.Infof("Received RequestAddressRequest: %+v", areq)
networkID := ""
addrPool := areq.PoolID
subnetLen := strings.Split(areq.PoolID, "/")[1]
// check if pool id contains address pool or network id
// HACK alert: This is very fragile. Simplify this when we stop supporting docker 1.9
if strings.Contains(areq.PoolID, "|") {
addrPool = strings.Split(areq.PoolID, "|")[1]
networkID = strings.Split(areq.PoolID, "|")[0]
}
// Build an alloc request to be sent to master
allocReq := master.AddressAllocRequest{
AddressPool: addrPool,
NetworkID: networkID,
PreferredIPv4Address: areq.Address,
}
var addr string
// check if this request is for gateway
reqType, ok := areq.Options["RequestAddressType"]
if ok && reqType == netlabel.Gateway {
if areq.Address != "" {
addr = areq.Address + "/" + subnetLen
} else {
// simply return a dummy address
addr = addrPool
}
} else if areq.Address != "" {
// This is a special case for docker 1.9 gateway request which does not
// come with 'RequestAddressType' label
// FIXME: Remove this hack when we stop supporting docker 1.9
addr = areq.Address + "/" + subnetLen
} else {
// Make a REST call to master
var allocResp master.AddressAllocResponse
err = cluster.MasterPostReq("/plugin/allocAddress", &allocReq, &allocResp)
if err != nil {
httpError(w, "master failed to allocate address", err)
return
}
addr = allocResp.IPv4Address
}
// build response
aresp := api.RequestAddressResponse{
Address: addr,
}
log.Infof("Sending RequestAddressResponse: %+v", aresp)
// build json
content, err = json.Marshal(aresp)
if err != nil {
httpError(w, "Could not generate requestAddress response", err)
return
}
w.Write(content)
}
func createEndpoint(hostname string) func(http.ResponseWriter, *http.Request) {
return func(w http.ResponseWriter, r *http.Request) {
logEvent("create endpoint")
content, err := ioutil.ReadAll(r.Body)
if err != nil {
httpError(w, "Could not read endpoint create request", err)
return
}
cereq := api.CreateEndpointRequest{}
if err := json.Unmarshal(content, &cereq); err != nil {
httpError(w, "Could not read endpoint create request", err)
return
}
log.Infof("CreateEndpointRequest: %+v. Interface: %+v", cereq, cereq.Interface)
tenantName, netName, serviceName, err := GetDockerNetworkName(cereq.NetworkID)
if err != nil {
log.Errorf("Error getting network name for UUID: %s. Err: %v", cereq.NetworkID, err)
httpError(w, "Could not get network name", err)
return
}
// Build endpoint request
mreq := master.CreateEndpointRequest{
TenantName: tenantName,
NetworkName: netName,
ServiceName: serviceName,
EndpointID: cereq.EndpointID,
ConfigEP: intent.ConfigEP{
Container: cereq.EndpointID,
Host: hostname,
IPAddress: strings.Split(cereq.Interface.Address, "/")[0],
ServiceName: serviceName,
},
}
var mresp master.CreateEndpointResponse
err = cluster.MasterPostReq("/plugin/createEndpoint", &mreq, &mresp)
if err != nil {
httpError(w, "master failed to create endpoint", err)
return
}
log.Infof("Got endpoint create resp from master: %+v", mresp)
netID := netName + "." + tenantName
// Ask netplugin to create the endpoint
err = netPlugin.CreateEndpoint(netID + "-" + cereq.EndpointID)
if err != nil {
log.Errorf("Endpoint creation failed. Error: %s", err)
httpError(w, "Could not create endpoint", err)
return
}
ep, err := netdGetEndpoint(netID + "-" + cereq.EndpointID)
if err != nil {
httpError(w, "Could not find created endpoint", err)
return
}
log.Debug(ep)
epResponse := api.CreateEndpointResponse{
Interface: &api.EndpointInterface{},
}
// Add the service information using Service plugin
if serviceName != "" {
log.Infof("Calling AddService with: ID: %s, Name: %s, Network: %s, Tenant: %s, IP: %s", cereq.EndpointID[len(cereq.EndpointID)-12:], serviceName, netName, tenantName, ep.IPAddress)
dnsBridge.AddService(cereq.EndpointID[len(cereq.EndpointID)-12:], serviceName, netName, tenantName, ep.IPAddress)
}
log.Infof("Sending CreateEndpointResponse: {%+v}, IP Addr: %v", epResponse, ep.IPAddress)
content, err = json.Marshal(epResponse)
if err != nil {
httpError(w, "Could not generate create endpoint response", err)
return
}
w.Write(content)
}
}
func deleteEndpoint(hostname string) func(http.ResponseWriter, *http.Request) {
return func(w http.ResponseWriter, r *http.Request) {
logEvent("delete endpoint")
content, err := ioutil.ReadAll(r.Body)
if err != nil {
httpError(w, "Could not read delete endpoint request", err)
return
}
der := api.DeleteEndpointRequest{}
if err := json.Unmarshal(content, &der); err != nil {
httpError(w, "Could not read delete endpoint request", err)
return
}
log.Infof("Received DeleteEndpointRequest: %+v", der)
tenantName, netName, serviceName, err := GetDockerNetworkName(der.NetworkID)
if err != nil {
log.Errorf("Error getting network name for UUID: %s. Err: %v", der.NetworkID, err)
httpError(w, "Could not get network name", err)
return
}
// Build endpoint delete request
delreq := master.DeleteEndpointRequest{
TenantName: tenantName,
NetworkName: netName,
ServiceName: serviceName,
EndpointID: der.EndpointID,
}
var delResp master.DeleteEndpointResponse
err = cluster.MasterPostReq("/plugin/deleteEndpoint", &delreq, &delResp)
if err != nil {
httpError(w, "master failed to delete endpoint", err)
return
}
// delete the endpoint
netID := netName + "." + tenantName
err = netPlugin.DeleteEndpoint(netID + "-" + delreq.EndpointID)
if err != nil {
log.Errorf("Error deleting endpoint %s. Err: %v", delreq.EndpointID, err)
httpError(w, "failed to delete endpoint", err)
return
}
ep, err := netdGetEndpoint(netID + "-" + delreq.EndpointID)
if err != nil {
httpError(w, "Could not find endpoint", err)
return
}
// Remove the DNS entry for the service
if serviceName != "" {
log.Infof("Calling RemoveService with: ID: %s, Name: %s, Network: %s, Tenant: %s, IP: %s", delreq.EndpointID[len(delreq.EndpointID)-12:], serviceName, netName, tenantName, ep.IPAddress)
dnsBridge.RemoveService(delreq.EndpointID[len(delreq.EndpointID)-12:], serviceName, netName, tenantName, ep.IPAddress)
}
// build response
content, err = json.Marshal(api.DeleteEndpointResponse{})
if err != nil {
httpError(w, "Could not generate delete endpoint response", err)
return
}
w.Write(content)
}
}
/*Handles docker events monitored by dockerclient. Currently we only handle
container start and die event*/
func handleDockerEvents(event *dockerclient.Event, ec chan error, args ...interface{}) {
log.Printf("Received Docker event: {%#v}\n", *event)
providerUpdReq := &master.SvcProvUpdateRequest{}
switch event.Status {
case "start":
defaultHeaders := map[string]string{"User-Agent": "engine-api-cli-1.0"}
cli, err := client.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)
return
}
if event.ID != "" {
labelMap := getLabelsFromContainerInspect(&containerInfo)
containerTenant := getTenantFromContainerInspect(&containerInfo)
network, ipAddress := getEpNetworkInfoFromContainerInspect(&containerInfo)
container := getContainerFromContainerInspect(&containerInfo)
if ipAddress != "" {
//Create provider info
networkname := strings.Split(network, "/")[0]
providerUpdReq.IPAddress = ipAddress
providerUpdReq.ContainerID = event.ID
providerUpdReq.Tenant = containerTenant
providerUpdReq.Network = networkname
providerUpdReq.Event = "start"
providerUpdReq.Container = container
providerUpdReq.Labels = make(map[string]string)
for k, v := range labelMap {
providerUpdReq.Labels[k] = v
}
}
if len(labelMap) == 0 {
//Ignore container without labels
return
}
var svcProvResp master.SvcProvUpdateResponse
log.Infof("Sending Provider create request to master: {%+v}", providerUpdReq)
err := cluster.MasterPostReq("/plugin/svcProviderUpdate", providerUpdReq, &svcProvResp)
if err != nil {
log.Errorf("Event: 'start' , Http error posting service provider update, Error:%s", err)
}
} else {
log.Errorf("Unable to fetch container labels for container %s ", event.ID)
}
case "die":
providerUpdReq.ContainerID = event.ID
providerUpdReq.Event = "die"
var svcProvResp master.SvcProvUpdateResponse
log.Infof("Sending Provider delete request to master: {%+v}", providerUpdReq)
err := cluster.MasterPostReq("/plugin/svcProviderUpdate", providerUpdReq, &svcProvResp)
if err != nil {
log.Errorf("Event:'die' Http error posting service provider update, Error:%s", err)
}
}
}
func (cniReq *cniServer) createCniEndPoint() error {
var err error
ovsEpDriver := &drivers.OvsOperEndpointState{}
ovsEpDriver.StateDriver = stateDriver
nwState := &mastercfg.CfgNetworkState{}
nwState.StateDriver = stateDriver
// build endpoint request
epReq := master.CreateEndpointRequest{
TenantName: cniReq.endPointLabels[cniapi.LabelTenantName],
NetworkName: cniReq.endPointLabels[cniapi.LabelNetworkName],
ServiceName: cniReq.endPointLabels[cniapi.LabelNetworkGroup],
EndpointID: cniReq.pluginArgs.CniContainerid,
ConfigEP: intent.ConfigEP{
Container: cniReq.pluginArgs.CniContainerid,
Host: hostName,
ServiceName: cniReq.endPointLabels[cniapi.LabelNetworkGroup],
},
}
cniLog.Infof("endpoint-req: epid:%s cont-id:%s ", epReq.EndpointID, epReq.ConfigEP.Container)
epResp := master.CreateEndpointResponse{}
if err = cluster.MasterPostReq("/plugin/createEndpoint", &epReq, &epResp); err != nil {
cniLog.Errorf("failed to create endpoint in master: %s", err.Error())
return err
}
cniLog.Infof("endpoint created %+v", epResp)
// create endpoint in netplugin
if err = netPlugin.CreateEndpoint(cniReq.endpointID); err != nil {
cniLog.Errorf("failed to create endpoint in netplugin: %s", err.Error())
goto cleanupMaster
}
// read end point
if err = ovsEpDriver.Read(cniReq.endpointID); err != nil {
cniLog.Errorf("failed to read endpoint: %s", err.Error())
goto cleanupNetplugin
}
if err = nwState.Read(cniReq.networkID); err != nil {
cniLog.Errorf("failed to read network config : %s", err.Error())
goto cleanupNetplugin
}
cniLog.Debugf("read new network config +%v", nwState)
if err = cniReq.configureNetNs(ovsEpDriver, &epResp, nwState); err != nil {
goto cleanupNetplugin
}
// host access
if strings.HasSuffix(cniReq.pluginArgs.CniIfname, "0") {
if err = cniReq.createHostBrIntf(ovsEpDriver); err != nil {
cniLog.Errorf("failed to configure host-br %s", err.Error())
goto cleanupNetns
}
}
return nil
// unwind the setup, ignore errors
cleanupNetns:
cniReq.unlinkNetNs()
cleanupNetplugin:
cniReq.deleteNetpluginEndPoint()
cleanupMaster:
cniReq.deleteMasterEndPoint()
return err
}
