Examples with Provider com.cloud.network.Network.Provider used on opensource projects

Example 36 with Provider

use of com.cloud.network.Network.Provider in project cloudstack by apache.

the class ConfigurationManagerImpl method createNetworkOffering.

@Override
@ActionEvent(eventType = EventTypes.EVENT_NETWORK_OFFERING_CREATE, eventDescription = "creating network offering")
public NetworkOffering createNetworkOffering(final CreateNetworkOfferingCmd cmd) {
    final String name = cmd.getNetworkOfferingName();
    final String displayText = cmd.getDisplayText();
    final String tags = cmd.getTags();
    final String trafficTypeString = cmd.getTraffictype();
    final boolean specifyVlan = cmd.getSpecifyVlan();
    final boolean conserveMode = cmd.getConserveMode();
    final String availabilityStr = cmd.getAvailability();
    Integer networkRate = cmd.getNetworkRate();
    TrafficType trafficType = null;
    Availability availability = null;
    Network.GuestType guestType = null;
    final boolean specifyIpRanges = cmd.getSpecifyIpRanges();
    final boolean isPersistent = cmd.getIsPersistent();
    final Map<String, String> detailsStr = cmd.getDetails();
    final Boolean egressDefaultPolicy = cmd.getEgressDefaultPolicy();
    Integer maxconn = null;
    boolean enableKeepAlive = false;
    // Verify traffic type
    for (final TrafficType tType : TrafficType.values()) {
        if (tType.name().equalsIgnoreCase(trafficTypeString)) {
            trafficType = tType;
            break;
        }
    }
    if (trafficType == null) {
        throw new InvalidParameterValueException("Invalid value for traffictype. Supported traffic types: Public, Management, Control, Guest, Vlan or Storage");
    }
    // Only GUEST traffic type is supported in Acton
    if (trafficType != TrafficType.Guest) {
        throw new InvalidParameterValueException("Only traffic type " + TrafficType.Guest + " is supported in the current release");
    }
    // Verify offering type
    for (final Network.GuestType offType : Network.GuestType.values()) {
        if (offType.name().equalsIgnoreCase(cmd.getGuestIpType())) {
            guestType = offType;
            break;
        }
    }
    if (guestType == null) {
        throw new InvalidParameterValueException("Invalid \"type\" parameter is given; can have Shared and Isolated values");
    }
    // Verify availability
    for (final Availability avlb : Availability.values()) {
        if (avlb.name().equalsIgnoreCase(availabilityStr)) {
            availability = avlb;
        }
    }
    if (availability == null) {
        throw new InvalidParameterValueException("Invalid value for Availability. Supported types: " + Availability.Required + ", " + Availability.Optional);
    }
    if (networkRate != null && networkRate < 0) {
        networkRate = 0;
    }
    final Long serviceOfferingId = cmd.getServiceOfferingId();
    if (serviceOfferingId != null) {
        final ServiceOfferingVO offering = _serviceOfferingDao.findById(serviceOfferingId);
        if (offering == null) {
            throw new InvalidParameterValueException("Cannot find specified service offering: " + serviceOfferingId);
        }
        if (!VirtualMachine.Type.DomainRouter.toString().equalsIgnoreCase(offering.getSystemVmType())) {
            throw new InvalidParameterValueException("The specified service offering " + serviceOfferingId + " cannot be used by virtual router!");
        }
    }
    // configure service provider map
    final Map<Network.Service, Set<Network.Provider>> serviceProviderMap = new HashMap<Network.Service, Set<Network.Provider>>();
    final Set<Network.Provider> defaultProviders = new HashSet<Network.Provider>();
    // populate the services first
    for (final String serviceName : cmd.getSupportedServices()) {
        // validate if the service is supported
        final Service service = Network.Service.getService(serviceName);
        if (service == null || service == Service.Gateway) {
            throw new InvalidParameterValueException("Invalid service " + serviceName);
        }
        if (service == Service.SecurityGroup) {
            // allow security group service for Shared networks only
            if (guestType != GuestType.Shared) {
                throw new InvalidParameterValueException("Secrity group service is supported for network offerings with guest ip type " + GuestType.Shared);
            }
            final Set<Network.Provider> sgProviders = new HashSet<Network.Provider>();
            sgProviders.add(Provider.SecurityGroupProvider);
            serviceProviderMap.put(Network.Service.SecurityGroup, sgProviders);
            continue;
        }
        serviceProviderMap.put(service, defaultProviders);
    }
    // add gateway provider (if sourceNat provider is enabled)
    final Set<Provider> sourceNatServiceProviders = serviceProviderMap.get(Service.SourceNat);
    if (sourceNatServiceProviders != null && !sourceNatServiceProviders.isEmpty()) {
        serviceProviderMap.put(Service.Gateway, sourceNatServiceProviders);
    }
    // populate providers
    final Map<Provider, Set<Service>> providerCombinationToVerify = new HashMap<Provider, Set<Service>>();
    final Map<String, List<String>> svcPrv = cmd.getServiceProviders();
    Provider firewallProvider = null;
    Provider dhcpProvider = null;
    Boolean IsVrUserdataProvider = false;
    if (svcPrv != null) {
        for (final String serviceStr : svcPrv.keySet()) {
            final Network.Service service = Network.Service.getService(serviceStr);
            if (serviceProviderMap.containsKey(service)) {
                final Set<Provider> providers = new HashSet<Provider>();
                // the service is LB
                if (!serviceStr.equalsIgnoreCase(Service.Lb.getName()) && svcPrv.get(serviceStr) != null && svcPrv.get(serviceStr).size() > 1) {
                    throw new InvalidParameterValueException("In the current release only one provider can be " + "specified for the service if the service is not LB");
                }
                for (final String prvNameStr : svcPrv.get(serviceStr)) {
                    // check if provider is supported
                    final Network.Provider provider = Network.Provider.getProvider(prvNameStr);
                    if (provider == null) {
                        throw new InvalidParameterValueException("Invalid service provider: " + prvNameStr);
                    }
                    if (provider == Provider.JuniperSRX || provider == Provider.CiscoVnmc) {
                        firewallProvider = provider;
                    }
                    if (provider == Provider.PaloAlto) {
                        firewallProvider = Provider.PaloAlto;
                    }
                    if ((service == Service.PortForwarding || service == Service.StaticNat) && provider == Provider.VirtualRouter) {
                        firewallProvider = Provider.VirtualRouter;
                    }
                    if (service == Service.Dhcp) {
                        dhcpProvider = provider;
                    }
                    if (service == Service.UserData && provider == Provider.VirtualRouter) {
                        IsVrUserdataProvider = true;
                    }
                    providers.add(provider);
                    Set<Service> serviceSet = null;
                    if (providerCombinationToVerify.get(provider) == null) {
                        serviceSet = new HashSet<Service>();
                    } else {
                        serviceSet = providerCombinationToVerify.get(provider);
                    }
                    serviceSet.add(service);
                    providerCombinationToVerify.put(provider, serviceSet);
                }
                serviceProviderMap.put(service, providers);
            } else {
                throw new InvalidParameterValueException("Service " + serviceStr + " is not enabled for the network " + "offering, can't add a provider to it");
            }
        }
    }
    // dhcp provider and userdata provider should be same because vm will be contacting dhcp server for user data.
    if (dhcpProvider == null && IsVrUserdataProvider) {
        s_logger.debug("User data provider VR can't be selected without VR as dhcp provider. In this case VM fails to contact the DHCP server for userdata");
        throw new InvalidParameterValueException("Without VR as dhcp provider, User data can't selected for VR. Please select VR as DHCP provider ");
    }
    // validate providers combination here
    _networkModel.canProviderSupportServices(providerCombinationToVerify);
    // validate the LB service capabilities specified in the network
    // offering
    final Map<Capability, String> lbServiceCapabilityMap = cmd.getServiceCapabilities(Service.Lb);
    if (!serviceProviderMap.containsKey(Service.Lb) && lbServiceCapabilityMap != null && !lbServiceCapabilityMap.isEmpty()) {
        throw new InvalidParameterValueException("Capabilities for LB service can be specifed only when LB service is enabled for network offering.");
    }
    validateLoadBalancerServiceCapabilities(lbServiceCapabilityMap);
    if (lbServiceCapabilityMap != null && !lbServiceCapabilityMap.isEmpty()) {
        maxconn = cmd.getMaxconnections();
        if (maxconn == null) {
            maxconn = Integer.parseInt(_configDao.getValue(Config.NetworkLBHaproxyMaxConn.key()));
        }
    }
    if (cmd.getKeepAliveEnabled() != null && cmd.getKeepAliveEnabled()) {
        enableKeepAlive = true;
    }
    // validate the Source NAT service capabilities specified in the network
    // offering
    final Map<Capability, String> sourceNatServiceCapabilityMap = cmd.getServiceCapabilities(Service.SourceNat);
    if (!serviceProviderMap.containsKey(Service.SourceNat) && sourceNatServiceCapabilityMap != null && !sourceNatServiceCapabilityMap.isEmpty()) {
        throw new InvalidParameterValueException("Capabilities for source NAT service can be specifed only when source NAT service is enabled for network offering.");
    }
    validateSourceNatServiceCapablities(sourceNatServiceCapabilityMap);
    // validate the Static Nat service capabilities specified in the network
    // offering
    final Map<Capability, String> staticNatServiceCapabilityMap = cmd.getServiceCapabilities(Service.StaticNat);
    if (!serviceProviderMap.containsKey(Service.StaticNat) && sourceNatServiceCapabilityMap != null && !staticNatServiceCapabilityMap.isEmpty()) {
        throw new InvalidParameterValueException("Capabilities for static NAT service can be specifed only when static NAT service is enabled for network offering.");
    }
    validateStaticNatServiceCapablities(staticNatServiceCapabilityMap);
    // validate the 'Connectivity' service capabilities specified in the network offering, if 'Connectivity' service
    // is in the supported services of network offering
    final Map<Capability, String> connectivityServiceCapabilityMap = cmd.getServiceCapabilities(Service.Connectivity);
    if (!serviceProviderMap.containsKey(Service.Connectivity) && connectivityServiceCapabilityMap != null && !connectivityServiceCapabilityMap.isEmpty()) {
        throw new InvalidParameterValueException("Capabilities for 'Connectivity' service can be specified " + "only when Connectivity service is enabled for network offering.");
    }
    validateConnectivityServiceCapablities(guestType, serviceProviderMap.get(Service.Connectivity), connectivityServiceCapabilityMap);
    final Map<Service, Map<Capability, String>> serviceCapabilityMap = new HashMap<Service, Map<Capability, String>>();
    serviceCapabilityMap.put(Service.Lb, lbServiceCapabilityMap);
    serviceCapabilityMap.put(Service.SourceNat, sourceNatServiceCapabilityMap);
    serviceCapabilityMap.put(Service.StaticNat, staticNatServiceCapabilityMap);
    serviceCapabilityMap.put(Service.Connectivity, connectivityServiceCapabilityMap);
    // combination
    if (firewallProvider != null) {
        s_logger.debug("Adding Firewall service with provider " + firewallProvider.getName());
        final Set<Provider> firewallProviderSet = new HashSet<Provider>();
        firewallProviderSet.add(firewallProvider);
        serviceProviderMap.put(Service.Firewall, firewallProviderSet);
        if (!(firewallProvider.getName().equals(Provider.JuniperSRX.getName()) || firewallProvider.getName().equals(Provider.PaloAlto.getName()) || firewallProvider.getName().equals(Provider.VirtualRouter.getName())) && egressDefaultPolicy == false) {
            throw new InvalidParameterValueException("Firewall egress with default policy " + egressDefaultPolicy + " is not supported by the provider " + firewallProvider.getName());
        }
    }
    final Map<NetworkOffering.Detail, String> details = new HashMap<NetworkOffering.Detail, String>();
    if (detailsStr != null) {
        for (final String detailStr : detailsStr.keySet()) {
            NetworkOffering.Detail offDetail = null;
            for (final NetworkOffering.Detail supportedDetail : NetworkOffering.Detail.values()) {
                if (detailStr.equalsIgnoreCase(supportedDetail.toString())) {
                    offDetail = supportedDetail;
                    break;
                }
            }
            if (offDetail == null) {
                throw new InvalidParameterValueException("Unsupported detail " + detailStr);
            }
            details.put(offDetail, detailsStr.get(detailStr));
        }
    }
    final NetworkOffering offering = createNetworkOffering(name, displayText, trafficType, tags, specifyVlan, availability, networkRate, serviceProviderMap, false, guestType, false, serviceOfferingId, conserveMode, serviceCapabilityMap, specifyIpRanges, isPersistent, details, egressDefaultPolicy, maxconn, enableKeepAlive);
    CallContext.current().setEventDetails(" Id: " + offering.getId() + " Name: " + name);
    return offering;
}

