@Override public NetscalerLoadBalancerResponse createNetscalerLoadBalancerResponse(ExternalLoadBalancerDeviceVO lbDeviceVO) { NetscalerLoadBalancerResponse response = new NetscalerLoadBalancerResponse(); Host lbHost = _hostDao.findById(lbDeviceVO.getHostId()); Map<String, String> lbDetails = _detailsDao.findDetails(lbDeviceVO.getHostId()); response.setId(lbDeviceVO.getUuid()); response.setIpAddress(lbHost.getPrivateIpAddress()); PhysicalNetwork pnw = ApiDBUtils.findPhysicalNetworkById(lbDeviceVO.getPhysicalNetworkId()); if (pnw != null) { response.setPhysicalNetworkId(pnw.getUuid()); response.setDeviceName(lbDeviceVO.getDeviceName()); if (lbDeviceVO.getCapacity() == 0) { long defaultLbCapacity = NumbersUtil .parseLong(_configDao.getValue(Config.DefaultExternalLoadBalancerCapacity.key()), 50); response.setDeviceCapacity(defaultLbCapacity); } else { response.setDeviceCapacity(lbDeviceVO.getCapacity()); response.setDedicatedLoadBalancer(lbDeviceVO.getIsDedicatedDevice()); response.setProvider(lbDeviceVO.getProviderName()); response.setDeviceState(lbDeviceVO.getState().name()); response.setObjectName("netscalerloadbalancer"); response.setGslbProvider(lbDeviceVO.getGslbProvider()); response.setExclusiveGslbProvider(lbDeviceVO.getExclusiveGslbProvider()); response.setGslbSitePublicIp(lbDeviceVO.getGslbSitePublicIP()); response.setGslbSitePrivateIp(lbDeviceVO.getGslbSitePrivateIP()); List<NetScalerPodVO> currentPodVOs = _netscalerPodDao.listByNetScalerDeviceId(lbDeviceVO.getId());
public ExternalLoadBalancerDeviceDaoImpl() { super(); physicalNetworkIdSearch = createSearchBuilder(); physicalNetworkIdSearch.and("physicalNetworkId", physicalNetworkIdSearch.entity().getPhysicalNetworkId(), Op.EQ); physicalNetworkIdSearch.done(); physicalNetworkServiceProviderSearch = createSearchBuilder(); physicalNetworkServiceProviderSearch.and("physicalNetworkId", physicalNetworkServiceProviderSearch.entity().getPhysicalNetworkId(), Op.EQ); physicalNetworkServiceProviderSearch.and("providerName", physicalNetworkServiceProviderSearch.entity().getProviderName(), Op.EQ); physicalNetworkServiceProviderSearch.done(); allocationStateSearch = createSearchBuilder(); allocationStateSearch.and("physicalNetworkId", allocationStateSearch.entity().getPhysicalNetworkId(), Op.EQ); allocationStateSearch.and("providerName", allocationStateSearch.entity().getProviderName(), Op.EQ); allocationStateSearch.and("allocationState", allocationStateSearch.entity().getAllocationState(), Op.EQ); allocationStateSearch.and("exclusiveGslbProvider", allocationStateSearch.entity().getExclusiveGslbProvider(), Op.EQ); allocationStateSearch.done(); deviceStatusSearch = createSearchBuilder(); deviceStatusSearch.and("physicalNetworkId", deviceStatusSearch.entity().getPhysicalNetworkId(), Op.EQ); deviceStatusSearch.and("providerName", deviceStatusSearch.entity().getProviderName(), Op.EQ); deviceStatusSearch.and("deviceState", deviceStatusSearch.entity().getState(), Op.EQ); deviceStatusSearch.done(); deviceManagedTypeSearch = createSearchBuilder(); deviceManagedTypeSearch.and("physicalNetworkId", deviceManagedTypeSearch.entity().getPhysicalNetworkId(), Op.EQ); deviceManagedTypeSearch.and("providerName", deviceManagedTypeSearch.entity().getProviderName(), Op.EQ); deviceManagedTypeSearch.and("managedType", deviceManagedTypeSearch.entity().getIsManagedDevice(), Op.EQ); deviceManagedTypeSearch.done(); gslbProviderSearch = createSearchBuilder(); gslbProviderSearch.and("physicalNetworkId", gslbProviderSearch.entity().getPhysicalNetworkId(), Op.EQ); gslbProviderSearch.and("providerName", gslbProviderSearch.entity().getProviderName(), Op.EQ); gslbProviderSearch.and("gslbProvider", gslbProviderSearch.entity().getGslbProvider(), Op.EQ); }
@Override public ExternalLoadBalancerDeviceVO doInTransaction(TransactionStatus status) { ExternalLoadBalancerDeviceVO lbDeviceVO = new ExternalLoadBalancerDeviceVO(host.getId(), pNetworkFinal.getId(), ntwkDevice.getNetworkServiceProvder(), deviceName, capacityFinal, dedicatedUse, gslbProvider); if (gslbProvider) { lbDeviceVO.setGslbSitePublicIP(gslbSitePublicIp); lbDeviceVO.setGslbSitePrivateIP(gslbSitePrivateIp); lbDeviceVO.setExclusiveGslbProvider(exclusiveGslbProivider); } _externalLoadBalancerDeviceDao.persist(lbDeviceVO); DetailVO hostDetail = new DetailVO(host.getId(), ApiConstants.LOAD_BALANCER_DEVICE_ID, String.valueOf(lbDeviceVO.getId())); _hostDetailDao.persist(hostDetail); return lbDeviceVO; } });
@Override public boolean deleteNetscalerLoadBalancer(DeleteNetscalerLoadBalancerCmd cmd) { Long lbDeviceId = cmd.getLoadBalancerDeviceId(); ExternalLoadBalancerDeviceVO lbDeviceVo = _lbDeviceDao.findById(lbDeviceId); if ((lbDeviceVo == null) || !isNetscalerDevice(lbDeviceVo.getDeviceName())) { throw new InvalidParameterValueException("No netscaler device found with ID: " + lbDeviceId); } return deleteExternalLoadBalancer(lbDeviceVo.getHostId()); }
if ((providerLbDevices != null) && (!providerLbDevices.isEmpty())) { for (ExternalLoadBalancerDeviceVO lbProviderDevice : providerLbDevices) { if (lbProviderDevice.getState() == LBDeviceState.Enabled) { DataCenterIpAddressVO dcPrivateIp = _dcDao.allocatePrivateIpAddress(guestConfig.getDataCenterId(), lbProviderDevice.getUuid()); if (dcPrivateIp == null) { throw new InsufficientNetworkCapacityException("failed to acquire a priavate IP in the zone " + guestConfig.getDataCenterId() + CreateLoadBalancerApplianceAnswer createLbAnswer = null; try { createLbAnswer = (CreateLoadBalancerApplianceAnswer)_agentMgr.easySend(lbProviderDevice.getHostId(), lbProvisionCmd); if (createLbAnswer == null || !createLbAnswer.getResult()) { s_logger.error("Could not provision load balancer instance on the load balancer device " + lbProviderDevice.getId()); continue; s_logger.error("Could not provision load balancer instance on the load balancer device " + lbProviderDevice.getId() + " due to " + agentException.getMessage()); continue; String capacity = Long.toString(lbProviderDevice.getCapacity()); ExternalLoadBalancerDeviceVO managedLb = _externalLoadBalancerDeviceDao.findById(lbAppliance.getId()); managedLb.setIsManagedDevice(true); managedLb.setParentHostId(lbProviderDevice.getHostId()); _externalLoadBalancerDeviceDao.update(lbAppliance.getId(), managedLb); } else { DestroyLoadBalancerApplianceAnswer answer = null; try {
if (lbdevice.getState() == LBDeviceState.Enabled && lbdevice.getIsDedicatedDevice()) { return lbdevice; if (lbdevice.getState() != LBDeviceState.Enabled) { continue; List<NetworkExternalLoadBalancerVO> mappedNetworks = _networkExternalLBDao.listByLoadBalancerDeviceId(lbdevice.getId()); long usedCapacity = ((mappedNetworks == null) || (mappedNetworks.isEmpty())) ? 0 : mappedNetworks.size(); long fullCapacity = lbdevice.getCapacity(); if (fullCapacity == 0) { if (lbDevices != null && !lbDevices.isEmpty()) { for (ExternalLoadBalancerDeviceVO lbdevice : lbDevices) { if (lbdevice.getState() == LBDeviceState.Enabled && !lbdevice.getIsDedicatedDevice()) { return lbdevice;
Boolean dedicatedUse, List<Long> newPodsConfig) { final ExternalLoadBalancerDeviceVO lbDeviceVo = _lbDeviceDao.findById(lbDeviceId); final Map<String, String> lbDetails = _detailsDao.findDetails(lbDeviceVo.getHostId()); if ((lbDeviceVo == null) || !isNetscalerDevice(lbDeviceVo.getDeviceName())) { throw new InvalidParameterValueException("No netscaler device found with ID: " + lbDeviceId); List<NetScalerPodVO> currentPodVOs = _netscalerPodDao.listByNetScalerDeviceId(lbDeviceVo.getId()); if (currentPodVOs != null && currentPodVOs.size() > 0) { for (NetScalerPodVO nsPodVo : currentPodVOs) { String deviceName = lbDeviceVo.getDeviceName(); if (dedicatedUse != null || capacity != null) { if (NetworkDevice.NetscalerSDXLoadBalancer.getName().equalsIgnoreCase(deviceName) lbDeviceVo.setCapacity(capacity); lbDeviceVo.setIsDedicatedDevice(dedicatedUse); HostVO host = _hostDao.findById(lbDeviceVo.getHostId());
@Override public ExternalLoadBalancerDeviceVO doInTransaction(TransactionStatus status) { // since network is shutdown remove the network mapping to the load balancer device NetworkExternalLoadBalancerVO networkLBDevice = _networkExternalLBDao.findByNetworkId(guestConfig.getId()); long lbDeviceId = networkLBDevice.getExternalLBDeviceId(); _networkExternalLBDao.remove(networkLBDevice.getId()); List<NetworkExternalLoadBalancerVO> ntwksMapped = _networkExternalLBDao.listByLoadBalancerDeviceId(networkLBDevice.getExternalLBDeviceId()); ExternalLoadBalancerDeviceVO lbDevice = _externalLoadBalancerDeviceDao.findById(lbDeviceId); boolean lbInUse = !(ntwksMapped == null || ntwksMapped.isEmpty()); boolean lbCloudManaged = lbDevice.getIsManagedDevice(); if (!lbInUse && !lbCloudManaged) { // this is the last network mapped to the load balancer device so set device allocation state to be free lbDevice.setAllocationState(LBDeviceAllocationState.Free); _externalLoadBalancerDeviceDao.update(lbDevice.getId(), lbDevice); } // commit the changes before sending agent command to destroy cloudstack managed LB if (!lbInUse && lbCloudManaged) { return lbDevice; } else { return null; } } });
@Override public boolean applyGlobalLoadBalancerRule(long zoneId, long physicalNetworkId, GlobalLoadBalancerConfigCommand gslbConfigCmd) throws ResourceUnavailableException { long zoneGslbProviderHosId = 0; // find the NetScaler device configured as gslb service provider in the // zone ExternalLoadBalancerDeviceVO nsGslbProvider = findGslbProvider(zoneId, physicalNetworkId); if (nsGslbProvider == null) { String msg = "Unable to find a NetScaler configured as gslb service provider in zone " + zoneId; s_logger.debug(msg); throw new ResourceUnavailableException(msg, DataCenter.class, zoneId); } // get the host Id corresponding to NetScaler acting as GSLB service // provider in the zone zoneGslbProviderHosId = nsGslbProvider.getHostId(); // send gslb configuration to NetScaler device Answer answer = _agentMgr.easySend(zoneGslbProviderHosId, gslbConfigCmd); if (answer == null || !answer.getResult()) { String msg = "Unable to apply global load balancer rule to the gslb service provider in zone " + zoneId; s_logger.debug(msg); throw new ResourceUnavailableException(msg, DataCenter.class, zoneId); } return true; }
externalLoadBalancer = _hostDao.findById(lbDeviceVO.getHostId()); s_logger.debug("Allocated external load balancer device:" + lbDeviceVO.getId() + " for the network: " + guestConfig.getId()); } else { externalLoadBalancer = _hostDao.findById(lbDeviceVO.getHostId()); assert (externalLoadBalancer != null) : "There is no device assigned to this network how did shutdown network ended up here??";
@Override public boolean isReady(PhysicalNetworkServiceProvider provider) { List<ExternalLoadBalancerDeviceVO> lbDevices = _lbDeviceDao .listByPhysicalNetworkAndProvider(provider.getPhysicalNetworkId(), Provider.Netscaler.getName()); // true if at-least one Netscaler device is added in to physical network // and is in configured (in enabled state) // state if (lbDevices != null && !lbDevices.isEmpty()) { for (ExternalLoadBalancerDeviceVO lbDevice : lbDevices) { if (lbDevice.getState() == LBDeviceState.Enabled) { return true; } } } return true; }
@Override public ExternalLoadBalancerDeviceVO doInTransaction(TransactionStatus status) throws InsufficientCapacityException { // FIXME: should the device allocation be done during network implement phase or do a // lazy allocation when first rule for the network is configured?? // find a load balancer device for this network as per the network offering ExternalLoadBalancerDeviceVO lbDevice = findSuitableLoadBalancerForNetwork(guestConfig, dedicatedLB); long lbDeviceId = lbDevice.getId(); // persist the load balancer device id that will be used for this network. Once a network // is implemented on a LB device then later on all rules will be programmed on to same device NetworkExternalLoadBalancerVO networkLB = new NetworkExternalLoadBalancerVO(guestConfig.getId(), lbDeviceId); _networkExternalLBDao.persist(networkLB); // mark device to be either dedicated or shared use lbDevice.setAllocationState(dedicatedLB ? LBDeviceAllocationState.Dedicated : LBDeviceAllocationState.Shared); _externalLoadBalancerDeviceDao.update(lbDeviceId, lbDevice); return lbDevice; } });
if (lbDeviceVo.getAllocationState() == LBDeviceAllocationState.Provider) { if (lbDevice.getParentHostId() == hostId) { throw new CloudRuntimeException( "This load balancer device can not be deleted as there are one or more load balancers applainces provisioned by cloudstack on the device.");
Host lbHost = _hostDao.findById(lbDevice.getHostId()); String lbIP = lbHost.getPrivateIpAddress(); DestroyLoadBalancerApplianceCommand lbDeleteCmd = new DestroyLoadBalancerApplianceCommand(lbIP); DestroyLoadBalancerApplianceAnswer answer = null; try { answer = (DestroyLoadBalancerApplianceAnswer)_agentMgr.easySend(lbDevice.getParentHostId(), lbDeleteCmd); if (answer == null || !answer.getResult()) { s_logger.warn("Failed to destoy load balancer appliance used by the network"
if (!isNetscalerDevice(lbDeviceVO.getDeviceName())) { errMsg = "There are no NetScaler load balancer assigned for this network. So NetScaler element can not be handle elastic load balancer rules."; s_logger.error(errMsg); .toArray(new LoadBalancerTO[numLoadBalancersForCommand]); HealthCheckLBConfigCommand cmd = new HealthCheckLBConfigCommand(loadBalancersForCommand, network.getId()); HostVO externalLoadBalancer = _hostDao.findById(lbDeviceVO.getHostId()); answer = (HealthCheckLBConfigAnswer)_agentMgr.easySend(externalLoadBalancer.getId(), cmd); return answer.getLoadBalancers();
@Override public List<Host> listExternalLoadBalancers(long physicalNetworkId, String deviceName) { List<Host> lbHosts = new ArrayList<Host>(); NetworkDevice lbNetworkDevice = NetworkDevice.getNetworkDevice(deviceName); PhysicalNetworkVO pNetwork = null; pNetwork = _physicalNetworkDao.findById(physicalNetworkId); if ((pNetwork == null) || (lbNetworkDevice == null)) { throw new InvalidParameterValueException("Atleast one of the required parameter physical networkId, device name is invalid."); } PhysicalNetworkServiceProviderVO ntwkSvcProvider = _physicalNetworkServiceProviderDao.findByServiceProvider(pNetwork.getId(), lbNetworkDevice.getNetworkServiceProvder()); // if provider not configured in to physical network, then there can be no instances if (ntwkSvcProvider == null) { return null; } List<ExternalLoadBalancerDeviceVO> lbDevices = _externalLoadBalancerDeviceDao.listByPhysicalNetworkAndProvider(physicalNetworkId, ntwkSvcProvider.getProviderName()); for (ExternalLoadBalancerDeviceVO provderInstance : lbDevices) { lbHosts.add(_hostDao.findById(provderInstance.getHostId())); } return lbHosts; }
if (!isNetscalerDevice(lbDevice.getDeviceName())) { errMsg = "There are no NetScaler load balancer assigned for this network. So NetScaler element will not be handling the static nat rules."; s_logger.error(errMsg); answer = (SetStaticNatRulesAnswer)_agentMgr.send(lbDevice.getHostId(), cmd); if (answer == null) { return false; SetStaticNatRulesAnswer answer = (SetStaticNatRulesAnswer)_agentMgr.send(lbDevice.getHostId(), cmd); if (answer == null) { String errMsg = "Failed to configure INAT rule on NetScaler device " + lbDevice.getHostId(); s_logger.error(errMsg); throw new ResourceUnavailableException(errMsg, this.getClass(), 0);
@Override public void doInTransactionWithoutResult(TransactionStatus status) { _lbDeviceDao.update(lbDeviceId, lbDeviceVo); for (Long podId : podsToAssociate) { NetScalerPodVO nsPodVo = new NetScalerPodVO(lbDeviceId, podId); _netscalerPodDao.persist(nsPodVo); } for (Long podId : podsToDeassociate) { NetScalerPodVO nsPodVo = _netscalerPodDao.findByPodId(podId); _netscalerPodDao.remove(nsPodVo.getId()); } // FIXME get the row lock to avoid race condition _detailsDao.persist(lbDeviceVo.getHostId(), lbDetails); } });
if (!isNetscalerDevice(lbDeviceVO.getDeviceName())) { errMsg = "There are no NetScaler load balancer assigned for this network. So NetScaler element can not be handle elastic load balancer rules."; s_logger.error(errMsg); LoadBalancerConfigCommand cmd = new LoadBalancerConfigCommand(loadBalancersForCommand, null); HostVO externalLoadBalancer = _hostDao.findById(lbDeviceVO.getHostId()); Answer answer = _agentMgr.easySend(externalLoadBalancer.getId(), cmd); if (answer == null || !answer.getResult()) {
externalLoadBalancer = externalNcc; } else { externalLoadBalancer = _hostDao.findById(lbDeviceVO.getHostId());