Examples with ExternalLoadBalancerDeviceVO com.cloud.network.dao.ExternalLoadBalancerDeviceVO used on opensource projects

Example 26 with ExternalLoadBalancerDeviceVO

use of com.cloud.network.dao.ExternalLoadBalancerDeviceVO in project cloudstack by apache.

the class NetscalerElement method getNetScalerForEIP.

// returns configured NetScaler device that is associated with the pod that
// owns guest IP
private ExternalLoadBalancerDeviceVO getNetScalerForEIP(StaticNat rule) {
    String guestIP = rule.getDestIpAddress();
    List<DataCenterIpAddressVO> dcGuestIps = _privateIpAddressDao.listAll();
    if (dcGuestIps != null) {
        for (DataCenterIpAddressVO dcGuestIp : dcGuestIps) {
            if (dcGuestIp.getIpAddress().equalsIgnoreCase(guestIP)) {
                long podId = dcGuestIp.getPodId();
                NetScalerPodVO nsPodVO = _netscalerPodDao.findByPodId(podId);
                if (nsPodVO != null) {
                    ExternalLoadBalancerDeviceVO lbDeviceVO = _lbDeviceDao.findById(nsPodVO.getNetscalerDeviceId());
                    return lbDeviceVO;
                }
            }
        }
    }
    return null;
}

Example 27 with ExternalLoadBalancerDeviceVO

use of com.cloud.network.dao.ExternalLoadBalancerDeviceVO in project cloudstack by apache.

the class ExternalDeviceUsageManagerImpl method updateExternalLoadBalancerNetworkUsageStats.

@Override
public void updateExternalLoadBalancerNetworkUsageStats(long loadBalancerRuleId) {
    LoadBalancerVO lb = _loadBalancerDao.findById(loadBalancerRuleId);
    if (lb == null) {
        if (s_logger.isDebugEnabled()) {
            s_logger.debug("Cannot update usage stats, LB rule is not found");
        }
        return;
    }
    long networkId = lb.getNetworkId();
    Network network = _networkDao.findById(networkId);
    if (network == null) {
        if (s_logger.isDebugEnabled()) {
            s_logger.debug("Cannot update usage stats, Network is not found");
        }
        return;
    }
    ExternalLoadBalancerDeviceVO lbDeviceVO = getExternalLoadBalancerForNetwork(network);
    if (lbDeviceVO == null) {
        if (s_logger.isDebugEnabled()) {
            s_logger.debug("Cannot update usage stats,  No external LB device found");
        }
        return;
    }
    // Get network stats from the external load balancer
    ExternalNetworkResourceUsageAnswer lbAnswer = null;
    HostVO externalLoadBalancer = _hostDao.findById(lbDeviceVO.getHostId());
    if (externalLoadBalancer != null) {
        ExternalNetworkResourceUsageCommand cmd = new ExternalNetworkResourceUsageCommand();
        lbAnswer = (ExternalNetworkResourceUsageAnswer) _agentMgr.easySend(externalLoadBalancer.getId(), cmd);
        if (lbAnswer == null || !lbAnswer.getResult()) {
            String details = (lbAnswer != null) ? lbAnswer.getDetails() : "details unavailable";
            String msg = "Unable to get external load balancer stats for network" + networkId + " due to: " + details + ".";
            s_logger.error(msg);
            return;
        }
    }
    long accountId = lb.getAccountId();
    AccountVO account = _accountDao.findById(accountId);
    if (account == null) {
        s_logger.debug("Skipping stats update for external LB for account with ID " + accountId);
        return;
    }
    String publicIp = _networkModel.getIp(lb.getSourceIpAddressId()).getAddress().addr();
    DataCenterVO zone = _dcDao.findById(network.getDataCenterId());
    String statsEntryIdentifier = "account " + account.getAccountName() + ", zone " + zone.getName() + ", network ID " + networkId + ", host ID " + externalLoadBalancer.getName();
    long newCurrentBytesSent = 0;
    long newCurrentBytesReceived = 0;
    if (publicIp != null) {
        long[] bytesSentAndReceived = null;
        statsEntryIdentifier += ", public IP: " + publicIp;
        boolean inline = _networkModel.isNetworkInlineMode(network);
        if (externalLoadBalancer.getType().equals(Host.Type.ExternalLoadBalancer) && inline) {
            // Look up stats for the guest IP address that's mapped to the public IP address
            InlineLoadBalancerNicMapVO mapping = _inlineLoadBalancerNicMapDao.findByPublicIpAddress(publicIp);
            if (mapping != null) {
                NicVO nic = _nicDao.findById(mapping.getNicId());
                String loadBalancingIpAddress = nic.getIPv4Address();
                bytesSentAndReceived = lbAnswer.ipBytes.get(loadBalancingIpAddress);
                if (bytesSentAndReceived != null) {
                    bytesSentAndReceived[0] = 0;
                }
            }
        } else {
            bytesSentAndReceived = lbAnswer.ipBytes.get(publicIp);
        }
        if (bytesSentAndReceived == null) {
            s_logger.debug("Didn't get an external network usage answer for public IP " + publicIp);
        } else {
            newCurrentBytesSent += bytesSentAndReceived[0];
            newCurrentBytesReceived += bytesSentAndReceived[1];
        }
        commitStats(networkId, externalLoadBalancer, accountId, publicIp, zone, statsEntryIdentifier, newCurrentBytesSent, newCurrentBytesReceived);
    }
}