Example 37 with Provider

use of com.cloud.network.Network.Provider in project cloudstack by apache.

the class ConfigurationManagerImpl method createNetworkOffering.

@Override
@DB
public NetworkOfferingVO createNetworkOffering(final String name, final String displayText, final TrafficType trafficType, String tags, final boolean specifyVlan, final Availability availability, final Integer networkRate, final Map<Service, Set<Provider>> serviceProviderMap, final boolean isDefault, final Network.GuestType type, final boolean systemOnly, final Long serviceOfferingId, final boolean conserveMode, final Map<Service, Map<Capability, String>> serviceCapabilityMap, final boolean specifyIpRanges, final boolean isPersistent, final Map<NetworkOffering.Detail, String> details, final boolean egressDefaultPolicy, final Integer maxconn, final boolean enableKeepAlive) {
    final String multicastRateStr = _configDao.getValue("multicast.throttling.rate");
    final int multicastRate = multicastRateStr == null ? 10 : Integer.parseInt(multicastRateStr);
    tags = StringUtils.cleanupTags(tags);
    // specifyVlan should always be true for Shared network offerings
    if (!specifyVlan && type == GuestType.Shared) {
        Set<Provider> connectivityProviders = serviceProviderMap != null ? serviceProviderMap.get(Service.Connectivity) : null;
        if (CollectionUtils.isEmpty(connectivityProviders) || !_networkModel.providerSupportsCapability(connectivityProviders, Service.Connectivity, Capability.NoVlan)) {
            throw new InvalidParameterValueException("SpecifyVlan should be true if network offering's type is " + type);
        }
    }
    // Nat service
    if (specifyIpRanges) {
        if (type == GuestType.Isolated) {
            if (serviceProviderMap.containsKey(Service.SourceNat)) {
                throw new InvalidParameterValueException("SpecifyIpRanges can only be true for Shared network offerings and Isolated with no SourceNat service");
            }
        }
    } else {
        if (type == GuestType.Shared) {
            throw new InvalidParameterValueException("SpecifyIpRanges should always be true for Shared network offerings");
        }
    }
    // isPersistent should always be false for Shared network Offerings
    if (isPersistent && type == GuestType.Shared) {
        throw new InvalidParameterValueException("isPersistent should be false if network offering's type is " + type);
    }
    // validate availability value
    if (availability == NetworkOffering.Availability.Required) {
        final boolean canOffBeRequired = type == GuestType.Isolated && serviceProviderMap.containsKey(Service.SourceNat);
        if (!canOffBeRequired) {
            throw new InvalidParameterValueException("Availability can be " + NetworkOffering.Availability.Required + " only for networkOfferings of type " + GuestType.Isolated + " and with " + Service.SourceNat.getName() + " enabled");
        }
        // only one network offering in the system can be Required
        final List<NetworkOfferingVO> offerings = _networkOfferingDao.listByAvailability(Availability.Required, false);
        if (!offerings.isEmpty()) {
            throw new InvalidParameterValueException("System already has network offering id=" + offerings.get(0).getId() + " with availability " + Availability.Required);
        }
    }
    boolean dedicatedLb = false;
    boolean elasticLb = false;
    boolean sharedSourceNat = false;
    boolean redundantRouter = false;
    boolean elasticIp = false;
    boolean associatePublicIp = false;
    boolean inline = false;
    boolean publicLb = false;
    boolean internalLb = false;
    boolean strechedL2Subnet = false;
    boolean publicAccess = false;
    if (serviceCapabilityMap != null && !serviceCapabilityMap.isEmpty()) {
        final Map<Capability, String> lbServiceCapabilityMap = serviceCapabilityMap.get(Service.Lb);
        if (lbServiceCapabilityMap != null && !lbServiceCapabilityMap.isEmpty()) {
            final String isolationCapability = lbServiceCapabilityMap.get(Capability.SupportedLBIsolation);
            if (isolationCapability != null) {
                _networkModel.checkCapabilityForProvider(serviceProviderMap.get(Service.Lb), Service.Lb, Capability.SupportedLBIsolation, isolationCapability);
                dedicatedLb = isolationCapability.contains("dedicated");
            } else {
                dedicatedLb = true;
            }
            final String param = lbServiceCapabilityMap.get(Capability.ElasticLb);
            if (param != null) {
                elasticLb = param.contains("true");
            }
            final String inlineMode = lbServiceCapabilityMap.get(Capability.InlineMode);
            if (inlineMode != null) {
                _networkModel.checkCapabilityForProvider(serviceProviderMap.get(Service.Lb), Service.Lb, Capability.InlineMode, inlineMode);
                inline = inlineMode.contains("true");
            } else {
                inline = false;
            }
            final String publicLbStr = lbServiceCapabilityMap.get(Capability.LbSchemes);
            if (serviceProviderMap.containsKey(Service.Lb)) {
                if (publicLbStr != null) {
                    _networkModel.checkCapabilityForProvider(serviceProviderMap.get(Service.Lb), Service.Lb, Capability.LbSchemes, publicLbStr);
                    internalLb = publicLbStr.contains("internal");
                    publicLb = publicLbStr.contains("public");
                }
            }
        }
        // both be set to true for the same network offering
        if (publicLb && internalLb) {
            throw new InvalidParameterValueException("Public lb and internal lb can't be enabled at the same time on the offering");
        }
        final Map<Capability, String> sourceNatServiceCapabilityMap = serviceCapabilityMap.get(Service.SourceNat);
        if (sourceNatServiceCapabilityMap != null && !sourceNatServiceCapabilityMap.isEmpty()) {
            final String sourceNatType = sourceNatServiceCapabilityMap.get(Capability.SupportedSourceNatTypes);
            if (sourceNatType != null) {
                _networkModel.checkCapabilityForProvider(serviceProviderMap.get(Service.SourceNat), Service.SourceNat, Capability.SupportedSourceNatTypes, sourceNatType);
                sharedSourceNat = sourceNatType.contains("perzone");
            }
            final String param = sourceNatServiceCapabilityMap.get(Capability.RedundantRouter);
            if (param != null) {
                _networkModel.checkCapabilityForProvider(serviceProviderMap.get(Service.SourceNat), Service.SourceNat, Capability.RedundantRouter, param);
                redundantRouter = param.contains("true");
            }
        }
        final Map<Capability, String> staticNatServiceCapabilityMap = serviceCapabilityMap.get(Service.StaticNat);
        if (staticNatServiceCapabilityMap != null && !staticNatServiceCapabilityMap.isEmpty()) {
            final String param = staticNatServiceCapabilityMap.get(Capability.ElasticIp);
            if (param != null) {
                elasticIp = param.contains("true");
                final String associatePublicIP = staticNatServiceCapabilityMap.get(Capability.AssociatePublicIP);
                if (associatePublicIP != null) {
                    associatePublicIp = associatePublicIP.contains("true");
                }
            }
        }
        final Map<Capability, String> connectivityServiceCapabilityMap = serviceCapabilityMap.get(Service.Connectivity);
        if (connectivityServiceCapabilityMap != null && !connectivityServiceCapabilityMap.isEmpty()) {
            if (connectivityServiceCapabilityMap.containsKey(Capability.StretchedL2Subnet)) {
                final String value = connectivityServiceCapabilityMap.get(Capability.StretchedL2Subnet);
                if ("true".equalsIgnoreCase(value)) {
                    strechedL2Subnet = true;
                }
            }
            if (connectivityServiceCapabilityMap.containsKey(Capability.PublicAccess)) {
                final String value = connectivityServiceCapabilityMap.get(Capability.PublicAccess);
                if ("true".equalsIgnoreCase(value)) {
                    publicAccess = true;
                }
            }
        }
    }
    if (serviceProviderMap != null && serviceProviderMap.containsKey(Service.Lb) && !internalLb && !publicLb) {
        //if not specified, default public lb to true
        publicLb = true;
    }
    final NetworkOfferingVO offeringFinal = new NetworkOfferingVO(name, displayText, trafficType, systemOnly, specifyVlan, networkRate, multicastRate, isDefault, availability, tags, type, conserveMode, dedicatedLb, sharedSourceNat, redundantRouter, elasticIp, elasticLb, specifyIpRanges, inline, isPersistent, associatePublicIp, publicLb, internalLb, egressDefaultPolicy, strechedL2Subnet, publicAccess);
    if (serviceOfferingId != null) {
        offeringFinal.setServiceOfferingId(serviceOfferingId);
    }
    // validate the details
    if (details != null) {
        validateNtwkOffDetails(details, serviceProviderMap);
    }
    return Transaction.execute(new TransactionCallback<NetworkOfferingVO>() {

        @Override
        public NetworkOfferingVO doInTransaction(final TransactionStatus status) {
            NetworkOfferingVO offering = offeringFinal;
            // 1) create network offering object
            s_logger.debug("Adding network offering " + offering);
            offering.setConcurrentConnections(maxconn);
            offering.setKeepAliveEnabled(enableKeepAlive);
            offering = _networkOfferingDao.persist(offering, details);
            // 2) populate services and providers
            if (serviceProviderMap != null) {
                for (final Network.Service service : serviceProviderMap.keySet()) {
                    final Set<Provider> providers = serviceProviderMap.get(service);
                    if (providers != null && !providers.isEmpty()) {
                        boolean vpcOff = false;
                        for (final Network.Provider provider : providers) {
                            if (provider == Provider.VPCVirtualRouter) {
                                vpcOff = true;
                            }
                            final NetworkOfferingServiceMapVO offService = new NetworkOfferingServiceMapVO(offering.getId(), service, provider);
                            _ntwkOffServiceMapDao.persist(offService);
                            s_logger.trace("Added service for the network offering: " + offService + " with provider " + provider.getName());
                        }
                        if (vpcOff) {
                            final List<Service> supportedSvcs = new ArrayList<Service>();
                            supportedSvcs.addAll(serviceProviderMap.keySet());
                            _vpcMgr.validateNtwkOffForVpc(offering, supportedSvcs);
                        }
                    } else {
                        final NetworkOfferingServiceMapVO offService = new NetworkOfferingServiceMapVO(offering.getId(), service, null);
                        _ntwkOffServiceMapDao.persist(offService);
                        s_logger.trace("Added service for the network offering: " + offService + " with null provider");
                    }
                }
            }
            return offering;
        }
    });
}

