public List<String> getRequiredNetworkServiceTypes() { List<String> nsTypes = new ArrayList<>(); if (getL3Networks() != null) { for (VmNicSpec nicSpec : getL3Networks()) { for (L3NetworkInventory l3: nicSpec.l3Invs) { nsTypes.addAll(l3.getNetworkServiceTypes()); } } } return nsTypes; }
@Override public void rollback(FlowRollback trigger, Map data) { Iterator<InstantiateResourceOnAttachingNicExtensionPoint> it = pluginRgty.getExtensionList(InstantiateResourceOnAttachingNicExtensionPoint.class).iterator(); VmInstanceSpec spec = (VmInstanceSpec) data.get(VmInstanceConstant.Params.VmInstanceSpec.toString()); L3NetworkInventory l3 = VmNicSpec.getL3NetworkInventoryOfSpec(spec.getL3Networks()).get(0); releaseResource(it, spec, l3, trigger); }
@Override public void run(FlowTrigger trigger, Map data) { Iterator<InstantiateResourceOnAttachingNicExtensionPoint> it = pluginRgty.getExtensionList(InstantiateResourceOnAttachingNicExtensionPoint.class).iterator(); VmInstanceSpec spec = (VmInstanceSpec) data.get(VmInstanceConstant.Params.VmInstanceSpec.toString()); L3NetworkInventory l3 = VmNicSpec.getL3NetworkInventoryOfSpec(spec.getL3Networks()).get(0); instantiateResource(it, spec, l3, trigger); }
private Map<NetworkServiceDhcpBackend, List<DhcpStruct>> workoutDhcp(VmInstanceSpec spec) { Map<NetworkServiceDhcpBackend, List<DhcpStruct>> map = new HashMap<NetworkServiceDhcpBackend, List<DhcpStruct>>(); Map<NetworkServiceProviderType, List<L3NetworkInventory>> providerMap = getNetworkServiceProviderMap(NetworkServiceType.DHCP, VmNicSpec.getL3NetworkInventoryOfSpec(spec.getL3Networks())); for (Map.Entry<NetworkServiceProviderType, List<L3NetworkInventory>> e : providerMap.entrySet()) { NetworkServiceProviderType ptype = e.getKey(); List<DhcpStruct> lst = new ArrayList<DhcpStruct>(); for (L3NetworkInventory l3 : e.getValue()) { lst.addAll(makeDhcpStruct(spec, l3)); } NetworkServiceDhcpBackend bkd = dhcpBackends.get(ptype); if (bkd == null) { throw new CloudRuntimeException(String.format("unable to find NetworkServiceDhcpBackend[provider type: %s]", ptype)); } map.put(bkd, lst); if (logger.isTraceEnabled()) { logger.trace(String.format("DHCP Backend[%s] is about to apply entries: \n%s", bkd.getClass().getName(), lst)); } } return map; }
private Map<NetworkServiceCentralizedDnsBackend, List<ForwardDnsStruct>> workoutForwardDns(VmInstanceSpec spec) { Map<NetworkServiceCentralizedDnsBackend, List<ForwardDnsStruct>> map = new HashMap<NetworkServiceCentralizedDnsBackend, List<ForwardDnsStruct>>(); Map<NetworkServiceProviderType, List<L3NetworkInventory>> providerMap = getNetworkServiceProviderMap(NetworkServiceType.Centralized_DNS, VmNicSpec.getL3NetworkInventoryOfSpec(spec.getL3Networks())); for (Map.Entry<NetworkServiceProviderType, List<L3NetworkInventory>> e : providerMap.entrySet()) { NetworkServiceProviderType ptype = e.getKey(); List<ForwardDnsStruct> lst = new ArrayList<ForwardDnsStruct>(); for (L3NetworkInventory l3 : e.getValue()) { lst.add(makeForwardDnsStruct(spec, l3)); } NetworkServiceCentralizedDnsBackend bkd = cDnsBackends.get(ptype); if (bkd == null) { throw new CloudRuntimeException(String.format("unable to find NetworkServiceDhcpBackend[provider type: %s]", ptype)); } map.put(bkd, lst); if (logger.isTraceEnabled()) { logger.trace(String.format("DHCP Backend[%s] is about to apply entries: \n%s", bkd.getClass().getName(), lst)); } } return map; }
private Map<NetworkServiceDnsBackend, List<DnsStruct>> workoutDns(VmInstanceSpec spec) { Map<NetworkServiceDnsBackend, List<DnsStruct>> map = new HashMap<NetworkServiceDnsBackend, List<DnsStruct>>(); Map<NetworkServiceProviderType, List<L3NetworkInventory>> providerMap = getNetworkServiceProviderMap(NetworkServiceType.DNS, VmNicSpec.getL3NetworkInventoryOfSpec(spec.getL3Networks())); for (Map.Entry<NetworkServiceProviderType, List<L3NetworkInventory>> e : providerMap.entrySet()) { NetworkServiceProviderType ptype = e.getKey(); List<DnsStruct> lst = new ArrayList<DnsStruct>(); for (L3NetworkInventory l3 : e.getValue()) { lst.add(makeDnsStruct(spec, l3)); } NetworkServiceDnsBackend bkd = dnsBackends.get(ptype); if (bkd == null) { throw new CloudRuntimeException(String.format("unable to find NetworkServiceDnsBackend[provider type: %s]", ptype)); } map.put(bkd, lst); if (logger.isTraceEnabled()) { logger.trace(String.format("DNS Backend[%s] is about to apply entries: \n%s", bkd.getClass().getName(), lst)); } } return map; }
private Map<NetworkServiceSnatBackend, List<SnatStruct>> workoutSnat(VmInstanceSpec spec) { Map<NetworkServiceSnatBackend, List<SnatStruct>> map = new HashMap<NetworkServiceSnatBackend, List<SnatStruct>>(); Map<NetworkServiceProviderType, List<L3NetworkInventory>> providerMap = getNetworkServiceProviderMap(NetworkServiceType.SNAT, VmNicSpec.getL3NetworkInventoryOfSpec(spec.getL3Networks())); for (Map.Entry<NetworkServiceProviderType, List<L3NetworkInventory>> e : providerMap.entrySet()) { NetworkServiceProviderType ptype = e.getKey(); List<SnatStruct> lst = new ArrayList<SnatStruct>(); for (L3NetworkInventory l3 : e.getValue()) { lst.add(makeSnatStruct(spec, l3)); } NetworkServiceSnatBackend bkd = snatBackends.get(ptype); if (bkd == null) { throw new CloudRuntimeException(String.format("unable to find NetworkServiceSnatBackend[provider type: %s]", ptype)); } if (logger.isTraceEnabled()) { logger.trace(String.format("SNAT Backend[%s] is about to apply entries: \n%s", bkd.getClass().getName(), lst)); } map.put(bkd, lst); } return map; }
private Map<String, List<PortForwardingStruct>> workoutPortForwarding(VmInstanceSpec spec) { Map<String, List<PortForwardingStruct>> map = new HashMap<String, List<PortForwardingStruct>>(); Map<NetworkServiceProviderType, List<L3NetworkInventory>> providerMap = getNetworkServiceProviderMap(NetworkServiceType.PortForwarding, VmNicSpec.getL3NetworkInventoryOfSpec(spec.getL3Networks())); for (Map.Entry<NetworkServiceProviderType, List<L3NetworkInventory>> e : providerMap.entrySet()) { NetworkServiceProviderType ptype = e.getKey(); List<PortForwardingStruct> lst = new ArrayList<PortForwardingStruct>(); for (L3NetworkInventory l3 : e.getValue()) { lst.addAll(makePortForwardingStruct(spec.getDestNics(), spec.getCurrentVmOperation() == VmOperation.Destroy || spec.getCurrentVmOperation() == VmOperation.DetachNic, l3)); } map.put(ptype.toString(), lst); } return map; } }
private Map<String, List<EipStruct>> workOutEipStruct(VmInstanceSpec spec) { Map<NetworkServiceProviderType, List<L3NetworkInventory>> map = getNetworkServiceProviderMap(EipConstant.EIP_TYPE, VmNicSpec.getL3NetworkInventoryOfSpec(spec.getL3Networks())); Map<String, List<EipStruct>> ret = new HashMap<String, List<EipStruct>>(); for (Map.Entry<NetworkServiceProviderType, List<L3NetworkInventory>> e : map.entrySet()) {
@Override public void beforeStartNewCreatedVm(VmInstanceSpec spec) { String providerUuid = new NetworkServiceProviderLookup().lookupUuidByType(FlatNetworkServiceConstant.FLAT_NETWORK_SERVICE_TYPE_STRING); // make sure the Flat DHCP acquired DHCP server IP before starting VMs, // otherwise it may not be able to get IP when lots of VMs start concurrently // because the logic of VM acquiring IP is ahead flat DHCP acquiring IP for (L3NetworkInventory l3 :VmNicSpec.getL3NetworkInventoryOfSpec(spec.getL3Networks())) { List<String> serviceTypes = l3.getNetworkServiceTypesFromProvider(providerUuid); if (serviceTypes.contains(NetworkServiceType.DHCP.toString())) { allocateDhcpIp(l3.getUuid()); } } }
private NetworkServiceProviderInventory findProvider(final VmInstanceSpec spec) { L3NetworkInventory defaultL3 = CollectionUtils.find(VmNicSpec.getL3NetworkInventoryOfSpec(spec.getL3Networks()), new Function<L3NetworkInventory, L3NetworkInventory>() { @Override public L3NetworkInventory call(L3NetworkInventory arg) { return arg.getUuid().equals(spec.getVmInventory().getDefaultL3NetworkUuid()) ? arg : null; } }); for (NetworkServiceL3NetworkRefInventory ref : defaultL3.getNetworkServices()) { if (UserdataConstant.USERDATA_TYPE_STRING.equals(ref.getNetworkServiceType())) { return NetworkServiceProviderInventory.valueOf(dbf.findByUuid(ref.getNetworkServiceProviderUuid(), NetworkServiceProviderVO.class)); } } return null; }
@Override public void run(FlowTrigger trigger, Map data) { VmInstanceSpec spec = (VmInstanceSpec) data.get(VmInstanceConstant.Params.VmInstanceSpec.toString()); if (spec.getVmInventory().getDefaultL3NetworkUuid() != null) { trigger.next(); return; } L3NetworkInventory l3 = VmNicSpec.getL3NetworkInventoryOfSpec(spec.getL3Networks()).get(0); VmInstanceVO vm = dbf.findByUuid(spec.getVmInventory().getUuid(), VmInstanceVO.class); vm.setDefaultL3NetworkUuid(l3.getUuid()); dbf.update(vm); data.put(VmSetDefaultL3NetworkOnAttachingFlow.class, true); trigger.next(); }
@Override public void run(final FlowTrigger trigger, Map data) { final VmInstanceSpec spec = (VmInstanceSpec) data.get(VmInstanceConstant.Params.VmInstanceSpec.toString()); List<CheckL2NetworkOnHostMsg> cmsgs = new ArrayList<CheckL2NetworkOnHostMsg>(); for (L3NetworkInventory l3 : VmNicSpec.getL3NetworkInventoryOfSpec(spec.getL3Networks())) { CheckL2NetworkOnHostMsg msg = new CheckL2NetworkOnHostMsg(); msg.setL2NetworkUuid(l3.getL2NetworkUuid()); msg.setHostUuid(spec.getDestHost().getUuid()); bus.makeTargetServiceIdByResourceUuid(msg, L2NetworkConstant.SERVICE_ID, l3.getL2NetworkUuid()); cmsgs.add(msg); } if (cmsgs.isEmpty()) { trigger.next(); return; } bus.send(cmsgs, new CloudBusListCallBack(trigger) { @Override public void run(List<MessageReply> replies) { for (MessageReply r : replies) { if (!r.isSuccess()) { trigger.fail(r.getError()); return; } } trigger.next(); } }); }
@Override public void applyNetworkService(VmInstanceSpec servedVm, Map<String, Object> data, final Completion completion) { Map<NetworkServiceProviderType, List<L3NetworkInventory>> map = getNetworkServiceProviderMap(SecurityGroupProviderFactory.networkServiceType, VmNicSpec.getL3NetworkInventoryOfSpec(servedVm.getL3Networks())); if (map.isEmpty()) { completion.success(); return; } RefreshSecurityGroupRulesOnVmMsg msg = new RefreshSecurityGroupRulesOnVmMsg(); msg.setVmInstanceUuid(servedVm.getVmInventory().getUuid()); msg.setHostUuid(servedVm.getDestHost().getUuid()); bus.makeLocalServiceId(msg, SecurityGroupConstant.SERVICE_ID); bus.send(msg, new CloudBusCallBack(completion) { @Override public void run(MessageReply reply) { if (reply.isSuccess()) { completion.success(); } else { completion.fail(reply.getError()); } } }); }
@Override public void rollback(final FlowRollback chain, Map data) { VmInstanceSpec spec = (VmInstanceSpec) data.get(VmInstanceConstant.Params.VmInstanceSpec.toString()); List<DetachIpAddressFromVmNicMsg> msgs = new ArrayList<>(); /* reload vmnic */ List<VmNicVO> vmNicVOS = Q.New(VmNicVO.class).eq(VmNicVO_.vmInstanceUuid, spec.getVmInventory().getUuid()).list(); for (VmNicVO nic : vmNicVOS) { List<String> ipUuids = VmNicHelper.getCanDetachL3List(VmNicInventory.valueOf(nic), spec.getL3Networks()); for (String uuid : ipUuids) { DetachIpAddressFromVmNicMsg msg = new DetachIpAddressFromVmNicMsg(); msg.setVmNicUuid(nic.getUuid()); msg.setUsedIpUuid(uuid); bus.makeTargetServiceIdByResourceUuid(msg, VmInstanceConstant.SERVICE_ID, nic.getUuid()); msgs.add(msg); } } new While<>(msgs).each((msg, comp) -> bus.send(msg, new CloudBusCallBack(comp) { @Override public void run(MessageReply reply) { comp.done(); } })).run(new NoErrorCompletion(chain) { @Override public void done() { chain.rollback(); } }); } }
@Override public void preInstantiateVmResource(VmInstanceSpec spec, Completion completion) { Set<String> vxlanUuids = new HashSet<>(); for (L3NetworkInventory l3 : VmNicSpec.getL3NetworkInventoryOfSpec(spec.getL3Networks())) { String type = Q.New(L2NetworkVO.class).select(L2NetworkVO_.type).eq(L2NetworkVO_.uuid, l3.getL2NetworkUuid()).findValue(); if (type.equals(VxlanNetworkConstant.VXLAN_NETWORK_TYPE)) {
L3NetworkInventory defaultL3 = CollectionUtils.find(VmNicSpec.getL3NetworkInventoryOfSpec(servedVm.getL3Networks()), new Function<L3NetworkInventory, L3NetworkInventory>() { @Override
@Override public void applyNetworkService(final VmInstanceSpec servedVm, Map<String, Object> data, Completion completion) { L3NetworkInventory defaultL3 = CollectionUtils.find(VmNicSpec.getL3NetworkInventoryOfSpec(servedVm.getL3Networks()), new Function<L3NetworkInventory, L3NetworkInventory>() { @Override public L3NetworkInventory call(L3NetworkInventory arg) { return arg.getUuid().equals(servedVm.getVmInventory().getDefaultL3NetworkUuid()) ? arg : null; } }); if (defaultL3 == null) { // the L3 for operation is not the default L3 completion.success(); return; } NetworkServiceProviderInventory provider = findProvider(servedVm); if (provider == null) { completion.success(); return; } UserdataStruct struct = new UserdataStruct(); struct.setL3NetworkUuid(servedVm.getVmInventory().getDefaultL3NetworkUuid()); struct.setParametersFromVmSpec(servedVm); struct.setUserdataList(servedVm.getUserdataList()); UserdataBackend bkd = getUserdataBackend(provider.getType()); bkd.applyUserdata(struct, completion); }
msg.setRequiredPrimaryStorageUuid(spec.getVmInventory().getRootVolume().getPrimaryStorageUuid()); msg.setL3NetworkUuids(CollectionUtils.transformToList( VmNicSpec.getL3NetworkInventoryOfSpec(spec.getL3Networks()), new Function<String, L3NetworkInventory>() { @Override public String call(L3NetworkInventory arg) {
msg.setVmOperation(spec.getCurrentVmOperation().toString()); msg.setAllocatorStrategy(HostAllocatorConstant.DESIGNATED_HOST_ALLOCATOR_STRATEGY_TYPE); msg.setL3NetworkUuids(CollectionUtils.transformToList(VmNicSpec.getL3NetworkInventoryOfSpec(spec.getL3Networks()), new Function<String, L3NetworkInventory>() { @Override public String call(L3NetworkInventory arg) {