// IsAciConfigured returns true if aci is configured on netmaster.
func IsAciConfigured() (res bool, err error) {
// Get the state driver
stateDriver, uErr := utils.GetStateDriver()
if uErr != nil {
log.Warnf("Couldn't read global config %v", uErr)
return false, uErr
}
// read global config
masterGc := &mastercfg.GlobConfig{}
masterGc.StateDriver = stateDriver
uErr = masterGc.Read("config")
if core.ErrIfKeyExists(uErr) != nil {
log.Errorf("Couldn't read global config %v", uErr)
return false, uErr
}
if uErr != nil {
log.Warnf("Couldn't read global config %v", uErr)
return false, nil
}
if masterGc.NwInfraType != "aci" {
log.Debugf("NwInfra type is %v, no ACI", masterGc.NwInfraType)
return false, nil
}
return true, nil
}
// GlobalUpdate updates global state
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
}
// Build global config
gCfg := intent.ConfigGlobal{
NwInfraType: params.NetworkInfraType,
VLANs: params.Vlans,
VXLANs: params.Vxlans,
}
// Create the object
err = master.CreateGlobal(stateDriver, &gCfg)
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
return nil
}
// FindDocknetByUUID find the docknet by UUID
func FindDocknetByUUID(dnetID string) (*OperState, error) {
// Get the state driver
stateDriver, err := utils.GetStateDriver()
if err != nil {
log.Warnf("Couldn't read global config %v", err)
return nil, err
}
tmpDnet := OperState{}
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.(*OperState).DocknetUUID == dnetID {
return dnet.(*OperState), nil
}
}
return nil, errors.New("docknet UUID not found")
}
// TenantCreate creates a tenant
func (ac *APIController) TenantCreate(tenant *contivModel.Tenant) error {
log.Infof("Received TenantCreate: %+v", tenant)
if tenant.TenantName == "" {
return core.Errorf("Invalid tenant name")
}
// Get the state driver
stateDriver, err := utils.GetStateDriver()
if err != nil {
return err
}
// Build tenant config
tenantCfg := intent.ConfigTenant{
Name: tenant.TenantName,
DefaultNetwork: tenant.DefaultNetwork,
}
// Create the tenant
err = master.CreateTenant(stateDriver, &tenantCfg)
if err != nil {
log.Errorf("Error creating tenant {%+v}. Err: %v", tenant, err)
return err
}
return nil
}
// NetworkDelete deletes network
func (ac *APIController) NetworkDelete(network *contivModel.Network) error {
log.Infof("Received NetworkDelete: %+v", network)
// Find the tenant
tenant := contivModel.FindTenant(network.TenantName)
if tenant == nil {
return core.Errorf("Tenant not found")
}
// Remove link
modeldb.RemoveLinkSet(&tenant.LinkSets.Networks, network)
// Save the tenant too since we removed the links
err := tenant.Write()
if err != nil {
return err
}
// Get the state driver
stateDriver, err := utils.GetStateDriver()
if err != nil {
return err
}
// Delete the network
networkID := network.NetworkName + "." + network.TenantName
err = master.DeleteNetworkID(stateDriver, networkID)
if err != nil {
log.Errorf("Error deleting network %s. Err: %v", network.NetworkName, err)
}
return nil
}
//UpdateEndpointGroup updates the endpointgroups
func UpdateEndpointGroup(bandwidth, groupName, tenantName string, Dscp, burst int) error {
// Get the state driver - get the etcd driver state
stateDriver, err := utils.GetStateDriver()
if err != nil {
return err
}
key := mastercfg.GetEndpointGroupKey(groupName, tenantName)
if key == "" {
return errors.New("Error finding endpointGroup key ")
}
// Read etcd driver
epCfg := mastercfg.EndpointGroupState{}
epCfg.StateDriver = stateDriver
err = epCfg.Read(key)
if err != nil {
log.Errorf("Error finding endpointgroup %s. Err: %v", key, err)
return err
}
//update the epGroup state
epCfg.DSCP = Dscp
epCfg.Bandwidth = bandwidth
epCfg.Burst = burst
//Write to etcd
err = epCfg.Write()
if err != nil {
return err
}
return nil
}
//BgpCreate add bgp neighbor
func (ac *APIController) BgpCreate(bgpNeighborCfg *contivModel.Bgp) error {
log.Infof("Received BgpCreate: %+v", bgpNeighborCfg)
if bgpNeighborCfg.Hostname == "" {
return core.Errorf("Invalid host name")
}
// Get the state driver
stateDriver, err := utils.GetStateDriver()
if err != nil {
return err
}
// Build bgp config
bgpCfg := intent.ConfigBgp{
Hostname: bgpNeighborCfg.Hostname,
As: bgpNeighborCfg.AS,
Neighbor: bgpNeighborCfg.Neighbor,
}
// Add the Bgp neighbor
err = master.AddBgpNeighbors(stateDriver, &bgpCfg)
if err != nil {
log.Errorf("Error creating Bgp neighbor {%+v}. Err: %v", bgpNeighborCfg.Neighbor, err)
return err
}
return nil
}
// XXX: This function should be returning logical state instead of driver state
func (d *daemon) endpoints(id string) ([]core.State, error) {
var (
err error
ep *drivers.OvsOperEndpointState
)
ep = &drivers.OvsOperEndpointState{}
if ep.StateDriver, err = utils.GetStateDriver(); err != nil {
return nil, err
}
if id == "all" {
eps, err := ep.ReadAll()
if err != nil {
return []core.State{}, nil
}
return eps, nil
}
err = ep.Read(id)
if err == nil {
return []core.State{core.State(ep)}, nil
}
return nil, core.Errorf("Unexpected code path. Recieved error during read: %v", err)
}
// ProcessDeletions deletes the configuration passed from netmaster's statestore.
// This may result in generating Delete triggers for the netplugin.
func ProcessDeletions(allCfg *intent.Config) (err error) {
stateDriver, err := utils.GetStateDriver()
if err != nil {
return err
}
for _, tenant := range allCfg.Tenants {
err1 := DeleteEndpoints(stateDriver, &tenant)
if err1 != nil {
log.Errorf("error deleting endpoints '%s' \n", err1)
err = err1
continue
}
err1 = DeleteNetworks(stateDriver, &tenant)
if err1 != nil {
log.Errorf("error deleting networks '%s' \n", err1)
err = err1
continue
}
err1 = DeleteTenant(stateDriver, &tenant)
if err1 != nil {
log.Errorf("error deleting tenant '%s' \n", err1)
err = err1
continue
}
}
return
}
//ServiceLBDelete deletes service object
func (ac *APIController) ServiceLBDelete(serviceCfg *contivModel.ServiceLB) error {
log.Info("Received Service Load Balancer delete : {%+v}", serviceCfg)
if serviceCfg.ServiceName == "" {
return core.Errorf("Invalid service name")
}
if serviceCfg.TenantName == "" {
serviceCfg.TenantName = "default"
}
// Get the state driver
stateDriver, err := utils.GetStateDriver()
if err != nil {
return err
}
// Add the service object
err = master.DeleteServiceLB(stateDriver, serviceCfg.ServiceName, serviceCfg.TenantName)
if err != nil {
log.Errorf("Error deleting Service Load Balancer object {%+v}. Err: %v", serviceCfg.ServiceName, err)
return err
}
return nil
}
// ReleaseAddressHandler releases addresses
func ReleaseAddressHandler(w http.ResponseWriter, r *http.Request, vars map[string]string) (interface{}, error) {
var relReq AddressReleaseRequest
// 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
}
// find the network from network id
nwCfg := &mastercfg.CfgNetworkState{}
nwCfg.StateDriver = stateDriver
err = nwCfg.Read(relReq.NetworkID)
if err != nil {
log.Errorf("network %s is not operational", relReq.NetworkID)
return nil, err
}
// release addresses
err = networkReleaseAddress(nwCfg, relReq.IPv4Address)
if err != nil {
log.Errorf("Failed to release address. Err: %v", err)
return nil, err
}
return "success", nil
}
// DeleteEndpointGroup handles endpoint group deletes
func DeleteEndpointGroup(tenantName, groupName string) error {
// Get the state driver
stateDriver, err := utils.GetStateDriver()
if err != nil {
return err
}
epgKey := mastercfg.GetEndpointGroupKey(groupName, tenantName)
epgCfg := &mastercfg.EndpointGroupState{}
epgCfg.StateDriver = stateDriver
err = epgCfg.Read(epgKey)
if err != nil {
log.Errorf("error reading EPG key %s. Error: %s", epgKey, err)
return err
}
if epgCfg.EpCount != 0 {
return core.Errorf("Error: EPG %s has active endpoints", groupName)
}
// Delete the endpoint group state
gstate.GlobalMutex.Lock()
defer gstate.GlobalMutex.Unlock()
gCfg := gstate.Cfg{}
gCfg.StateDriver = stateDriver
err = gCfg.Read(epgCfg.TenantName)
if err != nil {
log.Errorf("error reading tenant cfg state. Error: %s", err)
return err
}
// if aci mode we allocate per-epg vlan. free it here.
aciMode, aErr := IsAciConfigured()
if aErr != nil {
return aErr
}
if aciMode {
if epgCfg.PktTagType == "vlan" {
err = gCfg.FreeVLAN(uint(epgCfg.PktTag))
if err != nil {
return err
}
log.Debugf("Freed vlan %v\n", epgCfg.PktTag)
}
}
// Delete endpoint group
err = epgCfg.Clear()
if err != nil {
log.Errorf("error writing epGroup config. Error: %v", err)
return err
}
if GetClusterMode() == "docker" {
return docknet.DeleteDockNet(epgCfg.TenantName, epgCfg.NetworkName, epgCfg.GroupName)
}
return nil
}
// detachServiceContainer detaches the service container's endpoint during network delete
// - detach happens only if all other endpoints in the network are already removed
func detachServiceContainer(tenantName, networkName string) error {
docker, err := utils.GetDockerClient()
if err != nil {
log.Errorf("Unable to connect to docker. Error %v", err)
return errors.New("Unable to connect to docker")
}
dnsContName := getDNSName(tenantName)
cinfo, err := docker.InspectContainer(dnsContName)
if err != nil {
log.Errorf("Error inspecting the container %s. Err: %v", dnsContName, err)
return err
}
// Trim default tenant
dnetName := docknet.GetDocknetName(tenantName, networkName, "")
// inspect docker network
nwState, err := docker.InspectNetwork(dnetName)
if err != nil {
log.Errorf("Error while inspecting network: %+v", dnetName)
return err
}
log.Infof("Containers in network: %+v are {%+v}", dnetName, nwState.Containers)
dnsServerIP := strings.Split(nwState.Containers[cinfo.Id].IPv4Address, "/")[0]
stateDriver, err := utils.GetStateDriver()
if err != nil {
log.Errorf("Could not get StateDriver while trying to disconnect dnsContainer from %+v", networkName)
return err
}
// Read network config and get DNSServer information
nwCfg := &mastercfg.CfgNetworkState{}
nwCfg.StateDriver = stateDriver
networkID := networkName + "." + tenantName
err = nwCfg.Read(networkID)
if err != nil {
return err
}
log.Infof("dnsServerIP: %+v, nwCfg.dnsip: %+v", dnsServerIP, nwCfg.DNSServer)
// Remove dns container from network if all other endpoints are withdrawn
if len(nwState.Containers) == 1 && (dnsServerIP == nwCfg.DNSServer) {
log.Infof("Disconnecting dns container from network as all other endpoints are removed: %+v", networkName)
err = docker.DisconnectNetwork(dnetName, dnsContName, false)
if err != nil {
log.Errorf("Could not detach container(%s) from network %s. Error: %s",
dnsContName, dnetName, err)
return err
}
}
return nil
}
// NetworkCreate creates network
func (ac *APIController) NetworkCreate(network *contivModel.Network) error {
log.Infof("Received NetworkCreate: %+v", network)
// 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")
}
// 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,
}
// 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
}
// DeleteEndpointGroup handles endpoint group deletes
func DeleteEndpointGroup(epgID int) error {
// Get the state driver
stateDriver, err := utils.GetStateDriver()
if err != nil {
return err
}
epgCfg := &mastercfg.EndpointGroupState{}
epgCfg.StateDriver = stateDriver
err = epgCfg.Read(strconv.Itoa(epgID))
if err != nil {
log.Errorf("EpGroup %v is not configured", epgID)
return err
}
gCfg := gstate.Cfg{}
gCfg.StateDriver = stateDriver
err = gCfg.Read(epgCfg.Tenant)
if err != nil {
log.Errorf("error reading tenant cfg state. Error: %s", err)
return err
}
// if aci mode we allocate per-epg vlan. free it here.
aciMode, aErr := IsAciConfigured()
if aErr != nil {
return aErr
}
if aciMode {
tempRm, rErr := resources.GetStateResourceManager()
if rErr != nil {
return rErr
}
rm := core.ResourceManager(tempRm)
if epgCfg.PktTagType == "vlan" {
err = gCfg.FreeVLAN(rm, uint(epgCfg.PktTag))
if err != nil {
return err
}
log.Debugf("Freed vlan %v\n", epgCfg.PktTag)
}
}
epgNet := epgCfg.Name + "." + epgCfg.NetworkName + "." + epgCfg.Tenant
err = epgCfg.Clear()
if err != nil {
log.Errorf("error writing epGroup config. Error: %v", err)
return err
}
return deleteDockNet(epgNet)
}
//ServiceLBCreate creates service object
func (ac *APIController) ServiceLBCreate(serviceCfg *contivModel.ServiceLB) error {
log.Infof("Received Service Load Balancer create: %+v", serviceCfg)
if serviceCfg.ServiceName == "" {
return core.Errorf("Invalid service name")
}
if serviceCfg.TenantName == "" {
serviceCfg.TenantName = "default"
}
if len(serviceCfg.Selectors) == 0 {
return core.Errorf("Invalid selector options")
}
if !validatePorts(serviceCfg.Ports) {
return core.Errorf("Invalid Port maping . Port format is - Port:TargetPort:Protocol")
}
// Get the state driver
stateDriver, err := utils.GetStateDriver()
if err != nil {
return err
}
// Build service config
serviceIntentCfg := intent.ConfigServiceLB{
ServiceName: serviceCfg.ServiceName,
Tenant: serviceCfg.TenantName,
Network: serviceCfg.NetworkName,
IPAddress: serviceCfg.IpAddress,
}
serviceIntentCfg.Ports = append(serviceIntentCfg.Ports, serviceCfg.Ports...)
serviceIntentCfg.Selectors = make(map[string]string)
for _, selector := range serviceCfg.Selectors {
if validateSelectors(selector) {
key := strings.Split(selector, "=")[0]
value := strings.Split(selector, "=")[1]
serviceIntentCfg.Selectors[key] = value
} else {
return core.Errorf("Invalid selector %s. selector format is key1=value1", selector)
}
}
// Add the service object
err = master.CreateServiceLB(stateDriver, &serviceIntentCfg)
if err != nil {
log.Errorf("Error creating service {%+v}. Err: %v", serviceIntentCfg.ServiceName, err)
return err
}
return nil
}
//CreateAppNw Fill in the Nw spec and launch the nw infra
func CreateAppNw(app *contivModel.AppProfile) error {
aciPresent, aErr := master.IsAciConfigured()
if aErr != nil {
log.Errorf("Couldn't read global config %v", aErr)
return aErr
}
if !aciPresent {
log.Debugf("ACI not configured")
return nil
}
// Get the state driver
stateDriver, uErr := utils.GetStateDriver()
if uErr != nil {
return uErr
}
eMap := &epgMap{}
eMap.Specs = make(map[string]epgSpec)
ans := &appNwSpec{}
ans.TenantName = app.TenantName
ans.AppName = app.AppProfileName
// Gather all basic epg info into the epg map
for epgKey := range app.LinkSets.EndpointGroups {
epgObj := contivModel.FindEndpointGroup(epgKey)
if epgObj == nil {
err := fmt.Sprintf("Epg %v does not exist", epgKey)
log.Errorf("%v", err)
return errors.New(err)
}
if err := appendEpgInfo(eMap, epgObj, stateDriver); err != nil {
log.Errorf("Error getting epg info %v", err)
return err
}
}
// walk the map and add to ANS
for _, epg := range eMap.Specs {
ans.Epgs = append(ans.Epgs, epg)
log.Debugf("Added epg %v", epg.Name)
}
log.Infof("Launching appNwSpec: %+v", ans)
lErr := ans.launch()
time.Sleep(2 * time.Second)
ans.notifyDP()
return lErr
}
// NetworkCreate creates network
func (ac *APIController) NetworkCreate(network *contivModel.Network) error {
log.Infof("Received NetworkCreate: %+v", network)
// Make sure tenant exists
if network.TenantName == "" {
return errors.New("Invalid tenant name")
}
tenant := contivModel.FindTenant(network.TenantName)
if tenant == nil {
return errors.New("Tenant not found")
}
// 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
}
// Get the state driver
stateDriver, err := utils.GetStateDriver()
if err != nil {
return err
}
// Build networ config
networkCfg := intent.ConfigNetwork{
Name: network.NetworkName,
PktTagType: network.Encap,
PktTag: "",
SubnetCIDR: network.Subnet,
DefaultGw: network.DefaultGw,
}
// 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
}
return nil
}
// netdGetEndpoint is a utility that reads the EP oper state
func netdGetEndpoint(epID string) (*drivers.OvsOperEndpointState, error) {
// Get hold of the state driver
stateDriver, err := utils.GetStateDriver()
if err != nil {
return nil, err
}
operEp := &drivers.OvsOperEndpointState{}
operEp.StateDriver = stateDriver
err = operEp.Read(epID)
if err != nil {
return nil, err
}
return operEp, nil
}
//BgpDelete deletes bgp neighbor
func (ac *APIController) BgpDelete(bgpNeighborCfg *contivModel.Bgp) error {
log.Infof("Received delete for Bgp config on {%+v} ", bgpNeighborCfg.Hostname)
// Get the state driver
stateDriver, err := utils.GetStateDriver()
if err != nil {
return err
}
err = master.DeleteBgpNeighbors(stateDriver, bgpNeighborCfg.Hostname)
if err != nil {
log.Errorf("Error Deleting Bgp neighbor. Err: %v", err)
return err
}
return nil
}
func cniDriverInit(plugin *plugin.NetPlugin) error {
var err error
netPlugin = plugin
if stateDriver, err = utils.GetStateDriver(); err != nil {
cniLog.Errorf("failed to get state driver %s", err)
return err
}
if hostName, err = os.Hostname(); err != nil {
cniLog.Errorf("failed to get hostname %s", err)
return err
}
return nil
}
// netdGetNetwork is a utility that reads the n/w oper state
func netdGetNetwork(networkID string) (*mastercfg.CfgNetworkState, error) {
// Get hold of the state driver
stateDriver, err := utils.GetStateDriver()
if err != nil {
return nil, err
}
// find the network from network id
nwCfg := &mastercfg.CfgNetworkState{}
nwCfg.StateDriver = stateDriver
err = nwCfg.Read(networkID)
if err != nil {
return nil, err
}
return nwCfg, nil
}
// GlobalDelete is not supported
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
}
// CreateEndpointHandler handles create endpoint requests
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.ConfigEP)
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
}
// XXX: This function should be returning logical state instead of driver state
func (d *daemon) networks(id string) ([]core.State, error) {
var (
err error
nw *mastercfg.CfgNetworkState
)
nw = &mastercfg.CfgNetworkState{}
if nw.StateDriver, err = utils.GetStateDriver(); err != nil {
return nil, err
}
if id == "all" {
return nw.ReadAll()
} else if err := nw.Read(id); err == nil {
return []core.State{core.State(nw)}, nil
}
return nil, core.Errorf("Unexpected code path")
}
// TenantDelete deletes a tenant
func (ac *APIController) TenantDelete(tenant *contivModel.Tenant) error {
log.Infof("Received TenantDelete: %+v", tenant)
// Get the state driver
stateDriver, err := utils.GetStateDriver()
if err != nil {
return err
}
// FIXME: Should we walk all objects under the tenant and delete it?
// Delete the tenant
err = master.DeleteTenantID(stateDriver, tenant.TenantName)
if err != nil {
log.Errorf("Error deleting tenant %s. Err: %v", tenant.TenantName, err)
}
return nil
}
// Init initializes the NetPlugin instance via the configuration string passed.
func (p *NetPlugin) Init(pluginConfig Config) error {
var err error
if pluginConfig.Instance.HostLabel == "" {
return core.Errorf("empty host-label passed")
}
// initialize state driver
p.StateDriver, err = utils.GetStateDriver()
if err != nil {
p.StateDriver, err = utils.NewStateDriver(pluginConfig.Drivers.State, &pluginConfig.Instance)
if err != nil {
return err
}
}
defer func() {
if err != nil {
utils.ReleaseStateDriver()
}
}()
// set state driver in instance info
pluginConfig.Instance.StateDriver = p.StateDriver
fwdMode := GetFwdMode(p.StateDriver)
if fwdMode == "" {
fwdMode = "bridge"
}
pluginConfig.Instance.FwdMode = fwdMode
// initialize network driver
p.NetworkDriver, err = utils.NewNetworkDriver(pluginConfig.Drivers.Network, &pluginConfig.Instance)
if err != nil {
return err
}
defer func() {
if err != nil {
p.NetworkDriver.Deinit()
}
}()
return nil
}
// services: This function should be returning logical state instead of driver state
func (d *MasterDaemon) services(id string) ([]core.State, error) {
var (
err error
svc *mastercfg.CfgServiceLBState
)
svc = &mastercfg.CfgServiceLBState{}
if svc.StateDriver, err = utils.GetStateDriver(); err != nil {
return nil, err
}
if id == "all" {
return svc.ReadAll()
} else if err := svc.Read(id); err == nil {
return []core.State{core.State(svc)}, nil
}
return nil, err
}
// getDocknetState gets docknet oper state
func getDocknetState(tenantName, networkName, serviceName string) *OperState {
// Get the state driver
stateDriver, err := utils.GetStateDriver()
if err != nil {
log.Warnf("Couldn't read global config %v", err)
return nil
}
// save docknet oper state
dnetOper := OperState{}
dnetOper.StateDriver = stateDriver
// write the dnet oper state
err = dnetOper.Read(fmt.Sprintf("%s.%s.%s", tenantName, networkName, serviceName))
if err != nil {
return nil
}
return &dnetOper
}
// DeleteEndpointHandler handles delete endpoint requests
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)
// Gte 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
}