Example 28 with ExternalLoadBalancerDeviceVO

use of com.cloud.network.dao.ExternalLoadBalancerDeviceVO in project cloudstack by apache.

the class ExternalLoadBalancerDeviceManagerImpl method allocateLoadBalancerForNetwork.

@DB
protected ExternalLoadBalancerDeviceVO allocateLoadBalancerForNetwork(final Network guestConfig) throws InsufficientCapacityException {
    boolean retry = true;
    boolean tryLbProvisioning = false;
    ExternalLoadBalancerDeviceVO lbDevice = null;
    long physicalNetworkId = guestConfig.getPhysicalNetworkId();
    NetworkOfferingVO offering = _networkOfferingDao.findById(guestConfig.getNetworkOfferingId());
    String provider = _ntwkSrvcProviderDao.getProviderForServiceInNetwork(guestConfig.getId(), Service.Lb);
    while (retry) {
        GlobalLock deviceMapLock = GlobalLock.getInternLock("LoadBalancerAllocLock");
        try {
            if (deviceMapLock.lock(120)) {
                try {
                    // does network offering supports a dedicated load balancer?
                    final boolean dedicatedLB = offering.isDedicatedLB();
                    try {
                        lbDevice = Transaction.execute(new TransactionCallbackWithException<ExternalLoadBalancerDeviceVO, InsufficientCapacityException>() {

                            @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;
                            }
                        });
                        // allocated load balancer for the network, so skip retry
                        tryLbProvisioning = false;
                        retry = false;
                    } catch (InsufficientCapacityException exception) {
                        // if already attempted to provision load balancer then throw out of capacity exception,
                        if (tryLbProvisioning) {
                            retry = false;
                            // TODO: throwing warning instead of error for now as its possible another provider can service this network
                            s_logger.warn("There are no load balancer device with the capacity for implementing this network");
                            throw exception;
                        } else {
                            // if possible provision a LB appliance in to the physical network
                            tryLbProvisioning = true;
                        }
                    }
                } finally {
                    deviceMapLock.unlock();
                }
            }
        } finally {
            deviceMapLock.releaseRef();
        }
        // there are no LB devices or there is no free capacity on the devices in the physical network so provision a new LB appliance
        if (tryLbProvisioning) {
            // check if LB appliance can be dynamically provisioned
            List<ExternalLoadBalancerDeviceVO> providerLbDevices = _externalLoadBalancerDeviceDao.listByProviderAndDeviceAllocationState(physicalNetworkId, provider, LBDeviceAllocationState.Provider);
            if ((providerLbDevices != null) && (!providerLbDevices.isEmpty())) {
                for (ExternalLoadBalancerDeviceVO lbProviderDevice : providerLbDevices) {
                    if (lbProviderDevice.getState() == LBDeviceState.Enabled) {
                        // acquire a private IP from the data center which will be used as management IP of provisioned LB appliance,
                        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() + " needed for management IP of the load balancer appliance", DataCenter.class, guestConfig.getDataCenterId());
                        }
                        Pod pod = _podDao.findById(dcPrivateIp.getPodId());
                        String lbIP = dcPrivateIp.getIpAddress();
                        String netmask = NetUtils.getCidrNetmask(pod.getCidrSize());
                        String gateway = pod.getGateway();
                        // send CreateLoadBalancerApplianceCommand to the host capable of provisioning
                        CreateLoadBalancerApplianceCommand lbProvisionCmd = new CreateLoadBalancerApplianceCommand(lbIP, netmask, gateway);
                        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;
                            }
                        } catch (Exception agentException) {
                            s_logger.error("Could not provision load balancer instance on the load balancer device " + lbProviderDevice.getId() + " due to " + agentException.getMessage());
                            continue;
                        }
                        String username = createLbAnswer.getUsername();
                        String password = createLbAnswer.getPassword();
                        String publicIf = createLbAnswer.getPublicInterface();
                        String privateIf = createLbAnswer.getPrivateInterface();
                        // we have provisioned load balancer so add the appliance as cloudstack provisioned external load balancer
                        String dedicatedLb = offering.isDedicatedLB() ? "true" : "false";
                        String capacity = Long.toString(lbProviderDevice.getCapacity());
                        // acquire a public IP to associate with lb appliance (used as subnet IP to make the appliance part of private network)
                        PublicIp publicIp = _ipAddrMgr.assignPublicIpAddress(guestConfig.getDataCenterId(), null, _accountMgr.getSystemAccount(), VlanType.VirtualNetwork, null, null, false, false);
                        String publicIPNetmask = publicIp.getVlanNetmask();
                        String publicIPgateway = publicIp.getVlanGateway();
                        String publicIP = publicIp.getAddress().toString();
                        String publicIPVlanTag = "";
                        try {
                            publicIPVlanTag = BroadcastDomainType.getValue(publicIp.getVlanTag());
                        } catch (URISyntaxException e) {
                            s_logger.error("Failed to parse public ip vlan tag" + e.getMessage());
                        }
                        String url = "https://" + lbIP + "?publicinterface=" + publicIf + "&privateinterface=" + privateIf + "&lbdevicededicated=" + dedicatedLb + "&cloudmanaged=true" + "&publicip=" + publicIP + "&publicipnetmask=" + publicIPNetmask + "&lbdevicecapacity=" + capacity + "&publicipvlan=" + publicIPVlanTag + "&publicipgateway=" + publicIPgateway;
                        ExternalLoadBalancerDeviceVO lbAppliance = null;
                        try {
                            lbAppliance = addExternalLoadBalancer(physicalNetworkId, url, username, password, createLbAnswer.getDeviceName(), createLbAnswer.getServerResource(), false, false, null, null);
                        } catch (Exception e) {
                            s_logger.error("Failed to add load balancer appliance in to cloudstack due to " + e.getMessage() + ". So provisioned load balancer appliance will be destroyed.");
                        }
                        if (lbAppliance != null) {
                            // mark the load balancer as cloudstack managed and set parent host id on which lb appliance is provisioned
                            ExternalLoadBalancerDeviceVO managedLb = _externalLoadBalancerDeviceDao.findById(lbAppliance.getId());
                            managedLb.setIsManagedDevice(true);
                            managedLb.setParentHostId(lbProviderDevice.getHostId());
                            _externalLoadBalancerDeviceDao.update(lbAppliance.getId(), managedLb);
                        } else {
                            // failed to add the provisioned load balancer into cloudstack so destroy the appliance
                            DestroyLoadBalancerApplianceCommand lbDeleteCmd = new DestroyLoadBalancerApplianceCommand(lbIP);
                            DestroyLoadBalancerApplianceAnswer answer = null;
                            try {
                                answer = (DestroyLoadBalancerApplianceAnswer) _agentMgr.easySend(lbProviderDevice.getHostId(), lbDeleteCmd);
                                if (answer == null || !answer.getResult()) {
                                    s_logger.warn("Failed to destroy load balancer appliance created");
                                } else {
                                    // release the public & private IP back to dc pool, as the load balancer appliance is now destroyed
                                    _dcDao.releasePrivateIpAddress(lbIP, guestConfig.getDataCenterId(), null);
                                    _ipAddrMgr.disassociatePublicIpAddress(publicIp.getId(), _accountMgr.getSystemUser().getId(), _accountMgr.getSystemAccount());
                                }
                            } catch (Exception e) {
                                s_logger.warn("Failed to destroy load balancer appliance created for the network" + guestConfig.getId() + " due to " + e.getMessage());
                            }
                        }
                    }
                }
            }
        }
    }
    return lbDevice;
}

