groupbasedpolicy/src/main/java/org/opendaylight/groupbasedpolicy/util/PolicyInfoUtils.java

   1 /*
   2  * Copyright (c) 2015 Huawei Technologies 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 package org.opendaylight.groupbasedpolicy.util;
   9
  10 import java.util.ArrayList;
  11 import java.util.Collection;
  12 import java.util.HashSet;
  13 import java.util.List;
  14 import java.util.Set;
  15 import java.util.concurrent.ConcurrentMap;
  16
  17 import com.google.common.annotations.VisibleForTesting;
  18 import org.opendaylight.groupbasedpolicy.dto.ConditionSet;
  19 import org.opendaylight.groupbasedpolicy.dto.EgKey;
  20 import org.opendaylight.groupbasedpolicy.dto.EndpointConstraint;
  21 import org.opendaylight.groupbasedpolicy.dto.IndexedTenant;
  22 import org.opendaylight.groupbasedpolicy.dto.Policy;
  23 import org.opendaylight.groupbasedpolicy.dto.RuleGroup;
  24 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.common.rev140421.ActionName;
  25 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.common.rev140421.ClassifierName;
  26 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.common.rev140421.ConditionName;
  27 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.common.rev140421.EndpointGroupId;
  28 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.common.rev140421.TenantId;
  29 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.policy.rev140421.has.action.refs.ActionRef;
  30 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.policy.rev140421.has.classifier.refs.ClassifierRef;
  31 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.policy.rev140421.has.classifier.refs.ClassifierRef.ConnectionTracking;
  32 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.policy.rev140421.has.endpoint.identification.constraints.EndpointIdentificationConstraints;
  33 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.policy.rev140421.has.endpoint.identification.constraints.EndpointIdentificationConstraintsBuilder;
  34 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.policy.rev140421.has.endpoint.identification.constraints.endpoint.identification.constraints.L3EndpointIdentificationConstraintsBuilder;
  35 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.policy.rev140421.has.endpoint.identification.constraints.endpoint.identification.constraints.l3.endpoint.identification.constraints.PrefixConstraint;
  36 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.policy.rev140421.tenants.Tenant;
  37 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.policy.rev140421.tenants.tenant.policy.contract.subject.Rule;
  38 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.policy.rev140421.tenants.tenant.policy.subject.feature.instances.ActionInstance;
  39 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.policy.rev140421.tenants.tenant.policy.subject.feature.instances.ClassifierInstance;
  40 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.resolved.policy.rev150828.has.actions.Action;
  41 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.resolved.policy.rev150828.has.actions.ActionBuilder;
  42 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.resolved.policy.rev150828.has.actions.ActionKey;
  43 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.resolved.policy.rev150828.has.classifiers.Classifier;
  44 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.resolved.policy.rev150828.has.classifiers.ClassifierBuilder;
  45 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.resolved.policy.rev150828.has.classifiers.ClassifierKey;
  46 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.resolved.policy.rev150828.has.endpoint.conditions.EndpointConditions;
  47 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.resolved.policy.rev150828.has.endpoint.conditions.EndpointConditionsBuilder;
  48 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.resolved.policy.rev150828.has.endpoint.conditions.endpoint.conditions.AllCondition;
  49 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.resolved.policy.rev150828.has.endpoint.conditions.endpoint.conditions.AllConditionBuilder;
  50 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.resolved.policy.rev150828.has.endpoint.conditions.endpoint.conditions.AnyCondition;
  51 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.resolved.policy.rev150828.has.endpoint.conditions.endpoint.conditions.AnyConditionBuilder;
  52 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.resolved.policy.rev150828.has.endpoint.conditions.endpoint.conditions.NoneCondition;
  53 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.resolved.policy.rev150828.has.endpoint.conditions.endpoint.conditions.NoneConditionBuilder;
  54 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.resolved.policy.rev150828.has.resolved.rules.ResolvedRule;
  55 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.resolved.policy.rev150828.has.resolved.rules.ResolvedRuleBuilder;
  56 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.resolved.policy.rev150828.has.resolved.rules.ResolvedRuleKey;
  57 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.resolved.policy.rev150828.resolved.policies.ResolvedPolicy;
  58 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.resolved.policy.rev150828.resolved.policies.ResolvedPolicy.ExternalImplicitGroup;
  59 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.resolved.policy.rev150828.resolved.policies.ResolvedPolicyBuilder;
  60 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.resolved.policy.rev150828.resolved.policies.resolved.policy.PolicyRuleGroupWithEndpointConstraints;
  61 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.resolved.policy.rev150828.resolved.policies.resolved.policy.PolicyRuleGroupWithEndpointConstraintsBuilder;
  62 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.resolved.policy.rev150828.resolved.policies.resolved.policy.policy.rule.group.with.endpoint.constraints.ConsumerEndpointConstraintsBuilder;
  63 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.resolved.policy.rev150828.resolved.policies.resolved.policy.policy.rule.group.with.endpoint.constraints.PolicyRuleGroup;
  64 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.resolved.policy.rev150828.resolved.policies.resolved.policy.policy.rule.group.with.endpoint.constraints.PolicyRuleGroupBuilder;
  65 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.resolved.policy.rev150828.resolved.policies.resolved.policy.policy.rule.group.with.endpoint.constraints.ProviderEndpointConstraintsBuilder;
  66 import org.slf4j.Logger;
  67 import org.slf4j.LoggerFactory;
  68
  69 import com.google.common.collect.Table;
  70 import com.google.common.collect.Table.Cell;
  71
  72 public class PolicyInfoUtils {
  73     private static final Logger LOG = LoggerFactory.getLogger(PolicyInfoUtils.class);
  74     private PolicyInfoUtils() {
  75         throw new UnsupportedOperationException("Cannot create an instance");
  76     }
  77
  78     public static List<ResolvedPolicy> buildResolvedPolicy(Table<EgKey, EgKey, Policy> policyMap,
  79             ConcurrentMap<TenantId, IndexedTenant> resolvedTenants) {
  80         List<ResolvedPolicy> resolvedPolicies = new ArrayList<>();
  81         for (Cell<EgKey, EgKey, Policy> policyCell : policyMap.cellSet()) {
  82             ResolvedPolicyBuilder resolvedPolicyBuilder = new ResolvedPolicyBuilder();
  83             resolvedPolicyBuilder.setConsumerEpgId(policyCell.getRowKey().getEgId());
  84             resolvedPolicyBuilder.setConsumerTenantId(policyCell.getRowKey().getTenantId());
  85             resolvedPolicyBuilder.setProviderEpgId(policyCell.getColumnKey().getEgId());
  86             resolvedPolicyBuilder.setProviderTenantId(policyCell.getColumnKey().getTenantId());
  87             resolvedPolicyBuilder.setPolicyRuleGroupWithEndpointConstraints(
  88                     buildPolicyRuleGroupWithEndpointConstraints(policyCell.getValue()));
  89             Tenant consTenant = resolvedTenants.get(policyCell.getRowKey().getTenantId()).getTenant();
  90             Tenant provTenant = resolvedTenants.get(policyCell.getColumnKey().getTenantId()).getTenant();
  91             if (isExternalImplicitGroup(consTenant, policyCell.getRowKey().getEgId())) {
  92                 resolvedPolicyBuilder.setExternalImplicitGroup(ExternalImplicitGroup.ConsumerEpg);
  93             } else if (isExternalImplicitGroup(provTenant, policyCell.getColumnKey().getEgId())) {
  94                 resolvedPolicyBuilder.setExternalImplicitGroup(ExternalImplicitGroup.ProviderEpg);
  95             }
  96             resolvedPolicies.add(resolvedPolicyBuilder.build());
  97         }
  98         return resolvedPolicies;
  99     }
 100
 101     private static boolean isExternalImplicitGroup(Tenant tenant, EndpointGroupId epgId) {
 102         if (tenant == null || epgId == null || tenant.getPolicy() == null
 103                 || tenant.getPolicy().getExternalImplicitGroup() == null) {
 104             return false;
 105         }
 106         LOG.trace("Found External EPGs in Tenant {}", tenant.getId().getValue());
 107         for (org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.policy.rev140421.tenants.tenant.policy.ExternalImplicitGroup eig : tenant.getPolicy()
 108             .getExternalImplicitGroup()) {
 109             if (eig.getId().equals(epgId)) {
 110                 LOG.trace("EPG {} is External Implicit Group", epgId.getValue());
 111                 return true;
 112             }
 113         }
 114         LOG.trace("EPG {} is NOT External Implicit Group", epgId.getValue());
 115         return false;
 116     }
 117
 118     private static List<PolicyRuleGroupWithEndpointConstraints> buildPolicyRuleGroupWithEndpointConstraints(
 119             Policy policy) {
 120         List<PolicyRuleGroupWithEndpointConstraints> policyRuleGroupWithEndpointConstraintsList = new ArrayList<>();
 121         for (Cell<EndpointConstraint, EndpointConstraint, List<RuleGroup>> ruleGrpsWECCell : policy.getRuleMap()
 122             .cellSet()) {
 123             PolicyRuleGroupWithEndpointConstraintsBuilder policyRuleGroupWithEndpointConstraintsBuilder =
 124                     new PolicyRuleGroupWithEndpointConstraintsBuilder();
 125
 126             // consumer
 127             EndpointConditions consConditionSet = buildConditionSet(ruleGrpsWECCell.getRowKey().getConditionSet());
 128             EndpointIdentificationConstraints consEndpointIdentificationConstraints =
 129                     buildEndpointIdentificationConstraints(ruleGrpsWECCell.getRowKey());
 130             ConsumerEndpointConstraintsBuilder consumerEndpointConstraintsBuilder =
 131                     new ConsumerEndpointConstraintsBuilder();
 132
 133             if (consConditionSet != null) {
 134                 consumerEndpointConstraintsBuilder.setEndpointConditions(consConditionSet);
 135             }
 136             if (consEndpointIdentificationConstraints != null) {
 137                 consumerEndpointConstraintsBuilder
 138                     .setEndpointIdentificationConstraints(consEndpointIdentificationConstraints);
 139             }
 140             if (consConditionSet != null || consEndpointIdentificationConstraints != null) {
 141                 policyRuleGroupWithEndpointConstraintsBuilder
 142                     .setConsumerEndpointConstraints(consumerEndpointConstraintsBuilder.build());
 143             }
 144
 145             // provider
 146             EndpointConditions provConditionSet = buildConditionSet(ruleGrpsWECCell.getColumnKey().getConditionSet());
 147             EndpointIdentificationConstraints provEndpointIdentificationConstraints =
 148                     buildEndpointIdentificationConstraints(ruleGrpsWECCell.getColumnKey());
 149             ProviderEndpointConstraintsBuilder providerEndpointConstraintsBuilder =
 150                     new ProviderEndpointConstraintsBuilder();
 151
 152             if (provConditionSet != null) {
 153                 providerEndpointConstraintsBuilder.setEndpointConditions(provConditionSet);
 154             }
 155             if (provEndpointIdentificationConstraints != null) {
 156                 providerEndpointConstraintsBuilder
 157                     .setEndpointIdentificationConstraints(provEndpointIdentificationConstraints);
 158             }
 159             if (provConditionSet != null || provEndpointIdentificationConstraints != null) {
 160                 policyRuleGroupWithEndpointConstraintsBuilder
 161                     .setProviderEndpointConstraints(providerEndpointConstraintsBuilder.build());
 162             }
 163
 164             // Policy groups
 165             List<PolicyRuleGroup> policyRuleGroups = new ArrayList<>();
 166             for (RuleGroup ruleGrp : ruleGrpsWECCell.getValue()) {
 167                 PolicyRuleGroupBuilder policyRuleGroupBuilder = new PolicyRuleGroupBuilder();
 168                 policyRuleGroupBuilder.setContractId(ruleGrp.getRelatedContract().getId());
 169                 policyRuleGroupBuilder.setSubjectName(ruleGrp.getRelatedSubject());
 170                 policyRuleGroupBuilder.setTenantId(ruleGrp.getContractTenant().getId());
 171                 policyRuleGroupBuilder.setOrder(ruleGrp.getOrder());
 172                 policyRuleGroupBuilder
 173                     .setResolvedRule(buildResolvedRules(ruleGrp.getRules(), ruleGrp.getContractTenant()));
 174                 policyRuleGroups.add(policyRuleGroupBuilder.build());
 175             }
 176             policyRuleGroupWithEndpointConstraintsBuilder.setPolicyRuleGroup(policyRuleGroups);
 177
 178             // add policy group with EP constraints
 179             policyRuleGroupWithEndpointConstraintsList.add(policyRuleGroupWithEndpointConstraintsBuilder.build());
 180         }
 181         return policyRuleGroupWithEndpointConstraintsList;
 182     }
 183
 184     @VisibleForTesting
 185     static List<ResolvedRule> buildResolvedRules(List<Rule> rules, Tenant tenant) {
 186         if (rules == null) {
 187             return null;
 188         }
 189         List<ResolvedRule> resolvedRules = new ArrayList<>();
 190         for (Rule rule : rules) {
 191             ResolvedRuleBuilder resolvedRuleBuilder = new ResolvedRuleBuilder();
 192             resolvedRuleBuilder.setOrder(rule.getOrder());
 193             resolvedRuleBuilder.setName(rule.getName());
 194             resolvedRuleBuilder.setKey(new ResolvedRuleKey(rule.getName()));
 195
 196             List<Classifier> classifiers = new ArrayList<>();
 197             for (ClassifierRef cls : rule.getClassifierRef()) {
 198                 ClassifierBuilder classifierBuilder = new ClassifierBuilder();
 199                 classifierBuilder.setConnectionTracking(convertConnectionTracking(cls.getConnectionTracking()));
 200                 classifierBuilder.setDirection(cls.getDirection());
 201                 classifierBuilder.setKey(new ClassifierKey(cls.getName()));
 202                 classifierBuilder.setName(cls.getName());
 203                 ClassifierInstance classifierInstance = readClassifierInstance(tenant, cls.getInstanceName());
 204                 if (classifierInstance != null) {
 205                     classifierBuilder.setClassifierDefinitionId(classifierInstance.getClassifierDefinitionId());
 206                     classifierBuilder.setParameterValue(classifierInstance.getParameterValue());
 207                 }
 208                 classifiers.add(classifierBuilder.build());
 209             }
 210             resolvedRuleBuilder.setClassifier(classifiers);
 211
 212             List<Action> actions = new ArrayList<>();
 213             for (ActionRef act : rule.getActionRef()) {
 214                 ActionBuilder actionBuilder = new ActionBuilder();
 215                 actionBuilder.setName(act.getName());
 216                 actionBuilder.setKey(new ActionKey(act.getName()));
 217                 actionBuilder.setOrder(act.getOrder());
 218                 ActionInstance actionInstance = readActionInstance(tenant, act.getName());
 219                 if (actionInstance != null) {
 220                     actionBuilder.setActionDefinitionId(actionInstance.getActionDefinitionId());
 221                     actionBuilder.setParameterValue(actionInstance.getParameterValue());
 222                 }
 223                 actions.add(actionBuilder.build());
 224             }
 225             resolvedRuleBuilder.setAction(actions);
 226
 227             // add rule
 228             resolvedRules.add(resolvedRuleBuilder.build());
 229         }
 230         return resolvedRules;
 231     }
 232
 233     private static org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.resolved.policy.rev150828.has.classifiers.Classifier.ConnectionTracking convertConnectionTracking(
 234             ConnectionTracking connectionTracking) {
 235         if (connectionTracking == null) {
 236             return null;
 237         }
 238         return org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.resolved.policy.rev150828.has.classifiers.Classifier.ConnectionTracking
 239             .forValue(connectionTracking.getIntValue());
 240     }
 241
 242     private static ClassifierInstance readClassifierInstance(Tenant tenant, ClassifierName instanceName) {
 243         if (tenant.getPolicy() == null || tenant.getPolicy().getSubjectFeatureInstances() == null
 244                 || tenant.getPolicy().getSubjectFeatureInstances().getClassifierInstance() == null) {
 245             return null;
 246         }
 247         for (ClassifierInstance instance : tenant.getPolicy().getSubjectFeatureInstances().getClassifierInstance()) {
 248             if (instance.getName().equals(instanceName)) {
 249                 return instance;
 250             }
 251         }
 252         return null;
 253     }
 254
 255     private static ActionInstance readActionInstance(Tenant tenant, ActionName instanceName) {
 256         if (tenant.getPolicy() == null || tenant.getPolicy().getSubjectFeatureInstances() == null
 257                 || tenant.getPolicy().getSubjectFeatureInstances().getActionInstance() == null) {
 258             return null;
 259         }
 260         for (ActionInstance instance : tenant.getPolicy().getSubjectFeatureInstances().getActionInstance()) {
 261             if (instance.getName().equals(instanceName)) {
 262                 return instance;
 263             }
 264         }
 265         return null;
 266     }
 267
 268     private static EndpointIdentificationConstraints buildEndpointIdentificationConstraints(
 269             EndpointConstraint endpointConstraint) {
 270         if (isNullOrEmpty(endpointConstraint.getL3EpPrefixes())) {
 271             return null;
 272         }
 273         List<PrefixConstraint> prefixConstraints = new ArrayList<>();
 274         prefixConstraints.addAll(endpointConstraint.getL3EpPrefixes());
 275         L3EndpointIdentificationConstraintsBuilder l3EndpointIdentificationConstraintsBuilder =
 276                 new L3EndpointIdentificationConstraintsBuilder();
 277         l3EndpointIdentificationConstraintsBuilder.setPrefixConstraint(prefixConstraints);
 278         EndpointIdentificationConstraintsBuilder endpointIdentificationConstraintsBuilder =
 279                 new EndpointIdentificationConstraintsBuilder();
 280         endpointIdentificationConstraintsBuilder
 281             .setL3EndpointIdentificationConstraints(l3EndpointIdentificationConstraintsBuilder.build());
 282         return endpointIdentificationConstraintsBuilder.build();
 283     }
 284
 285     private static EndpointConditions buildConditionSet(ConditionSet conditionSet) {
 286         EndpointConditionsBuilder endpointConditionsBuilder = new EndpointConditionsBuilder();
 287
 288         if (isNullOrEmpty(conditionSet.getTypeAll()) && isNullOrEmpty(conditionSet.getTypeAny())
 289                 && isNullOrEmpty(conditionSet.getTypeNone())) {
 290             return null;
 291         }
 292
 293         if (!isNullOrEmpty(conditionSet.getTypeAll())) {
 294             List<AllCondition> allConditions = new ArrayList<>();
 295             for (ConditionName c : conditionSet.getTypeAll()) {
 296                 AllConditionBuilder allConditionBuilder = new AllConditionBuilder();
 297                 allConditionBuilder.setName(c);
 298                 allConditions.add(allConditionBuilder.build());
 299             }
 300             endpointConditionsBuilder.setAllCondition(allConditions);
 301         }
 302         if (!isNullOrEmpty(conditionSet.getTypeNone())) {
 303             List<NoneCondition> noneConditions = new ArrayList<>();
 304             for (ConditionName c : conditionSet.getTypeNone()) {
 305                 NoneConditionBuilder noneConditionBuilder = new NoneConditionBuilder();
 306                 noneConditionBuilder.setName(c);
 307                 noneConditions.add(noneConditionBuilder.build());
 308             }
 309             endpointConditionsBuilder.setNoneCondition(noneConditions);
 310         }
 311         if (!isNullOrEmpty(conditionSet.getTypeAny())) {
 312             Set<ConditionName> typeAnyMergedSet = new HashSet<>();
 313             for (Set<ConditionName> cSet : conditionSet.getTypeAny()) {
 314                 typeAnyMergedSet.addAll(cSet);
 315             }
 316             List<AnyCondition> anyConditions = new ArrayList<>();
 317             for (ConditionName c : typeAnyMergedSet) {
 318                 AnyConditionBuilder anyConditionBuilder = new AnyConditionBuilder();
 319                 anyConditionBuilder.setName(c);
 320                 anyConditions.add(anyConditionBuilder.build());
 321             }
 322             endpointConditionsBuilder.setAnyCondition(anyConditions);
 323         }
 324
 325         return endpointConditionsBuilder.build();
 326     }
 327
 328     private static <T> boolean isNullOrEmpty(Collection<T> collection) {
 329         return (collection == null || collection.isEmpty());
 330     }
 331 }