Add external contracts support (import and export) for ACI

Author: Satish Ramachandran

netctl/commands.go

@@ -55,6 +55,14 @@ var Commands = []cli.Command{
 						Name:  "policy, p",
 						Usage: "Policy List (separated by commas)",
 					},
+					cli.StringFlag{
+						Name:  "consumed-external-contracts, i",
+						Usage: "Consumed external contracts(separated by commas)",
+					},
+					cli.StringFlag{
+						Name:  "provided-external-contracts, e",
+						Usage: "Provided external contracts(separated by commas)",
+					},
 				},
 				Action: createEndpointGroup,
 			},
@@ -256,6 +264,44 @@ var Commands = []cli.Command{
 			},
 		},
 	},
+	{
+		Name:  "external-contracts",
+		Usage: "External contracts",
+		Subcommands: []cli.Command{
+			{
+				Name:    "ls",
+				Aliases: []string{"list"},
+				Usage:   "List external contracts",
+				Flags:   []cli.Flag{quietFlag, jsonFlag},
+				Action:  listExternalContracts,
+			},
+			{
+				Name:    "rm",
+				Aliases: []string{"delete"},
+				Usage:   "Delete external contracts",
+				Action:  deleteExternalContracts,
+			},
+			{
+				Name:  "create",
+				Usage: "Create external contracts",
+				Flags: []cli.Flag{
+					cli.BoolFlag{
+						Name:  "consumed, c",
+						Usage: "External contracts type - consumed",
+					},
+					cli.BoolFlag{
+						Name:  "provided, p",
+						Usage: "External contracts type - provided",
+					},
+					cli.StringFlag{
+						Name:  "contracts, a",
+						Usage: "Contracts (separated by commas)",
+					},
+				},
+				Action: createExternalContracts,
+			},
+		},
+	},
 	{
 		Name:  "global",
 		Usage: "Global information",

netctl/netctl.go

@@ -401,11 +401,23 @@ func createEndpointGroup(ctx *cli.Context) {
 		policies = []string{}
 	}
 
+	consExtContractsGrps := strings.Split(ctx.String("consumed-external-contracts"), ",")
+	if ctx.String("consumed-external-contracts") == "" {
+		consExtContractsGrps = []string{}
+	}
+
+	provExtContractsGrps := strings.Split(ctx.String("provided-external-contracts"), ",")
+	if ctx.String("provided-external-contracts") == "" {
+		provExtContractsGrps = []string{}
+	}
+
 	errCheck(ctx, getClient(ctx).EndpointGroupPost(&contivClient.EndpointGroup{
-		TenantName:  tenant,
-		NetworkName: network,
-		GroupName:   group,
-		Policies:    policies,
+		TenantName:           tenant,
+		NetworkName:          network,
+		GroupName:            group,
+		Policies:             policies,
+		ConsExtContractsGrps: consExtContractsGrps,
+		ProvExtContractsGrps: provExtContractsGrps,
 	}))
 }
 
@@ -800,3 +812,67 @@ func listServiceLB(ctx *cli.Context) {
 		}
 	}
 }
+
+func listExternalContracts(ctx *cli.Context) {
+	argCheck(0, ctx)
+
+	extContractsGroups, err := getClient(ctx).ExtContractsGroupList()
+	errCheck(ctx, err)
+
+	if ctx.Bool("json") {
+		dumpJSONList(ctx, extContractsGroups)
+	} else if ctx.Bool("quiet") {
+		contractsGroupNames := ""
+		for _, extContractsGroup := range *extContractsGroups {
+			contractsGroupNames += extContractsGroup.ContractsGroupName + "\n"
+		}
+		os.Stdout.WriteString(contractsGroupNames)
+	} else {
+		writer := tabwriter.NewWriter(os.Stdout, 0, 2, 2, ' ', 0)
+		defer writer.Flush()
+		for _, extContractsGroup := range *extContractsGroups {
+			writer.Write([]byte(fmt.Sprintf(" Name: %s\t\tType: %s\n", extContractsGroup.ContractsGroupName, extContractsGroup.ContractsType)))
+			writer.Write([]byte(fmt.Sprintf(" Contracts:\n")))
+			for _, contract := range extContractsGroup.Contracts {
+				writer.Write([]byte(fmt.Sprintf("\t\t%s\n", contract)))
+			}
+		}
+	}
+}
+
+func deleteExternalContracts(ctx *cli.Context) {
+	argCheck(1, ctx)
+	contractsGroupName := ctx.Args()[0]
+
+	logrus.Infof("Deleting external contracts group %s", contractsGroupName)
+	errCheck(ctx, getClient(ctx).ExtContractsGroupDelete(contractsGroupName))
+
+}
+
+func createExternalContracts(ctx *cli.Context) {
+	argCheck(1, ctx)
+
+	var contractsType string
+	if ctx.Bool("provided") && ctx.Bool("consumed") {
+		errExit(ctx, exitHelp, "Cannot use both provided and consumed", false)
+	} else if ctx.Bool("provided") {
+		contractsType = "provided"
+	} else if ctx.Bool("consumed") {
+		contractsType = "consumed"
+	} else {
+		errExit(ctx, exitHelp, "Either provided or consumed must be specified", false)
+	}
+
+	contracts := strings.Split(ctx.String("contracts"), ",")
+	if ctx.String("contracts") == "" {
+		errExit(ctx, exitHelp, "Contracts not provided", false)
+	}
+
+	contractsGroupName := ctx.Args()[0]
+
+	errCheck(ctx, getClient(ctx).ExtContractsGroupPost(&contivClient.ExtContractsGroup{
+		ContractsGroupName: contractsGroupName,
+		ContractsType:      contractsType,
+		Contracts:          contracts,
+	}))
+}