Example 29 with ExternalLoadBalancerDeviceVO

use of com.cloud.network.dao.ExternalLoadBalancerDeviceVO in project cloudstack by apache.

the class ExternalLoadBalancerDeviceManagerImpl method findSuitableLoadBalancerForNetwork.

@Override
public ExternalLoadBalancerDeviceVO findSuitableLoadBalancerForNetwork(Network network, boolean dedicatedLb) throws InsufficientCapacityException {
    long physicalNetworkId = network.getPhysicalNetworkId();
    List<ExternalLoadBalancerDeviceVO> lbDevices = null;
    String provider = _ntwkSrvcProviderDao.getProviderForServiceInNetwork(network.getId(), Service.Lb);
    assert (provider != null);
    if (dedicatedLb) {
        lbDevices = _externalLoadBalancerDeviceDao.listByProviderAndDeviceAllocationState(physicalNetworkId, provider, LBDeviceAllocationState.Free);
        if (lbDevices != null && !lbDevices.isEmpty()) {
            // return first device that is free, fully configured and meant for dedicated use
            for (ExternalLoadBalancerDeviceVO lbdevice : lbDevices) {
                if (lbdevice.getState() == LBDeviceState.Enabled && lbdevice.getIsDedicatedDevice()) {
                    return lbdevice;
                }
            }
        }
    } else {
        // get the LB devices that are already allocated for shared use
        lbDevices = _externalLoadBalancerDeviceDao.listByProviderAndDeviceAllocationState(physicalNetworkId, provider, LBDeviceAllocationState.Shared);
        if (lbDevices != null) {
            ExternalLoadBalancerDeviceVO maxFreeCapacityLbdevice = null;
            long maxFreeCapacity = 0;
            // loop through the LB device in the physical network and pick the one with maximum free capacity
            for (ExternalLoadBalancerDeviceVO lbdevice : lbDevices) {
                // skip if device is not enabled
                if (lbdevice.getState() != LBDeviceState.Enabled) {
                    continue;
                }
                // get the used capacity from the list of guest networks that are mapped to this load balancer
                List<NetworkExternalLoadBalancerVO> mappedNetworks = _networkExternalLBDao.listByLoadBalancerDeviceId(lbdevice.getId());
                long usedCapacity = ((mappedNetworks == null) || (mappedNetworks.isEmpty())) ? 0 : mappedNetworks.size();
                // get the configured capacity for this device
                long fullCapacity = lbdevice.getCapacity();
                if (fullCapacity == 0) {
                    // if capacity not configured then use the default
                    fullCapacity = _defaultLbCapacity;
                }
                long freeCapacity = fullCapacity - usedCapacity;
                if (freeCapacity > 0) {
                    if (maxFreeCapacityLbdevice == null) {
                        maxFreeCapacityLbdevice = lbdevice;
                        maxFreeCapacity = freeCapacity;
                    } else if (freeCapacity > maxFreeCapacity) {
                        maxFreeCapacityLbdevice = lbdevice;
                        maxFreeCapacity = freeCapacity;
                    }
                }
            }
            // return the device with maximum free capacity and is meant for shared use
            if (maxFreeCapacityLbdevice != null) {
                return maxFreeCapacityLbdevice;
            }
        }
        // if we are here then there are no existing LB devices in shared use or the devices in shared use has no
        // free capacity left
        // so allocate a new load balancer configured for shared use from the pool of free LB devices
        lbDevices = _externalLoadBalancerDeviceDao.listByProviderAndDeviceAllocationState(physicalNetworkId, provider, LBDeviceAllocationState.Free);
        if (lbDevices != null && !lbDevices.isEmpty()) {
            for (ExternalLoadBalancerDeviceVO lbdevice : lbDevices) {
                if (lbdevice.getState() == LBDeviceState.Enabled && !lbdevice.getIsDedicatedDevice()) {
                    return lbdevice;
                }
            }
        }
    }
    // there are no devices which capacity
    throw new InsufficientNetworkCapacityException("Unable to find a load balancing provider with sufficient capcity " + " to implement the network", Network.class, network.getId());
}

