// Licensed to the Apache Software Foundation (ASF) under one

// or more contributor license agreements. See the NOTICE file

// distributed with this work for additional information

// regarding copyright ownership. The ASF licenses this file

// to you under the Apache License, Version 2.0 (the

// "License"); you may not use this file except in compliance

// with the License. You may obtain a copy of the License at

//

// http://www.apache.org/licenses/LICENSE-2.0

//

// Unless required by applicable law or agreed to in writing,

// software distributed under the License is distributed on an

// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY

// KIND, either express or implied. See the License for the

// specific language governing permissions and limitations

// under the License.

package com.cloud.network;

import java.math.BigInteger;

import java.security.InvalidParameterException;

import java.util.ArrayList;

import java.util.HashMap;

import java.util.HashSet;

import java.util.Iterator;

import java.util.List;

import java.util.Map;

import java.util.Set;

import java.util.TreeSet;

import javax.ejb.Local;

import javax.inject.Inject;

import javax.naming.ConfigurationException;

import org.apache.cloudstack.acl.ControlledEntity.ACLType;

import org.apache.cloudstack.lb.dao.ApplicationLoadBalancerRuleDao;

import org.apache.log4j.Logger;

import org.springframework.stereotype.Component;

import com.cloud.api.ApiDBUtils;

import com.cloud.configuration.Config;

import com.cloud.configuration.ConfigurationManager;

import com.cloud.configuration.dao.ConfigurationDao;

import com.cloud.dc.DataCenter;

import com.cloud.dc.PodVlanMapVO;

import com.cloud.dc.Vlan;

import com.cloud.dc.Vlan.VlanType;

import com.cloud.dc.VlanVO;

import com.cloud.dc.dao.DataCenterDao;

import com.cloud.dc.dao.PodVlanMapDao;

import com.cloud.dc.dao.VlanDao;

import com.cloud.domain.DomainVO;

import com.cloud.domain.dao.DomainDao;

import com.cloud.exception.InsufficientAddressCapacityException;

import com.cloud.exception.InvalidParameterValueException;

import com.cloud.exception.PermissionDeniedException;

import com.cloud.exception.UnsupportedServiceException;

import com.cloud.hypervisor.Hypervisor.HypervisorType;

import com.cloud.network.IpAddress.State;

import com.cloud.network.Network.Capability;

import com.cloud.network.Network.GuestType;

import com.cloud.network.Network.Provider;

import com.cloud.network.Network.Service;

import com.cloud.network.Networks.TrafficType;

import com.cloud.network.addr.PublicIp;

import com.cloud.network.dao.FirewallRulesDao;

import com.cloud.network.dao.IPAddressDao;

import com.cloud.network.dao.IPAddressVO;

import com.cloud.network.dao.NetworkDao;

import com.cloud.network.dao.NetworkDomainDao;

import com.cloud.network.dao.NetworkDomainVO;

import com.cloud.network.dao.NetworkServiceMapDao;

import com.cloud.network.dao.NetworkServiceMapVO;

import com.cloud.network.dao.NetworkVO;

import com.cloud.network.dao.PhysicalNetworkDao;

import com.cloud.network.dao.PhysicalNetworkServiceProviderDao;

import com.cloud.network.dao.PhysicalNetworkServiceProviderVO;

import com.cloud.network.dao.PhysicalNetworkTrafficTypeDao;

import com.cloud.network.dao.PhysicalNetworkTrafficTypeVO;

import com.cloud.network.dao.PhysicalNetworkVO;

import com.cloud.network.dao.UserIpv6AddressDao;

import com.cloud.network.element.IpDeployer;

import com.cloud.network.element.IpDeployingRequester;

import com.cloud.network.element.NetworkElement;

import com.cloud.network.element.UserDataServiceProvider;

import com.cloud.network.rules.FirewallRule.Purpose;

import com.cloud.network.rules.FirewallRuleVO;

import com.cloud.network.rules.dao.PortForwardingRulesDao;

import com.cloud.network.vpc.dao.PrivateIpDao;

import com.cloud.offering.NetworkOffering;

import com.cloud.offering.NetworkOffering.Detail;

import com.cloud.offerings.NetworkOfferingServiceMapVO;

import com.cloud.offerings.NetworkOfferingVO;

import com.cloud.offerings.dao.NetworkOfferingDao;

import com.cloud.offerings.dao.NetworkOfferingDetailsDao;

import com.cloud.offerings.dao.NetworkOfferingServiceMapDao;

import com.cloud.projects.dao.ProjectAccountDao;

import com.cloud.server.ConfigurationServer;

import com.cloud.user.Account;

import com.cloud.user.AccountVO;

import com.cloud.user.DomainManager;

