2 * Copyright (c) 2015 Huawei Technologies and others. All rights reserved.
4 * This program and the accompanying materials are made available under the
5 * terms of the Eclipse Public License v1.0 which accompanies this distribution,
6 * and is available at http://www.eclipse.org/legal/epl-v10.html
8 package org.opendaylight.groupbasedpolicy.renderer.faas;
10 import static com.google.common.base.Preconditions.checkNotNull;
12 import java.util.ArrayList;
13 import java.util.HashMap;
14 import java.util.HashSet;
15 import java.util.List;
18 import java.util.UUID;
19 import java.util.concurrent.ConcurrentHashMap;
20 import java.util.concurrent.ScheduledExecutorService;
22 import org.opendaylight.controller.md.sal.binding.api.DataBroker;
23 import org.opendaylight.controller.md.sal.binding.api.DataChangeListener;
24 import org.opendaylight.controller.md.sal.binding.api.ReadOnlyTransaction;
25 import org.opendaylight.controller.md.sal.binding.api.ReadWriteTransaction;
26 import org.opendaylight.controller.md.sal.binding.api.WriteTransaction;
27 import org.opendaylight.controller.md.sal.common.api.data.AsyncDataBroker;
28 import org.opendaylight.controller.md.sal.common.api.data.AsyncDataBroker.DataChangeScope;
29 import org.opendaylight.controller.md.sal.common.api.data.AsyncDataChangeEvent;
30 import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
31 import org.opendaylight.faas.uln.datastore.api.Pair;
32 import org.opendaylight.faas.uln.datastore.api.UlnDatastoreApi;
33 import org.opendaylight.groupbasedpolicy.util.DataStoreHelper;
34 import org.opendaylight.groupbasedpolicy.util.IidFactory;
35 import org.opendaylight.groupbasedpolicy.util.TenantUtils;
36 import org.opendaylight.yang.gen.v1.urn.opendaylight.faas.logical.faas.common.rev151013.Text;
37 import org.opendaylight.yang.gen.v1.urn.opendaylight.faas.logical.faas.common.rev151013.Uuid;
38 import org.opendaylight.yang.gen.v1.urn.opendaylight.faas.logical.faas.logical.routers.rev151013.logical.routers.container.logical.routers.LogicalRouterBuilder;
39 import org.opendaylight.yang.gen.v1.urn.opendaylight.faas.logical.faas.logical.switches.rev151013.logical.switches.container.logical.switches.LogicalSwitchBuilder;
40 import org.opendaylight.yang.gen.v1.urn.opendaylight.faas.logical.faas.ports.rev151013.PortLocationAttributes.LocationType;
41 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.common.rev140421.ContextId;
42 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.common.rev140421.ContractId;
43 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.common.rev140421.EndpointGroupId;
44 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.common.rev140421.L2BridgeDomainId;
45 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.common.rev140421.L2FloodDomainId;
46 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.common.rev140421.L3ContextId;
47 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.common.rev140421.SubnetId;
48 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.common.rev140421.TenantId;
49 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.faas.rev151009.LogicalNetworks;
50 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.faas.rev151009.ScopeType;
51 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.faas.rev151009.ServiceCommunicationLayer;
52 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.faas.rev151009.logical.networks.LogicalNetwork;
53 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.faas.rev151009.logical.networks.LogicalNetworkBuilder;
54 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.faas.rev151009.logical.networks.logical.network.ConsumerNetworkBuilder;
55 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.faas.rev151009.logical.networks.logical.network.ProviderNetworkBuilder;
56 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.faas.rev151009.mapped.tenants.entities.MappedEntity;
57 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.faas.rev151009.mapped.tenants.entities.MappedEntityBuilder;
58 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.faas.rev151009.mapped.tenants.entities.MappedTenant;
59 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.faas.rev151009.mapped.tenants.entities.MappedTenantBuilder;
60 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.faas.rev151009.mapped.tenants.entities.mapped.entity.MappedContract;
61 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.faas.rev151009.mapped.tenants.entities.mapped.entity.MappedSubnet;
62 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.policy.rev140421.tenants.Tenant;
63 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.policy.rev140421.tenants.tenant.forwarding.context.L2BridgeDomain;
64 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.policy.rev140421.tenants.tenant.forwarding.context.L2FloodDomain;
65 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.policy.rev140421.tenants.tenant.forwarding.context.L3Context;
66 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.policy.rev140421.tenants.tenant.forwarding.context.Subnet;
67 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.policy.rev140421.tenants.tenant.policy.Contract;
68 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.policy.rev140421.tenants.tenant.policy.EndpointGroup;
69 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.renderer.rev151103.RendererName;
70 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.renderer.rev151103.renderers.RendererBuilder;
71 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.renderer.rev151103.renderers.renderer.interests.followed.tenants.FollowedTenantBuilder;
72 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.renderer.rev151103.renderers.renderer.interests.followed.tenants.followed.tenant.FollowedEndpointGroup;
73 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.renderer.rev151103.renderers.renderer.interests.followed.tenants.followed.tenant.FollowedEndpointGroupBuilder;
74 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.resolved.policy.rev150828.ResolvedPolicies;
75 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.resolved.policy.rev150828.resolved.policies.ResolvedPolicy;
76 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.resolved.policy.rev150828.resolved.policies.ResolvedPolicy.ExternalImplicitGroup;
77 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.resolved.policy.rev150828.resolved.policies.resolved.policy.PolicyRuleGroupWithEndpointConstraints;
78 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.resolved.policy.rev150828.resolved.policies.resolved.policy.policy.rule.group.with.endpoint.constraints.PolicyRuleGroup;
79 import org.opendaylight.yangtools.concepts.ListenerRegistration;
80 import org.opendaylight.yangtools.yang.binding.DataObject;
81 import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
82 import org.slf4j.Logger;
83 import org.slf4j.LoggerFactory;
85 import com.google.common.base.Optional;
87 public class FaasPolicyManager implements DataChangeListener, AutoCloseable {
89 private static final Logger LOG = LoggerFactory.getLogger(FaasPolicyManager.class);
90 private static final RendererName rendererName = new RendererName("faas");
91 private final ListenerRegistration<DataChangeListener> registerListener;
92 private final ScheduledExecutorService executor;
93 private final DataBroker dataProvider;
94 private final Map<Pair<EndpointGroupId, TenantId>, List<SubnetId>> epgSubnetsMap = new HashMap<>();
95 private final ConcurrentHashMap<TenantId, Uuid> mappedTenants = new ConcurrentHashMap<>();
96 private final ConcurrentHashMap<TenantId, ArrayList<ListenerRegistration<DataChangeListener>>> registeredTenants = new ConcurrentHashMap<TenantId, ArrayList<ListenerRegistration<DataChangeListener>>>();
98 public FaasPolicyManager(DataBroker dataBroker, ScheduledExecutorService executor) {
99 this.dataProvider = dataBroker;
100 this.executor = executor;
101 this.registerListener = checkNotNull(dataProvider).registerDataChangeListener(LogicalDatastoreType.OPERATIONAL,
102 InstanceIdentifier.builder(ResolvedPolicies.class).child(ResolvedPolicy.class).build(), this,
103 AsyncDataBroker.DataChangeScope.SUBTREE);
105 RendererBuilder rendBuilder = new RendererBuilder();
106 rendBuilder.setName(rendererName);
107 WriteTransaction wTx = dataProvider.newWriteOnlyTransaction();
108 wTx.put(LogicalDatastoreType.OPERATIONAL, IidFactory.rendererIid(rendererName), rendBuilder.build());
109 if (DataStoreHelper.submitToDs(wTx)) {
110 LOG.debug("{} renderer registered with the multi-renderer manager", rendererName.getValue());
112 LOG.error("{} renderer Failed to register with the multi-renderer manager", rendererName.getValue());
117 public void close() throws Exception {
118 synchronized (registeredTenants) {
119 for (ArrayList<ListenerRegistration<DataChangeListener>> list : registeredTenants.values()) {
120 for (ListenerRegistration<DataChangeListener> reg : list) {
124 registeredTenants.clear();
126 LOG.debug("Closed All Tenant Registerations");
128 if (registerListener != null)
129 registerListener.close();
133 public void onDataChanged(final AsyncDataChangeEvent<InstanceIdentifier<?>, DataObject> change) {
134 executor.execute(new Runnable() {
137 executeEvent(change);
142 private void executeEvent(final AsyncDataChangeEvent<InstanceIdentifier<?>, DataObject> change) {
144 for (DataObject dao : change.getCreatedData().values()) {
145 if (dao instanceof ResolvedPolicy) {
146 ResolvedPolicy newPolicy = (ResolvedPolicy) dao;
147 if (handledPolicy(newPolicy)) {
148 LOG.debug("Created Policy: Consumer EPG {}, Provider EPG {}", newPolicy.getConsumerEpgId(),
149 newPolicy.getProviderEpgId());
150 updateLogicalNetwork(newPolicy);
155 Map<InstanceIdentifier<?>, DataObject> d = change.getUpdatedData();
156 for (Map.Entry<InstanceIdentifier<?>, DataObject> entry : d.entrySet()) {
157 if (entry.getValue() instanceof ResolvedPolicy) {
158 ResolvedPolicy newPolicy = (ResolvedPolicy) entry.getValue();
159 ResolvedPolicy oldPolicy = (ResolvedPolicy) change.getOriginalData().get(entry.getKey());
160 if (!isEqualService(newPolicy, oldPolicy)) {
161 removeLogicalNetwork(oldPolicy);
163 if (handledPolicy(newPolicy)) {
164 LOG.debug("Updated Policy: Consumer EPG {}, Provider EPG {}", newPolicy.getConsumerEpgId(),
165 newPolicy.getProviderEpgId());
166 updateLogicalNetwork(newPolicy);
172 for (InstanceIdentifier<?> iid : change.getRemovedPaths()) {
173 DataObject old = change.getOriginalData().get(iid);
174 if (old != null && old instanceof ResolvedPolicy) {
175 ResolvedPolicy oldPolicy = (ResolvedPolicy) old;
176 LOG.debug("Removed Policy: Consumer EPG {}, Provider EPG {}", oldPolicy.getConsumerEpgId(),
177 oldPolicy.getProviderEpgId());
178 removeLogicalNetwork(oldPolicy);
183 public void registerTenant(TenantId gbpTenantId) {
184 registerTenant(gbpTenantId, null);
187 public void registerTenant(TenantId gbpTenantId, EndpointGroupId epgId) {
188 if (registeredTenants.get(gbpTenantId) != null) {
189 registerFollowedEndpointgroup(gbpTenantId, epgId);
190 return; // already registered
192 synchronized (this) {
193 if (registeredTenants.get(gbpTenantId) != null) {
194 return; // already registered
197 * map tenant's required elements to faas logical networks
199 Optional<MappedTenant> mTenantOptional = DataStoreHelper.readFromDs(LogicalDatastoreType.OPERATIONAL,
200 FaasIidFactory.mappedTenantIid(gbpTenantId), dataProvider.newReadOnlyTransaction());
202 if (mTenantOptional.isPresent()) {
203 faasTenantId = mTenantOptional.get().getFaasTenantId();
205 faasTenantId = getFaasTenantId(gbpTenantId);
207 // load tenant datastore info
208 Tenant tenant = null;
209 Optional<Tenant> tenantOptional = DataStoreHelper.readFromDs(LogicalDatastoreType.CONFIGURATION,
210 TenantUtils.tenantIid(gbpTenantId), dataProvider.newReadOnlyTransaction());
211 if (tenantOptional.isPresent()) {
212 tenant = tenantOptional.get();
214 List<Contract> contracts = null;
215 List<Subnet> subnets = null;
216 if (tenant != null) {
217 contracts = tenant.getPolicy().getContract();
218 subnets = tenant.getForwardingContext().getSubnet();
220 Optional<MappedEntity> mEntityOptional = DataStoreHelper.readFromDs(LogicalDatastoreType.OPERATIONAL,
221 FaasIidFactory.mappedEntityIid(gbpTenantId),
222 dataProvider.newReadOnlyTransaction());
223 MappedEntity mappedEntity;
224 if (mEntityOptional.isPresent()) {
225 mappedEntity = mEntityOptional.get();
227 // This is needed as a workaround of a datastore problem
228 MappedEntityBuilder builder = new MappedEntityBuilder();
229 builder.setGbpTenantId(gbpTenantId);
230 mappedEntity = builder.build();
231 WriteTransaction wTx = dataProvider.newWriteOnlyTransaction();
232 wTx.put(LogicalDatastoreType.OPERATIONAL,
233 FaasIidFactory.mappedEntityIid(gbpTenantId), mappedEntity);
234 if (DataStoreHelper.submitToDs(wTx)) {
235 LOG.debug("Initailized Mapped Entry in Datastore for tenant {}", gbpTenantId);
237 LOG.error("Couldn't Initailized Mapped Entry in Datastore for tenant {}", gbpTenantId);
242 FaasContractManagerListener faasContractManagerListener = new FaasContractManagerListener(dataProvider,
243 gbpTenantId, faasTenantId, executor);
244 faasContractManagerListener.loadAll(contracts, mappedEntity.getMappedContract());
246 FaasSubnetManagerListener faasSubnetManagerListener = new FaasSubnetManagerListener(dataProvider,
247 gbpTenantId, faasTenantId, executor);
248 faasSubnetManagerListener.loadAll(subnets, mappedEntity.getMappedSubnet());
251 * tenant registrations
253 ArrayList<ListenerRegistration<DataChangeListener>> list = new ArrayList<ListenerRegistration<DataChangeListener>>();
254 ListenerRegistration<DataChangeListener> reg;
256 reg = dataProvider.registerDataChangeListener(LogicalDatastoreType.CONFIGURATION,
257 IidFactory.contractWildcardIid(gbpTenantId), faasContractManagerListener, DataChangeScope.SUBTREE);
260 reg = dataProvider.registerDataChangeListener(LogicalDatastoreType.CONFIGURATION,
261 IidFactory.subnetWildcardIid(gbpTenantId), faasSubnetManagerListener, DataChangeScope.SUBTREE);
265 reg = dataProvider.registerDataChangeListener(LogicalDatastoreType.CONFIGURATION,
266 IidFactory.tenantIid(gbpTenantId), new FaasTenantManagerListener(this, gbpTenantId, faasTenantId,
267 executor), DataChangeScope.BASE);
270 // Map previously resolved policy for this tenant
271 mapAllTenantResolvedPolicies(gbpTenantId, null);
273 registerFollowedTenant(gbpTenantId, epgId);
275 // track all registrations
276 registeredTenants.put(gbpTenantId, list);
278 LOG.debug("Registered tenant {}", gbpTenantId);
282 private void mapAllTenantResolvedPolicies(TenantId gbpTenantId, EndpointGroupId epgId) {
283 Optional<ResolvedPolicies> resolvedPoliciesOptional = DataStoreHelper.readFromDs(
284 LogicalDatastoreType.OPERATIONAL, InstanceIdentifier.builder(ResolvedPolicies.class).build(),
285 dataProvider.newReadOnlyTransaction());
286 if (!resolvedPoliciesOptional.isPresent() || resolvedPoliciesOptional.get().getResolvedPolicy() == null) {
289 List<ResolvedPolicy> resolvedPolicies = resolvedPoliciesOptional.get().getResolvedPolicy();
290 for (ResolvedPolicy policy : resolvedPolicies) {
291 if (policy.getConsumerTenantId().equals(gbpTenantId)) {
292 if (epgId == null || epgId.equals(policy.getConsumerEpgId()) || epgId.equals(policy.getProviderEpgId())) {
293 // if any epg or a specific epg policy
294 updateLogicalNetwork(policy);
300 private void registerFollowedTenant(TenantId gbpTenantId, EndpointGroupId epgId) {
301 FollowedTenantBuilder fTenantBuilder = new FollowedTenantBuilder();
302 fTenantBuilder.setId(gbpTenantId);
304 List<FollowedEndpointGroup> epgs = new ArrayList<>();
305 epgs.add(new FollowedEndpointGroupBuilder().setId(epgId).build());
306 fTenantBuilder.setFollowedEndpointGroup(epgs);
308 WriteTransaction wTx = dataProvider.newWriteOnlyTransaction();
309 wTx.put(LogicalDatastoreType.OPERATIONAL, IidFactory.followedTenantIid(rendererName, gbpTenantId),
310 fTenantBuilder.build());
311 if (DataStoreHelper.submitToDs(wTx)) {
312 LOG.info("Tenant {} is followed by renderer {}", gbpTenantId.getValue(), rendererName.getValue());
314 LOG.info("Couldn't register Tenant {} that is followed by renderer {}", gbpTenantId.getValue(),
315 rendererName.getValue());
319 private void registerFollowedEndpointgroup(TenantId gbpTenantId, EndpointGroupId epgId) {
323 FollowedEndpointGroupBuilder fEpgBuilder = new FollowedEndpointGroupBuilder();
324 fEpgBuilder.setId(epgId);
325 WriteTransaction wTx = dataProvider.newWriteOnlyTransaction();
326 wTx.put(LogicalDatastoreType.OPERATIONAL,
327 IidFactory.followedEndpointgroupIid(rendererName, gbpTenantId, epgId), fEpgBuilder.build());
328 if (DataStoreHelper.submitToDs(wTx)) {
329 LOG.trace("EPG {} in Tenant {} is followed by renderer {}", epgId.getValue(), gbpTenantId.getValue(),
330 rendererName.getValue());
332 LOG.info("Couldn't register EPG {} in Tenant {} that is followed by renderer {}", epgId.getValue(),
333 gbpTenantId.getValue(), rendererName.getValue());
337 public Uuid getFaasTenantId(TenantId tenantId) {
338 Uuid val = mappedTenants.get(tenantId);
342 Uuid faasTenantId = null;
343 if (isUUid(tenantId.getValue())) {
344 faasTenantId = new Uuid(tenantId.getValue());
346 faasTenantId = new Uuid(UUID.randomUUID().toString());
348 mappedTenants.putIfAbsent(tenantId, faasTenantId);
349 val = mappedTenants.get(tenantId);
350 MappedTenantBuilder builder = new MappedTenantBuilder();
351 builder.setFaasTenantId(val);
352 builder.setGbpTenantId(tenantId);
353 WriteTransaction wTx = dataProvider.newWriteOnlyTransaction();
354 MappedTenant result = builder.build();
355 wTx.put(LogicalDatastoreType.OPERATIONAL, FaasIidFactory.mappedTenantIid(tenantId), result);
356 if (DataStoreHelper.submitToDs(wTx)) {
357 LOG.debug("Cached in Datastore Mapped Tenant {}", result);
359 LOG.error("Couldn't Cache in Datastore Mapped Tenant {}", result);
364 public static boolean isUUid(String value) {
365 return (value != null && value.matches("[0-9a-f]{8}-[0-9a-f]{4}-[1-5][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}"));
368 public void unregisterTenant(TenantId tenantId) {
370 ArrayList<ListenerRegistration<DataChangeListener>> list = registeredTenants.remove(tenantId);
372 for (ListenerRegistration<DataChangeListener> reg : list) {
375 LOG.debug("Unregistered tenant {}", tenantId);
377 registeredTenants.remove(tenantId);
378 Uuid faasTenantId = mappedTenants.get(tenantId);
379 if (faasTenantId != null) {
380 removeTenantLogicalNetwork(tenantId, faasTenantId, false);
384 public boolean isTenantRegistered(TenantId tenantId) {
385 return registeredTenants.containsKey(tenantId);
388 private boolean handledPolicy(ResolvedPolicy policy) {
389 if (!policy.getConsumerTenantId().equals(policy.getProviderTenantId())) {
390 // FAAS always assumes consumer and provider EPGs belong to the same tenant
392 "Ignore Resolved Policy between Consumer EPG {} and Provider EPG {} becuase they belong to different Tenants",
393 policy.getConsumerTenantId().getValue(), policy.getProviderTenantId().getValue());
396 if (!isTenantRegistered(policy.getConsumerTenantId())) {
402 private boolean isEqualService(ResolvedPolicy newPolicy, ResolvedPolicy oldPolicy) {
403 return oldPolicy != null && newPolicy.getConsumerEpgId().equals(oldPolicy.getConsumerEpgId())
404 && newPolicy.getProviderEpgId().equals(oldPolicy.getProviderEpgId())
405 && newPolicy.getConsumerTenantId().equals(oldPolicy.getConsumerTenantId())
406 && newPolicy.getProviderTenantId().equals(oldPolicy.getProviderTenantId());
409 public void registerSubnetWithEpg(EndpointGroupId epgId, TenantId tenantId, SubnetId subnetId) {
410 registerSubnetWithEpg(epgId, tenantId, subnetId, true);
413 private void registerSubnetWithEpg(EndpointGroupId epgId, TenantId tenantId, SubnetId subnetId, boolean updateLn) {
414 synchronized (this) {
415 List<SubnetId> subnets = cloneAndGetEpgSubnets(epgId, tenantId);
416 for (SubnetId id : subnets) {
417 if (id.equals(subnetId)) {
421 subnets.add(subnetId);
422 epgSubnetsMap.put(new Pair<>(epgId, tenantId), subnets);
423 LOG.debug("Registered Subnet {} with EPG {}", subnetId, epgId);
425 mapAllTenantResolvedPolicies(tenantId, epgId);
430 private void removeLogicalNetwork(ResolvedPolicy oldPolicy) {
431 if (oldPolicy == null) {
434 removeLogicalNetwork(oldPolicy.getConsumerEpgId(), oldPolicy.getConsumerTenantId(), getContractId(oldPolicy),
435 oldPolicy.getProviderEpgId(), oldPolicy.getProviderTenantId());
438 private void removeLogicalNetwork(EndpointGroupId consumerEpgId, TenantId consumerTenantId, ContractId contractId,
439 EndpointGroupId providerEpgId, TenantId providerTenantId) {
440 ReadWriteTransaction rwTx = dataProvider.newReadWriteTransaction();
441 Optional<LogicalNetwork> lnOp = DataStoreHelper.removeIfExists(LogicalDatastoreType.OPERATIONAL,
442 FaasIidFactory.logicalNetworkIid(consumerEpgId, consumerTenantId, contractId,
443 providerEpgId, providerTenantId), rwTx);
444 if (lnOp.isPresent()) {
445 DataStoreHelper.submitToDs(rwTx);
446 LogicalNetwork logicalNetwork = lnOp.get();
447 Uuid consTenantId = getFaasTenantId(logicalNetwork.getConsumerTenantId());
448 Uuid provTenantId = getFaasTenantId(logicalNetwork.getProviderTenantId());
450 UlnDatastoreApi.removeLogicalSwitchFromDsIfExists(consTenantId, logicalNetwork.getConsumerNetwork()
451 .getLogicalSwitchId());
452 UlnDatastoreApi.removeLogicalSwitchFromDsIfExists(provTenantId, logicalNetwork.getProviderNetwork()
453 .getLogicalSwitchId());
454 if (logicalNetwork.getConsumerNetwork().getLogicalRouterId() != null) {
455 UlnDatastoreApi.removeLogicalRouterFromDsIfExists(consTenantId, logicalNetwork.getConsumerNetwork()
456 .getLogicalRouterId());
458 if (logicalNetwork.getProviderNetwork().getLogicalRouterId() != null) {
459 UlnDatastoreApi.removeLogicalRouterFromDsIfExists(provTenantId, logicalNetwork.getProviderNetwork()
460 .getLogicalRouterId());
465 private synchronized void updateLogicalNetwork(ResolvedPolicy policy) {
466 updateLogicalNetwork(policy.getConsumerEpgId(), getContractId(policy), policy.getProviderEpgId(),
467 policy.getConsumerTenantId(), policy.getExternalImplicitGroup());
470 private synchronized void updateLogicalNetwork(EndpointGroupId consumerEpgId, ContractId contractId,
471 EndpointGroupId providerEpgId, TenantId tenantId, ExternalImplicitGroup externalImplicitGroup) {
473 LOG.trace("Start updateLogicalNetwork: Consumer EPG {} Provider Epg {} Contract {}", consumerEpgId,
474 providerEpgId, contractId);
476 // Create Logical network
477 EndpointGroup consEpg = readEndpointGroup(consumerEpgId, tenantId);
478 if (consEpg == null) {
479 LOG.error("Couldn't Creat Logical Network. Missing EPG {}", consumerEpgId);
482 List<SubnetId> consSubnetIds = cloneAndGetEpgSubnets(consEpg.getId(), tenantId);
483 if (consSubnetIds.isEmpty()) {
484 LOG.info("Couldn't Creat Logical Network. Missing Subnets for Consumer EPG {}", consumerEpgId);
487 EndpointGroup provEpg = readEndpointGroup(providerEpgId, tenantId);
488 if (provEpg == null) {
489 LOG.error("Couldn't Creat Logical Network. Missing EPG {}", providerEpgId);
492 List<SubnetId> provSubnetIds = cloneAndGetEpgSubnets(provEpg.getId(), tenantId);
493 if (provSubnetIds.isEmpty()) {
494 LOG.info("Couldn't Creat Logical Network. Missing Subnets for Provider EPG {}", providerEpgId);
498 ServiceCommunicationLayer comLayer = findLayerNetwork(tenantId, consSubnetIds, provSubnetIds);
499 if (comLayer == null) {
501 "Couldn't determine forwarding Context. Couldn't Process Logical Network for Consumer EPG {} Provider Epg {} Contract {}",
502 consumerEpgId, providerEpgId, contractId);
506 if (needToCreateLogicalNetwork(comLayer, consSubnetIds, provSubnetIds, tenantId, contractId, provEpg, consEpg,
507 externalImplicitGroup)) {
508 if (comLayer == ServiceCommunicationLayer.Layer2) {
509 createLayer2LogicalNetwork(consEpg, contractId, provEpg, tenantId, comLayer, externalImplicitGroup);
510 } else if (comLayer == ServiceCommunicationLayer.Layer3) {
511 createLayer3LogicalNetwork(consEpg, contractId, provEpg, tenantId, comLayer, externalImplicitGroup);
513 LOG.error("Couldn't find the communication layer.Consumer EPG {} Provider Epg {} Contract {}",
514 consumerEpgId, providerEpgId, contractId);
517 LOG.debug("No need to Create the Logical Network. Consumer EPG {} Provider Epg {} Contract {}",
518 consumerEpgId, providerEpgId, contractId);
522 private boolean isConsumerPublic(ExternalImplicitGroup externalImplicitGroup) {
523 return externalImplicitGroup != null && externalImplicitGroup == ExternalImplicitGroup.ConsumerEpg;
526 private boolean isProviderPublic(ExternalImplicitGroup externalImplicitGroup) {
527 return externalImplicitGroup != null && externalImplicitGroup == ExternalImplicitGroup.ProviderEpg;
530 private List<SubnetId> cloneAndGetEpgSubnets(EndpointGroupId epgId, TenantId tenantId) {
531 synchronized (this) {
532 List<SubnetId> list1 = epgSubnetsMap.get(new Pair<>(epgId, tenantId));
534 return new ArrayList<>();
536 List<SubnetId> list2 = new ArrayList<>();
537 for (SubnetId id : list1) {
538 list2.add(new SubnetId(id));
544 private void createLayer3LogicalNetwork(EndpointGroup consEpg, ContractId contractId, EndpointGroup provEpg,
545 TenantId gbpTenantId, ServiceCommunicationLayer comLayer, ExternalImplicitGroup externalImplicitGroup) {
546 LOG.trace("Start createLayer3LogicalNetwork: Consumer EPG {} Provider Epg {} Contract {}", consEpg.getId()
547 .getValue(), provEpg.getId().getValue(), contractId);
548 LogicalNetworkBuilder lNetbuilder = buildLayer2LogicalNetwork(consEpg, provEpg, gbpTenantId, null,
549 externalImplicitGroup);
550 if (lNetbuilder == null) {
551 LOG.error("Failed to create Logical Switchs layer on the Logical network");
554 Uuid privateSecRulesId = getFaasSecRulesId(contractId, gbpTenantId);
555 if (privateSecRulesId == null) {
557 "Couldn't Create Logical Network because unable to find FAAS Security Rules Id based on GBP Contract {}",
562 Uuid faasTenantId = getFaasTenantId(gbpTenantId);
563 LogicalRouterBuilder consLR = initLogicalRouterBuilder(consEpg, faasTenantId,
564 isConsumerPublic(externalImplicitGroup));
565 LogicalRouterBuilder provLR = initLogicalRouterBuilder(provEpg, faasTenantId,
566 isProviderPublic(externalImplicitGroup));
568 if (!UlnDatastoreApi.attachAndSubmitToDs(consLR, provLR, new Pair<Uuid, Uuid>(null, privateSecRulesId), null)) {
569 LOG.error("Failed to join Logical Routers in a Logical Network");
573 if (!UlnDatastoreApi.attachAndSubmitToDs(consLR.getUuid(), lNetbuilder.getConsumerNetwork()
574 .getLogicalSwitchId(), faasTenantId, new Pair<>(LocationType.RouterType, LocationType.SwitchType))) {
575 LOG.error("Failed to join Consumer Logical Router to Logical Switch in a Logical Network");
578 LOG.debug("Attached Consumer Router {} to Consumer Switch {}", consLR.getUuid().getValue(),
579 lNetbuilder.getConsumerNetwork().getLogicalSwitchId().getValue());
580 if (!UlnDatastoreApi.attachAndSubmitToDs(provLR.getUuid(), lNetbuilder.getProviderNetwork()
581 .getLogicalSwitchId(), faasTenantId, new Pair<>(LocationType.RouterType, LocationType.SwitchType))) {
582 LOG.error("Failed to join Provider Logical Router to Logical Switch in a Logical Network");
585 LOG.debug("Attached Provider Router {} to Provider Switch {}", provLR.getUuid().getValue(),
586 lNetbuilder.getProviderNetwork().getLogicalSwitchId().getValue());
587 ConsumerNetworkBuilder cNetBuilder = new ConsumerNetworkBuilder(lNetbuilder.getConsumerNetwork());
588 cNetBuilder.setLogicalRouterId(consLR.getUuid());
589 lNetbuilder.setConsumerNetwork(cNetBuilder.build());
590 ProviderNetworkBuilder pNetBuilder = new ProviderNetworkBuilder(lNetbuilder.getProviderNetwork());
591 pNetBuilder.setLogicalRouterId(provLR.getUuid());
592 lNetbuilder.setProviderNetwork(pNetBuilder.build());
593 lNetbuilder.setContractId(contractId);
594 lNetbuilder.setContractTenantId(gbpTenantId);
595 LogicalNetwork result = lNetbuilder.build();
596 WriteTransaction wTx = dataProvider.newWriteOnlyTransaction();
597 InstanceIdentifier<LogicalNetwork> iid = FaasIidFactory.logicalNetworkIid(
598 consEpg.getId(), gbpTenantId, contractId, provEpg.getId(), gbpTenantId);
599 wTx.put(LogicalDatastoreType.OPERATIONAL, iid, result);
600 if (DataStoreHelper.submitToDs(wTx)) {
601 LOG.debug("Cached in Datastore Mapped Logical Network {}", result);
603 LOG.error("Couldn't Cache in Datastore Mapped Logical Network {}", result);
605 LOG.debug("Created Layer 3 Logical network consEpg {}, contractId {}, provEpg {}", consEpg.getId().getValue(),
606 contractId.getValue(), provEpg.getId().getValue());
609 private void createLayer2LogicalNetwork(EndpointGroup consEpg, ContractId contractId, EndpointGroup provEpg,
610 TenantId gbpTenantId, ServiceCommunicationLayer comLayer, ExternalImplicitGroup externalImplicitGroup) {
611 LOG.trace("Start createLayer2LogicalNetwork: Consumer EPG {} Provider Epg {} Contract {}", consEpg.getId()
612 .getValue(), provEpg.getId().getValue(), contractId);
613 Uuid secRulesId = getFaasSecRulesId(contractId, gbpTenantId);
614 if (secRulesId == null) {
616 "Couldn't Create Logical Network because unable to find FAAS Security Rules Id based on GBP Contract {}",
620 LogicalNetworkBuilder lNetbuilder = buildLayer2LogicalNetwork(consEpg, provEpg, gbpTenantId, secRulesId,
621 externalImplicitGroup);
622 if (lNetbuilder == null) {
623 LOG.error("Failed to create Logical Switchs layer on the Logical network");
627 if (isConsumerPublic(externalImplicitGroup)) {
628 Uuid faasTenantId = getFaasTenantId(gbpTenantId);
629 LogicalRouterBuilder consLR = initLogicalRouterBuilder(consEpg, faasTenantId, true);
630 UlnDatastoreApi.submitLogicalRouterToDs(consLR.build());
631 ConsumerNetworkBuilder cNetBuilder = new ConsumerNetworkBuilder(lNetbuilder.getConsumerNetwork());
632 cNetBuilder.setLogicalRouterId(consLR.getUuid());
633 lNetbuilder.setConsumerNetwork(cNetBuilder.build());
634 if (!UlnDatastoreApi.attachAndSubmitToDs(consLR.getUuid(), lNetbuilder.getConsumerNetwork()
635 .getLogicalSwitchId(), faasTenantId, new Pair<>(LocationType.RouterType, LocationType.SwitchType),
637 LOG.error("Failed to join Consumer Public Logical Router to Logical Switch in a Logical Network");
639 LOG.debug("Attached Consumer Public Router {} to Consumer Switch {}", consLR.getUuid().getValue(),
640 lNetbuilder.getConsumerNetwork().getLogicalSwitchId().getValue());
642 if (isProviderPublic(externalImplicitGroup)) {
643 Uuid faasTenantId = getFaasTenantId(gbpTenantId);
644 LogicalRouterBuilder provLR = initLogicalRouterBuilder(provEpg, faasTenantId, true);
645 provLR.setPublic(true);
646 UlnDatastoreApi.submitLogicalRouterToDs(provLR.build());
647 ProviderNetworkBuilder cNetBuilder = new ProviderNetworkBuilder(lNetbuilder.getProviderNetwork());
648 cNetBuilder.setLogicalRouterId(provLR.getUuid());
649 lNetbuilder.setProviderNetwork(cNetBuilder.build());
650 if (!UlnDatastoreApi.attachAndSubmitToDs(provLR.getUuid(), lNetbuilder.getProviderNetwork()
651 .getLogicalSwitchId(), faasTenantId, new Pair<>(LocationType.RouterType, LocationType.SwitchType),
653 LOG.error("Failed to join Provider Public Logical Router to Logical Switch in a Logical Network");
655 LOG.debug("Attached Provider Public Router {} to Provider Switch {}", provLR.getUuid().getValue(),
656 lNetbuilder.getProviderNetwork().getLogicalSwitchId().getValue());
659 lNetbuilder.setContractId(contractId);
660 lNetbuilder.setContractTenantId(gbpTenantId);
661 LogicalNetwork result = lNetbuilder.build();
662 WriteTransaction wTx = dataProvider.newWriteOnlyTransaction();
663 InstanceIdentifier<LogicalNetwork> iid = FaasIidFactory.logicalNetworkIid(
664 consEpg.getId(), gbpTenantId, contractId, provEpg.getId(), gbpTenantId);
665 wTx.put(LogicalDatastoreType.OPERATIONAL, iid, result);
666 if (DataStoreHelper.submitToDs(wTx)) {
667 LOG.debug("Cached in Datastore Mapped Logical Network {}", result);
669 LOG.error("Couldn't Cache in Datastore Mapped Logical Network {}", result);
671 LOG.debug("Created Layer 2 Logical network consEpg {}, contractId {}, provEpg {}", consEpg.getId().getValue(),
672 contractId.getValue(), provEpg.getId().getValue());
675 private LogicalNetworkBuilder buildLayer2LogicalNetwork(EndpointGroup consEpg, EndpointGroup provEpg,
676 TenantId gbpTenantId, Uuid layer2SecRulesId, ExternalImplicitGroup externalImplicitGroup) {
677 LOG.trace("Start buildLayer2LogicalNetwork: Consumer EPG {} Provider Epg {}", consEpg.getId().getValue(),
678 provEpg.getId().getValue());
679 List<SubnetId> consSubnetIds = cloneAndGetEpgSubnets(consEpg.getId(), gbpTenantId);
680 List<Uuid> consFaasSubnetIds = new ArrayList<>();
681 for (SubnetId subnetId : consSubnetIds) {
682 Uuid id = getFaasSubnetId(subnetId, gbpTenantId);
684 LOG.trace("Added to Consumer Network Faas Subnet {}", id.getValue());
685 consFaasSubnetIds.add(id);
688 if (consFaasSubnetIds.isEmpty()) {
689 LOG.error("Couldn't find Faas subnets based on EPG {} -- Unable to create Layer2 Logical Network",
690 consEpg.getId().getValue());
693 List<SubnetId> provSubnetIds = cloneAndGetEpgSubnets(provEpg.getId(), gbpTenantId);
694 List<Uuid> provFaasSubnetIds = new ArrayList<>();
695 for (SubnetId subnetId : provSubnetIds) {
696 Uuid id = getFaasSubnetId(subnetId, gbpTenantId);
698 LOG.trace("Added to Provider Network Faas Subnet {}", id.getValue());
699 provFaasSubnetIds.add(id);
702 if (provFaasSubnetIds.isEmpty()) {
703 LOG.error("Couldn't find Faas subnets based on EPG {} -- Unable to create Layer2 Logical Network",
704 provEpg.getId().getValue());
707 Uuid faasTenantId = getFaasTenantId(gbpTenantId);
708 LogicalSwitchBuilder consLS = initLogicalSwitchBuilder(consEpg, faasTenantId);
709 LogicalSwitchBuilder provLS = initLogicalSwitchBuilder(provEpg, faasTenantId);
710 if (layer2SecRulesId != null) {
711 if (!UlnDatastoreApi.attachAndSubmitToDs(consLS, provLS, new Pair<Uuid, Uuid>(null, layer2SecRulesId))) {
712 LOG.error("Failed to join Logical Switches in a Logical Network");
716 UlnDatastoreApi.submitLogicalSwitchToDs(consLS.build());
717 UlnDatastoreApi.submitLogicalSwitchToDs(provLS.build());
719 for (Uuid subnetId : consFaasSubnetIds) {
720 if (!UlnDatastoreApi.attachAndSubmitToDs(consLS.getUuid(), subnetId, consLS.getTenantId(), new Pair<>(
721 LocationType.SwitchType, LocationType.SubnetType))) {
722 LOG.error("Failed to join Consumer Logical Switch with Subnet {} in a Logical Network", subnetId);
725 LOG.debug("Attached Consumer Switch {} to Subnet {}", consLS.getUuid().getValue(), subnetId.getValue());
727 for (Uuid subnetId : provFaasSubnetIds) {
728 if (!UlnDatastoreApi.attachAndSubmitToDs(provLS.getUuid(), subnetId, provLS.getTenantId(), new Pair<>(
729 LocationType.SwitchType, LocationType.SubnetType))) {
730 LOG.error("Failed to join Provider Logical Switch with Subnet {} in a Logical Network", subnetId);
733 LOG.debug("Attached Provider Switch {} to Subnet {}", provLS.getUuid().getValue(), subnetId.getValue());
735 LogicalNetworkBuilder lNetbuilder = new LogicalNetworkBuilder();
736 lNetbuilder.setConsumerEpgId(consEpg.getId());
737 lNetbuilder.setConsumerTenantId(gbpTenantId);
738 lNetbuilder.setContractTenantId(gbpTenantId);
739 lNetbuilder.setProviderEpgId(provEpg.getId());
740 lNetbuilder.setProviderTenantId(gbpTenantId);
741 ConsumerNetworkBuilder cNetBuilder = new ConsumerNetworkBuilder();
742 cNetBuilder.setLogicalSwitchId(consLS.getUuid());
743 cNetBuilder.setGbpSubnetId(consSubnetIds);
744 if (isConsumerPublic(externalImplicitGroup)) {
745 cNetBuilder.setNetworkScopeType(ScopeType.Public);
747 cNetBuilder.setNetworkScopeType(ScopeType.Private);
749 lNetbuilder.setConsumerNetwork(cNetBuilder.build());
750 ProviderNetworkBuilder pNetBuilder = new ProviderNetworkBuilder();
751 pNetBuilder.setLogicalSwitchId(provLS.getUuid());
752 pNetBuilder.setGbpSubnetId(provSubnetIds);
753 if (isProviderPublic(externalImplicitGroup)) {
754 pNetBuilder.setNetworkScopeType(ScopeType.Public);
756 pNetBuilder.setNetworkScopeType(ScopeType.Private);
758 lNetbuilder.setProviderNetwork(pNetBuilder.build());
764 private Uuid getFaasSubnetId(SubnetId subnetId, TenantId gbpTenantId) {
765 if (subnetId != null) {
766 Optional<MappedSubnet> mSubnetOp = DataStoreHelper.readFromDs(LogicalDatastoreType.OPERATIONAL,
767 FaasIidFactory.mappedSubnetIid(gbpTenantId, subnetId),
768 dataProvider.newReadOnlyTransaction());
769 if (mSubnetOp.isPresent()) {
770 return mSubnetOp.get().getFaasSubnetId();
776 private Uuid getFaasSecRulesId(ContractId contractId, TenantId gbpTenantId) {
777 if (contractId != null) {
778 Optional<MappedContract> mContractOp = DataStoreHelper.readFromDs(LogicalDatastoreType.OPERATIONAL,
779 FaasIidFactory.mappedContractIid(gbpTenantId, contractId),
780 dataProvider.newReadOnlyTransaction());
781 if (mContractOp.isPresent()) {
782 return mContractOp.get().getFaasSecurityRulesId();
788 private LogicalRouterBuilder initLogicalRouterBuilder(EndpointGroup epg, Uuid tenantId, boolean isPublic) {
789 LogicalRouterBuilder builder = new LogicalRouterBuilder();
790 builder.setAdminStateUp(true);
791 builder.setName(new Text(epg.getId().getValue()));
792 if (epg.getDescription() != null)
793 builder.setDescription(new Text("gbp-epg: " + epg.getDescription().getValue()));
795 builder.setDescription(new Text("gbp-epg"));
796 builder.setPublic(isPublic);
797 builder.setTenantId(tenantId);
798 builder.setUuid(new Uuid(UUID.randomUUID().toString()));
802 private LogicalSwitchBuilder initLogicalSwitchBuilder(EndpointGroup epg, Uuid tenantId) {
803 LogicalSwitchBuilder builder = new LogicalSwitchBuilder();
804 builder.setAdminStateUp(true);
805 builder.setName(new Text(epg.getId().getValue()));
806 if (epg.getDescription() != null)
807 builder.setDescription(new Text("gbp-epg: " + epg.getDescription().getValue()));
809 builder.setDescription(new Text("gbp-epg"));
810 builder.setTenantId(tenantId);
811 builder.setUuid(new Uuid(UUID.randomUUID().toString()));
815 private boolean needToCreateLogicalNetwork(ServiceCommunicationLayer comLayer, List<SubnetId> consSubnetIds,
816 List<SubnetId> provSubnetIds, TenantId tenantId, ContractId contractId, EndpointGroup providerEpg,
817 EndpointGroup consumerEpg, ExternalImplicitGroup externalImplicitGroup) {
818 Optional<LogicalNetwork> lnOp = DataStoreHelper.readFromDs(LogicalDatastoreType.OPERATIONAL,
819 FaasIidFactory.logicalNetworkIid(consumerEpg.getId(), tenantId, contractId,
820 providerEpg.getId(), tenantId), dataProvider.newReadOnlyTransaction());
821 if (!lnOp.isPresent()) {
824 LogicalNetwork logicalNet = lnOp.get();
825 if (!comLayer.equals(logicalNet.getCommunicationLayer())) {
829 boolean isConsPublic = logicalNet.getConsumerNetwork().getNetworkScopeType() != null
830 && logicalNet.getConsumerNetwork().getNetworkScopeType() == ScopeType.Public;
831 if (isConsumerPublic(externalImplicitGroup) != isConsPublic) {
834 boolean isProvPublic = logicalNet.getProviderNetwork().getNetworkScopeType() != null
835 && logicalNet.getProviderNetwork().getNetworkScopeType() == ScopeType.Public;
836 if (isProviderPublic(externalImplicitGroup) != isProvPublic) {
839 Set<SubnetId> lnConsSubnets = new HashSet<>(logicalNet.getConsumerNetwork().getGbpSubnetId());
840 if (lnConsSubnets.size() != consSubnetIds.size() || !lnConsSubnets.containsAll(consSubnetIds)) {
843 Set<SubnetId> lnProvSubnets = new HashSet<>(logicalNet.getProviderNetwork().getGbpSubnetId());
844 if (lnProvSubnets.size() != provSubnetIds.size() || !lnProvSubnets.containsAll(provSubnetIds)) {
850 private ServiceCommunicationLayer findLayerNetwork(TenantId tenantId, List<SubnetId> consSubnetIds,
851 List<SubnetId> provSubnetIds) {
852 Subnet consSubnet = null;
853 Subnet provSubnet = null;
854 ContextId contextId = null;
855 for (SubnetId subnetId : consSubnetIds) {
856 consSubnet = readSubnet(subnetId, tenantId);
857 if (consSubnet == null) {
858 LOG.error("Couldn't find subnet {} in datastore", subnetId);
861 if (consSubnet.getParent() == null) {
862 LOG.error("Flood domain is set to NULL in subnet " + consSubnet.getId());
865 if (contextId == null) {
866 contextId = consSubnet.getParent();
867 } else if (!contextId.equals(consSubnet.getParent())) {
868 LOG.error("Flood domain is not the same for all Network domains in the Consumer EPG ");
874 for (SubnetId subnetId : provSubnetIds) {
875 provSubnet = readSubnet(subnetId, tenantId);
876 if (provSubnet == null) {
877 LOG.error("Couldn't find subnet {} in datastore", subnetId);
880 if (provSubnet.getParent() == null) {
881 LOG.error("Flood domain is set to NULL in subnet " + provSubnet.getId());
884 if (contextId == null) {
885 contextId = provSubnet.getParent();
886 } else if (!contextId.equals(provSubnet.getParent())) {
887 LOG.error("Flood domain is not the same for all Network domains in the Provider EPG ");
892 if (consSubnet == null || provSubnet == null) {
893 LOG.error("Couldn't find Consumer and/or Provider subnets");
897 L2FloodDomainId consL2FldId = new L2FloodDomainId(consSubnet.getParent().getValue());
898 L2FloodDomain consFloodDomain = readL2FloodDomain(consL2FldId, tenantId);
899 if (consFloodDomain == null) {
900 LOG.error("Couldn't find flood domain instance in datastore with id " + consL2FldId);
903 L2FloodDomainId provL2FldId = new L2FloodDomainId(provSubnet.getParent().getValue());
904 L2FloodDomain provFloodDomain = readL2FloodDomain(provL2FldId, tenantId);
905 if (provFloodDomain == null) {
906 LOG.error("Couldn't find flood domain instance in datastore with id " + provL2FldId);
910 if (consFloodDomain.equals(provFloodDomain)) {
911 return ServiceCommunicationLayer.Layer2;
914 if (consFloodDomain.getParent() == null) {
915 LOG.error("Bridge domain is set to NULL in flood domain " + consFloodDomain.getId());
918 if (provFloodDomain.getParent() == null) {
919 LOG.error("Bridge domain is set to NULL in flood domain " + provFloodDomain.getId());
923 L2BridgeDomain consBridgeDomain = readL2BridgeDomainInstance(tenantId, consFloodDomain.getParent());
924 if (consBridgeDomain == null) {
925 LOG.error("Couldn't find bridge domain instance in datastore with id " + consFloodDomain.getParent());
928 L2BridgeDomain provBridgeDomain = readL2BridgeDomainInstance(tenantId, provFloodDomain.getParent());
929 if (provBridgeDomain == null) {
930 LOG.error("Couldn't find bridge domain instance in datastore with id " + provFloodDomain.getParent());
933 if (consBridgeDomain.equals(provBridgeDomain)) {
934 return ServiceCommunicationLayer.Layer2;
937 L3Context consL3ContextDomain = readL3ContextInstance(tenantId, consBridgeDomain.getParent());
938 if (consL3ContextDomain == null) {
939 LOG.error("Couldn't find L3 context instance in datastore with id " + consBridgeDomain.getParent());
942 L3Context provL3ContextDomain = readL3ContextInstance(tenantId, provBridgeDomain.getParent());
943 if (provL3ContextDomain == null) {
944 LOG.error("Couldn't find L3 context instance in datastore with id " + provBridgeDomain.getParent());
947 if (consL3ContextDomain.equals(provL3ContextDomain)) {
948 return ServiceCommunicationLayer.Layer3;
953 private L3Context readL3ContextInstance(TenantId tenantId, L3ContextId l3cId) {
954 ReadOnlyTransaction rTx = dataProvider.newReadOnlyTransaction();
955 InstanceIdentifier<L3Context> iid = IidFactory.l3ContextIid(tenantId, l3cId);
956 Optional<L3Context> l2Op = DataStoreHelper.readFromDs(LogicalDatastoreType.CONFIGURATION, iid, rTx);
957 if (!l2Op.isPresent()) {
958 LOG.error("Couldn't find L3 Context Domain {} which belongs to Tenant {}", l3cId, tenantId);
965 private L2BridgeDomain readL2BridgeDomainInstance(TenantId tenantId, L2BridgeDomainId l2bId) {
966 ReadOnlyTransaction rTx = dataProvider.newReadOnlyTransaction();
967 InstanceIdentifier<L2BridgeDomain> iid = IidFactory.l2BridgeDomainIid(tenantId, l2bId);
968 Optional<L2BridgeDomain> l2Op = DataStoreHelper.readFromDs(LogicalDatastoreType.CONFIGURATION, iid, rTx);
969 if (!l2Op.isPresent()) {
970 LOG.error("Couldn't find L2 Brdge Domain {} which belongs to Tenant {}", l2bId, tenantId);
977 private L2FloodDomain readL2FloodDomain(L2FloodDomainId l2fId, TenantId tenantId) {
978 ReadOnlyTransaction rTx = dataProvider.newReadOnlyTransaction();
979 InstanceIdentifier<L2FloodDomain> iid = IidFactory.l2FloodDomainIid(tenantId, l2fId);
980 Optional<L2FloodDomain> l2Op = DataStoreHelper.readFromDs(LogicalDatastoreType.CONFIGURATION, iid, rTx);
981 if (!l2Op.isPresent()) {
982 LOG.error("Couldn't find L2 Flood Domain {} which belongs to Tenant {}", l2fId, tenantId);
989 public Subnet readSubnet(SubnetId subnetId, TenantId tenantId) {
990 ReadOnlyTransaction rTx = dataProvider.newReadOnlyTransaction();
991 InstanceIdentifier<Subnet> iid = IidFactory.subnetIid(tenantId, subnetId);
992 Optional<Subnet> subnetOp = DataStoreHelper.readFromDs(LogicalDatastoreType.CONFIGURATION, iid, rTx);
993 if (!subnetOp.isPresent()) {
994 LOG.warn("Couldn't find Subnet {} which belongs to Tenant {}", subnetId, tenantId);
998 return subnetOp.get();
1001 public EndpointGroup readEndpointGroup(EndpointGroupId epgId, TenantId tenantId) {
1002 ReadOnlyTransaction rTx = dataProvider.newReadOnlyTransaction();
1003 InstanceIdentifier<EndpointGroup> iid = IidFactory.endpointGroupIid(tenantId, epgId);
1004 Optional<EndpointGroup> epgOp = DataStoreHelper.readFromDs(LogicalDatastoreType.CONFIGURATION, iid, rTx);
1005 if (!epgOp.isPresent()) {
1006 LOG.warn("Couldn't find EPG {} which belongs to Tenant {}", epgId, tenantId);
1013 private ContractId getContractId(ResolvedPolicy policy) {
1014 for (PolicyRuleGroupWithEndpointConstraints prgwec : policy.getPolicyRuleGroupWithEndpointConstraints()) {
1015 for (PolicyRuleGroup prg : prgwec.getPolicyRuleGroup()) {
1016 return prg.getContractId();
1022 public void removeTenantLogicalNetwork(TenantId gbpTenantId, Uuid faasTenantId) {
1023 removeTenantLogicalNetwork(gbpTenantId, faasTenantId, true);
1026 private void removeTenantLogicalNetwork(TenantId gbpTenantId, Uuid faasTenantId, boolean unregister) {
1027 UlnDatastoreApi.removeTenantFromDsIfExists(faasTenantId);
1028 synchronized (this) {
1029 mappedTenants.remove(gbpTenantId);
1030 Optional<LogicalNetworks> op3 = DataStoreHelper.readFromDs(LogicalDatastoreType.OPERATIONAL,
1031 FaasIidFactory.logicalNetworksIid(), dataProvider.newReadOnlyTransaction());
1032 if (op3.isPresent()) {
1033 LogicalNetworks logicalNetworks = op3.get();
1034 for (LogicalNetwork ln : logicalNetworks.getLogicalNetwork()) {
1035 if (ln.getConsumerTenantId().equals(gbpTenantId) || ln.getProviderTenantId().equals(gbpTenantId)) {
1036 removeLogicalNetwork(ln.getConsumerEpgId(), ln.getConsumerTenantId(), ln.getContractId(),
1037 ln.getProviderEpgId(), ln.getProviderTenantId());
1041 boolean toSubmit = false;
1042 ReadWriteTransaction rwTx = dataProvider.newReadWriteTransaction();
1043 Optional<MappedEntity> op1 = DataStoreHelper.removeIfExists(LogicalDatastoreType.OPERATIONAL,
1044 FaasIidFactory.mappedEntityIid(gbpTenantId), rwTx);
1045 if (op1.isPresent()) {
1048 Optional<MappedTenant> op2 = DataStoreHelper.removeIfExists(LogicalDatastoreType.OPERATIONAL,
1049 FaasIidFactory.mappedTenantIid(gbpTenantId), rwTx);
1050 if (op2.isPresent()) {
1054 DataStoreHelper.submitToDs(rwTx);
1058 unregisterTenant(gbpTenantId);