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