private void verifyExtraDhcpOptionsNetwork(Map<String, Map<Integer, String>> dhcpOptionsMap, List<NetworkVO> networkList) throws InvalidParameterValueException { if (dhcpOptionsMap != null) { for (String networkUuid : dhcpOptionsMap.keySet()) { boolean networkFound = false; for (NetworkVO network : networkList) { if (network.getUuid().equals(networkUuid)) { networkFound = true; break; } } if (!networkFound) { throw new InvalidParameterValueException("VM does not has a nic in the Network (" + networkUuid + ") that is specified in the extra dhcp options."); } } } }
@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()); } };
private void loadVmNetworks(VMEntityVO dbVO) { List<Long> networksIds = _vmNetworkMapDao.getNetworks(dbVO.getId()); List<String> networks = new ArrayList<String>(); for (Long networkId : networksIds) { NetworkVO network = _networkDao.findById(networkId); if (network != null) { networks.add(network.getUuid()); } } dbVO.setNetworkIds(networks); }
public VspDomainCleanUp buildVspDomainCleanUp(Domain domain) { VspDomainCleanUp.Builder vspDomainCleanUpBuilder = new VspDomainCleanUp.Builder().uuid(domain.getUuid()); Map<String, List<String>> sharedNetworkUuids = Maps.newHashMap(); List<NetworkVO> allSharedNetworks = _networkDao.listByGuestType(Network.GuestType.Shared); for (NetworkVO sharedNetwork : allSharedNetworks) { if (_networkModel.isNetworkAvailableInDomain(sharedNetwork.getId(), domain.getId())) { String preConfiguredDomainTemplateName = _nuageVspManager.getPreConfiguredDomainTemplateName(sharedNetwork); if (!sharedNetworkUuids.containsKey(preConfiguredDomainTemplateName)) { sharedNetworkUuids.put(preConfiguredDomainTemplateName, Lists.<String>newArrayList()); } sharedNetworkUuids.get(preConfiguredDomainTemplateName).add(sharedNetwork.getUuid()); } } vspDomainCleanUpBuilder.sharedNetworkUuids(sharedNetworkUuids); return vspDomainCleanUpBuilder.build(); }
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()); }
/** * Swaps the UUID's of the given networks * @param oldNetwork * @param newNetwork */ private void swapUuids(NetworkVO oldNetwork, NetworkVO newNetwork) { String realUuid = oldNetwork.getUuid(); String dummyUuid = newNetwork.getUuid(); oldNetwork.setUuid(dummyUuid.replace("-","+")); newNetwork.setUuid(realUuid); _networksDao.update(oldNetwork.getId(), oldNetwork); _networksDao.update(newNetwork.getId(), newNetwork); oldNetwork.setUuid(dummyUuid); _networksDao.update(oldNetwork.getId(), oldNetwork); }
@Override public VirtualNetworkModel lookupPublicNetworkModel() { List<TrafficType> types = new ArrayList<TrafficType>(); types.add(TrafficType.Public); List<NetworkVO> dbNets = findManagedNetworks(types); if (dbNets == null) { return null; } NetworkVO net = dbNets.get(0); VirtualNetworkModel vnModel = getDatabase().lookupVirtualNetwork(net.getUuid(), getCanonicalName(net), TrafficType.Public); if (vnModel == null) { vnModel = new VirtualNetworkModel(net, net.getUuid(), getCanonicalName(net), net.getTrafficType()); vnModel.setProperties(getModelController(), net); } try { if (!vnModel.verify(getModelController())) { vnModel.update(getModelController()); } getDatabase().getVirtualNetworks().add(vnModel); } catch (Exception ex) { s_logger.warn("virtual-network update: ", ex); } return vnModel; }
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()); syncLogMesg.append("VN# VNC: " + dbNet.getUuid() + ", " + vnModel.getName() + " created\n"); } else { syncLogMesg.append("VN# VNC: " + vnModel.getName() + " created \n");
@Override public void shutdown(NetworkProfile profile, NetworkOffering offering) { NetworkVO networkObject = _networkDao.findById(profile.getId()); if (networkObject.getBroadcastDomainType() != BroadcastDomainType.Vlan || networkObject.getBroadcastUri() == null) { s_logger.warn("BroadcastUri is empty or incorrect for guestnetwork " + networkObject.getDisplayText()); return; } bcfUtilsInit(); // tenantId stored in network domain field at creation String tenantId = networkObject.getNetworkDomain(); String networkId = networkObject.getUuid(); DeleteBcfSegmentCommand cmd = new DeleteBcfSegmentCommand(tenantId, networkId); _bcfUtils.sendBcfCommandWithNetworkSyncCheck(cmd, networkObject); super.shutdown(profile, offering); }
private boolean implement(Long vpcId, long physicalNetworkId, VspNetwork vspNetwork, NetworkVO implemented, VspDhcpDomainOption vspDhcpDomainOption) { HostVO nuageVspHost = _nuageVspManager.getNuageVspHost(physicalNetworkId); final boolean isVsdManaged = vspNetwork.getNetworkRelatedVsdIds() .getVsdSubnetId() .isPresent(); if (isVsdManaged) { //Implement cmd was already send in design step. _dcDetailsDao.persist(implemented.getDataCenterId(), vspNetwork.getNetworkRelatedVsdIds().getVsdSubnetId().orElseThrow(() -> new CloudRuntimeException("Managed but no subnetId. How can this happen?")), implemented.getUuid()); return true; } ImplementNetworkVspCommand cmd = new ImplementNetworkVspCommand(vspNetwork, vspDhcpDomainOption, false); Answer answer = _agentMgr.easySend(nuageVspHost.getId(), cmd); if (answer == null || !answer.getResult()) { s_logger.error("ImplementNetworkVspCommand for network " + vspNetwork.getUuid() + " failed on Nuage VSD " + nuageVspHost.getDetail("hostname")); if ((null != answer) && (null != answer.getDetails())) { s_logger.error(answer.getDetails()); } return false; } ImplementNetworkVspAnswer implementAnswer = (ImplementNetworkVspAnswer) answer; saveNetworkAndVpcDetails(vspNetwork, implementAnswer.getNetworkRelatedVsdIds(), vpcId); return true; }
AccountVO networkOwner = _accountDao.findById(network.getAccountId()); if (networkOwner == null) throw new PermissionDeniedException("Unable to use network with id= " + ((NetworkVO)network).getUuid() + ", network does not have an owner"); if (owner.getType() != Account.ACCOUNT_TYPE_PROJECT && networkOwner.getType() == Account.ACCOUNT_TYPE_PROJECT) { if (!_projectAccountDao.canAccessProjectAccount(owner.getAccountId(), network.getAccountId())) { throw new PermissionDeniedException("Unable to use network with id= " + ((NetworkVO)network).getUuid() + ", permission denied"); List<NetworkVO> networkMap = _networksDao.listBy(owner.getId(), network.getId()); if (networkMap == null || networkMap.isEmpty()) { throw new PermissionDeniedException("Unable to use network with id= " + ((NetworkVO)network).getUuid() + ", permission denied"); throw new CloudRuntimeException("cannot check permission on account " + owner.getAccountName() + " whose domain does not exist"); throw new PermissionDeniedException("Shared network id=" + ((NetworkVO)network).getUuid() + " is not available in domain id=" + ownerDomain.getUuid());
@Override public NicSecondaryIpResponse createSecondaryIPToNicResponse(NicSecondaryIp result) { NicSecondaryIpResponse response = new NicSecondaryIpResponse(); NicVO nic = _entityMgr.findById(NicVO.class, result.getNicId()); NetworkVO network = _entityMgr.findById(NetworkVO.class, result.getNetworkId()); response.setId(result.getUuid()); setResponseIpAddress(result, response); response.setNicId(nic.getUuid()); response.setNwId(network.getUuid()); response.setObjectName("nicsecondaryip"); return response; }
private void vpcTiersCanBeMigrated(List<? extends Network> tiersInVpc, Account account, Map<String, String> networkToOffering, boolean resume) { for (Network network : tiersInVpc) { String networkOfferingUuid = networkToOffering.get(network.getUuid()); //offering uuid can be a tier where the uuid is previously already swapped in a previous migration if (resume && networkOfferingUuid == null) { NetworkVO oldVPCtier = _networksDao.findById(network.getRelated()); networkOfferingUuid = networkToOffering.get(oldVPCtier.getUuid()); } if (networkOfferingUuid == null) { throwInvalidIdException("Failed to migrate VPC as the specified tierNetworkOfferings is not complete", String.valueOf(network.getUuid()), "networkUuid"); } NetworkOfferingVO newNtwkOff = _networkOfferingDao.findByUuid(networkOfferingUuid); if (newNtwkOff == null) { throwInvalidIdException("Failed to migrate VPC as at least one network offering in tierNetworkOfferings does not exist", networkOfferingUuid, "networkOfferingUuid"); } if (!_configMgr.isOfferingForVpc(newNtwkOff)) { throw new InvalidParameterValueException( "Network offering " + newNtwkOff.getName() + " (" + newNtwkOff.getUuid() + ") can't be used for VPC networks for network " + network.getName() + "(" + network.getUuid() + ")"); } verifyNetworkCanBeMigrated(account, network); long newPhysicalNetworkId = findPhysicalNetworkId(network.getDataCenterId(), newNtwkOff.getTags(), newNtwkOff.getTrafficType()); final long oldNetworkOfferingId = network.getNetworkOfferingId(); NetworkOffering oldNtwkOff = _networkOfferingDao.findByIdIncludingRemoved(oldNetworkOfferingId); networkNeedsMigration(network, newPhysicalNetworkId, oldNtwkOff, newNtwkOff); } }
name = ((NetworkVO)network).getUuid();
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); } }
throw new InvalidParameterValueException("Can't find network offering associated with network: " + network.getUuid());
throw new InvalidParameterValueException("Network is not part of a VPC: " + network.getUuid());
@Override @ActionEvent(eventType = EventTypes.EVENT_NETWORK_DELETE, eventDescription = "deleting network", async = true) public boolean deleteNetwork(long networkId, boolean forced) { Account caller = CallContext.current().getCallingAccount(); // Verify network id NetworkVO network = _networksDao.findById(networkId); if (network == null) { // see NetworkVO.java throwInvalidIdException("unable to find network with specified id", String.valueOf(networkId), "networkId"); } // don't allow to delete system network if (isNetworkSystem(network)) { throwInvalidIdException("Network with specified id is system and can't be removed", network.getUuid(), "networkId"); } Account owner = _accountMgr.getAccount(network.getAccountId()); // Only Admin can delete Shared and L2 networks if ((network.getGuestType() == GuestType.Shared || network.getGuestType() == GuestType.L2) && !_accountMgr.isAdmin(caller.getId())) { throw new InvalidParameterValueException("Only Admins can delete network with guest type " + network.getGuestType()); } // Perform permission check _accountMgr.checkAccess(caller, null, true, network); if (forced && !_accountMgr.isRootAdmin(caller.getId())) { throw new InvalidParameterValueException("Delete network with 'forced' option can only be called by root admins"); } User callerUser = _accountMgr.getActiveUser(CallContext.current().getCallingUserId()); ReservationContext context = new ReservationContextImpl(null, null, callerUser, owner); return _networkMgr.destroyNetwork(networkId, context, forced); }
vmiModel.addToVirtualMachine(this); NetworkVO network = networkDao.findById(nic.getNetworkId()); VirtualNetworkModel vnModel = manager.getDatabase().lookupVirtualNetwork(network.getUuid(), manager.getCanonicalName(network), network.getTrafficType()); assert vnModel != null; vmiModel.addToVirtualNetwork(vnModel);
protected NicTO toNicTO(final NicVO nic, final NicProfile profile, final NetworkVO config) { final NicTO to = new NicTO(); to.setDeviceId(nic.getDeviceId()); to.setBroadcastType(config.getBroadcastDomainType()); to.setType(config.getTrafficType()); to.setIp(nic.getIPv4Address()); to.setNetmask(nic.getIPv4Netmask()); to.setMac(nic.getMacAddress()); to.setDns1(profile.getIPv4Dns1()); to.setDns2(profile.getIPv4Dns2()); if (nic.getIPv4Gateway() != null) { to.setGateway(nic.getIPv4Gateway()); } else { to.setGateway(config.getGateway()); } if (nic.getVmType() != VirtualMachine.Type.User) { to.setPxeDisable(true); } to.setDefaultNic(nic.isDefaultNic()); to.setBroadcastUri(nic.getBroadcastUri()); to.setIsolationuri(nic.getIsolationUri()); if (profile != null) { to.setDns1(profile.getIPv4Dns1()); to.setDns2(profile.getIPv4Dns2()); } final Integer networkRate = _networkModel.getNetworkRate(config.getId(), null); to.setNetworkRateMbps(networkRate); to.setUuid(config.getUuid()); return to; }