Example 38 with Provider

use of com.cloud.network.Network.Provider in project cloudstack by apache.

the class VpcVirtualNetworkApplianceManagerImpl method sendNetworkRulesToRouter.

protected boolean sendNetworkRulesToRouter(final long routerId, final long networkId) throws ResourceUnavailableException {
    final DomainRouterVO router = _routerDao.findById(routerId);
    final Commands cmds = new Commands(OnError.Continue);
    final VirtualRouterProvider vrProvider = _vrProviderDao.findById(router.getElementId());
    if (vrProvider == null) {
        throw new CloudRuntimeException("Cannot find related virtual router provider of router: " + router.getHostName());
    }
    final Provider provider = Network.Provider.getProvider(vrProvider.getType().toString());
    if (provider == null) {
        throw new CloudRuntimeException("Cannot find related provider of virtual router provider: " + vrProvider.getType().toString());
    }
    finalizeNetworkRulesForNetwork(cmds, router, provider, networkId);
    return _nwHelper.sendCommandsToRouter(router, cmds);
}

Example 39 with Provider

use of com.cloud.network.Network.Provider in project cloudstack by apache.

the class ApiResponseHelper method createNetworkServiceProviderResponse.

@Override
public ProviderResponse createNetworkServiceProviderResponse(PhysicalNetworkServiceProvider result) {
    ProviderResponse response = new ProviderResponse();
    response.setId(result.getUuid());
    response.setName(result.getProviderName());
    PhysicalNetwork pnw = ApiDBUtils.findPhysicalNetworkById(result.getPhysicalNetworkId());
    if (pnw != null) {
        response.setPhysicalNetworkId(pnw.getUuid());
    }
    PhysicalNetwork dnw = ApiDBUtils.findPhysicalNetworkById(result.getDestinationPhysicalNetworkId());
    if (dnw != null) {
        response.setDestinationPhysicalNetworkId(dnw.getUuid());
    }
    response.setState(result.getState().toString());
    // set enabled services
    List<String> services = new ArrayList<String>();
    for (Service service : result.getEnabledServices()) {
        services.add(service.getName());
    }
    response.setServices(services);
    Provider serviceProvider = Provider.getProvider(result.getProviderName());
    boolean canEnableIndividualServices = ApiDBUtils.canElementEnableIndividualServices(serviceProvider);
    response.setCanEnableIndividualServices(canEnableIndividualServices);
    response.setObjectName("networkserviceprovider");
    return response;
}