Example 30 with ExternalLoadBalancerDeviceVO

use of com.cloud.network.dao.ExternalLoadBalancerDeviceVO in project cloudstack by apache.

the class ExternalLoadBalancerDeviceManagerImpl method deleteExternalLoadBalancer.

@Override
public boolean deleteExternalLoadBalancer(long hostId) {
    HostVO externalLoadBalancer = _hostDao.findById(hostId);
    if (externalLoadBalancer == null) {
        throw new InvalidParameterValueException("Could not find an external load balancer with ID: " + hostId);
    }
    DetailVO lbHostDetails = _hostDetailDao.findDetail(hostId, ApiConstants.LOAD_BALANCER_DEVICE_ID);
    long lbDeviceId = Long.parseLong(lbHostDetails.getValue());
    ExternalLoadBalancerDeviceVO lbDeviceVo = _externalLoadBalancerDeviceDao.findById(lbDeviceId);
    if (lbDeviceVo.getAllocationState() == LBDeviceAllocationState.Provider) {
        // check if cloudstack has provisioned any load balancer appliance on the device before deleting
        List<ExternalLoadBalancerDeviceVO> lbDevices = _externalLoadBalancerDeviceDao.listAll();
        if (lbDevices != null) {
            for (ExternalLoadBalancerDeviceVO lbDevice : lbDevices) {
                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.");
                }
            }
        }
    } else {
        // check if any networks are using this load balancer device
        List<NetworkExternalLoadBalancerVO> networks = _networkLBDao.listByLoadBalancerDeviceId(lbDeviceId);
        if ((networks != null) && !networks.isEmpty()) {
            throw new CloudRuntimeException("Delete can not be done as there are networks using this load balancer device ");
        }
    }
    try {
        // put the host in maintenance state in order for it to be deleted
        externalLoadBalancer.setResourceState(ResourceState.Maintenance);
        _hostDao.update(hostId, externalLoadBalancer);
        _resourceMgr.deleteHost(hostId, false, false);
        // delete the external load balancer entry
        _externalLoadBalancerDeviceDao.remove(lbDeviceId);
        return true;
    } catch (Exception e) {
        s_logger.debug(e);
        return false;
    }
}