Exemple #1
0
// getEndpointGroupID returns endpoint group Id for a service
// It autocreates the endpoint group if it doesnt exist
func getEndpointGroupID(serviceName, networkName string) (int, error) {
	// FIXME: Get tenant name
	tenantName := "default"

	// If service name is not specified, we are done
	if serviceName == "" {
		return 0, nil
	}

	// form the key based on network and service name.
	epgName := serviceName + "." + networkName
	epgKey := tenantName + ":" + epgName

	// See if the epg exists
	epg := contivModel.FindEndpointGroup(epgKey)
	if epg == nil {
		endpointGroup := contivModel.EndpointGroup{
			Key:         epgKey,
			TenantName:  tenantName,
			NetworkName: networkName,
			GroupName:   epgName,
		}

		// Create endpoint group
		err := contivModel.CreateEndpointGroup(&endpointGroup)
		if err != nil {
			log.Errorf("Error creating endpoint group: %+v, Err: %v", endpointGroup, err)
			return 0, err
		}

		// find again
		epg = contivModel.FindEndpointGroup(epgKey)
		if epg == nil {
			log.Errorf("Error creating endpoint group %s.", epgName)
			return 0, core.Errorf("EPG not created")
		}
	}

	// return endpoint group id
	return epg.EndpointGroupID, nil
}
// getEndpointGroupID returns endpoint group Id for a service
// It autocreates the endpoint group if it doesnt exist
func getEndpointGroupID(serviceName, networkName, tenantName string) (int, error) {
	// If service name is not specified, we are done
	if serviceName == "" {
		// FIXME: Need a better way to handle default epg for the network
		return 0, nil
	}

	// form the key based on network and service name.
	epgKey := tenantName + ":" + networkName + ":" + serviceName

	// See if the epg exists
	epg := contivModel.FindEndpointGroup(epgKey)
	if epg == nil {
		return 0, core.Errorf("EPG not created")
	}

	// return endpoint group id
	return epg.EndpointGroupID, nil
}
// ServiceCreate creates service
func (ac *APIController) ServiceCreate(service *contivModel.Service) error {
	log.Infof("Received ServiceCreate: %+v", service)

	// check params
	if (service.TenantName == "") || (service.AppName == "") {
		return core.Errorf("Invalid parameters")
	}

	// Make sure tenant exists
	tenant := contivModel.FindTenant(service.TenantName)
	if tenant == nil {
		return core.Errorf("Tenant not found")
	}

	// Find the app this service belongs to
	app := contivModel.FindApp(service.TenantName + ":" + service.AppName)
	if app == nil {
		return core.Errorf("App not found")
	}

	// Setup links
	modeldb.AddLink(&service.Links.App, app)
	modeldb.AddLinkSet(&app.LinkSets.Services, service)

	// Save the app too since we added the links
	err := app.Write()
	if err != nil {
		return err
	}

	// Check if user specified any networks
	if len(service.Networks) == 0 {
		service.Networks = append(service.Networks, "private")
	}

	// link service with network
	for _, netName := range service.Networks {
		netKey := service.TenantName + ":" + netName
		network := contivModel.FindNetwork(netKey)
		if network == nil {
			log.Errorf("Service: %s could not find network %s", service.Key, netKey)
			return core.Errorf("Network not found")
		}

		// Link the network
		modeldb.AddLinkSet(&service.LinkSets.Networks, network)
		modeldb.AddLinkSet(&network.LinkSets.Services, service)

		// save the network
		err := network.Write()
		if err != nil {
			return err
		}
	}

	// Check if user specified any endpoint group for the service
	if len(service.EndpointGroups) == 0 {
		// Create one default endpointGroup per network
		for _, netName := range service.Networks {
			// params for default endpoint group
			dfltEpgName := service.AppName + "." + service.ServiceName + "." + netName
			endpointGroup := contivModel.EndpointGroup{
				Key:         service.TenantName + ":" + dfltEpgName,
				TenantName:  service.TenantName,
				NetworkName: netName,
				GroupName:   dfltEpgName,
			}

			// Create default endpoint group for the service
			err = contivModel.CreateEndpointGroup(&endpointGroup)
			if err != nil {
				log.Errorf("Error creating endpoint group: %+v, Err: %v", endpointGroup, err)
				return err
			}

			// Add the endpoint group to the list
			service.EndpointGroups = append(service.EndpointGroups, dfltEpgName)
		}
	}

	// Link the service and endpoint group
	for _, epgName := range service.EndpointGroups {
		endpointGroup := contivModel.FindEndpointGroup(service.TenantName + ":" + epgName)
		if endpointGroup == nil {
			log.Errorf("Error: could not find endpoint group: %s", epgName)
			return core.Errorf("could not find endpointGroup")
		}

		// setup links
		modeldb.AddLinkSet(&service.LinkSets.EndpointGroups, endpointGroup)
		modeldb.AddLinkSet(&endpointGroup.LinkSets.Services, service)

		// save the endpointGroup
		err = endpointGroup.Write()
		if err != nil {
			return err
		}
	}

	return nil
}
Exemple #4
0
//CreateAppNw Fill in the Nw spec and launch the nw infra
func CreateAppNw(app *contivModel.App) 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
	}

	netName := ""
	eMap := &epgMap{}
	eMap.Specs = make(map[string]epgSpec)
	ans := &appNwSpec{}

	ans.TenantName = app.TenantName
	ans.AppName = app.AppName

	// Gather all basic epg info into the epg map
	for epgKey := range app.LinkSets.Services {
		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
		}
		netName = epgObj.NetworkName
	}

	// 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)
	}

	// get the subnet info and add it to ans
	nwCfg := &mastercfg.CfgNetworkState{}
	nwCfg.StateDriver = stateDriver
	networkID := netName + "." + app.TenantName
	nErr := nwCfg.Read(networkID)
	if nErr != nil {
		log.Errorf("Failed to network info %v %v ", netName, nErr)
		return nErr
	}
	ans.Subnet = nwCfg.Gateway + "/" + strconv.Itoa(int(nwCfg.SubnetLen))
	log.Debugf("Nw %v subnet %v", netName, ans.Subnet)

	ans.launch()

	return nil
}
Exemple #5
0
// createOfnetRule creates a directional ofnet rule
func (gp *EpgPolicy) createOfnetRule(rule *contivModel.Rule, dir string) (*ofnet.OfnetPolicyRule, error) {
	ruleID := gp.EpgPolicyKey + ":" + rule.Key + ":" + dir

	// Create an ofnet rule
	ofnetRule := new(ofnet.OfnetPolicyRule)
	ofnetRule.RuleId = ruleID
	ofnetRule.Priority = rule.Priority
	ofnetRule.Action = rule.Action

	remoteEpgID := 0
	// See if user specified an endpoint Group in the rule
	if rule.EndpointGroup != "" {
		epgKey := rule.TenantName + ":" + rule.EndpointGroup

		// find the endpoint group
		epg := contivModel.FindEndpointGroup(epgKey)
		if epg == nil {
			log.Errorf("Error finding endpoint group %s", epgKey)
			return nil, core.Errorf("endpoint group not found")
		}

		remoteEpgID = epg.EndpointGroupID
	}

	// Set protocol
	switch rule.Protocol {
	case "tcp":
		ofnetRule.IpProtocol = 6
	case "udp":
		ofnetRule.IpProtocol = 17
	case "icmp":
		ofnetRule.IpProtocol = 1
	case "igmp":
		ofnetRule.IpProtocol = 2
	case "":
		ofnetRule.IpProtocol = 0
	default:
		proto, err := strconv.Atoi(rule.Protocol)
		if err == nil && proto < 256 {
			ofnetRule.IpProtocol = uint8(proto)
		}
	}

	// Set directional parameters
	switch dir {
	case "inRx":
		// Set src/dest endpoint group
		ofnetRule.DstEndpointGroup = gp.EndpointGroupID
		ofnetRule.SrcEndpointGroup = remoteEpgID

		// Set src/dest IP Address
		ofnetRule.SrcIpAddr = rule.IpAddress

		// set port numbers
		ofnetRule.DstPort = uint16(rule.Port)

		// set tcp flags
		if rule.Protocol == "tcp" && rule.Port == 0 {
			ofnetRule.TcpFlags = "syn,!ack"
		}
	case "inTx":
		// Set src/dest endpoint group
		ofnetRule.SrcEndpointGroup = gp.EndpointGroupID
		ofnetRule.DstEndpointGroup = remoteEpgID

		// Set src/dest IP Address
		ofnetRule.DstIpAddr = rule.IpAddress

		// set port numbers
		ofnetRule.SrcPort = uint16(rule.Port)
	case "outRx":
		// Set src/dest endpoint group
		ofnetRule.DstEndpointGroup = gp.EndpointGroupID
		ofnetRule.SrcEndpointGroup = remoteEpgID

		// Set src/dest IP Address
		ofnetRule.SrcIpAddr = rule.IpAddress

		// set port numbers
		ofnetRule.SrcPort = uint16(rule.Port)
	case "outTx":
		// Set src/dest endpoint group
		ofnetRule.SrcEndpointGroup = gp.EndpointGroupID
		ofnetRule.DstEndpointGroup = remoteEpgID

		// Set src/dest IP Address
		ofnetRule.DstIpAddr = rule.IpAddress

		// set port numbers
		ofnetRule.DstPort = uint16(rule.Port)

		// set tcp flags
		if rule.Protocol == "tcp" && rule.Port == 0 {
			ofnetRule.TcpFlags = "syn,!ack"
		}
	default:
		log.Fatalf("Unknown rule direction %s", dir)
	}

	// Add the Rule to policyDB
	err := ofnetMaster.AddRule(ofnetRule)
	if err != nil {
		log.Errorf("Error creating rule {%+v}. Err: %v", ofnetRule, err)
		return nil, err
	}

	log.Infof("Added rule {%+v} to policyDB", ofnetRule)

	return ofnetRule, nil
}
// ServiceCreate creates service
func (ac *APIController) ServiceCreate(service *contivModel.Service) error {
	log.Infof("Received ServiceCreate: %+v", service)

	// check params
	if (service.TenantName == "") || (service.AppName == "") {
		return errors.New("Invalid parameters")
	}

	// Make sure tenant exists
	tenant := contivModel.FindTenant(service.TenantName)
	if tenant == nil {
		return errors.New("Tenant not found")
	}

	// Find the app this service belongs to
	app := contivModel.FindApp(service.TenantName + ":" + service.AppName)
	if app == nil {
		return errors.New("App not found")
	}

	// Setup links
	modeldb.AddLink(&service.Links.App, app)
	modeldb.AddLinkSet(&app.LinkSets.Services, service)

	// Save the app too since we added the links
	err := app.Write()
	if err != nil {
		return err
	}

	// Check if user specified any networks
	if len(service.Networks) == 0 {
		service.Networks = append(service.Networks, "privateNet")
	}

	// link service with network
	for _, netName := range service.Networks {
		netKey := service.TenantName + ":" + netName
		network := contivModel.FindNetwork(netKey)
		if network == nil {
			log.Errorf("Service: %s could not find network %s", service.Key, netKey)
			return errors.New("Network not found")
		}

		// Link the network
		modeldb.AddLinkSet(&service.LinkSets.Networks, network)
		modeldb.AddLinkSet(&network.LinkSets.Services, service)

		// save the network
		err := network.Write()
		if err != nil {
			return err
		}
	}

	// Check if user specified any endpoint group for the service
	if len(service.EndpointGroups) == 0 {
		// Create one default endpointGroup per network
		for _, netName := range service.Networks {
			// params for default endpoint group
			dfltEpgName := service.AppName + "." + service.ServiceName + "." + netName
			endpointGroup := contivModel.EndpointGroup{
				Key:         service.TenantName + ":" + dfltEpgName,
				TenantName:  service.TenantName,
				NetworkName: netName,
				GroupName:   dfltEpgName,
			}

			// Create default endpoint group for the service
			err = contivModel.CreateEndpointGroup(&endpointGroup)
			if err != nil {
				log.Errorf("Error creating endpoint group: %+v, Err: %v", endpointGroup, err)
				return err
			}

			// Add the endpoint group to the list
			service.EndpointGroups = append(service.EndpointGroups, dfltEpgName)
		}
	}

	// Link the service and endpoint group
	for _, epgName := range service.EndpointGroups {
		endpointGroup := contivModel.FindEndpointGroup(service.TenantName + ":" + epgName)
		if endpointGroup == nil {
			log.Errorf("Error: could not find endpoint group: %s", epgName)
			return errors.New("could not find endpointGroup")
		}

		// setup links
		modeldb.AddLinkSet(&service.LinkSets.EndpointGroups, endpointGroup)
		modeldb.AddLinkSet(&endpointGroup.LinkSets.Services, service)

		// save the endpointGroup
		err = endpointGroup.Write()
		if err != nil {
			return err
		}
	}

	// Check if user specified any volume profile
	if service.VolumeProfile == "" {
		service.VolumeProfile = "default"
	}

	volProfKey := service.TenantName + ":" + service.VolumeProfile
	volProfile := contivModel.FindVolumeProfile(volProfKey)
	if volProfile == nil {
		log.Errorf("Could not find the volume profile: %s", service.VolumeProfile)
		return errors.New("VolumeProfile not found")
	}

	// fixup default values
	if service.Scale == 0 {
		service.Scale = 1
	}

	// Create service instances
	for idx := int64(0); idx < service.Scale; idx++ {
		instID := fmt.Sprintf("%d", idx+1)
		var volumes []string

		// Create a volume for each instance based on the profile
		if volProfile.DatastoreType != "none" {
			instVolName := service.AppName + "." + service.ServiceName + "." + instID
			err = contivModel.CreateVolume(&contivModel.Volume{
				Key:           service.TenantName + ":" + instVolName,
				VolumeName:    instVolName,
				TenantName:    service.TenantName,
				DatastoreType: volProfile.DatastoreType,
				PoolName:      volProfile.PoolName,
				Size:          volProfile.Size,
				MountPoint:    volProfile.MountPoint,
			})
			if err != nil {
				log.Errorf("Error creating volume %s. Err: %v", instVolName, err)
				return err
			}
			volumes = []string{instVolName}
		}

		// build instance params
		instKey := service.TenantName + ":" + service.AppName + ":" + service.ServiceName + ":" + instID
		inst := contivModel.ServiceInstance{
			Key:         instKey,
			InstanceID:  instID,
			TenantName:  service.TenantName,
			AppName:     service.AppName,
			ServiceName: service.ServiceName,
			Volumes:     volumes,
		}

		// create the instance
		err := contivModel.CreateServiceInstance(&inst)
		if err != nil {
			log.Errorf("Error creating service instance: %+v. Err: %v", inst, err)
			return err
		}
	}

	return nil
}