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