groupbasedpolicy/src/main/java/org/opendaylight/groupbasedpolicy/renderer/RendererConfigurationBuilder.java

   1 /*
   2  * Copyright (c) 2016 Cisco Systems, Inc. and others. All rights reserved.
   3  *
   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
   7  */
   8
   9 package org.opendaylight.groupbasedpolicy.renderer;
  10
  11 import java.util.ArrayList;
  12 import java.util.Collections;
  13 import java.util.HashMap;
  14 import java.util.HashSet;
  15 import java.util.List;
  16 import java.util.Map;
  17 import java.util.Map.Entry;
  18 import java.util.Set;
  19
  20 import javax.annotation.Nonnull;
  21 import javax.annotation.Nullable;
  22
  23 import org.opendaylight.groupbasedpolicy.api.EndpointAugmentor;
  24 import org.opendaylight.groupbasedpolicy.api.NetworkDomainAugmentor;
  25 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.base_endpoint.rev160427.endpoint.locations.AddressEndpointLocation;
  26 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.base_endpoint.rev160427.endpoint.locations.ContainmentEndpointLocation;
  27 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.base_endpoint.rev160427.endpoints.address.endpoints.AddressEndpoint;
  28 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.base_endpoint.rev160427.endpoints.address.endpoints.AddressEndpointKey;
  29 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.base_endpoint.rev160427.endpoints.containment.endpoints.ContainmentEndpoint;
  30 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.base_endpoint.rev160427.endpoints.containment.endpoints.ContainmentEndpointKey;
  31 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.forwarding.rev160427.Forwarding;
  32 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.forwarding.rev160427.forwarding.ForwardingByTenant;
  33 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.forwarding.rev160427.forwarding.forwarding.by.tenant.ForwardingContext;
  34 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.forwarding.rev160427.forwarding.forwarding.by.tenant.NetworkDomain;
  35 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.renderer.rev151103.EndpointPolicyParticipation;
  36 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.renderer.rev151103.RendererName;
  37 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.renderer.rev151103.has.peer.endpoints.PeerEndpointKey;
  38 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.renderer.rev151103.has.peer.external.containment.endpoints.PeerExternalContainmentEndpointKey;
  39 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.renderer.rev151103.has.peer.external.endpoints.PeerExternalEndpointKey;
  40 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.renderer.rev151103.has.rule.group.with.renderer.endpoint.participation.RuleGroupWithRendererEndpointParticipation;
  41 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.renderer.rev151103.has.rule.group.with.renderer.endpoint.participation.RuleGroupWithRendererEndpointParticipationBuilder;
  42 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.renderer.rev151103.renderers.renderer.renderer.policy.configuration.Endpoints;
  43 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.renderer.rev151103.renderers.renderer.renderer.policy.configuration.EndpointsBuilder;
  44 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.renderer.rev151103.renderers.renderer.renderer.policy.configuration.RendererEndpoints;
  45 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.renderer.rev151103.renderers.renderer.renderer.policy.configuration.RendererEndpointsBuilder;
  46 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.renderer.rev151103.renderers.renderer.renderer.policy.configuration.RendererForwarding;
  47 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.renderer.rev151103.renderers.renderer.renderer.policy.configuration.RendererForwardingBuilder;
  48 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.renderer.rev151103.renderers.renderer.renderer.policy.configuration.RuleGroups;
  49 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.renderer.rev151103.renderers.renderer.renderer.policy.configuration.RuleGroupsBuilder;
  50 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.renderer.rev151103.renderers.renderer.renderer.policy.configuration.endpoints.AddressEndpointWithLocation;
  51 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.renderer.rev151103.renderers.renderer.renderer.policy.configuration.endpoints.AddressEndpointWithLocationBuilder;
  52 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.renderer.rev151103.renderers.renderer.renderer.policy.configuration.endpoints.ContainmentEndpointWithLocation;
  53 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.renderer.rev151103.renderers.renderer.renderer.policy.configuration.endpoints.ContainmentEndpointWithLocationBuilder;
  54 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.renderer.rev151103.renderers.renderer.renderer.policy.configuration.renderer.endpoints.RendererEndpoint;
  55 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.renderer.rev151103.renderers.renderer.renderer.policy.configuration.renderer.endpoints.RendererEndpointBuilder;
  56 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.renderer.rev151103.renderers.renderer.renderer.policy.configuration.renderer.endpoints.RendererEndpointKey;
  57 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.renderer.rev151103.renderers.renderer.renderer.policy.configuration.renderer.endpoints.renderer.endpoint.PeerEndpointWithPolicy;
  58 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.renderer.rev151103.renderers.renderer.renderer.policy.configuration.renderer.endpoints.renderer.endpoint.PeerEndpointWithPolicyBuilder;
  59 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.renderer.rev151103.renderers.renderer.renderer.policy.configuration.renderer.endpoints.renderer.endpoint.PeerEndpointWithPolicyKey;
  60 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.renderer.rev151103.renderers.renderer.renderer.policy.configuration.renderer.endpoints.renderer.endpoint.PeerExternalContainmentEndpointWithPolicy;
  61 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.renderer.rev151103.renderers.renderer.renderer.policy.configuration.renderer.endpoints.renderer.endpoint.PeerExternalContainmentEndpointWithPolicyBuilder;
  62 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.renderer.rev151103.renderers.renderer.renderer.policy.configuration.renderer.endpoints.renderer.endpoint.PeerExternalContainmentEndpointWithPolicyKey;
  63 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.renderer.rev151103.renderers.renderer.renderer.policy.configuration.renderer.endpoints.renderer.endpoint.PeerExternalEndpointWithPolicy;
  64 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.renderer.rev151103.renderers.renderer.renderer.policy.configuration.renderer.endpoints.renderer.endpoint.PeerExternalEndpointWithPolicyBuilder;
  65 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.renderer.rev151103.renderers.renderer.renderer.policy.configuration.renderer.endpoints.renderer.endpoint.PeerExternalEndpointWithPolicyKey;
  66 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.renderer.rev151103.renderers.renderer.renderer.policy.configuration.renderer.forwarding.RendererForwardingByTenant;
  67 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.renderer.rev151103.renderers.renderer.renderer.policy.configuration.renderer.forwarding.RendererForwardingByTenantBuilder;
  68 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.renderer.rev151103.renderers.renderer.renderer.policy.configuration.renderer.forwarding.renderer.forwarding.by.tenant.RendererForwardingContext;
  69 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.renderer.rev151103.renderers.renderer.renderer.policy.configuration.renderer.forwarding.renderer.forwarding.by.tenant.RendererForwardingContextBuilder;
  70 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.renderer.rev151103.renderers.renderer.renderer.policy.configuration.renderer.forwarding.renderer.forwarding.by.tenant.RendererNetworkDomain;
  71 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.renderer.rev151103.renderers.renderer.renderer.policy.configuration.renderer.forwarding.renderer.forwarding.by.tenant.RendererNetworkDomainBuilder;
  72 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.renderer.rev151103.renderers.renderer.renderer.policy.configuration.rule.groups.RuleGroup;
  73 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.renderer.rev151103.renderers.renderer.renderer.policy.configuration.rule.groups.RuleGroupBuilder;
  74 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.resolved.policy.rev150828.resolved.policies.resolved.policy.policy.rule.group.with.endpoint.constraints.PolicyRuleGroup;
  75 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.resolved.policy.rev150828.resolved.policies.resolved.policy.policy.rule.group.with.endpoint.constraints.PolicyRuleGroupKey;
  76 import org.opendaylight.yangtools.yang.binding.Augmentation;
  77 import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
  78
  79 import com.google.common.base.Function;
  80 import com.google.common.base.Optional;
  81 import com.google.common.base.Preconditions;
  82 import com.google.common.collect.FluentIterable;
  83 import com.google.common.collect.HashBasedTable;
  84 import com.google.common.collect.ImmutableSet;
  85 import com.google.common.collect.ImmutableTable;
  86 import com.google.common.collect.Table;
  87
  88 public class RendererConfigurationBuilder {
  89
  90     private final Table<RendererEndpointKey, PeerEndpointKey, Set<RuleGroupWithRendererEndpointParticipation>> policiesByEpAndPeerEp =
  91             HashBasedTable.create();
  92     private final Table<RendererEndpointKey, PeerExternalEndpointKey, Set<RuleGroupWithRendererEndpointParticipation>> policiesByEpAndPeerExtEp =
  93             HashBasedTable.create();
  94     private final Table<RendererEndpointKey, PeerExternalContainmentEndpointKey, Set<RuleGroupWithRendererEndpointParticipation>> policiesByEpAndPeerExtCtxEp =
  95             HashBasedTable.create();
  96     private final Set<AddressEndpointKey> adrEpKeys = new HashSet<>();
  97     private final Set<ContainmentEndpointKey> contEpKeys = new HashSet<>();
  98     private final Set<PolicyRuleGroupKey> policyRuleGrpKeys = new HashSet<>();
  99
 100     public void add(RendererEndpointKey rendererEpKey, PeerEndpointKey peerEpKey, PolicyRuleGroupKey ruleGrpKey,
 101             EndpointPolicyParticipation rendererEpParticipation) {
 102         Set<RuleGroupWithRendererEndpointParticipation> ruleGrpWithRendererEpParticipation =
 103                 policiesByEpAndPeerEp.get(rendererEpKey, peerEpKey);
 104         if (ruleGrpWithRendererEpParticipation == null) {
 105             ruleGrpWithRendererEpParticipation = new HashSet<>();
 106             policiesByEpAndPeerEp.put(rendererEpKey, peerEpKey, ruleGrpWithRendererEpParticipation);
 107             adrEpKeys.add(AddressEndpointUtils.fromRendererEpKey(rendererEpKey));
 108             adrEpKeys.add(AddressEndpointUtils.fromPeerEpKey(peerEpKey));
 109         }
 110         policyRuleGrpKeys.add(ruleGrpKey);
 111         ruleGrpWithRendererEpParticipation
 112             .add(toRuleGroupWithRendererEndpointParticipation(ruleGrpKey, rendererEpParticipation));
 113     }
 114
 115     public void add(RendererEndpointKey rendererEpKey, PeerExternalEndpointKey peerExtEpKey,
 116             PolicyRuleGroupKey ruleGrpKey, EndpointPolicyParticipation rendererEpParticipation) {
 117         Set<RuleGroupWithRendererEndpointParticipation> ruleGrpWithRendererEpParticipation =
 118                 policiesByEpAndPeerExtEp.get(rendererEpKey, peerExtEpKey);
 119         if (ruleGrpWithRendererEpParticipation == null) {
 120             ruleGrpWithRendererEpParticipation = new HashSet<>();
 121             policiesByEpAndPeerExtEp.put(rendererEpKey, peerExtEpKey, ruleGrpWithRendererEpParticipation);
 122             adrEpKeys.add(AddressEndpointUtils.fromRendererEpKey(rendererEpKey));
 123             adrEpKeys.add(AddressEndpointUtils.fromPeerExtEpKey(peerExtEpKey));
 124         }
 125         policyRuleGrpKeys.add(ruleGrpKey);
 126         ruleGrpWithRendererEpParticipation
 127             .add(toRuleGroupWithRendererEndpointParticipation(ruleGrpKey, rendererEpParticipation));
 128     }
 129
 130     public void add(RendererEndpointKey rendererEpKey, PeerExternalContainmentEndpointKey peerExtContainmentEpKey,
 131             PolicyRuleGroupKey ruleGrpKey, EndpointPolicyParticipation rendererEpParticipation) {
 132         Set<RuleGroupWithRendererEndpointParticipation> ruleGrpWithRendererEpParticipation =
 133                 policiesByEpAndPeerExtCtxEp.get(rendererEpKey, peerExtContainmentEpKey);
 134         if (ruleGrpWithRendererEpParticipation == null) {
 135             ruleGrpWithRendererEpParticipation = new HashSet<>();
 136             policiesByEpAndPeerExtCtxEp.put(rendererEpKey, peerExtContainmentEpKey, ruleGrpWithRendererEpParticipation);
 137             adrEpKeys.add(AddressEndpointUtils.fromRendererEpKey(rendererEpKey));
 138             contEpKeys.add(ContainmentEndpointUtils.fromPeerExtContEpKey(peerExtContainmentEpKey));
 139         }
 140         policyRuleGrpKeys.add(ruleGrpKey);
 141         ruleGrpWithRendererEpParticipation
 142             .add(toRuleGroupWithRendererEndpointParticipation(ruleGrpKey, rendererEpParticipation));
 143     }
 144
 145     public static RuleGroupWithRendererEndpointParticipation toRuleGroupWithRendererEndpointParticipation(
 146             PolicyRuleGroupKey ruleGrpKey, EndpointPolicyParticipation rendererEpParticipation) {
 147         return new RuleGroupWithRendererEndpointParticipationBuilder().setTenantId(ruleGrpKey.getTenantId())
 148             .setContractId(ruleGrpKey.getContractId())
 149             .setSubjectName(ruleGrpKey.getSubjectName())
 150             .setRendererEndpointParticipation(rendererEpParticipation)
 151             .build();
 152     }
 153
 154     public ImmutableTable<RendererEndpointKey, PeerEndpointKey, Set<RuleGroupWithRendererEndpointParticipation>> getPoliciesByEpAndPeerEp() {
 155         return ImmutableTable.copyOf(policiesByEpAndPeerEp);
 156     }
 157
 158     public ImmutableTable<RendererEndpointKey, PeerExternalEndpointKey, Set<RuleGroupWithRendererEndpointParticipation>> getPoliciesByEpAndPeerExtEp() {
 159         return ImmutableTable.copyOf(policiesByEpAndPeerExtEp);
 160     }
 161
 162     public ImmutableTable<RendererEndpointKey, PeerExternalContainmentEndpointKey, Set<RuleGroupWithRendererEndpointParticipation>> getPoliciesByEpAndPeerExtConEp() {
 163         return ImmutableTable.copyOf(policiesByEpAndPeerExtCtxEp);
 164     }
 165
 166     public ImmutableSet<AddressEndpointKey> getAddressEndpointKeys() {
 167         return ImmutableSet.copyOf(adrEpKeys);
 168     }
 169
 170     public ImmutableSet<ContainmentEndpointKey> getContainmentEndpointKeys() {
 171         return ImmutableSet.copyOf(contEpKeys);
 172     }
 173
 174     public ImmutableSet<PolicyRuleGroupKey> getPolicyRuleGroupKeys() {
 175         return ImmutableSet.copyOf(policyRuleGrpKeys);
 176     }
 177
 178     public @Nonnull RendererEndpoints buildRendererEndpoints() {
 179         Map<RendererEndpointKey, RendererEndpointBuilder> rendererEpBuilderByKey = new HashMap<>();
 180         for (RendererEndpointKey rendererEpKey : policiesByEpAndPeerEp.rowKeySet()) {
 181             RendererEndpointBuilder rendererEpBuilder =
 182                     resolveRendererEndpointBuilder(rendererEpKey, rendererEpBuilderByKey);
 183             List<PeerEndpointWithPolicy> peerEpsWithPolicy =
 184                     toListPeerEndpointWithPolicy(policiesByEpAndPeerEp.row(rendererEpKey));
 185             rendererEpBuilder.setPeerEndpointWithPolicy(peerEpsWithPolicy);
 186             rendererEpBuilderByKey.put(rendererEpKey, rendererEpBuilder);
 187         }
 188         for (RendererEndpointKey rendererEpKey : policiesByEpAndPeerExtEp.rowKeySet()) {
 189             RendererEndpointBuilder rendererEpBuilder =
 190                     resolveRendererEndpointBuilder(rendererEpKey, rendererEpBuilderByKey);
 191             List<PeerExternalEndpointWithPolicy> peerExtEpsWithPolicy =
 192                     toListPeerExternalEndpointWithPolicy(policiesByEpAndPeerExtEp.row(rendererEpKey));
 193             rendererEpBuilder.setPeerExternalEndpointWithPolicy(peerExtEpsWithPolicy);
 194             rendererEpBuilderByKey.put(rendererEpKey, rendererEpBuilder);
 195         }
 196         for (RendererEndpointKey rendererEpKey : policiesByEpAndPeerExtCtxEp.rowKeySet()) {
 197             RendererEndpointBuilder rendererEpBuilder =
 198                     resolveRendererEndpointBuilder(rendererEpKey, rendererEpBuilderByKey);
 199             List<PeerExternalContainmentEndpointWithPolicy> peerExtContEpsWithPolicy =
 200                     toListPeerExternalContainmentEndpointWithPolicy(policiesByEpAndPeerExtCtxEp.row(rendererEpKey));
 201             rendererEpBuilder.setPeerExternalContainmentEndpointWithPolicy(peerExtContEpsWithPolicy);
 202             rendererEpBuilderByKey.put(rendererEpKey, rendererEpBuilder);
 203         }
 204         List<RendererEndpoint> rendererEps = new ArrayList<>();
 205         for (RendererEndpointBuilder builder : rendererEpBuilderByKey.values()) {
 206             rendererEps.add(builder.build());
 207         }
 208         return new RendererEndpointsBuilder().setRendererEndpoint(rendererEps).build();
 209     }
 210
 211     private static RendererEndpointBuilder resolveRendererEndpointBuilder(RendererEndpointKey rendererEpKey,
 212             Map<RendererEndpointKey, RendererEndpointBuilder> rendererEpBuilderByKey) {
 213         RendererEndpointBuilder rendererEpBuilder = rendererEpBuilderByKey.get(rendererEpKey);
 214         if (rendererEpBuilder == null) {
 215             rendererEpBuilder = new RendererEndpointBuilder();
 216             rendererEpBuilder.setKey(rendererEpKey);
 217         }
 218         return rendererEpBuilder;
 219     }
 220
 221     private static List<PeerEndpointWithPolicy> toListPeerEndpointWithPolicy(
 222             Map<PeerEndpointKey, Set<RuleGroupWithRendererEndpointParticipation>> policiesByPeerEp) {
 223         List<PeerEndpointWithPolicy> peerEpsWithPolicy = new ArrayList<>();
 224         for (Entry<PeerEndpointKey, Set<RuleGroupWithRendererEndpointParticipation>> entry : policiesByPeerEp
 225             .entrySet()) {
 226             PeerEndpointKey peerEpKey = entry.getKey();
 227             PeerEndpointWithPolicyKey peerEndpointWithPolicyKey = new PeerEndpointWithPolicyKey(peerEpKey.getAddress(),
 228                     peerEpKey.getAddressType(), peerEpKey.getContextId(), peerEpKey.getContextType());
 229             PeerEndpointWithPolicy peerEndpointWithPolicy =
 230                     new PeerEndpointWithPolicyBuilder().setKey(peerEndpointWithPolicyKey)
 231                         .setRuleGroupWithRendererEndpointParticipation(new ArrayList<>(entry.getValue()))
 232                         .build();
 233             peerEpsWithPolicy.add(peerEndpointWithPolicy);
 234         }
 235         return peerEpsWithPolicy;
 236     }
 237
 238     private static List<PeerExternalEndpointWithPolicy> toListPeerExternalEndpointWithPolicy(
 239             Map<PeerExternalEndpointKey, Set<RuleGroupWithRendererEndpointParticipation>> policiesByPeerExtEp) {
 240         List<PeerExternalEndpointWithPolicy> peerExtEpsWithPolicy = new ArrayList<>();
 241         for (Entry<PeerExternalEndpointKey, Set<RuleGroupWithRendererEndpointParticipation>> entry : policiesByPeerExtEp
 242             .entrySet()) {
 243             PeerExternalEndpointKey peerEpKey = entry.getKey();
 244             PeerExternalEndpointWithPolicyKey peerExternalEpWithPolicyKey =
 245                     new PeerExternalEndpointWithPolicyKey(peerEpKey.getAddress(), peerEpKey.getAddressType(),
 246                             peerEpKey.getContextId(), peerEpKey.getContextType());
 247             PeerExternalEndpointWithPolicy peerExternalEpWithPolicy =
 248                     new PeerExternalEndpointWithPolicyBuilder().setKey(peerExternalEpWithPolicyKey)
 249                         .setRuleGroupWithRendererEndpointParticipation(new ArrayList<>(entry.getValue()))
 250                         .build();
 251             peerExtEpsWithPolicy.add(peerExternalEpWithPolicy);
 252         }
 253         return peerExtEpsWithPolicy;
 254     }
 255
 256     private static List<PeerExternalContainmentEndpointWithPolicy> toListPeerExternalContainmentEndpointWithPolicy(
 257             Map<PeerExternalContainmentEndpointKey, Set<RuleGroupWithRendererEndpointParticipation>> policiesByPeerExtContEp) {
 258         List<PeerExternalContainmentEndpointWithPolicy> peerExtContEpsWithPolicy = new ArrayList<>();
 259         for (Entry<PeerExternalContainmentEndpointKey, Set<RuleGroupWithRendererEndpointParticipation>> entry : policiesByPeerExtContEp
 260             .entrySet()) {
 261             PeerExternalContainmentEndpointKey peerEpKey = entry.getKey();
 262             PeerExternalContainmentEndpointWithPolicyKey peerExternalContEpWithPolicyKey =
 263                     new PeerExternalContainmentEndpointWithPolicyKey(peerEpKey.getContextId(),
 264                             peerEpKey.getContextType());
 265             PeerExternalContainmentEndpointWithPolicy peerExternalContEpWithPolicy =
 266                     new PeerExternalContainmentEndpointWithPolicyBuilder().setKey(peerExternalContEpWithPolicyKey)
 267                         .setRuleGroupWithRendererEndpointParticipation(new ArrayList<>(entry.getValue()))
 268                         .build();
 269             peerExtContEpsWithPolicy.add(peerExternalContEpWithPolicy);
 270         }
 271         return peerExtContEpsWithPolicy;
 272     }
 273
 274     public Endpoints buildEndoints(EndpointInfo epInfo, EndpointLocationInfo epLocInfo,
 275             Map<InstanceIdentifier<?>, RendererName> rendererByNode, Set<EndpointAugmentor> augmentors) {
 276         List<AddressEndpointWithLocation> epsWithLoc =
 277                 resolveEpsWithLoc(getAddressEndpointKeys(), epInfo, epLocInfo, rendererByNode, augmentors);
 278         List<ContainmentEndpointWithLocation> contEpsWithLoc =
 279                 resolveContEpsWithLoc(getContainmentEndpointKeys(), epInfo, epLocInfo, augmentors);
 280         return new EndpointsBuilder().setAddressEndpointWithLocation(epsWithLoc)
 281             .setContainmentEndpointWithLocation(contEpsWithLoc)
 282             .build();
 283     }
 284
 285     private static List<AddressEndpointWithLocation> resolveEpsWithLoc(Set<AddressEndpointKey> epKeys,
 286             EndpointInfo epInfo, EndpointLocationInfo epLocInfo,
 287             Map<InstanceIdentifier<?>, RendererName> rendererByNode, Set<EndpointAugmentor> augmentors) {
 288         List<AddressEndpointWithLocation> result = new ArrayList<>();
 289         for (AddressEndpointKey epKey : epKeys) {
 290             Optional<AddressEndpoint> potentialEp = epInfo.getEndpoint(epKey);
 291             Preconditions.checkArgument(potentialEp.isPresent());
 292             Optional<AddressEndpointLocation> potentionalEpLoc = epLocInfo.getAdressEndpointLocation(epKey);
 293             Preconditions.checkArgument(potentionalEpLoc.isPresent());
 294             RendererName rendererName = resolveRendererName(potentionalEpLoc.get(), rendererByNode);
 295             result.add(createEpWithLoc(potentialEp.get(), potentionalEpLoc.get(), rendererName, augmentors));
 296         }
 297         return result;
 298     }
 299
 300     private static RendererName resolveRendererName(AddressEndpointLocation epLoc,
 301             Map<InstanceIdentifier<?>, RendererName> rendererByNode) {
 302         Optional<InstanceIdentifier<?>> potentialAbsNodeLoc = EndpointLocationUtils.resolveAbsoluteNodeLocation(epLoc);
 303         if (potentialAbsNodeLoc.isPresent()) {
 304             return rendererByNode.get(potentialAbsNodeLoc.get());
 305         }
 306         return null;
 307     }
 308
 309     private static AddressEndpointWithLocation createEpWithLoc(AddressEndpoint ep, AddressEndpointLocation epLoc,
 310             RendererName rendererName, Set<EndpointAugmentor> augmentors) {
 311         AddressEndpointWithLocationBuilder addrEpWithLoc = new AddressEndpointWithLocationBuilder()
 312             .setAddress(ep.getAddress())
 313             .setAddressType(ep.getAddressType())
 314             .setContextId(ep.getContextId())
 315             .setContextType(ep.getContextType())
 316             .setTenant(ep.getTenant())
 317             .setChildEndpoint(ep.getChildEndpoint())
 318             .setParentEndpointChoice(ep.getParentEndpointChoice())
 319             .setEndpointGroup(ep.getEndpointGroup())
 320             .setCondition(ep.getCondition())
 321             .setNetworkContainment(ep.getNetworkContainment())
 322             .setTimestamp(ep.getTimestamp())
 323             .setAbsoluteLocation(epLoc.getAbsoluteLocation())
 324             .setRelativeLocations(epLoc.getRelativeLocations())
 325             .setRendererName(rendererName);
 326         for (EndpointAugmentor augmentor : augmentors) {
 327             Entry<Class<? extends Augmentation<AddressEndpointWithLocation>>, Augmentation<AddressEndpointWithLocation>> addrEpWithLocAug =
 328                     augmentor.buildAddressEndpointWithLocationAugmentation(ep);
 329             if (addrEpWithLocAug != null) {
 330                 addrEpWithLoc.addAugmentation(addrEpWithLocAug.getKey(), addrEpWithLocAug.getValue());
 331             }
 332         }
 333         return addrEpWithLoc.build();
 334     }
 335
 336     private static List<ContainmentEndpointWithLocation> resolveContEpsWithLoc(Set<ContainmentEndpointKey> contEpKeys,
 337             EndpointInfo epInfo, EndpointLocationInfo epLocInfo, Set<EndpointAugmentor> augmentors) {
 338         List<ContainmentEndpointWithLocation> result = new ArrayList<>();
 339         for (ContainmentEndpointKey contEpKey : contEpKeys) {
 340             Optional<ContainmentEndpoint> potentialContEp = epInfo.getContainmentEndpoint(contEpKey);
 341             Preconditions.checkArgument(potentialContEp.isPresent());
 342             Optional<ContainmentEndpointLocation> potentialContEpLoc =
 343                     epLocInfo.getContainmentEndpointLocation(contEpKey);
 344             Preconditions.checkArgument(potentialContEpLoc.isPresent());
 345             result.add(createContEpWithLoc(potentialContEp.get(), potentialContEpLoc.get(), augmentors));
 346         }
 347         return result;
 348     }
 349
 350     private static ContainmentEndpointWithLocation createContEpWithLoc(ContainmentEndpoint contEp,
 351             ContainmentEndpointLocation contEpLoc, Set<EndpointAugmentor> augmentors) {
 352         ContainmentEndpointWithLocationBuilder contEpWithLoc = new ContainmentEndpointWithLocationBuilder()
 353             .setContextId(contEp.getContextId())
 354             .setContextType(contEp.getContextType())
 355             .setTenant(contEp.getTenant())
 356             .setChildEndpoint(contEp.getChildEndpoint())
 357             .setEndpointGroup(contEp.getEndpointGroup())
 358             .setCondition(contEp.getCondition())
 359             .setNetworkContainment(contEp.getNetworkContainment())
 360             .setTimestamp(contEp.getTimestamp())
 361             .setRelativeLocations(contEpLoc.getRelativeLocations());
 362         for (EndpointAugmentor augmentor : augmentors) {
 363             Entry<Class<? extends Augmentation<ContainmentEndpointWithLocation>>, Augmentation<ContainmentEndpointWithLocation>> contEpWithLocAug =
 364                     augmentor.buildContainmentEndpointWithLocationAugmentation(contEp);
 365             if (contEpWithLocAug != null) {
 366                 contEpWithLoc.addAugmentation(contEpWithLocAug.getKey(), contEpWithLocAug.getValue());
 367             }
 368         }
 369         return contEpWithLoc.build();
 370     }
 371
 372     public RuleGroups buildRuluGroups(ResolvedPolicyInfo policyInfo) {
 373         List<RuleGroup> ruleGroups = resolveRuleGroups(getPolicyRuleGroupKeys(), policyInfo);
 374         return new RuleGroupsBuilder().setRuleGroup(ruleGroups).build();
 375     }
 376
 377     private List<RuleGroup> resolveRuleGroups(Set<PolicyRuleGroupKey> policyRuleGrpKeys,
 378             ResolvedPolicyInfo policyInfo) {
 379         List<RuleGroup> result = new ArrayList<>();
 380         for (PolicyRuleGroupKey policyRuleGrpKey : policyRuleGrpKeys) {
 381             Optional<PolicyRuleGroup> potentialPolicyRuleGrp = policyInfo.getPolicyRuleGroup(policyRuleGrpKey);
 382             Preconditions.checkArgument(potentialPolicyRuleGrp.isPresent());
 383             result.add(createRuleGroup(potentialPolicyRuleGrp.get()));
 384         }
 385         return result;
 386     }
 387
 388     private RuleGroup createRuleGroup(PolicyRuleGroup policyRuleGrp) {
 389         return new RuleGroupBuilder().setTenantId(policyRuleGrp.getTenantId())
 390             .setContractId(policyRuleGrp.getContractId())
 391             .setSubjectName(policyRuleGrp.getSubjectName())
 392             .setResolvedRule(policyRuleGrp.getResolvedRule())
 393             .setOrder(policyRuleGrp.getOrder())
 394             .build();
 395     }
 396
 397     // TODO this copies entire Forwarding to RendererForwarding - it could copy only forwarding used
 398     // in EPs (renderer EPs + peers)
 399     public RendererForwarding buildRendererForwarding(Forwarding forwarding, Set<NetworkDomainAugmentor> augmentors) {
 400         List<RendererForwardingByTenant> forwardingContextByTenant =
 401                 resolveForwardingContextByTenant(forwarding.getForwardingByTenant(), augmentors);
 402         return new RendererForwardingBuilder().setRendererForwardingByTenant(forwardingContextByTenant).build();
 403     }
 404
 405     private static List<RendererForwardingByTenant> resolveForwardingContextByTenant(
 406             List<ForwardingByTenant> forwardingByTenant, Set<NetworkDomainAugmentor> augmentors) {
 407         List<RendererForwardingByTenant> result = new ArrayList<>();
 408         for (ForwardingByTenant fwdByTenant : forwardingByTenant) {
 409             result.add(resolveRendererForwardingByTenant(fwdByTenant, augmentors));
 410         }
 411         return result;
 412     }
 413
 414     private static RendererForwardingByTenant resolveRendererForwardingByTenant(ForwardingByTenant fwdByTenant,
 415             Set<NetworkDomainAugmentor> augmentors) {
 416         List<RendererForwardingContext> rendererForwardingContexts =
 417                 resolveRendererForwardingContexts(fwdByTenant.getForwardingContext());
 418         List<RendererNetworkDomain> rendererNetworkDomains =
 419                 resolveRendererNetworkDomains(fwdByTenant.getNetworkDomain(), augmentors);
 420         return new RendererForwardingByTenantBuilder().setTenantId(fwdByTenant.getTenantId())
 421             .setRendererForwardingContext(rendererForwardingContexts)
 422             .setRendererNetworkDomain(rendererNetworkDomains)
 423             .build();
 424     }
 425
 426     private static List<RendererForwardingContext> resolveRendererForwardingContexts(
 427             @Nullable List<ForwardingContext> fwdCtx) {
 428         if (fwdCtx == null) {
 429             return Collections.emptyList();
 430         }
 431         return FluentIterable.from(fwdCtx).transform(new Function<ForwardingContext, RendererForwardingContext>() {
 432
 433             @Override
 434             public RendererForwardingContext apply(ForwardingContext input) {
 435                 return new RendererForwardingContextBuilder().setContextId(input.getContextId())
 436                     .setContextType(input.getContextType())
 437                     .setName(input.getName())
 438                     .setParent(input.getParent())
 439                     .build();
 440             }
 441         }).toList();
 442     }
 443
 444     private static List<RendererNetworkDomain> resolveRendererNetworkDomains(@Nullable List<NetworkDomain> netDomains,
 445             Set<NetworkDomainAugmentor> augmentors) {
 446         if (netDomains == null) {
 447             return Collections.emptyList();
 448         }
 449         return FluentIterable.from(netDomains).transform(new Function<NetworkDomain, RendererNetworkDomain>() {
 450
 451             @Override
 452             public RendererNetworkDomain apply(NetworkDomain input) {
 453                 RendererNetworkDomainBuilder rendererNetworkDomainBuilder =
 454                         new RendererNetworkDomainBuilder().setNetworkDomainId(input.getNetworkDomainId())
 455                             .setNetworkDomainType(input.getNetworkDomainType())
 456                             .setName(input.getName())
 457                             .setParent(input.getParent());
 458                 for (NetworkDomainAugmentor augmentor : augmentors) {
 459                     Entry<Class<? extends Augmentation<RendererNetworkDomain>>, Augmentation<RendererNetworkDomain>> networkDomainAugmentation =
 460                             augmentor.buildRendererNetworkDomainAugmentation(input);
 461                     if (networkDomainAugmentation != null) {
 462                         rendererNetworkDomainBuilder.addAugmentation(networkDomainAugmentation.getKey(),
 463                                 networkDomainAugmentation.getValue());
 464                     }
 465                 }
 466                 return rendererNetworkDomainBuilder.build();
 467             }
 468         }).toList();
 469     }
 470
 471 }