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