// 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.contrail.management;
import java.io.IOException;
import java.io.Serializable;
import java.lang.reflect.Method;
import java.util.ArrayList;
import java.util.Comparator;
import java.util.List;
import java.util.concurrent.locks.ReentrantLock;
import javax.inject.Inject;
import net.juniper.contrail.api.ApiConnector;
import net.juniper.contrail.api.ApiObjectBase;
import net.juniper.contrail.api.ApiPropertyBase;
import net.juniper.contrail.api.ObjectReference;
import net.juniper.contrail.api.types.FloatingIp;
import net.juniper.contrail.api.types.FloatingIpPool;
import net.juniper.contrail.api.types.NetworkPolicy;
import net.juniper.contrail.api.types.InstanceIp;
import net.juniper.contrail.api.types.ServiceInstance;
import net.juniper.contrail.api.types.VirtualMachine;
import net.juniper.contrail.api.types.VirtualMachineInterface;
import net.juniper.contrail.api.types.VirtualNetwork;
import org.apache.commons.lang.StringUtils;
import org.apache.log4j.Logger;
import org.springframework.stereotype.Component;
import org.apache.cloudstack.network.contrail.model.FloatingIpModel;
import org.apache.cloudstack.network.contrail.model.FloatingIpPoolModel;
import org.apache.cloudstack.network.contrail.model.NetworkPolicyModel;
import org.apache.cloudstack.network.contrail.model.ServiceInstanceModel;
import org.apache.cloudstack.network.contrail.model.VMInterfaceModel;
import org.apache.cloudstack.network.contrail.model.VirtualMachineModel;
import org.apache.cloudstack.network.contrail.model.VirtualNetworkModel;
import com.cloud.dc.dao.VlanDao;
import com.cloud.domain.DomainVO;
import com.cloud.domain.dao.DomainDao;
import com.cloud.exception.InternalErrorException;
import com.cloud.network.IpAddress;
import com.cloud.network.Networks.TrafficType;
import com.cloud.network.addr.PublicIp;
import com.cloud.network.dao.IPAddressVO;
import com.cloud.network.dao.NetworkDao;
import com.cloud.network.dao.NetworkVO;
import com.cloud.network.dao.PhysicalNetworkDao;
import com.cloud.network.dao.PhysicalNetworkServiceProviderDao;
import com.cloud.network.vpc.NetworkACLItemDao;
import com.cloud.network.vpc.NetworkACLItemVO;
import com.cloud.network.vpc.NetworkACLVO;
import com.cloud.network.vpc.dao.NetworkACLDao;
import com.cloud.network.vpc.VpcVO;
import com.cloud.network.vpc.dao.VpcDao;
import com.cloud.projects.ProjectVO;
import com.cloud.projects.dao.ProjectDao;
import com.cloud.vm.NicVO;
import com.cloud.vm.VMInstanceVO;
import com.cloud.vm.dao.NicDao;
import com.cloud.vm.dao.VMInstanceDao;
@Component
public class ServerDBSyncImpl implements ServerDBSync {
@Inject
DomainDao _domainDao;
@Inject
ProjectDao _projectDao;
@Inject
NetworkDao _networksDao;
@Inject
VMInstanceDao _vmInstanceDao;
@Inject
NicDao _nicDao;
@Inject
VlanDao _vlanDao;
@Inject
PhysicalNetworkDao _physicalNetworkDao;
@Inject
PhysicalNetworkServiceProviderDao _physProviderDao;
@Inject
ContrailManager _manager;
@Inject
VpcDao _vpcDao;
@Inject
NetworkACLItemDao _networkACLItemDao;
@Inject
NetworkACLDao _networkACLDao;
DBSyncGeneric _dbSync;
Class<?>[] _vncClasses;
// Read-Write (true) or Read-Only mode.
boolean _rwMode;
private final ReentrantLock _lockSyncMode = new ReentrantLock();
ServerDBSyncImpl() {
_vncClasses =
new Class[] {net.juniper.contrail.api.types.Domain.class, net.juniper.contrail.api.types.Project.class, NetworkPolicy.class, VirtualNetwork.class,
VirtualMachine.class, ServiceInstance.class, FloatingIp.class};
_dbSync = new DBSyncGeneric(this);
}
private static final Logger s_logger = Logger.getLogger(ServerDBSync.class);
/*
* API for syncing all classes of vnc objects with cloudstack
*
* Sync cloudstack and vnc objects.
* Order has to be maintained
*/
@Override
public short syncAll(short syncMode) {
short syncState = SYNC_STATE_IN_SYNC;
/* vnc classes need to be synchronized with cloudstack */
s_logger.debug("syncing cloudstack db with vnc");
try {
for (Class<?> cls : _vncClasses) {
/* lock the sync mode*/
_lockSyncMode.lock();
_rwMode = syncMode == DBSyncGeneric.SYNC_MODE_UPDATE;
_dbSync.setSyncMode(syncMode);
if (_dbSync.getSyncMode() == DBSyncGeneric.SYNC_MODE_CHECK) {
s_logger.debug("sync check start: " + DBSyncGeneric.getClassName(cls));
} else {
s_logger.debug("sync start: " + DBSyncGeneric.getClassName(cls));
}
if (_dbSync.sync(cls) == false) {
if (_dbSync.getSyncMode() == DBSyncGeneric.SYNC_MODE_CHECK) {
s_logger.info("out of sync detected: " + DBSyncGeneric.getClassName(cls));
} else {
s_logger.info("out of sync detected and re-synced: " + DBSyncGeneric.getClassName(cls));
}
syncState = SYNC_STATE_OUT_OF_SYNC;
}
if (_dbSync.getSyncMode() == DBSyncGeneric.SYNC_MODE_CHECK) {
s_logger.debug("sync check finish: " + DBSyncGeneric.getClassName(cls));
} else {
s_logger.debug("sync finish: " + DBSyncGeneric.getClassName(cls));
}
/* unlock the sync mode */
_lockSyncMode.unlock();
}
} catch (Exception ex) {
s_logger.warn("DB Synchronization", ex);
syncState = SYNC_STATE_UNKNOWN;
if (_lockSyncMode.isLocked()) {
_lockSyncMode.unlock();
}
}
return syncState;
}
@Override
public void syncClass(Class<?> cls) {
s_logger.debug("syncClass: " + cls.getName());
try {
s_logger.debug("sync start: " + DBSyncGeneric.getClassName(cls));
_lockSyncMode.lock();
_dbSync.setSyncMode(DBSyncGeneric.SYNC_MODE_UPDATE);
_dbSync.sync(cls);
_lockSyncMode.unlock();
s_logger.debug("sync finish: " + DBSyncGeneric.getClassName(cls));
} catch (Exception ex) {
s_logger.warn("Sync error: " + cls.getName(), ex);
if (_lockSyncMode.isLocked()) {
_lockSyncMode.unlock();
}
}
}
public <T extends ApiPropertyBase> void deleteChildren(List<ObjectReference<T>> childs, Class<?> childCls, StringBuffer syncLogMesg) throws Exception {
final ApiConnector api = _manager.getApiConnector();
if (childs == null) {
syncLogMesg.append("no children of type: " + childCls.getName() + "\n");
return;
}
syncLogMesg.append("delete children of type : " + DBSyncGeneric.getClassName(childCls) + "\n");
String deleteChildMethod = "delete" + DBSyncGeneric.getClassName(childCls);
Method method = null;
Method methods[] = this.getClass().getMethods();
for (int i = 0; i < methods.length; i++) {
if (methods[i].getName().equalsIgnoreCase(deleteChildMethod)) {
method = methods[i];
break;
}
}
int count = 0;
for (ObjectReference<T> childRef : childs) {
@SuppressWarnings("unchecked")
ApiObjectBase child = api.findById((Class<? extends ApiObjectBase>)childCls, childRef.getUuid());
if (method != null) {
method.invoke(this, child, syncLogMesg);
} else {
deleteDefault(child, childCls, syncLogMesg);
}
count++;
}
syncLogMesg.append("deleted children count : " + count + "\n");
}
public void deleteDefault(ApiObjectBase vnc, Class<?> cls, StringBuffer syncLogMesg) throws IOException {
final ApiConnector api = _manager.getApiConnector();
api.delete(vnc);
syncLogMesg.append(cls.getCanonicalName() + "# VNC: " + vnc.getName() + " deleted\n");
}
/*
* Domain Synchronization methods
*/
public boolean syncDomain() throws Exception {
final ApiConnector api = _manager.getApiConnector();
try {
List<?> dbList = _domainDao.listAll();
@SuppressWarnings("unchecked")
List<?> vncList = api.list(net.juniper.contrail.api.types.Domain.class, null);
return _dbSync.syncGeneric(net.juniper.contrail.api.types.Domain.class, dbList, vncList);
} catch (Exception ex) {
s_logger.warn("syncDomain", ex);
throw ex;
}
}
@Override
public void createDomain(DomainVO db, StringBuffer syncLogMesg) throws IOException {
final ApiConnector api = _manager.getApiConnector();
net.juniper.contrail.api.types.Domain vnc = new net.juniper.contrail.api.types.Domain();
vnc.setName(db.getName());
vnc.setUuid(db.getUuid());
if (!api.create(vnc)) {
s_logger.error("Unable to create domain " + vnc.getName());
syncLogMesg.append("Error: Virtual domain# VNC : Unable to create domain: " + vnc.getName() + "\n");
return;
}
syncLogMesg.append("Domain# VNC: " + vnc.getName() + " created \n");
}
public void deleteDomain(net.juniper.contrail.api.types.Domain vnc, StringBuffer syncLogMesg) throws IOException {
final ApiConnector api = _manager.getApiConnector();
api.read(vnc);
syncLogMesg.append("Domain# DB: none; VNC: " + vnc.getName() + "(" + vnc.getUuid() + "); action: delete\n");
/* delete all projects under this domain */
try {
deleteChildren(vnc.getProjects(), net.juniper.contrail.api.types.Project.class, syncLogMesg);
} catch (Exception ex) {
s_logger.warn("deleteDomain", ex);
}
api.delete(vnc);
syncLogMesg.append("Domain# VNC: " + vnc.getName() + " deleted\n");
}
public Integer compareDomain(DomainVO db, net.juniper.contrail.api.types.Domain vnc, StringBuffer syncLogMesg) {
if (_manager.isSystemRootDomain(db) && _manager.isSystemRootDomain(vnc)) {
return _manager.getDomainCanonicalName(db).compareTo(vnc.getName());
} else if (_manager.isSystemRootDomain(db)) {
return -1;
} else if (_manager.isSystemRootDomain(vnc)) {
return 1;
}
return db.getUuid().compareTo(vnc.getUuid());
}
public Boolean filterDomain(net.juniper.contrail.api.types.Domain vnc, StringBuffer syncLogMesg) {
if (_manager.isSystemRootDomain(vnc)) {
return true;
}
return false;
}
public Boolean equalDomain(DomainVO db, net.juniper.contrail.api.types.Domain vnc, StringBuffer syncLogMesg) {
syncLogMesg.append("Domain# DB: " + db.getName() + "; VNC: " + vnc.getName() + "; action: equal, no action\n");
return true;
}
public Comparator<?> dbComparatorDomain() {
Comparator<?> comparator = new Comparator<DomainVO>() {
@Override
public int compare(DomainVO u1, DomainVO u2) {
if (_manager.isSystemRootDomain(u1)) {
return -1;
}
if (_manager.isSystemRootDomain(u2)) {
return 1;
}
return u1.getUuid().compareTo(u2.getUuid());
}
};
return comparator;
}
public Comparator<?> vncComparatorDomain() {
Comparator<?> comparator = new Comparator<net.juniper.contrail.api.types.Domain>() {
@Override
public int compare(net.juniper.contrail.api.types.Domain u1, net.juniper.contrail.api.types.Domain u2) {
if (_manager.isSystemRootDomain(u1)) {
return -1;
}
if (_manager.isSystemRootDomain(u2)) {
return 1;
}
return u1.getUuid().compareTo(u2.getUuid());
}
};
return comparator;
}
/*
* Project Synchronization methods
*/
@SuppressWarnings("unchecked")
public boolean syncProject() throws Exception {
final ApiConnector api = _manager.getApiConnector();
try {
List<?> dbList = _projectDao.listAll();
List<?> vncList = api.list(net.juniper.contrail.api.types.Project.class, null);
return _dbSync.syncGeneric(net.juniper.contrail.api.types.Project.class, dbList, vncList);
} catch (Exception ex) {
s_logger.warn("syncProject", ex);
throw ex;
}
}
@Override
public void createProject(ProjectVO db, StringBuffer syncLogMesg) throws IOException {
final ApiConnector api = _manager.getApiConnector();
net.juniper.contrail.api.types.Project vnc = new net.juniper.contrail.api.types.Project();
vnc.setName(db.getName());
vnc.setUuid(db.getUuid());
if (!api.create(vnc)) {
s_logger.error("Unable to create project: " + vnc.getName());
syncLogMesg.append("Error: Virtual project# VNC : Unable to create project: " + vnc.getName() + "\n");
return;
}
syncLogMesg.append("Project# VNC: " + vnc.getName() + " created \n");
}
public void deleteProject(net.juniper.contrail.api.types.Project vnc, StringBuffer syncLogMesg) throws IOException {
final ApiConnector api = _manager.getApiConnector();
api.read(vnc);
syncLogMesg.append("Project# DB: none; VNC: " + vnc.getName() + "(" + vnc.getUuid() + "); action: delete\n");
try {
deleteChildren(vnc.getVirtualNetworks(), VirtualNetwork.class, syncLogMesg);
deleteChildren(vnc.getSecurityGroups(), net.juniper.contrail.api.types.SecurityGroup.class, syncLogMesg);
deleteChildren(vnc.getNetworkIpams(), net.juniper.contrail.api.types.NetworkIpam.class, syncLogMesg);
deleteChildren(vnc.getNetworkPolicys(), net.juniper.contrail.api.types.NetworkPolicy.class, syncLogMesg);
} catch (Exception ex) {
s_logger.warn("deleteProject", ex);
}
api.delete(vnc);
syncLogMesg.append("Project# VNC: " + vnc.getName() + " deleted\n");
}
public Integer compareProject(ProjectVO db, net.juniper.contrail.api.types.Project vnc, StringBuffer syncLogMesg) {
if (_manager.isSystemDefaultProject(db) && _manager.isSystemDefaultProject(vnc)) {
return _manager.getProjectCanonicalName(db).compareTo(vnc.getName());
} else if (_manager.isSystemDefaultProject(db)) {
return -1;
} else if (_manager.isSystemDefaultProject(vnc)) {
return 1;
}
return db.getUuid().compareTo(vnc.getUuid());
}
public Boolean filterProject(net.juniper.contrail.api.types.Project vnc, StringBuffer syncLogMesg) {
if (_manager.isSystemDefaultProject(vnc)) {
syncLogMesg.append("VNC: " + vnc.getName() + " filtered; action: don't delete\n");
return true;
}
return false;
}
public Boolean equalProject(ProjectVO db, net.juniper.contrail.api.types.Project vnc, StringBuffer syncLogMesg) {
syncLogMesg.append("Project# DB: " + db.getName() + "; VNC: " + vnc.getName() + "; action: equal, no action\n");
return true;
}
public Comparator<?> dbComparatorProject() {
Comparator<?> comparator = new Comparator<ProjectVO>() {
@Override
public int compare(ProjectVO u1, ProjectVO u2) {
if (_manager.isSystemDefaultProject(u1)) {
return -1;
}
if (_manager.isSystemDefaultProject(u2)) {
return 1;
}
return u1.getUuid().compareTo(u2.getUuid());
}
};
return comparator;
}
public Comparator<?> vncComparatorProject() {
Comparator<?> comparator = new Comparator<net.juniper.contrail.api.types.Project>() {
@Override
public int compare(net.juniper.contrail.api.types.Project u1, net.juniper.contrail.api.types.Project u2) {
if (_manager.isSystemDefaultProject(u1)) {
return -1;
}
if (_manager.isSystemDefaultProject(u2)) {
return 1;
}
return u1.getUuid().compareTo(u2.getUuid());
}
};
return comparator;
}
/*
* Security Groups
*/
public void deleteSecurityGroup(net.juniper.contrail.api.types.SecurityGroup vnc, StringBuffer syncLogMesg) throws IOException {
final ApiConnector api = _manager.getApiConnector();
api.delete(vnc);
syncLogMesg.append("SecurityGroup# VNC: " + vnc.getName() + " deleted\n");
}
/*
* Virtual Network Synchronization methods
*/
@SuppressWarnings({"unchecked"})
public boolean syncVirtualNetwork() throws Exception {
final ApiConnector api = _manager.getApiConnector();
try {
List<TrafficType> types = new ArrayList<TrafficType>();
types.add(TrafficType.Public);
types.add(TrafficType.Guest);
List<NetworkVO> dbNets = _manager.findManagedNetworks(types);
List<VirtualNetwork> vList = (List<VirtualNetwork>)api.list(VirtualNetwork.class, null);
List<VirtualNetwork> vncList = new ArrayList<VirtualNetwork>();
for (VirtualNetwork vn : vList) {
if (!_manager.isSystemDefaultNetwork(vn)) {
vncList.add(vn);
}
}
s_logger.debug("sync VN - DB size: " + dbNets.size() + " VNC Size: " + vncList.size());
return _dbSync.syncGeneric(VirtualNetwork.class, dbNets, vncList);
} catch (Exception ex) {
s_logger.warn("sync virtual-networks", ex);
throw ex;
}
}
public Comparator<NetworkVO> dbComparatorVirtualNetwork() {
Comparator<NetworkVO> comparator = new Comparator<NetworkVO>() {
@Override
public int compare(NetworkVO u1, NetworkVO u2) {
if (_manager.isSystemDefaultNetwork(u1) && _manager.isSystemDefaultNetwork(u2)) {
return _manager.getCanonicalName(u1).compareTo(_manager.getCanonicalName(u2));
} else if (_manager.isSystemDefaultNetwork(u1)) {
return -1;
} else if (_manager.isSystemDefaultNetwork(u2)) {
return 1;
}
return u1.getUuid().compareTo(u2.getUuid());
}
};
return comparator;
}
public Comparator<?> vncComparatorVirtualNetwork() {
Comparator<?> comparator = new Comparator<VirtualNetwork>() {
@Override
public int compare(VirtualNetwork u1, VirtualNetwork u2) {
if (_manager.isSystemDefaultNetwork(u1) && _manager.isSystemDefaultNetwork(u2)) {
return u1.getName().compareTo(u2.getName());
} else if (_manager.isSystemDefaultNetwork(u1)) {
return -1;
} else if (_manager.isSystemDefaultNetwork(u2)) {
return 1;
}
return u1.getUuid().compareTo(u2.getUuid());
}
};
return comparator;
}
public void createVirtualNetwork(NetworkVO dbNet, StringBuffer syncLogMesg) throws IOException {
syncLogMesg.append("VN# DB: " + _manager.getCanonicalName(dbNet) + "(" + dbNet.getUuid() + "); VNC: none; action: create\n");
if (_manager.getDatabase().lookupVirtualNetwork(dbNet.getUuid(), _manager.getCanonicalName(dbNet), dbNet.getTrafficType()) != null) {
s_logger.warn("VN model object is already present in DB: " + dbNet.getUuid() + ", name: " + dbNet.getName());
}
VirtualNetworkModel vnModel = new VirtualNetworkModel(dbNet, dbNet.getUuid(), _manager.getCanonicalName(dbNet), dbNet.getTrafficType());
if (dbNet.getTrafficType() == TrafficType.Guest && dbNet.getNetworkACLId() != null) {
NetworkACLVO acl = _networkACLDao.findById(dbNet.getNetworkACLId());
NetworkPolicyModel policyModel = _manager.getDatabase().lookupNetworkPolicy(acl.getUuid());
if (policyModel == null) {
s_logger.error("Network(" + dbNet.getName() + ") has ACL but policy model not created: " +
acl.getUuid() + ", name: " + acl.getName());
} else {
vnModel.addToNetworkPolicy(policyModel);
}
}
vnModel.build(_manager.getModelController(), dbNet);
if (_rwMode) {
try {
if (!vnModel.verify(_manager.getModelController())) {
vnModel.update(_manager.getModelController());
}
} catch (InternalErrorException ex) {
s_logger.warn("create virtual-network", ex);
syncLogMesg.append("Error: VN# VNC : Unable to create network " + dbNet.getName() + "\n");
return;
}
s_logger.debug("add model " + vnModel.getName());
_manager.getDatabase().getVirtualNetworks().add(vnModel);
syncLogMesg.append("VN# VNC: " + dbNet.getUuid() + ", " + vnModel.getName() + " created\n");
} else {
syncLogMesg.append("VN# VNC: " + vnModel.getName() + " created \n");
}
}
public void deleteVirtualNetwork(VirtualNetwork vnet, StringBuffer syncLogMesg) throws IOException {
final ApiConnector api = _manager.getApiConnector();
if (_manager.isSystemDefaultNetwork(vnet)) {
syncLogMesg.append("VN# System default virtual Network# VNC: " + vnet.getName() + " can not be deleted\n");
return;
}
api.read(vnet);
deleteInstanceIps(vnet.getInstanceIpBackRefs(), syncLogMesg);
List<ObjectReference<ApiPropertyBase>> fipPools = vnet.getFloatingIpPools();
if (fipPools != null && !fipPools.isEmpty()) {
FloatingIpPool floatingIpPool = (FloatingIpPool)api.findById(FloatingIpPool.class, fipPools.get(0).getUuid());
if (floatingIpPool != null) {
deleteFloatingIps(floatingIpPool.getFloatingIps(), syncLogMesg);
}
}
deleteVirtualMachineInterfaces(vnet.getVirtualMachineInterfaceBackRefs(), syncLogMesg);
syncLogMesg.append("VN# DB: none; VNC: " + vnet.getName() + "(" + vnet.getUuid() + "); action: delete\n");
api.delete(vnet);
syncLogMesg.append("VN# VNC: " + vnet.getName() + " deleted\n");
}
public Integer compareVirtualNetwork(NetworkVO dbn, VirtualNetwork vnet, StringBuffer syncLogMesg) {
if (_manager.isSystemDefaultNetwork(dbn) && _manager.isSystemDefaultNetwork(vnet)) {
return _manager.getCanonicalName(dbn).compareTo(vnet.getName());
} else if (_manager.isSystemDefaultNetwork(dbn)) {
return -1;
} else if (_manager.isSystemDefaultNetwork(vnet)) {
return 1;
}
return dbn.getUuid().compareTo(vnet.getUuid());
}
public Boolean filterVirtualNetwork(VirtualNetwork vnet, StringBuffer syncLogMesg) {
if (_manager.isSystemDefaultNetwork(vnet)) {
syncLogMesg.append("VN# VNC: " + vnet.getName() + " filtered; action: don't delete\n");
return true;
}
return false;
}
public Boolean equalVirtualNetwork(NetworkVO dbn, VirtualNetwork vnet, StringBuffer syncLogMesg) {
syncLogMesg.append("VN# DB: " + _manager.getCanonicalName(dbn) + "; VNC: " + vnet.getName() + "; action: equal\n");
VirtualNetworkModel current = _manager.getDatabase().lookupVirtualNetwork(vnet.getUuid(), _manager.getCanonicalName(dbn), dbn.getTrafficType());
VirtualNetworkModel vnModel = new VirtualNetworkModel(dbn, vnet.getUuid(), _manager.getCanonicalName(dbn), dbn.getTrafficType());
if (dbn.getTrafficType() == TrafficType.Guest && dbn.getNetworkACLId() != null) {
NetworkACLVO acl = _networkACLDao.findById(dbn.getNetworkACLId());
NetworkPolicyModel policyModel = _manager.getDatabase().lookupNetworkPolicy(acl.getUuid());
if (policyModel == null) {
s_logger.error("Network(" + dbn.getName() + ") has ACL but policy model not created: " +
acl.getUuid() + ", name: " + acl.getName());
} else {
vnModel.addToNetworkPolicy(policyModel);
}
}
vnModel.build(_manager.getModelController(), dbn);
if (_rwMode) {
if (current != null) {
FloatingIpPoolModel fipPoolModel = current.getFipPoolModel();
if (fipPoolModel != null) {
vnModel.setFipPoolModel(fipPoolModel);
fipPoolModel.addToVirtualNetwork(vnModel);
}
_manager.getDatabase().getVirtualNetworks().remove(current);
}
s_logger.debug("add model " + vnModel.getName());
_manager.getDatabase().getVirtualNetworks().add(vnModel);
try {
if (!vnModel.verify(_manager.getModelController())) {
vnModel.update(_manager.getModelController());
}
} catch (Exception ex) {
s_logger.warn("update virtual-network", ex);
}
if (current != null) {
NetworkPolicyModel oldPolicyModel = current.getNetworkPolicyModel();
if (oldPolicyModel != vnModel.getNetworkPolicyModel()) {
/*
* if no other VNs are associated with the old policy,
* we could delete it from the Contrail VNC
*/
if (oldPolicyModel != null && !oldPolicyModel.hasDescendents()) {
try {
oldPolicyModel.delete(_manager.getModelController());
_manager.getDatabase().getNetworkPolicys().remove(oldPolicyModel);
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
} else {
//compare
if (current != null && current.compare(_manager.getModelController(), vnModel) == false) {
syncLogMesg.append("VN# DB: " + _manager.getCanonicalName(dbn) + "; VNC: " + vnet.getName() + "; attributes differ\n");
return false;
}
}
return true;
}
/*
* Virtual Machine Synchronization methods
*/
public boolean syncVirtualMachine() {
final ApiConnector api = _manager.getApiConnector();
try {
List<VMInstanceVO> vmDbList = _vmInstanceDao.listAll();
@SuppressWarnings("unchecked")
List<VirtualMachine> vncVmList = (List<VirtualMachine>)api.list(VirtualMachine.class, null);
s_logger.debug("sync VM: CS size: " + vmDbList.size() + " VNC size: " + vncVmList.size());
return _dbSync.syncGeneric(VirtualMachine.class, vmDbList, vncVmList);
} catch (Exception ex) {
s_logger.warn("sync virtual-machines", ex);
}
return false;
}
public Comparator<?> dbComparatorVirtualMachine() {
Comparator<?> comparator = new Comparator<VMInstanceVO>() {
@Override
public int compare(VMInstanceVO u1, VMInstanceVO u2) {
return u1.getUuid().compareTo(u2.getUuid());
}
};
return comparator;
}
public Comparator<?> vncComparatorVirtualMachine() {
Comparator<?> comparator = new Comparator<VirtualMachine>() {
@Override
public int compare(VirtualMachine u1, VirtualMachine u2) {
return u1.getUuid().compareTo(u2.getUuid());
}
};
return comparator;
}
public void createVirtualMachine(VMInstanceVO dbVm, StringBuffer syncLogMesg) throws IOException {
syncLogMesg.append("VM# DB: " + dbVm.getInstanceName() + "/" + dbVm.getUuid() + "; VNC: none; action: create\n");
VirtualMachineModel vmModel = new VirtualMachineModel(dbVm, dbVm.getUuid());
vmModel.build(_manager.getModelController(), dbVm);
buildNicResources(vmModel, dbVm, syncLogMesg);
if (_rwMode) {
try {
vmModel.update(_manager.getModelController());
} catch (InternalErrorException ex) {
s_logger.warn("create virtual-machine", ex);
return;
}
_manager.getDatabase().getVirtualMachines().add(vmModel);
syncLogMesg.append("VM# VNC: " + dbVm.getUuid() + " created\n");
}
}
private void deleteVirtualMachineInterfaces(List<ObjectReference<ApiPropertyBase>> list, StringBuffer syncLogMesg) throws IOException {
if (list == null) {
return;
}
final ApiConnector api = _manager.getApiConnector();
for (ObjectReference<ApiPropertyBase> vmiRef : list) {
VirtualMachineInterface vmi = (VirtualMachineInterface)api.findById(VirtualMachineInterface.class, vmiRef.getUuid());
deleteInstanceIps(vmi.getInstanceIpBackRefs(), syncLogMesg);
deleteFloatingIps(vmi.getFloatingIpBackRefs(), syncLogMesg);
api.delete(VirtualMachineInterface.class, vmiRef.getUuid());
syncLogMesg.append("VNC vmi: " + vmi.getUuid() + " deleted\n");
}
}
private void deleteInstanceIps(List<ObjectReference<ApiPropertyBase>> list, StringBuffer syncLogMesg) throws IOException {
if (list == null) {
return;
}
final ApiConnector api = _manager.getApiConnector();
for (ObjectReference<ApiPropertyBase> instIp : list) {
api.delete(InstanceIp.class, instIp.getUuid());
syncLogMesg.append("VNC instance ip: " + instIp.getUuid() + " deleted\n");
}
}
private void deleteFloatingIps(List<ObjectReference<ApiPropertyBase>> list, StringBuffer syncLogMesg) throws IOException {
if (list == null) {
return;
}
final ApiConnector api = _manager.getApiConnector();
for (ObjectReference<?> floatingIp : list) {
api.delete(FloatingIp.class, floatingIp.getUuid());
syncLogMesg.append("VNC instance ip: " + floatingIp.getUuid() + " deleted\n");
}
}
public void deleteVirtualMachine(VirtualMachine vncVm, StringBuffer syncLogMesg) {
final ApiConnector api = _manager.getApiConnector();
syncLogMesg.append("VM# DB:none; VNC: " + vncVm.getName() + "/" + vncVm.getUuid() + "; action: delete\n");
if (!_rwMode) {
return;
}
try {
if (!api.read(vncVm)) {
return;
}
deleteVirtualMachineInterfaces(vncVm.getVirtualMachineInterfaces(), syncLogMesg);
api.delete(VirtualMachine.class, vncVm.getUuid());
} catch (IOException ex) {
s_logger.warn("delete virtual-machine", ex);
return;
}
syncLogMesg.append("VM# VNC: " + vncVm.getName() + " deleted\n");
}
public Integer compareVirtualMachine(VMInstanceVO dbVm, VirtualMachine vncVm, StringBuffer syncLogMesg) {
String dbVmId = dbVm.getUuid();
String vncVmId = vncVm.getUuid();
return dbVmId.compareTo(vncVmId);
}
public boolean filterVirtualMachine(VirtualMachine vncVm, StringBuffer syncLogMesg) {
return false;
}
private void buildNicResources(VirtualMachineModel vmModel, VMInstanceVO dbVm, StringBuffer syncLogMsg) throws IOException {
List<NicVO> nics = _nicDao.listByVmId(dbVm.getId());
for (NicVO nic : nics) {
VMInterfaceModel vmiModel = vmModel.getVMInterface(nic.getUuid());
if (vmiModel == null) {
vmiModel = new VMInterfaceModel(nic.getUuid());
NetworkVO network = _networksDao.findById(nic.getNetworkId());
VirtualNetworkModel vnModel =
_manager.getDatabase().lookupVirtualNetwork(network.getUuid(), _manager.getCanonicalName(network), network.getTrafficType());
if (vnModel == null) {
s_logger.warn("Unable to locate virtual-network for network id " + network.getId());
continue;
}
vmiModel.addToVirtualMachine(vmModel);
vmiModel.addToVirtualNetwork(vnModel);
}
vmiModel.build(_manager.getModelController(), dbVm, nic);
}
}
public Boolean equalVirtualMachine(VMInstanceVO dbVm, VirtualMachine vncVm, StringBuffer syncLogMsg) {
syncLogMsg.append("VM# DB: " + dbVm.getInstanceName() + "/" + dbVm.getUuid() + "; VNC: " + vncVm.getUuid() + "; action: equal; DB VM State: " + dbVm.getState() +
"\n");
VirtualMachineModel vmModel = new VirtualMachineModel(dbVm, dbVm.getUuid());
vmModel.build(_manager.getModelController(), dbVm);
if (vmModel.isActive()) {
try {
buildNicResources(vmModel, dbVm, syncLogMsg);
} catch (IOException ex) {
s_logger.warn("build nic information for " + dbVm.getInstanceName(), ex);
}
}
VirtualMachineModel current = _manager.getDatabase().lookupVirtualMachine(vncVm.getUuid());
if (_rwMode) {
if (current != null) {
_manager.getDatabase().getVirtualMachines().remove(current);
}
_manager.getDatabase().getVirtualMachines().add(vmModel);
try {
vmModel.update(_manager.getModelController());
} catch (Exception ex) {
s_logger.warn("update virtual-machine", ex);
}
} else {
//compare
if (current != null && current.compare(_manager.getModelController(), vmModel) == false) {
syncLogMsg.append("VM # DB: " + dbVm.getInstanceName() + "; VNC: " + vncVm.getName() + "; attributes differ\n");
return false;
}
}
return true;
}
public boolean syncFloatingIp() throws Exception {
List<IPAddressVO> ipList = _manager.findManagedPublicIps();
List<FloatingIp> vncList = _manager.getFloatingIps();
if (ipList == null) {
ipList = new ArrayList<IPAddressVO>();
}
if (vncList == null) {
vncList = new ArrayList<FloatingIp>();
}
boolean status = false;
try {
status = _dbSync.syncGeneric(FloatingIp.class, ipList, vncList);
} catch (Exception ex) {
s_logger.warn("sync floating-ips", ex);
throw ex;
}
return status;
}
public Comparator<?> dbComparatorFloatingIp() {
Comparator<?> comparator = new Comparator<IpAddress>() {
@Override
public int compare(IpAddress u1, IpAddress u2) {
return u1.getUuid().compareTo(u2.getUuid());
}
};
return comparator;
}
public Comparator<?> vncComparatorFloatingIp() {
Comparator<?> comparator = new Comparator<FloatingIp>() {
@Override
public int compare(FloatingIp u1, FloatingIp u2) {
return u1.getUuid().compareTo(u2.getUuid());
}
};
return comparator;
}
public Integer compareFloatingIp(IpAddress db, FloatingIp vnc, StringBuffer syncLogMesg) {
String dbId = db.getUuid();
String vncId = vnc.getUuid();
return dbId.compareTo(vncId);
}
public void createFloatingIp(IPAddressVO dbIp, StringBuffer syncLogMesg) throws Exception {
if (dbIp.getState() == IpAddress.State.Releasing) {
/* Don't need to push releasing ip */
syncLogMesg.append("fip# DB: " + dbIp.getUuid() + ", state releasing, don't create in vnc\n");
return;
}
syncLogMesg.append("fip# DB: " + dbIp.getAddress().addr() + "; VNC: none; action: create\n");
if (!_manager.createFloatingIp(PublicIp.createFromAddrAndVlan(dbIp, _vlanDao.findById(dbIp.getVlanId())))) {
syncLogMesg.append("fip# VNC: " + dbIp.getAddress().addr() + " unable to create\n");
return;
}
syncLogMesg.append("fip# VNC: " + dbIp.getUuid() + " created\n");
}
public void deleteFloatingIp(FloatingIp vnc, StringBuffer syncLogMesg) throws IOException {
final ApiConnector api = _manager.getApiConnector();
syncLogMesg.append("fip# DB: none; VNC: " + vnc.getAddress() + "(" + vnc.getUuid() + "); action: delete\n");
api.delete(vnc);
syncLogMesg.append("fip# VNC: " + vnc.getUuid() + " deleted\n");
}
public Boolean equalFloatingIp(IPAddressVO db, FloatingIp vnc, StringBuffer syncLogMsg) throws IOException {
syncLogMsg.append("fip# DB: " + db.getAddress().addr() + "; VNC: " + vnc.getAddress() + "; action: equal" + "\n");
VirtualNetworkModel vnModel = _manager.lookupPublicNetworkModel();
assert vnModel != null : "public network vn model is null";
FloatingIpPoolModel fipPoolModel = vnModel.getFipPoolModel();
if (fipPoolModel == null) {
fipPoolModel = new FloatingIpPoolModel();
fipPoolModel.addToVirtualNetwork(vnModel);
fipPoolModel.build(_manager.getModelController());
try {
fipPoolModel.update(_manager.getModelController());
vnModel.setFipPoolModel(fipPoolModel);
} catch (Exception ex) {
s_logger.warn("floating-ip-pool create: ", ex);
return false;
}
}
FloatingIpModel current = fipPoolModel.getFloatingIpModel(db.getUuid());
if (current == null) {
s_logger.debug("add model " + db.getAddress().addr());
FloatingIpModel fipModel = new FloatingIpModel(db.getUuid());
fipModel.addToFloatingIpPool(fipPoolModel);
fipModel.build(_manager.getModelController(), PublicIp.createFromAddrAndVlan(db, _vlanDao.findById(db.getVlanId())));
try {
fipModel.update(_manager.getModelController());
} catch (Exception ex) {
s_logger.warn("floating-ip create: ", ex);
return false;
}
}
return true;
}
/*
* Network Policy Synchronization methods
*/
@SuppressWarnings({ "unchecked" })
public boolean syncNetworkPolicy() throws Exception {
final ApiConnector api = _manager.getApiConnector();
try {
List<NetworkACLVO> dbAcls = _manager.findManagedACLs();
if (dbAcls == null) {
dbAcls = new ArrayList<NetworkACLVO>();
}
List<NetworkPolicy> pList = (List<NetworkPolicy>) api.list(NetworkPolicy.class, null);
List<NetworkPolicy> vncList = new ArrayList<NetworkPolicy>();
for (NetworkPolicy policy:pList) {
if (!_manager.isSystemDefaultNetworkPolicy(policy)) {
vncList.add(policy);
}
}
s_logger.debug("sync Network Policy - DB size: " + dbAcls.size() + " VNC Size: " + vncList.size());
return _dbSync.syncGeneric(NetworkPolicy.class, dbAcls, vncList);
} catch (Exception ex) {
s_logger.warn("sync network-policys", ex);
throw ex;
}
}
public Comparator<NetworkACLVO> dbComparatorNetworkPolicy() {
Comparator<NetworkACLVO> comparator = new Comparator<NetworkACLVO>() {
public int compare(NetworkACLVO u1, NetworkACLVO u2) {
return u1.getUuid().compareTo(u2.getUuid());
}
};
return comparator;
}
public Comparator<?> vncComparatorNetworkPolicy() {
Comparator<?> comparator = new Comparator<NetworkPolicy>() {
public int compare(NetworkPolicy u1, NetworkPolicy u2) {
return u1.getUuid().compareTo(u2.getUuid());
}
};
return comparator;
}
public void createNetworkPolicy(NetworkACLVO db, StringBuffer syncLogMesg) throws IOException {
syncLogMesg.append("Policy# DB: " + db.getName() +
"(" + db.getUuid() + "); VNC: none; action: create\n");
if (_manager.getDatabase().lookupNetworkPolicy(db.getUuid()) != null) {
s_logger.warn("Policy model object is already present in DB: " +
db.getUuid() + ", name: " + db.getName());
}
NetworkPolicyModel policyModel = new NetworkPolicyModel(db.getUuid(), db.getName());
net.juniper.contrail.api.types.Project project = null;
try {
VpcVO vpc = _vpcDao.findById(db.getVpcId());
if (vpc != null) {
project = _manager.getVncProject(vpc.getDomainId(), vpc.getAccountId());
} else {
project = _manager.getDefaultVncProject();
}
} catch (IOException ex) {
s_logger.warn("read project", ex);
throw ex;
}
policyModel.setProject(project);
List<NetworkACLItemVO> rules = _networkACLItemDao.listByACL(db.getId());
try {
policyModel.build(_manager.getModelController(), rules);
} catch (Exception e) {
e.printStackTrace();
}
if (_rwMode) {
try {
if (!policyModel.verify(_manager.getModelController())) {
policyModel.update(_manager.getModelController());
}
} catch (Exception ex) {
s_logger.warn("create network-policy", ex);
syncLogMesg.append("Error: Policy# VNC : Unable to create network policy " +
db.getName() + "\n");
return;
}
s_logger.debug("add model " + policyModel.getName());
_manager.getDatabase().getNetworkPolicys().add(policyModel);
syncLogMesg.append("Policy# VNC: " + db.getUuid() + ", " + policyModel.getName() + " created\n");
} else {
syncLogMesg.append("Policy# VNC: " + policyModel.getName() + " created \n");
}
}
public void deleteNetworkPolicy(NetworkPolicy policy, StringBuffer syncLogMesg) throws IOException {
final ApiConnector api = _manager.getApiConnector();
if (_manager.isSystemDefaultNetworkPolicy(policy)) {
syncLogMesg.append("Policy# System default Network Policy# VNC: " + policy.getName() + " can not be deleted\n");
return;
}
syncLogMesg.append("Policy# DB: none; VNC: " + policy.getName() + "(" + policy.getUuid() + "); action: delete\n");
api.delete(policy);
syncLogMesg.append("Policy# VNC: " + policy.getName() + " deleted\n");
}
public Integer compareNetworkPolicy(NetworkACLVO dbn, NetworkPolicy policy, StringBuffer syncLogMesg) {
if (_manager.isSystemDefaultNetworkPolicy(policy)) {
return 1;
}
return dbn.getUuid().compareTo(policy.getUuid());
}
public Boolean filterNetworkPolicy(NetworkPolicy policy, StringBuffer syncLogMesg) {
if (_manager.isSystemDefaultNetworkPolicy(policy)) {
syncLogMesg.append("Policy# VNC: " + policy.getName() + " filtered; action: don't delete\n");
return true;
}
return false;
}
public Boolean equalNetworkPolicy(NetworkACLVO db, NetworkPolicy policy, StringBuffer syncLogMesg) {
syncLogMesg.append("Policy# DB: " + db.getName() +
"; VNC: " + policy.getName() + "; action: equal\n");
NetworkPolicyModel current = _manager.getDatabase().lookupNetworkPolicy(policy.getUuid());
NetworkPolicyModel policyModel = new NetworkPolicyModel(db.getUuid(), db.getName());
net.juniper.contrail.api.types.Project project = null;
try {
VpcVO vpc = _vpcDao.findById(db.getVpcId());
if (vpc != null) {
project = _manager.getVncProject(vpc.getDomainId(), vpc.getAccountId());
} else {
project = _manager.getDefaultVncProject();
}
} catch (IOException ex) {
s_logger.warn("read project", ex);
}
policyModel.setProject(project);
List<NetworkACLItemVO> rules = _networkACLItemDao.listByACL(db.getId());
try {
policyModel.build(_manager.getModelController(), rules);
} catch (Exception e) {
e.printStackTrace();
}
if (_rwMode) {
if (current != null) {
_manager.getDatabase().getNetworkPolicys().remove(current);
}
s_logger.debug("add policy model " + policyModel.getName());
_manager.getDatabase().getNetworkPolicys().add(policyModel);
try {
if (!policyModel.verify(_manager.getModelController())) {
policyModel.update(_manager.getModelController());
}
} catch (Exception ex) {
s_logger.warn("update network-policy", ex);
}
} else {
//compare
if (current != null && current.compare(_manager.getModelController(), policyModel) == false) {
syncLogMesg.append("Policy# DB: " + db.getName() +
"; VNC: " + policy.getName() + "; attributes differ\n");
return false;
}
}
return true;
}
public Integer compareServiceInstance(ServiceInstanceModel siModel, ServiceInstance siObj, StringBuffer logMsg) {
String fqn = StringUtils.join(siObj.getQualifiedName(), ':');
return siModel.getQualifiedName().compareTo(fqn);
}
/**
* createServiceInstance
*
* This method should never be invoked since the model objects have been installed already when sync is called.
* @param siModel
* @param logMsg
*/
public void createServiceInstance(ServiceInstanceModel siModel, StringBuffer logMsg) {
assert false;
}
public void deleteServiceInstance(ServiceInstance siObj, StringBuffer logMsg) {
final ApiConnector api = _manager.getApiConnector();
s_logger.debug("delete " + siObj.getQualifiedName());
if (!_rwMode) {
return;
}
try {
api.delete(siObj);
} catch (IOException ex) {
s_logger.warn("service-instance delete", ex);
}
}
/**
* equalServiceInstance
*
* @param siModel
* @param siObj
* @param logMsg
*/
public void equalServiceInstance(ServiceInstanceModel siModel, ServiceInstance siObj, StringBuffer logMsg) {
s_logger.debug("equal " + siModel.getQualifiedName());
}
static class ServiceInstanceComparator implements Comparator<ServiceInstance>, Serializable {
@Override
public int compare(ServiceInstance obj1, ServiceInstance obj2) {
String name1 = StringUtils.join(obj1.getQualifiedName(), ':');
String name2 = StringUtils.join(obj2.getQualifiedName(), ':');
return name1.compareTo(name2);
}
}
/**
* The service-instance model list is build as a result of synchronizing virtual-machines.
* @return
*/
public boolean syncServiceInstance() {
final ApiConnector api = _manager.getApiConnector();
boolean inSync;
try {
@SuppressWarnings("unchecked")
List<ServiceInstance> siList = (List<ServiceInstance>)api.list(ServiceInstance.class, null);
java.util.Collections.sort(siList, new ServiceInstanceComparator());
DBSyncGeneric.SyncStats stats = new DBSyncGeneric.SyncStats();
_dbSync.syncCollections(ServiceInstance.class, _manager.getDatabase().getServiceInstances(), siList, _rwMode, stats);
inSync = stats.create == 0 && stats.delete == 0;
} catch (Exception ex) {
s_logger.warn("synchronize service-instances", ex);
return false;
}
return inSync;
}
}