netmaster/objApi/apiController.go

@@ -22,6 +22,7 @@ import (
 	"github.com/contiv/netplugin/netmaster/intent"
 	"github.com/contiv/netplugin/netmaster/master"
 	"github.com/contiv/netplugin/utils"
+	"github.com/contiv/netplugin/utils/extContracts"
 	"github.com/contiv/objdb/modeldb"
 	"strconv"
 	"strings"
@@ -57,9 +58,8 @@ func NewAPIController(router *mux.Router, storeURL string) *APIController {
 	contivModel.RegisterRuleCallbacks(ctrler)
 	contivModel.RegisterTenantCallbacks(ctrler)
 	contivModel.RegisterBgpCallbacks(ctrler)
-	contivModel.RegisterBgpCallbacks(ctrler)
 	contivModel.RegisterServiceLBCallbacks(ctrler)
-
+	contivModel.RegisterExtContractsGroupCallbacks(ctrler)
 	// Register routes
 	contivModel.AddRoutes(router)
 
@@ -343,6 +343,12 @@ func endpointGroupCleanup(endpointGroup *contivModel.EndpointGroup) {
 		policy.Write()
 	}
 
+    // Cleanup any external contracts
+	err = extContracts.CleanupExternalContracts(endpointGroup)
+	if err != nil {
+		return err
+	}
+
 	// Remove the endpoint group from network and tenant link sets.
 	nwObjKey := endpointGroup.TenantName + ":" + endpointGroup.NetworkName
 	network := contivModel.FindNetwork(nwObjKey)
@@ -360,6 +366,107 @@ func endpointGroupCleanup(endpointGroup *contivModel.EndpointGroup) {
 // FIXME: hack to allocate unique endpoint group ids
 var globalEpgID = 1
 
+/*
+// Some utility functions to work with the external contracts
+func extContractsGrpDeregister(epg *contivModel.EndpointGroup, contractsGrp *contivModel.ExtContractsGroup, contractType string) error {
+	if contractsGrp == nil {
+		errStr := fmt.Sprintf("%s External contracts group not found", contractType)
+		log.Errorf(errStr)
+		return core.Errorf(errStr)
+	}
+
+	modeldb.RemoveLinkSet(&contractsGrp.LinkSets.EndpointGroups, epg)
+	if contractType == "provided" {
+		modeldb.RemoveLinkSet(&epg.LinkSets.ProvExtContractsGrps, contractsGrp)
+	} else if contractType == "consumed" {
+		modeldb.RemoveLinkSet(&epg.LinkSets.ConsExtContractsGrps, contractsGrp)
+	}
+	// Links broken, update the contracts group object.
+	err := contractsGrp.Write()
+	if err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func extContractsGrpValidateAndRegister(epg *contivModel.EndpointGroup, contractsGrp *contivModel.ExtContractsGroup, contractType string) error {
+	if contractsGrp == nil {
+		errStr := fmt.Sprintf("%s External contracts group not found", contractType)
+		log.Errorf(errStr)
+		return core.Errorf(errStr)
+	}
+
+	if strings.ToLower(contractsGrp.ContractsType) != contractType {
+		errStr := fmt.Sprintf("Incorrect type for contract group: %v", contractsGrp)
+		log.Errorf(errStr)
+		return core.Errorf(errStr)
+	}
+
+	// Establish the necessary links.
+	// TBD: Error handling. In the loop, we are bailing out
+	// on failure. How do we take care of already established
+	// links?
+	modeldb.AddLinkSet(&contractsGrp.LinkSets.EndpointGroups, epg)
+	if contractType == "provided" {
+		modeldb.AddLinkSet(&epg.LinkSets.ProvExtContractsGrps, contractsGrp)
+	} else if contractType == "consumed" {
+		modeldb.AddLinkSet(&epg.LinkSets.ConsExtContractsGrps, contractsGrp)
+	}
+
+	// Links made, write the policy set object.
+	err := contractsGrp.Write()
+	if err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func cleanupExternalContracts(endpointGroup *contivModel.EndpointGroup) error {
+	// Cleanup consumed external contracts
+	for _, consExtContractsGrp := range endpointGroup.ConsExtContractsGrps {
+		contractsGrp := contivModel.FindExtContractsGroup(consExtContractsGrp)
+		err = extContractsGrpDeregister(endpointGroup, contractsGrp, "consumed")
+		if err != nil {
+			return err
+		}
+	}
+
+	// Cleanup provided external contracts
+	for _, provExtContractsGrp := range endpointGroup.ProvExtContractsGrps {
+		contractsGrp := contivModel.FindExtContractsGroup(provExtContractsGrp)
+		err = extContractsGrpDeregister(endpointGroup, contractsGrp, "provided")
+		if err != nil {
+			return err
+		}
+	}
+
+    return nil
+}
+
+func setupExternalContracts(endpointGroup *contivModel.EndpointGroup, consContractsGrps, provContractsGrps string[]) error {
+	// Validate presence and register consumed external contracts
+	for _, consExtContractsGrp := range consContractsGrps {
+		contractsGrp := contivModel.FindExtContractsGroup(consExtContractsGrp)
+		err = extContractsGrpValidateAndRegister(endpointGroup, contractsGrp, "consumed")
+		if err != nil {
+			return err
+		}
+	}
+
+	// Validate presence and register provided external contracts
+	for _, provExtContractsGrp := range provContractsGrps {
+		contractsGrp := contivModel.FindExtContractsGroup(provExtContractsGrp)
+		err = extContractsGrpValidateAndRegister(endpointGroup, contractsGrp, "provided")
+		if err != nil {
+			return err
+		}
+	}
+
+    return nil
+}
+*/
 // EndpointGroupCreate creates end point group
 func (ac *APIController) EndpointGroupCreate(endpointGroup *contivModel.EndpointGroup) error {
 	log.Infof("Received EndpointGroupCreate: %+v", endpointGroup)
@@ -391,6 +498,12 @@ func (ac *APIController) EndpointGroupCreate(endpointGroup *contivModel.Endpoint
 		return err
 	}
 
+	// Setup external contracts this EPG might have.
+	err = extContracts.SetupExternalContracts(endpointGroup, endpointGroup.ConsExtContractsGrps, endpointGroup.ProvExtContractsGrps)
+	if err != nil {
+		return err
+	}
+
 	// for each policy create an epg policy Instance
 	for _, policyName := range endpointGroup.Policies {
 		policyKey := endpointGroup.TenantName + ":" + policyName
@@ -512,10 +625,27 @@ func (ac *APIController) EndpointGroupUpdate(endpointGroup, params *contivModel.
 			}
 		}
 	}
-
 	// Update the policy list
 	endpointGroup.Policies = params.Policies
 
+	// For the external contracts, we can keep the update simple. Remove
+	// all that we have now, and update the epg with the new list.
+	// Step 1: Cleanup existing external contracts.
+	err := extContracts.CleanupExternalContracts(endpointGroup)
+	if err != nil {
+		return err
+	}
+	// Step 2: Add contracts from the update.
+	// Consumed contracts
+	err = extContracts.SetupExternalContracts(endpointGroup, params.ConsExtContractsGrps, params.ProvExtContractsGrps)
+	if err != nil {
+		return err
+	}
+
+	// Update the epg itself with the new contracts groups.
+	endpointGroup.ConsExtContractsGrps = params.ConsExtContractsGrps
+	endpointGroup.ProvExtContractsGrps = params.ProvExtContractsGrps
+
 	// if there is an associated app profiles, update that as well
 	profKey := endpointGroup.Links.AppProfile.ObjKey
 	profObj := contivModel.FindAppProfile(profKey)
@@ -1135,3 +1265,40 @@ func validatePorts(ports []string) bool {
 	}
 	return true
 }
+
+func isExtContractsGroupUsed(contractsGroup *contivModel.ExtContractsGroup) bool {
+	if len(contractsGroup.LinkSets.EndpointGroups) > 0 {
+		return true
+	}
+
+	return false
+}
+
+// ExtContractsGroupCreate creates a new group of external contracts
+func (ac *APIController) ExtContractsGroupCreate(contractsGroup *contivModel.ExtContractsGroup) error {
+	log.Infof("Received ExtContractsGroupCreate: %+v", contractsGroup)
+
+	return nil
+}
+
+// ExtContractsGroupUpdate updates an existing group of contract sets
+func (ac *APIController) ExtContractsGroupUpdate(contractsGroup, params *contivModel.ExtContractsGroup) error {
+	log.Infof("Received ExtContractsGroupUpdate: %+v, params: %+v", contractsGroup, params)
+	log.Errorf("Error: external contracts update not supported: %s", contractsGroup.ContractsGroupName)
+
+	return core.Errorf("external contracts update not supported")
+}
+
+// ExtContractsGroupDelete deletes an existing external contracts group
+func (ac *APIController) ExtContractsGroupDelete(contractsGroup *contivModel.ExtContractsGroup) error {
+	log.Infof("Received ExtContractsGroupDelete: %+v", contractsGroup)
+
+	// At this moment, we let the external contracts to be deleted only
+	// if there are no consumers of this external contracts group
+	if isExtContractsGroupUsed(contractsGroup) == true {
+		log.Errorf("Error: External contracts groups is being used: %s", contractsGroup.ContractsGroupName)
+		return core.Errorf("External contracts group is in-use")
+	}
+
+	return nil
+}