import com.cloud.user.dao.AccountDao;

import com.cloud.utils.component.AdapterBase;

import com.cloud.utils.component.ManagerBase;

import com.cloud.utils.db.DB;

import com.cloud.utils.db.JoinBuilder;

import com.cloud.utils.db.JoinBuilder.JoinType;

import com.cloud.utils.db.SearchBuilder;

import com.cloud.utils.db.SearchCriteria;

import com.cloud.utils.db.SearchCriteria.Op;

import com.cloud.utils.exception.CloudRuntimeException;

import com.cloud.utils.net.NetUtils;

import com.cloud.vm.Nic;

import com.cloud.vm.NicProfile;

import com.cloud.vm.NicVO;

import com.cloud.vm.VMInstanceVO;

import com.cloud.vm.VirtualMachine;

import com.cloud.vm.VirtualMachine.Type;

import com.cloud.vm.dao.NicDao;

import com.cloud.vm.dao.NicSecondaryIpDao;

import com.cloud.vm.dao.VMInstanceDao;

@Component

@Local(value = { NetworkModel.class})

public class NetworkModelImpl extends ManagerBase implements NetworkModel {

static final Logger s_logger = Logger.getLogger(NetworkModelImpl.class);

@Inject

DataCenterDao _dcDao = null;

@Inject

VlanDao _vlanDao = null;

@Inject

IPAddressDao _ipAddressDao = null;

@Inject

AccountDao _accountDao = null;

@Inject

DomainDao _domainDao = null;

@Inject

ConfigurationDao _configDao;

@Inject

ConfigurationManager _configMgr;

@Inject

NetworkOfferingDao _networkOfferingDao = null;

@Inject

NetworkDao _networksDao = null;

@Inject

NicDao _nicDao = null;

@Inject

PodVlanMapDao _podVlanMapDao;

@Inject

ConfigurationServer _configServer;

List<NetworkElement> _networkElements;

public List<NetworkElement> getNetworkElements() {

return _networkElements;

}

public void setNetworkElements(List<NetworkElement> _networkElements) {

this._networkElements = _networkElements;

}

@Inject

NetworkDomainDao _networkDomainDao;

@Inject

VMInstanceDao _vmDao;

@Inject

FirewallRulesDao _firewallDao;

@Inject

DomainManager _domainMgr;

@Inject

NetworkOfferingServiceMapDao _ntwkOfferingSrvcDao;

@Inject

PhysicalNetworkDao _physicalNetworkDao;

@Inject

PhysicalNetworkServiceProviderDao _pNSPDao;

@Inject

PortForwardingRulesDao _portForwardingRulesDao;

@Inject

PhysicalNetworkTrafficTypeDao _pNTrafficTypeDao;

@Inject

NetworkServiceMapDao _ntwkSrvcDao;

@Inject

PrivateIpDao _privateIpDao;

@Inject

UserIpv6AddressDao _ipv6Dao;

@Inject

NicSecondaryIpDao _nicSecondaryIpDao;

@Inject

ApplicationLoadBalancerRuleDao _appLbRuleDao;

@Inject

private ProjectAccountDao _projectAccountDao;

@Inject

NetworkOfferingDetailsDao _ntwkOffDetailsDao;

private final HashMap<String, NetworkOfferingVO> _systemNetworks = new HashMap<String, NetworkOfferingVO>(5);

static Long _privateOfferingId = null;

SearchBuilder<IPAddressVO> IpAddressSearch;

SearchBuilder<NicVO> NicForTrafficTypeSearch;

private String _networkDomain;

private boolean _allowSubdomainNetworkAccess;

private Map<String, String> _configs;

protected boolean _executeInSequenceNtwkElmtCmd;

HashMap<Long, Long> _lastNetworkIdsToFree = new HashMap<Long, Long>();

static HashMap<Service, List<Provider>> s_serviceToImplementedProvidersMap = new HashMap<Service, List<Provider>>();

static HashMap<String, String> s_providerToNetworkElementMap = new HashMap<String, String>();

/**

*

*/

public NetworkModelImpl() {

super();

}

@Override

public NetworkElement getElementImplementingProvider(String providerName) {

String elementName = s_providerToNetworkElementMap.get(providerName);

NetworkElement element = AdapterBase.getAdapterByName(_networkElements, elementName);

return element;

}

@Override

public List<Service> getElementServices(Provider provider) {

NetworkElement element = getElementImplementingProvider(provider.getName());

if (element == null) {

throw new InvalidParameterValueException("Unable to find the Network Element implementing the Service Provider '" + provider.getName() + "'");

}

return new ArrayList<Service>(element.getCapabilities().keySet());

}

@Override

public boolean canElementEnableIndividualServices(Provider provider) {

NetworkElement element = getElementImplementingProvider(provider.getName());

if (element == null) {

throw new InvalidParameterValueException("Unable to find the Network Element implementing the Service Provider '" + provider.getName() + "'");

}

return element.canEnableIndividualServices();

}

Set<Purpose> getPublicIpPurposeInRules(PublicIpAddress ip, boolean includeRevoked, boolean includingFirewall) {

Set<Purpose> result = new HashSet<Purpose>();

List<FirewallRuleVO> rules = null;

if (includeRevoked) {

rules = _firewallDao.listByIp(ip.getId());

} else {

rules = _firewallDao.listByIpAndNotRevoked(ip.getId());

}

if (rules == null || rules.isEmpty()) {

return null;

}

for (FirewallRuleVO rule : rules) {

if (rule.getPurpose() != Purpose.Firewall || includingFirewall) {

result.add(rule.getPurpose());

}

}

return result;

}

@Override

public Map<PublicIpAddress, Set<Service>> getIpToServices(List<? extends PublicIpAddress> publicIps, boolean postApplyRules, boolean includingFirewall) {

Map<PublicIpAddress, Set<Service>> ipToServices = new HashMap<PublicIpAddress, Set<Service>>();

if (publicIps != null && !publicIps.isEmpty()) {

Set<Long> networkSNAT = new HashSet<Long>();

for (PublicIpAddress ip : publicIps) {

Set<Service> services = ipToServices.get(ip);

if (services == null) {

services = new HashSet<Service>();

}

if (ip.isSourceNat()) {

if (!networkSNAT.contains(ip.getAssociatedWithNetworkId())) {

services.add(Service.SourceNat);

networkSNAT.add(ip.getAssociatedWithNetworkId());

} else {

CloudRuntimeException ex = new CloudRuntimeException("Multiple generic soure NAT IPs provided for network");

// see the IPAddressVO.java class.

IPAddressVO ipAddr = ApiDBUtils.findIpAddressById(ip.getAssociatedWithNetworkId());

String ipAddrUuid = ip.getAssociatedWithNetworkId().toString();

if ( ipAddr != null){

ipAddrUuid = ipAddr.getUuid();

}

ex.addProxyObject(ipAddrUuid, "networkId");

throw ex;

}

}

ipToServices.put(ip, services);

// if IP in allocating state then it will not have any rules attached so skip IPAssoc to network service

// provider

if (ip.getState() == State.Allocating) {

continue;

}

// check if any active rules are applied on the public IP

Set<Purpose> purposes = getPublicIpPurposeInRules(ip, false, includingFirewall);

// Firewall rules didn't cover static NAT

if (ip.isOneToOneNat() && ip.getAssociatedWithVmId() != null) {

if (purposes == null) {

purposes = new HashSet<Purpose>();

}

purposes.add(Purpose.StaticNat);

}

if (purposes == null || purposes.isEmpty()) {

// since no active rules are there check if any rules are applied on the public IP but are in

// revoking state

purposes = getPublicIpPurposeInRules(ip, true, includingFirewall);

if (ip.isOneToOneNat()) {

if (purposes == null) {

purposes = new HashSet<Purpose>();

}

purposes.add(Purpose.StaticNat);

}

if (purposes == null || purposes.isEmpty()) {

// IP is not being used for any purpose so skip IPAssoc to network service provider

continue;

} else {

if (postApplyRules) {

// no active rules/revoked rules are associated with this public IP, so remove the

// association with the provider

if (ip.isSourceNat()) {

s_logger.debug("Not releasing ip " + ip.getAddress().addr() + " as it is in use for SourceNat");

} else {

ip.setState(State.Releasing);

}

} else {

if (ip.getState() == State.Releasing) {

// rules are not revoked yet, so don't let the network service provider revoke the IP

// association

// mark IP is allocated so that IP association will not be removed from the provider

ip.setState(State.Allocated);

}

}

}

}

if (purposes.contains(Purpose.StaticNat)) {

services.add(Service.StaticNat);

}

if (purposes.contains(Purpose.LoadBalancing)) {

services.add(Service.Lb);

}

if (purposes.contains(Purpose.PortForwarding)) {

services.add(Service.PortForwarding);

}

if (purposes.contains(Purpose.Vpn)) {

services.add(Service.Vpn);

}

if (purposes.contains(Purpose.Firewall)) {

services.add(Service.Firewall);

}

if (services.isEmpty()) {

continue;

}

ipToServices.put(ip, services);

}

}

return ipToServices;

}

public boolean canIpUsedForNonConserveService(PublicIp ip, Service service) {

// If it's non-conserve mode, then the new ip should not be used by any other services

List<PublicIpAddress> ipList = new ArrayList<PublicIpAddress>();

ipList.add(ip);

Map<PublicIpAddress, Set<Service>> ipToServices = getIpToServices(ipList, false, false);

Set<Service> services = ipToServices.get(ip);

// Not used currently, safe

if (services == null || services.isEmpty()) {

return true;

}

// Since it's non-conserve mode, only one service should used for IP

if (services.size() != 1) {

throw new InvalidParameterException("There are multiple services used ip " + ip.getAddress() + ".");

}

if (service != null && !((Service) services.toArray()[0] == service || service.equals(Service.Firewall))) {

throw new InvalidParameterException("The IP " + ip.getAddress() + " is already used as " + ((Service) services.toArray()[0]).getName() + " rather than " + service.getName());

}

return true;

}

Map<Service, Set<Provider>> getServiceProvidersMap(long networkId) {

Map<Service, Set<Provider>> map = new HashMap<Service, Set<Provider>>();

List<NetworkServiceMapVO> nsms = _ntwkSrvcDao.getServicesInNetwork(networkId);

for (NetworkServiceMapVO nsm : nsms) {

Set<Provider> providers = map.get(Service.getService(nsm.getService()));

if (providers == null) {

providers = new HashSet<Provider>();

}

providers.add(Provider.getProvider(nsm.getProvider()));

map.put(Service.getService(nsm.getService()), providers);

}

return map;

}

public boolean canIpUsedForService(PublicIp publicIp, Service service, Long networkId) {

List<PublicIpAddress> ipList = new ArrayList<PublicIpAddress>();

ipList.add(publicIp);

Map<PublicIpAddress, Set<Service>> ipToServices = getIpToServices(ipList, false, true);

Set<Service> services = ipToServices.get(publicIp);

if (services == null || services.isEmpty()) {

return true;

}

if (networkId == null) {

networkId = publicIp.getAssociatedWithNetworkId();

}

// We only support one provider for one service now

Map<Service, Set<Provider>> serviceToProviders = getServiceProvidersMap(networkId);

Set<Provider> oldProviders = serviceToProviders.get(services.toArray()[0]);

Provider oldProvider = (Provider) oldProviders.toArray()[0];

// Since IP already has service to bind with, the oldProvider can't be null

Set<Provider> newProviders = serviceToProviders.get(service);

if (newProviders == null || newProviders.isEmpty()) {

throw new InvalidParameterException("There is no new provider for IP " + publicIp.getAddress() + " of service " + service.getName() + "!");

}

Provider newProvider = (Provider) newProviders.toArray()[0];

Network network = _networksDao.findById(networkId);

NetworkElement oldElement = getElementImplementingProvider(oldProvider.getName());

NetworkElement newElement = getElementImplementingProvider(newProvider.getName());

if (oldElement instanceof IpDeployingRequester && newElement instanceof IpDeployingRequester) {

IpDeployer oldIpDeployer = ((IpDeployingRequester)oldElement).getIpDeployer(network);

IpDeployer newIpDeployer = ((IpDeployingRequester)newElement).getIpDeployer(network);

if (!oldIpDeployer.getProvider().getName().equals(newIpDeployer.getProvider().getName())) {

throw new InvalidParameterException("There would be multiple providers for IP " + publicIp.getAddress() + "!");

}

} else {

throw new InvalidParameterException("Ip cannot be applied for new provider!");

}

return true;

}

Map<Provider, Set<Service>> getProviderServicesMap(long networkId) {

Map<Provider, Set<Service>> map = new HashMap<Provider, Set<Service>>();

List<NetworkServiceMapVO> nsms = _ntwkSrvcDao.getServicesInNetwork(networkId);

for (NetworkServiceMapVO nsm : nsms) {

Set<Service> services = map.get(Provider.getProvider(nsm.getProvider()));

if (services == null) {

services = new HashSet<Service>();

}

services.add(Service.getService(nsm.getService()));

map.put(Provider.getProvider(nsm.getProvider()), services);

}

return map;

}

@Override

public Map<Provider, ArrayList<PublicIpAddress>> getProviderToIpList(Network network, Map<PublicIpAddress, Set<Service>> ipToServices) {

NetworkOffering offering = _networkOfferingDao.findById(network.getNetworkOfferingId());

if (!offering.isConserveMode()) {

for (PublicIpAddress ip : ipToServices.keySet()) {

Set<Service> services = new HashSet<Service>() ;

services.addAll(ipToServices.get(ip));

if (services != null && services.contains(Service.Firewall)) {

services.remove(Service.Firewall);

}

if (services != null && services.size() > 1) {

throw new CloudRuntimeException("Ip " + ip.getAddress() + " is used by multiple services!");

}

}

}

Map<Service, Set<PublicIpAddress>> serviceToIps = new HashMap<Service, Set<PublicIpAddress>>();

for (PublicIpAddress ip : ipToServices.keySet()) {

for (Service service : ipToServices.get(ip)) {

Set<PublicIpAddress> ips = serviceToIps.get(service);

if (ips == null) {

ips = new HashSet<PublicIpAddress>();

}

ips.add(ip);

serviceToIps.put(service, ips);

}

}

// TODO Check different provider for same IP

Map<Provider, Set<Service>> providerToServices = getProviderServicesMap(network.getId());

Map<Provider, ArrayList<PublicIpAddress>> providerToIpList = new HashMap<Provider, ArrayList<PublicIpAddress>>();

for (Provider provider : providerToServices.keySet()) {

if (!(getElementImplementingProvider(provider.getName()) instanceof IpDeployingRequester)) {

continue;

}

Set<Service> services = providerToServices.get(provider);

ArrayList<PublicIpAddress> ipList = new ArrayList<PublicIpAddress>();

Set<PublicIpAddress> ipSet = new HashSet<PublicIpAddress>();

for (Service service : services) {

Set<PublicIpAddress> serviceIps = serviceToIps.get(service);

if (serviceIps == null || serviceIps.isEmpty()) {

continue;

}

ipSet.addAll(serviceIps);

}

Set<PublicIpAddress> sourceNatIps = serviceToIps.get(Service.SourceNat);

if (sourceNatIps != null && !sourceNatIps.isEmpty()) {

ipList.addAll(0, sourceNatIps);

ipSet.removeAll(sourceNatIps);

}

ipList.addAll(ipSet);

providerToIpList.put(provider, ipList);

}

return providerToIpList;

}

@Override

public List<IPAddressVO> listPublicIpsAssignedToGuestNtwk(long accountId, long associatedNetworkId, Boolean sourceNat) {

SearchCriteria<IPAddressVO> sc = IpAddressSearch.create();

sc.setParameters("accountId", accountId);

sc.setParameters("associatedWithNetworkId", associatedNetworkId);

if (sourceNat != null) {

sc.addAnd("sourceNat", SearchCriteria.Op.EQ, sourceNat);

}

sc.setJoinParameters("virtualNetworkVlanSB", "vlanType", VlanType.VirtualNetwork);

return _ipAddressDao.search(sc, null);

}

@Override

public List<IPAddressVO> listPublicIpsAssignedToAccount(long accountId, long dcId, Boolean sourceNat) {

SearchCriteria<IPAddressVO> sc = IpAddressSearch.create();

sc.setParameters("accountId", accountId);

sc.setParameters("dataCenterId", dcId);

if (sourceNat != null) {

sc.addAnd("sourceNat", SearchCriteria.Op.EQ, sourceNat);

}

sc.setJoinParameters("virtualNetworkVlanSB", "vlanType", VlanType.VirtualNetwork);

return _ipAddressDao.search(sc, null);

}

@Override

public List<? extends Nic> getNics(long vmId) {

return _nicDao.listByVmId(vmId);

}

@Override

public String getNextAvailableMacAddressInNetwork(long networkId) throws InsufficientAddressCapacityException {

String mac = _networksDao.getNextAvailableMacAddress(networkId);

if (mac == null) {

throw new InsufficientAddressCapacityException("Unable to create another mac address", Network.class, networkId);

}

return mac;

}

@Override

@DB

public Network getNetwork(long id) {

return _networksDao.findById(id);

}

@Override

public boolean canUseForDeploy(Network network) {

if (network.getTrafficType() != TrafficType.Guest) {

return false;

}

boolean hasFreeIps = true;

if (network.getGuestType() == GuestType.Shared) {

if (network.getGateway() != null) {

hasFreeIps = _ipAddressDao.countFreeIPsInNetwork(network.getId()) > 0;

}

if (!hasFreeIps) {

return false;

}

if (network.getIp6Gateway() != null) {

hasFreeIps = isIP6AddressAvailableInNetwork(network.getId());

}

} else {

hasFreeIps = (getAvailableIps(network, null)).size() > 0;

}

return hasFreeIps;

}

@Override

public boolean isIP6AddressAvailableInNetwork(long networkId) {

Network network = _networksDao.findById(networkId);

if (network == null) {

return false;

}

if (network.getIp6Gateway() == null) {

return false;

}

List<VlanVO> vlans = _vlanDao.listVlansByNetworkId(networkId);

for (Vlan vlan : vlans) {

if (isIP6AddressAvailableInVlan(vlan.getId())) {

return true;

}

}

return false;

}

@Override

public boolean isIP6AddressAvailableInVlan(long vlanId) {

VlanVO vlan = _vlanDao.findById(vlanId);

if (vlan.getIp6Range() == null) {

return false;

}

long existedCount = _ipv6Dao.countExistedIpsInVlan(vlanId);

BigInteger existedInt = BigInteger.valueOf(existedCount);

BigInteger rangeInt = NetUtils.countIp6InRange(vlan.getIp6Range());

return (existedInt.compareTo(rangeInt) < 0);

}

@Override

public Map<Service, Map<Capability, String>> getNetworkCapabilities(long networkId) {

Map<Service, Map<Capability, String>> networkCapabilities = new HashMap<Service, Map<Capability, String>>();

// list all services of this networkOffering

List<NetworkServiceMapVO> servicesMap = _ntwkSrvcDao.getServicesInNetwork(networkId);

for (NetworkServiceMapVO instance : servicesMap) {

Service service = Service.getService(instance.getService());

NetworkElement element = getElementImplementingProvider(instance.getProvider());

if (element != null) {

Map<Service, Map<Capability, String>> elementCapabilities = element.getCapabilities();

if (elementCapabilities != null) {

networkCapabilities.put(service, elementCapabilities.get(service));

}

}

}

return networkCapabilities;

}

@Override

public Map<Capability, String> getNetworkServiceCapabilities(long networkId, Service service) {

if (!areServicesSupportedInNetwork(networkId, service)) {

// TBD: networkId to uuid. No VO object being passed. So we will need to call

// addProxyObject with hardcoded tablename. Or we should probably look up the correct dao proxy object.

throw new UnsupportedServiceException("Service " + service.getName() + " is not supported in the network id=" + networkId);

}

Map<Capability, String> serviceCapabilities = new HashMap<Capability, String>();

// get the Provider for this Service for this offering

String provider = _ntwkSrvcDao.getProviderForServiceInNetwork(networkId, service);

NetworkElement element = getElementImplementingProvider(provider);

if (element != null) {

Map<Service, Map<Capability, String>> elementCapabilities = element.getCapabilities();

;

if (elementCapabilities == null || !elementCapabilities.containsKey(service)) {

throw new UnsupportedServiceException("Service " + service.getName() + " is not supported by the element=" + element.getName() + " implementing Provider=" + provider);

}

serviceCapabilities = elementCapabilities.get(service);

}

return serviceCapabilities;

}

@Override

public Map<Capability, String> getNetworkOfferingServiceCapabilities(NetworkOffering offering, Service service) {

if (!areServicesSupportedByNetworkOffering(offering.getId(), service)) {

// TBD: We should be sending networkOfferingId and not the offering object itself.

throw new UnsupportedServiceException("Service " + service.getName() + " is not supported by the network offering " + offering);

}

Map<Capability, String> serviceCapabilities = new HashMap<Capability, String>();

// get the Provider for this Service for this offering

List<String> providers = _ntwkOfferingSrvcDao.listProvidersForServiceForNetworkOffering(offering.getId(), service);

if (providers.isEmpty()) {

// TBD: We should be sending networkOfferingId and not the offering object itself.

throw new InvalidParameterValueException("Service " + service.getName() + " is not supported by the network offering " + offering);

}

// FIXME - in post 3.0 we are going to support multiple providers for the same service per network offering, so

// we have to calculate capabilities for all of them

String provider = providers.get(0);

// FIXME we return the capabilities of the first provider of the service - what if we have multiple providers

// for same Service?

NetworkElement element = getElementImplementingProvider(provider);

if (element != null) {

Map<Service, Map<Capability, String>> elementCapabilities = element.getCapabilities();

;

if (elementCapabilities == null || !elementCapabilities.containsKey(service)) {

// TBD: We should be sending providerId and not the offering object itself.

throw new UnsupportedServiceException("Service " + service.getName() + " is not supported by the element=" + element.getName() + " implementing Provider=" + provider);

}

serviceCapabilities = elementCapabilities.get(service);

}

return serviceCapabilities;

}

@Override

public NetworkVO getSystemNetworkByZoneAndTrafficType(long zoneId, TrafficType trafficType) {

// find system public network offering

Long networkOfferingId = null;

List<NetworkOfferingVO> offerings = _networkOfferingDao.listSystemNetworkOfferings();

for (NetworkOfferingVO offering : offerings) {

if (offering.getTrafficType() == trafficType) {

networkOfferingId = offering.getId();

break;

}

}

if (networkOfferingId == null) {

throw new InvalidParameterValueException("Unable to find system network offering with traffic type " + trafficType);

}

List<NetworkVO> networks = _networksDao.listBy(Account.ACCOUNT_ID_SYSTEM, networkOfferingId, zoneId);

if (networks == null || networks.isEmpty()) {

// TBD: send uuid instead of zoneId. Hardcode tablename in call to addProxyObject().

throw new InvalidParameterValueException("Unable to find network with traffic type " + trafficType + " in zone " + zoneId);

}

return networks.get(0);

}

@Override

public NetworkVO getNetworkWithSecurityGroupEnabled(Long zoneId) {

List<NetworkVO> networks = _networksDao.listByZoneSecurityGroup(zoneId);

if (networks == null || networks.isEmpty()) {

return null;

}

if (networks.size() > 1) {

s_logger.debug("There are multiple network with security group enabled? select one of them...");

}

return networks.get(0);

}

@Override

public PublicIpAddress getPublicIpAddress(long ipAddressId) {

IPAddressVO addr = _ipAddressDao.findById(ipAddressId);

if (addr == null) {

return null;

}

return PublicIp.createFromAddrAndVlan(addr, _vlanDao.findById(addr.getVlanId()));

}

@Override

public List<VlanVO> listPodVlans(long podId) {

List<VlanVO> vlans = _vlanDao.listVlansForPodByType(podId, VlanType.DirectAttached);

return vlans;

}

@Override

public List<NetworkVO> listNetworksUsedByVm(long vmId, boolean isSystem) {

List<NetworkVO> networks = new ArrayList<NetworkVO>();

List<NicVO> nics = _nicDao.listByVmId(vmId);

if (nics != null) {

for (Nic nic : nics) {

NetworkVO network = _networksDao.findByIdIncludingRemoved(nic.getNetworkId());

if (isNetworkSystem(network) == isSystem) {

networks.add(network);

}

}

}

return networks;

}

@Override

public Nic getNicInNetwork(long vmId, long networkId) {

return _nicDao.findByNtwkIdAndInstanceId(networkId, vmId);

}

@Override

public String getIpInNetwork(long vmId, long networkId) {

Nic guestNic = getNicInNetwork(vmId, networkId);

assert (guestNic != null && guestNic.getIp4Address() != null) : "Vm doesn't belong to network associated with " +

"ipAddress or ip4 address is null";

return guestNic.getIp4Address();

}

@Override

public String getIpInNetworkIncludingRemoved(long vmId, long networkId) {

Nic guestNic = getNicInNetworkIncludingRemoved(vmId, networkId);

assert (guestNic != null && guestNic.getIp4Address() != null) : "Vm doesn't belong to network associated with " +

"ipAddress or ip4 address is null";

return guestNic.getIp4Address();

}

@Override

public List<NicVO> getNicsForTraffic(long vmId, TrafficType type) {

SearchCriteria<NicVO> sc = NicForTrafficTypeSearch.create();

sc.setParameters("instance", vmId);

sc.setJoinParameters("network", "traffictype", type);

return _nicDao.search(sc, null);

}

@Override

public IpAddress getIp(long ipAddressId) {

return _ipAddressDao.findById(ipAddressId);

}

@Override

public Network getDefaultNetworkForVm(long vmId) {

Nic defaultNic = getDefaultNic(vmId);

if (defaultNic == null) {

return null;

} else {

return _networksDao.findById(defaultNic.getNetworkId());

}

}

@Override

public Nic getDefaultNic(long vmId) {

List<NicVO> nics = _nicDao.listByVmId(vmId);

Nic defaultNic = null;

if (nics != null) {

for (Nic nic : nics) {

if (nic.isDefaultNic()) {

defaultNic = nic;

break;

}

}

} else {

s_logger.debug("Unable to find default network for the vm; vm doesn't have any nics");

return null;

}

if (defaultNic == null) {

s_logger.debug("Unable to find default network for the vm; vm doesn't have default nic");

}

return defaultNic;

}

@Override

public UserDataServiceProvider getUserDataUpdateProvider(Network network) {

String userDataProvider = _ntwkSrvcDao.getProviderForServiceInNetwork(network.getId(), Service.UserData);

if (userDataProvider == null) {

s_logger.debug("Network " + network + " doesn't support service " + Service.UserData.getName());

return null;

}

return (UserDataServiceProvider)getElementImplementingProvider(userDataProvider);

}

@Override

public boolean areServicesSupportedByNetworkOffering(long networkOfferingId, Service... services) {

return (_ntwkOfferingSrvcDao.areServicesSupportedByNetworkOffering(networkOfferingId, services));

}

@Override

public boolean areServicesSupportedInNetwork(long networkId, Service... services) {

return (_ntwkSrvcDao.areServicesSupportedInNetwork(networkId, services));

}

@Override

public String getIpOfNetworkElementInVirtualNetwork(long accountId, long dataCenterId) {

List<NetworkVO> virtualNetworks = _networksDao.listByZoneAndGuestType(accountId, dataCenterId, Network.GuestType.Isolated, false);

if (virtualNetworks.isEmpty()) {

s_logger.trace("Unable to find default Virtual network account id=" + accountId);

return null;

}

NetworkVO virtualNetwork = virtualNetworks.get(0);

NicVO networkElementNic = _nicDao.findByNetworkIdAndType(virtualNetwork.getId(), Type.DomainRouter);

if (networkElementNic != null) {

return networkElementNic.getIp4Address();

} else {

s_logger.warn("Unable to set find network element for the network id=" + virtualNetwork.getId());

return null;

}

}

@Override

public List<NetworkVO> listNetworksForAccount(long accountId, long zoneId, Network.GuestType type) {

List<NetworkVO> accountNetworks = new ArrayList<NetworkVO>();

List<NetworkVO> zoneNetworks = _networksDao.listByZone(zoneId);

for (NetworkVO network : zoneNetworks) {

if (!isNetworkSystem(network)) {

if (network.getGuestType() == Network.GuestType.Shared || !_networksDao.listBy(accountId, network.getId()).isEmpty()) {

if (type == null || type == network.getGuestType()) {

accountNetworks.add(network);

}

}

}

}

return accountNetworks;

}

@Override

public List<NetworkVO> listAllNetworksInAllZonesByType(Network.GuestType type) {

List<NetworkVO> networks = new ArrayList<NetworkVO>();

for (NetworkVO network: _networksDao.listAll()) {

if (!isNetworkSystem(network)) {

networks.add(network);

}

}

return networks;

}

@Override

public Long getDedicatedNetworkDomain(long networkId) {

NetworkDomainVO networkMaps = _networkDomainDao.getDomainNetworkMapByNetworkId(networkId);

if (networkMaps != null) {

return networkMaps.getDomainId();

} else {

return null;

}

}

@Override

public Integer getNetworkRate(long networkId, Long vmId) {

VMInstanceVO vm = null;

if (vmId != null) {

vm = _vmDao.findById(vmId);

}

Network network = getNetwork(networkId);

NetworkOffering ntwkOff = _configMgr.getNetworkOffering(network.getNetworkOfferingId());

// For default userVm Default network and domR guest/public network, get rate information from the service

// offering; for other situations get information

// from the network offering

boolean isUserVmsDefaultNetwork = false;

boolean isDomRGuestOrPublicNetwork = false;

boolean isSystemVmNetwork = false;

if (vm != null) {

Nic nic = _nicDao.findByNtwkIdAndInstanceId(networkId, vmId);

if (vm.getType() == Type.User && nic != null && nic.isDefaultNic()) {

isUserVmsDefaultNetwork = true;

} else if (vm.getType() == Type.DomainRouter && ntwkOff != null && (ntwkOff.getTrafficType() == TrafficType.Public || ntwkOff.getTrafficType() == TrafficType.Guest)) {

isDomRGuestOrPublicNetwork = true;

} else if (vm.getType() == Type.ConsoleProxy || vm.getType() == Type.SecondaryStorageVm) {

isSystemVmNetwork = true;

}

}

if (isUserVmsDefaultNetwork || isDomRGuestOrPublicNetwork) {

return _configMgr.getServiceOfferingNetworkRate(vm.getServiceOfferingId(), network.getDataCenterId());

} else if (isSystemVmNetwork) {

return -1;

} else {

return _configMgr.getNetworkOfferingNetworkRate(ntwkOff.getId(), network.getDataCenterId());

}

}

@Override

public String getAccountNetworkDomain(long accountId, long zoneId) {

String networkDomain = _accountDao.findById(accountId).getNetworkDomain();

if (networkDomain == null) {

// get domain level network domain

return getDomainNetworkDomain(_accountDao.findById(accountId).getDomainId(), zoneId);

}

return networkDomain;

}

@Override

public String getGlobalGuestDomainSuffix() {

return _networkDomain;

}

@Override

public String getStartIpAddress(long networkId) {

List<VlanVO> vlans = _vlanDao.listVlansByNetworkId(networkId);

if (vlans.isEmpty()) {

return null;

}

String startIP = vlans.get(0).getIpRange().split("-")[0];

for (VlanVO vlan : vlans) {

String startIP1 = vlan.getIpRange().split("-")[0];

long startIPLong = NetUtils.ip2Long(startIP);

long startIPLong1 = NetUtils.ip2Long(startIP1);

if (startIPLong1 < startIPLong) {

startIP = startIP1;

}

}

return startIP;