Example 40 with Provider

use of com.cloud.network.Network.Provider in project cloudstack by apache.

the class LoadBalancingRulesManagerImpl method applyLoadBalancerConfig.

@Override
public boolean applyLoadBalancerConfig(long lbRuleId) throws ResourceUnavailableException {
    LoadBalancerVO lb = _lbDao.findById(lbRuleId);
    List<LoadBalancerVO> lbs;
    if (isRollBackAllowedForProvider(lb)) {
        // this is for Netscalar type of devices. if their is failure the db
        // entries will be rollbacked.
        lbs = Arrays.asList(lb);
    } else {
        boolean onlyRulesInTransitionState = true;
        for (LoadBalancingServiceProvider lbElement : _lbProviders) {
            Provider provider = lbElement.getProvider();
            boolean isLbProvider = _networkModel.isProviderSupportServiceInNetwork(lb.getNetworkId(), Service.Lb, provider);
            if (!isLbProvider) {
                continue;
            }
            onlyRulesInTransitionState = lbElement.handlesOnlyRulesInTransitionState();
            break;
        }
        // get all rules in transition state
        if (onlyRulesInTransitionState) {
            lbs = _lbDao.listInTransitionStateByNetworkIdAndScheme(lb.getNetworkId(), lb.getScheme());
        } else {
            lbs = _lbDao.listByNetworkIdAndScheme(lb.getNetworkId(), lb.getScheme());
        }
    }
    return applyLoadBalancerRules(lbs, true);
}