private boolean applyAutoScaleConfig(LoadBalancerVO lb, AutoScaleVmGroupVO vmGroup, String currentState) throws ResourceUnavailableException { LbAutoScaleVmGroup lbAutoScaleVmGroup = getLbAutoScaleVmGroup(vmGroup, currentState, lb); /* * Regular config like destinations need not be packed for applying * autoscale config as of today. */ List<LbStickinessPolicy> policyList = getStickinessPolicies(lb.getId()); Ip sourceIp = getSourceIp(lb); LoadBalancingRule rule = new LoadBalancingRule(lb, null, policyList, null, sourceIp, null, lb.getLbProtocol()); rule.setAutoScaleVmGroup(lbAutoScaleVmGroup); if (!isRollBackAllowedForProvider(lb)) { // this is for Netscaler type of devices. if their is failure the db // entries will be rollbacked. return false; } List<LoadBalancingRule> rules = Arrays.asList(rule); if (!applyLbRules(rules, false)) { s_logger.debug("LB rules' autoscale config are not completely applied"); return false; } return true; }
@Override public boolean applyLoadBalancersForNetwork(long networkId, Scheme scheme) throws ResourceUnavailableException { List<LoadBalancerVO> lbs = _lbDao.listByNetworkIdAndScheme(networkId, scheme); if (lbs != null) { s_logger.debug("Applying load balancer rules of scheme " + scheme + " in network id=" + networkId); return applyLoadBalancerRules(lbs, true); } else { s_logger.info("Network id=" + networkId + " doesn't have load balancer rules of scheme " + scheme + ", nothing to apply"); return true; } }
@Override public boolean removeAllLoadBalanacersForNetwork(long networkId, Account caller, long callerUserId) { List<FirewallRuleVO> rules = _firewallDao.listByNetworkAndPurposeAndNotRevoked(networkId, Purpose.LoadBalancing); if (rules != null) { s_logger.debug("Found " + rules.size() + " lb rules to cleanup"); for (FirewallRule rule : rules) { boolean result = deleteLoadBalancerRule(rule.getId(), true, caller, callerUserId, false); if (result == false) { s_logger.warn("Unable to remove load balancer rule " + rule.getId()); return false; } } } return true; }
LoadBalancingRule rule = getLoadBalancerRuleToApply(lb); if (!validateLbRule(rule)) { throw new InvalidParameterValueException("Modifications in lb rule " + lbRuleId + " are not supported."); lb.setState(FirewallRule.State.Add); _lbDao.persist(lb); applyLoadBalancerConfig(lbRuleId); } catch (ResourceUnavailableException e) { if (isRollBackAllowedForProvider(lb)) {
if (!applyLoadBalancerConfig(loadBalancerId)) { s_logger.warn("Failed to remove load balancer rule id " + loadBalancerId + " for vms " + instanceIds); CloudRuntimeException ex = new CloudRuntimeException("Failed to remove specified load balancer rule id for vms " + instanceIds); if (rollBack && isRollBackAllowedForProvider(loadBalancer)) {
@Override @DB @ActionEvent(eventType = EventTypes.EVENT_LB_HEALTHCHECKPOLICY_CREATE, eventDescription = "Apply HealthCheckPolicy to load balancer ", async = true) public boolean applyLBHealthCheckPolicy(CreateLBHealthCheckPolicyCmd cmd) { boolean success = true; LoadBalancerVO loadBalancer = _lbDao.findById(cmd.getLbRuleId()); if (loadBalancer == null) { throw new InvalidParameterException("Invalid Load balancer Id:" + cmd.getLbRuleId()); } FirewallRule.State backupState = loadBalancer.getState(); loadBalancer.setState(FirewallRule.State.Add); _lbDao.persist(loadBalancer); try { applyLoadBalancerConfig(cmd.getLbRuleId()); } catch (ResourceUnavailableException e) { s_logger.warn("Unable to apply healthcheck policy to the lb rule: " + cmd.getLbRuleId() + " because resource is unavaliable:", e); if (isRollBackAllowedForProvider(loadBalancer)) { loadBalancer.setState(backupState); _lbDao.persist(loadBalancer); s_logger.debug("LB Rollback rule id: " + loadBalancer.getId() + " lb state rolback while creating healthcheck policy"); } deleteLBHealthCheckPolicy(cmd.getEntityId(), false); success = false; } return success; }
List<LoadBalancingRule> rules = new ArrayList<LoadBalancingRule>(); for (LoadBalancerVO lb : lbs) { rules.add(getLoadBalancerRuleToApply(lb)); if (!applyLbRules(rules, false)) { s_logger.debug("LB rules are not completely applied"); return false; if (count == 0) { try { success = handleSystemLBIpRelease(lb); } catch (Exception ex) { s_logger.warn("Failed to release system ip as a part of lb rule " + lb + " deletion due to exception ", ex);
applyLoadBalancerConfig(cmd.getLbRuleId()); } catch (ResourceUnavailableException e) { s_logger.warn("Unable to apply Stickiness policy to the lb rule: " + cmd.getLbRuleId() + " because resource is unavaliable:", e); if (isRollBackAllowedForProvider(loadBalancer)) { loadBalancer.setState(backupState); _lbDao.persist(loadBalancer); deleteLBStickinessPolicy(cmd.getEntityId(), false); s_logger.debug("LB Rollback rule id: " + loadBalancer.getId() + " lb state rolback while creating sticky policy"); } else { deleteLBStickinessPolicy(cmd.getEntityId(), false); if (oldStickinessPolicyId != 0) { LBStickinessPolicyVO stickinessPolicy = _lb2stickinesspoliciesDao.findById(oldStickinessPolicyId); try { if (backupState.equals(FirewallRule.State.Active)) applyLoadBalancerConfig(cmd.getLbRuleId()); } catch (ResourceUnavailableException e1) { s_logger.info("[ignored] applying load balancer config.", e1);
boolean removeResult = removeCertFromLoadBalancer(loadBalancerId); if (!removeResult) { throw new CloudRuntimeException("Unable to remove certificate from load balancer rule " + loadBalancerId); if (!applyLoadBalancerConfig(loadBalancerId)) { s_logger.warn("Unable to apply the load balancer config"); return false; if (rollBack && isRollBackAllowedForProvider(lb)) { if (backupMaps != null) { for (LoadBalancerVMMapVO map : backupMaps) {
String capability = getLBCapability(loadBalancer.getNetworkId(), Capability.SslTermination.getName()); if (capability == null) { throw new InvalidParameterValueException("Ssl termination not supported by the loadbalancer"); LoadBalancerCertMapVO certMap = new LoadBalancerCertMapVO(lbRuleId, certId, false); _lbCertMapDao.persist(certMap); applyLoadBalancerConfig(loadBalancer.getId()); success = true; } catch (ResourceUnavailableException e) { if (isRollBackAllowedForProvider(loadBalancer)) {
@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); }
success = applyAutoScaleConfig(loadBalancer, vmGroup, currentState); } catch (ResourceUnavailableException e) { s_logger.warn("Unable to configure AutoScaleVmGroup to the lb rule: " + loadBalancer.getId() + " because resource is unavaliable:", e); if (isRollBackAllowedForProvider(loadBalancer)) { loadBalancer.setState(backupState); _lbDao.persist(loadBalancer);
applyLbRules(network, rules); } catch (ResourceUnavailableException e) { if (!continueOnError) {
loadBalancer.setState(FirewallRule.State.Add); _lbDao.persist(loadBalancer); applyLoadBalancerConfig(loadBalancerId); success = true; } catch (ResourceUnavailableException e) {
@Override public List<LBHealthCheckPolicyVO> searchForLBHealthCheckPolicies(ListLBHealthCheckPoliciesCmd cmd) throws PermissionDeniedException { Account caller = CallContext.current().getCallingAccount(); Long loadBalancerId = cmd.getLbRuleId(); Long policyId = cmd.getId(); boolean forDisplay = cmd.getDisplay(); if(loadBalancerId == null) { loadBalancerId = findLBIdByHealtCheckPolicyId(policyId); } LoadBalancerVO loadBalancer = _lbDao.findById(loadBalancerId); if (loadBalancer == null) { return null; } _accountMgr.checkAccess(caller, null, true, loadBalancer); List<LBHealthCheckPolicyVO> hcDbpolicies = _lb2healthcheckDao.listByLoadBalancerIdAndDisplayFlag(loadBalancerId, forDisplay); return hcDbpolicies; }
@Override public List<LBStickinessPolicyVO> searchForLBStickinessPolicies(ListLBStickinessPoliciesCmd cmd) throws PermissionDeniedException { Account caller = CallContext.current().getCallingAccount(); Long loadBalancerId = cmd.getLbRuleId(); Long stickinessId = cmd.getId(); boolean forDisplay = cmd.getDisplay(); LoadBalancerVO loadBalancer = null; if (loadBalancerId == null) { loadBalancer = findLbByStickinessId(stickinessId); } else { loadBalancer = _lbDao.findById(loadBalancerId); } if (loadBalancer == null) { return null; } _accountMgr.checkAccess(caller, null, true, loadBalancer); List<LBStickinessPolicyVO> sDbpolicies = _lb2stickinesspoliciesDao.listByLoadBalancerIdAndDisplayFlag(loadBalancer.getId(), forDisplay); return sDbpolicies; }
result = createPublicLoadBalancer(xId, name, description, srcPortStart, defPortStart, ipVO.getId(), protocol, algorithm, openFirewall, CallContext.current(), lbProtocol, forDisplay); } catch (Exception ex) {
if (!applyLoadBalancerConfig(loadBalancerId)) { s_logger.warn("Failed to remove load balancer rule id " + loadBalancerId + " for stickinesspolicyID " + stickinessPolicyId); throw new CloudRuntimeException("Failed to remove load balancer rule id " + loadBalancerId + " for stickinesspolicyID " + stickinessPolicyId); if (isRollBackAllowedForProvider(loadBalancer)) { stickinessPolicy.setRevoke(backupStickyState); _lb2stickinesspoliciesDao.persist(stickinessPolicy);
_lbCertMapDao.persist(lbCertMap); if (!applyLoadBalancerConfig(lbRuleId)) { s_logger.warn("Failed to remove cert from load balancer rule id " + lbRuleId); CloudRuntimeException ex = new CloudRuntimeException("Failed to remove certificate load balancer rule id " + lbRuleId); if (isRollBackAllowedForProvider(loadBalancer)) { lbCertMap.setRevoke(false); _lbCertMapDao.persist(lbCertMap);
@Override public boolean removeAllLoadBalanacersForIp(long ipId, Account caller, long callerUserId) { //Included revoked rules to remove the rules of ips which are in revoke state List<FirewallRuleVO> rules = _firewallDao.listByIpAndPurpose(ipId, Purpose.LoadBalancing); if (rules != null) { s_logger.debug("Found " + rules.size() + " lb rules to cleanup"); for (FirewallRule rule : rules) { boolean result = deleteLoadBalancerRule(rule.getId(), true, caller, callerUserId, false); if (result == false) { s_logger.warn("Unable to remove load balancer rule " + rule.getId()); return false; } } } return true; }