// 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 org.apache.cloudstack.network.element;
import java.net.MalformedURLException;
import java.net.URL;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.UUID;
import javax.inject.Inject;
import javax.naming.ConfigurationException;
import org.apache.log4j.Logger;
import org.apache.cloudstack.api.commands.AddSspCmd;
import org.apache.cloudstack.api.commands.DeleteSspCmd;
import org.apache.cloudstack.engine.orchestration.service.NetworkOrchestrationService;
import org.apache.cloudstack.framework.config.dao.ConfigurationDao;
import org.apache.cloudstack.network.dao.SspCredentialDao;
import org.apache.cloudstack.network.dao.SspCredentialVO;
import org.apache.cloudstack.network.dao.SspTenantDao;
import org.apache.cloudstack.network.dao.SspTenantVO;
import org.apache.cloudstack.network.dao.SspUuidDao;
import org.apache.cloudstack.network.dao.SspUuidVO;
import com.cloud.dc.dao.DataCenterDao;
import com.cloud.deploy.DeployDestination;
import com.cloud.exception.ConcurrentOperationException;
import com.cloud.exception.InsufficientCapacityException;
import com.cloud.exception.InvalidParameterValueException;
import com.cloud.exception.ResourceUnavailableException;
import com.cloud.host.Host;
import com.cloud.host.HostVO;
import com.cloud.host.dao.HostDao;
import com.cloud.network.Network;
import com.cloud.network.Network.Capability;
import com.cloud.network.Network.Provider;
import com.cloud.network.Network.Service;
import com.cloud.network.NetworkMigrationResponder;
import com.cloud.network.NetworkModel;
import com.cloud.network.Networks.BroadcastDomainType;
import com.cloud.network.PhysicalNetwork;
import com.cloud.network.PhysicalNetworkServiceProvider;
import com.cloud.network.PhysicalNetworkServiceProvider.State;
import com.cloud.network.dao.NetworkServiceMapDao;
import com.cloud.network.dao.PhysicalNetworkDao;
import com.cloud.network.dao.PhysicalNetworkServiceProviderDao;
import com.cloud.network.dao.PhysicalNetworkServiceProviderVO;
import com.cloud.network.element.ConnectivityProvider;
import com.cloud.offering.NetworkOffering;
import com.cloud.resource.ResourceManager;
import com.cloud.utils.component.AdapterBase;
import com.cloud.utils.exception.CloudRuntimeException;
import com.cloud.vm.NicProfile;
import com.cloud.vm.NicVO;
import com.cloud.vm.ReservationContext;
import com.cloud.vm.VirtualMachineProfile;
import com.cloud.vm.dao.NicDao;
/**
* Stratosphere sdn platform network element
*
* This class will be called per network setup operations.
* This class also have ssp specific methods.
*
* Current implementation use HostVO for storage of api endpoint information,
* but note this is not necessary. The other way is create our own database
* table for that information.
*/
public class SspElement extends AdapterBase implements ConnectivityProvider, SspManager, SspService, NetworkMigrationResponder {
private static final Logger s_logger = Logger.getLogger(SspElement.class);
public static final String s_SSP_NAME = "StratosphereSsp";
private static final Provider s_ssp_provider = new Provider(s_SSP_NAME, false);
@Inject
NetworkServiceMapDao _ntwkSrvcDao;
@Inject
NetworkModel _networkModel;
@Inject
NetworkOrchestrationService _networkMgr;
@Inject
ResourceManager _resourceMgr;
@Inject
PhysicalNetworkDao _physicalNetworkDao;
@Inject
PhysicalNetworkServiceProviderDao _physicalNetworkServiceProviderDao;
@Inject
SspCredentialDao _sspCredentialDao;
@Inject
SspTenantDao _sspTenantDao;
@Inject
SspUuidDao _sspUuidDao;
@Inject
DataCenterDao _dcDao;
@Inject
HostDao _hostDao;
@Inject
ConfigurationDao _configDao;
@Inject
NicDao _nicDao = null;
@Override
public boolean configure(String name, Map<String, Object> params) throws ConfigurationException {
return super.configure(name, params);
}
@Override
public Map<Service, Map<Capability, String>> getCapabilities() {
Map<Service, Map<Capability, String>> capabilities = new HashMap<Service, Map<Capability, String>>();
capabilities.put(Service.Connectivity, new HashMap<Capability, String>()); // XXX: We might need some more category here.
return capabilities;
}
@Override
public Provider getProvider() {
return s_ssp_provider;
}
private List<SspClient> fetchSspClients(Long physicalNetworkId, Long dataCenterId, boolean enabledOnly) {
ArrayList<SspClient> clients = new ArrayList<SspClient>();
boolean provider_found = false;
PhysicalNetworkServiceProviderVO provider = _physicalNetworkServiceProviderDao.findByServiceProvider(physicalNetworkId, s_SSP_NAME);
if (enabledOnly) {
if (provider != null && provider.getState() == State.Enabled) {
provider_found = true;
}
} else {
provider_found = true;
}
if (physicalNetworkId != null && provider_found) {
SspCredentialVO credential = _sspCredentialDao.findByZone(dataCenterId);
List<HostVO> hosts = _resourceMgr.listAllHostsInOneZoneByType(Host.Type.L2Networking, dataCenterId);
for (HostVO host : hosts) {
assert (credential != null);
_hostDao.loadDetails(host);
if ("v1Api".equals(host.getDetail("sspHost"))) {
clients.add(new SspClient(host.getDetail("url"), credential.getUsername(), credential.getPassword()));
}
}
}
if (clients.size() == 0) {
String global_apiUrl = _configDao.getValueAndInitIfNotExist("ssp.url", "Network", null);
String global_username = _configDao.getValueAndInitIfNotExist("ssp.username", "Network", null);
String global_password = _configDao.getValueAndInitIfNotExist("ssp.password", "Network", null);
if (global_apiUrl != null && global_username != null && global_password != null) {
clients.add(new SspClient(global_apiUrl, global_username, global_password));
}
}
return clients;
}
/* (non-Javadoc)
* @see org.apache.cloudstack.network.element.NetworkElement#isReady(com.cloud.network.PhysicalNetworkServiceProvider)
*/
@Override
public boolean isReady(PhysicalNetworkServiceProvider provider) {
PhysicalNetwork physicalNetwork = _physicalNetworkDao.findById(provider.getPhysicalNetworkId());
assert (physicalNetwork != null);
if (fetchSspClients(physicalNetwork.getId(), physicalNetwork.getDataCenterId(), false).size() > 0) {
return true;
}
s_logger.warn("Ssp api endpoint not found. " + physicalNetwork.toString());
return false;
}
/* (non-Javadoc)
* If this element is ready, then it can be enabled.
* @see org.apache.cloudstack.network.element.SspManager#isEnabled(com.cloud.network.PhysicalNetwork)
*/
@Override
public boolean canHandle(PhysicalNetwork physicalNetwork) {
if (physicalNetwork != null) {
if (fetchSspClients(physicalNetwork.getId(), physicalNetwork.getDataCenterId(), true).size() > 0) {
return true;
}
s_logger.warn("enabled Ssp api endpoint not found. " + physicalNetwork.toString());
} else {
s_logger.warn("PhysicalNetwork is NULL.");
}
return false;
}
private boolean canHandle(Network network) {
if (canHandle(_physicalNetworkDao.findById(network.getPhysicalNetworkId()))) {
if (!_ntwkSrvcDao.canProviderSupportServiceInNetwork(network.getId(), Service.Connectivity, getProvider())) {
s_logger.info("SSP is implicitly active for " + network);
}
return true;
}
return false;
}
@Override
public Host addSspHost(AddSspCmd cmd) {
SspClient client = new SspClient(cmd.getUrl(), cmd.getUsername(), cmd.getPassword());
if (!client.login()) {
throw new CloudRuntimeException("Ssp login failed.");
}
long zoneId = cmd.getZoneId();
SspCredentialVO credential = _sspCredentialDao.findByZone(zoneId);
if (credential == null) {
if (cmd.getUsername() == null || cmd.getPassword() == null) {
throw new InvalidParameterValueException("Initial credential required for zone: " + zoneId);
}
credential = new SspCredentialVO();
credential.setZoneId(zoneId);
credential.setUsername(cmd.getUsername());
credential.setPassword(cmd.getPassword());
_sspCredentialDao.persist(credential);
} else {
if (cmd.getUsername() != null || cmd.getPassword() != null) {
s_logger.warn("Tenant credential already configured for zone:" + zoneId);
}
}
String tenantUuid = _sspTenantDao.findUuidByZone(zoneId);
if (tenantUuid == null) {
if (cmd.getTenantUuid() == null) {
throw new InvalidParameterValueException("Initial tenant uuid required for zone: " + zoneId);
}
SspTenantVO tenant = new SspTenantVO();
tenant.setZoneId(zoneId);
tenant.setUuid(cmd.getTenantUuid());
_sspTenantDao.persist(tenant);
} else {
if (cmd.getTenantUuid() != null) {
s_logger.warn("Tenant uuid already configured for zone:" + zoneId);
}
}
String normalizedUrl = null;
String hostname = null;
try {
URL url = new URL(cmd.getUrl());
normalizedUrl = url.toString();
hostname = url.getHost();
} catch (MalformedURLException e1) {
throw new CloudRuntimeException("Invalid url " + cmd.getUrl());
}
List<HostVO> hosts = _resourceMgr.listAllHostsInOneZoneByType(Host.Type.L2Networking, zoneId);
for (HostVO host : hosts) {
assert (credential != null);
_hostDao.loadDetails(host);
if ("v1Api".equals(host.getDetail("sspHost"))) {
if (normalizedUrl.equals(host.getDetail("url"))) {
s_logger.warn("Ssp host already registered " + normalizedUrl);
return host;
}
}
}
// SspHost HostVO will be created per zone and url.
HostVO host = new HostVO(UUID.randomUUID().toString());
host.setDataCenterId(zoneId);
host.setType(Host.Type.L2Networking);
host.setPrivateIpAddress(hostname); // db schema not null. It may be a name, not IP address.
// host.setPrivateMacAddress(""); // db schema nullable
// host.setPrivateNetmask(""); // db schema nullable
host.setVersion("1"); // strange db schema not null
host.setName(cmd.getName());
host.setDetails(new HashMap<String, String>());
host.setDetail("sspHost", "v1Api");
host.setDetail("url", normalizedUrl);
return _hostDao.persist(host);
}
@Override
public boolean deleteSspHost(DeleteSspCmd cmd) {
s_logger.info("deleteStratosphereSsp");
return _hostDao.remove(cmd.getHostId());
}
@Override
public boolean createNetwork(Network network, NetworkOffering offering, DeployDestination dest, ReservationContext context) {
if (_sspUuidDao.findUuidByNetwork(network) != null) {
s_logger.info("Network already has ssp TenantNetwork uuid :" + network.toString());
return true;
}
if (!canHandle(network)) {
return false;
}
String tenantUuid = _sspTenantDao.findUuidByZone(network.getDataCenterId());
if (tenantUuid == null) {
tenantUuid = _configDao.getValueAndInitIfNotExist("ssp.tenant", "Network", null);
}
boolean processed = false;
for (SspClient client : fetchSspClients(network.getPhysicalNetworkId(), network.getDataCenterId(), true)) {
SspClient.TenantNetwork sspNet = client.createTenantNetwork(tenantUuid, network.getName());
if (sspNet != null) {
SspUuidVO uuid = new SspUuidVO();
uuid.setUuid(sspNet.uuid);
uuid.setObjClass(SspUuidVO.objClassNetwork);
uuid.setObjId(network.getId());
_sspUuidDao.persist(uuid);
return true;
}
processed = true;
}
if (processed) {
s_logger.error("Could not allocate an uuid for network " + network.toString());
return false;
} else {
s_logger.error("Skipping #createNetwork() for " + network.toString());
return true;
}
}
@Override
public boolean deleteNetwork(Network network) {
String tenantNetworkUuid = _sspUuidDao.findUuidByNetwork(network);
if (tenantNetworkUuid != null) {
boolean processed = false;
for (SspClient client : fetchSspClients(network.getPhysicalNetworkId(), network.getDataCenterId(), true)) {
if (client.deleteTenantNetwork(tenantNetworkUuid)) {
_sspUuidDao.removeUuid(tenantNetworkUuid);
processed = true;
break;
}
}
if (!processed) {
s_logger.error("Ssp api tenant network deletion failed " + network.toString());
}
} else {
s_logger.debug("Silently skipping #deleteNetwork() for " + network.toString());
}
return true;
}
// we use context.reservationId for dedup of guru & element operations.
@Override
public boolean createNicEnv(Network network, NicProfile nic, DeployDestination dest, ReservationContext context) {
String tenantNetworkUuid = _sspUuidDao.findUuidByNetwork(network);
if (tenantNetworkUuid == null) {
s_logger.debug("Skipping #createNicEnv() for nic on " + network.toString());
return true;
}
String reservationId = context.getReservationId();
List<SspUuidVO> tenantPortUuidVos = _sspUuidDao.listUUidVoByNicProfile(nic);
for (SspUuidVO tenantPortUuidVo : tenantPortUuidVos) {
if (reservationId.equals(tenantPortUuidVo.getReservationId())) {
s_logger.info("Skipping because reservation found " + reservationId);
return true;
}
}
String tenantPortUuid = null;
for (SspClient client : fetchSspClients(network.getPhysicalNetworkId(), network.getDataCenterId(), true)) {
SspClient.TenantPort sspPort = client.createTenantPort(tenantNetworkUuid);
if (sspPort != null) {
tenantPortUuid = sspPort.uuid;
nic.setReservationId(reservationId);
SspUuidVO uuid = new SspUuidVO();
uuid.setUuid(tenantPortUuid);
uuid.setObjClass(SspUuidVO.objClassNicProfile);
uuid.setObjId(nic.getId());
uuid.setReservationId(reservationId);
_sspUuidDao.persist(uuid);
break;
}
}
if (tenantPortUuid == null) {
s_logger.debug("#createNicEnv() failed for nic on " + network.toString());
return false;
}
for (SspClient client : fetchSspClients(network.getPhysicalNetworkId(), network.getDataCenterId(), true)) {
SspClient.TenantPort sspPort = client.updateTenantVifBinding(tenantPortUuid, dest.getHost().getPrivateIpAddress());
if (sspPort != null) {
if (sspPort.vlanId != null) {
nic.setBroadcastType(BroadcastDomainType.Vlan);
nic.setBroadcastUri(BroadcastDomainType.Vlan.toUri(String.valueOf(sspPort.vlanId)));
}
return true;
}
}
s_logger.error("Updating vif failed " + nic.toString());
return false;
}
@Override
public boolean deleteNicEnv(Network network, NicProfile nic, ReservationContext context) {
if (context == null) {
s_logger.error("ReservationContext was null for " + nic + " " + network);
return false;
}
String reservationId = context.getReservationId();
SspUuidVO deleteTarget = null;
SspUuidVO remainingTarget = null;
List<SspUuidVO> tenantPortUuidVos = _sspUuidDao.listUUidVoByNicProfile(nic);
for (SspUuidVO tenantPortUuidVo : tenantPortUuidVos) {
if (reservationId.equals(tenantPortUuidVo.getReservationId())) {
deleteTarget = tenantPortUuidVo;
} else {
remainingTarget = tenantPortUuidVo;
}
}
if (deleteTarget != null) { // delete the target ssp uuid (tenant-port)
String tenantPortUuid = deleteTarget.getUuid();
boolean processed = false;
for (SspClient client : fetchSspClients(network.getPhysicalNetworkId(), network.getDataCenterId(), true)) {
SspClient.TenantPort sspPort = client.updateTenantVifBinding(tenantPortUuid, null);
if (sspPort != null) {
processed = true;
break;
}
}
if (!processed) {
s_logger.warn("Ssp api nic detach failed " + nic.toString());
}
processed = false;
for (SspClient client : fetchSspClients(network.getPhysicalNetworkId(), network.getDataCenterId(), true)) {
if (client.deleteTenantPort(tenantPortUuid)) {
_sspUuidDao.removeUuid(tenantPortUuid);
processed = true;
break;
}
}
if (!processed) {
s_logger.warn("Ssp api tenant port deletion failed " + nic.toString());
}
_sspUuidDao.removeUuid(tenantPortUuid);
}
if (remainingTarget != null) {
NicVO nicVo = _nicDao.findById(nic.getId());
nicVo.setReservationId(remainingTarget.getReservationId());
_nicDao.persist(nicVo); // persist the new reservationId
}
return true;
}
/* (non-Javadoc)
* Implements a network using ssp element.
*
* This method will be called right after NetworkGuru#implement().
* see also {@link #shutdown(Network, ReservationContext, boolean)}
* @see org.apache.cloudstack.network.element.NetworkElement#implement(com.cloud.network.Network, com.cloud.offering.NetworkOffering, com.cloud.deploy.DeployDestination, com.cloud.vm.ReservationContext)
*/
@Override
public boolean implement(Network network, NetworkOffering offering, DeployDestination dest, ReservationContext context) throws ConcurrentOperationException,
ResourceUnavailableException, InsufficientCapacityException {
s_logger.info("implement");
return createNetwork(network, offering, dest, context);
}
/* (non-Javadoc)
* Shutdown the network implementation
*
* This method will be called right BEFORE NetworkGuru#shutdown().
* The entities was acquired by {@link #implement(Network, NetworkOffering, DeployDestination, ReservationContext)}
* @see org.apache.cloudstack.network.element.NetworkElement#shutdown(com.cloud.network.Network, com.cloud.vm.ReservationContext, boolean)
*/
@Override
public boolean shutdown(Network network, ReservationContext context, boolean cleanup) throws ConcurrentOperationException, ResourceUnavailableException {
s_logger.trace("shutdown");
return deleteNetwork(network);
}
/* (non-Javadoc)
* Prepares a network environment for a VM nic.
*
* This method will be called right after NetworkGuru#reserve().
* The entities will be released by {@link #release(Network, NicProfile, VirtualMachineProfile, ReservationContext)}
* @see org.apache.cloudstack.network.element.NetworkElement#prepare(com.cloud.network.Network, com.cloud.vm.NicProfile, com.cloud.vm.VirtualMachineProfile, com.cloud.deploy.DeployDestination, com.cloud.vm.ReservationContext)
*/
@Override
public boolean prepare(Network network, NicProfile nic, VirtualMachineProfile vm, DeployDestination dest, ReservationContext context)
throws ConcurrentOperationException, ResourceUnavailableException, InsufficientCapacityException {
s_logger.trace("prepare");
return createNicEnv(network, nic, dest, context);
}
/* (non-Javadoc)
* Release the network environment that was prepared for a VM nic.
*
* This method will be called right AFTER NetworkGuru#release().
* The entities was acquired in {@link #prepare(Network, NicProfile, VirtualMachineProfile, DeployDestination, ReservationContext)}
* @see org.apache.cloudstack.network.element.NetworkElement#release(com.cloud.network.Network, com.cloud.vm.NicProfile, com.cloud.vm.VirtualMachineProfile, com.cloud.vm.ReservationContext)
*/
@Override
public boolean release(Network network, NicProfile nic, VirtualMachineProfile vm, ReservationContext context) throws ConcurrentOperationException,
ResourceUnavailableException {
s_logger.trace("release");
return deleteNicEnv(network, nic, context);
}
/* (non-Javadoc)
* Destroy a network implementation.
*
* This method will be called right BEFORE NetworkGuru#trash() in "Expunge" phase.
* @see org.apache.cloudstack.network.element.NetworkElement#destroy(com.cloud.network.Network)
*/
@Override
public boolean destroy(Network network, ReservationContext context) throws ConcurrentOperationException, ResourceUnavailableException {
s_logger.trace("destroy");
// nothing to do here.
return true;
}
@Override
public boolean shutdownProviderInstances(PhysicalNetworkServiceProvider provider, ReservationContext context) throws ConcurrentOperationException,
ResourceUnavailableException {
s_logger.trace("shutdownProviderInstances");
return true;
}
@Override
public boolean canEnableIndividualServices() {
s_logger.trace("canEnableIndividualServices");
return true; // because there is only Connectivity
}
@Override
public boolean verifyServicesCombination(Set<Service> services) {
s_logger.trace("verifyServicesCombination " + services.toString());
return true;
}
@Override
public boolean prepareMigration(NicProfile nic, Network network, VirtualMachineProfile vm, DeployDestination dest, ReservationContext context) {
try {
prepare(network, nic, vm, dest, context);
} catch (ConcurrentOperationException e) {
s_logger.error("prepareForMigration failed.", e);
return false;
} catch (ResourceUnavailableException e) {
s_logger.error("prepareForMigration failed.", e);
return false;
} catch (InsufficientCapacityException e) {
s_logger.error("prepareForMigration failed.", e);
return false;
}
return true;
}
@Override
public void rollbackMigration(NicProfile nic, Network network, VirtualMachineProfile vm, ReservationContext src, ReservationContext dst) {
try {
release(network, nic, vm, dst);
} catch (ConcurrentOperationException e) {
s_logger.error("rollbackMigration failed.", e);
} catch (ResourceUnavailableException e) {
s_logger.error("rollbackMigration failed.", e);
}
}
@Override
public void commitMigration(NicProfile nic, Network network, VirtualMachineProfile vm, ReservationContext src, ReservationContext dst) {
try {
release(network, nic, vm, src);
} catch (ConcurrentOperationException e) {
s_logger.error("commitMigration failed.", e);
} catch (ResourceUnavailableException e) {
s_logger.error("commitMigration failed.", e);
}
}
@Override
public List<Class<?>> getCommands() {
return Arrays.<Class<?>> asList(AddSspCmd.class, DeleteSspCmd.class);
}
}