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