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
 171                     .setResolvedRule(buildResolvedRules(ruleGrp.getRules(), ruleGrp.getContractTenant()));
 172                 policyRuleGroups.add(policyRuleGroupBuilder.build());
 173             }
 174             policyRuleGroupWithEndpointConstraintsBuilder.setPolicyRuleGroup(policyRuleGroups);
 175
 176             // add policy group with EP constraints
 177             policyRuleGroupWithEndpointConstraintsList.add(policyRuleGroupWithEndpointConstraintsBuilder.build());
 178         }
 179         return policyRuleGroupWithEndpointConstraintsList;
 180     }
 181
 182     private static List<ResolvedRule> buildResolvedRules(List<Rule> rules, Tenant tenant) {
 183         if (rules == null) {
 184             return null;
 185         }
 186         List<ResolvedRule> resolvedRules = new ArrayList<>();
 187         for (Rule rule : rules) {
 188             ResolvedRuleBuilder resolvedRuleBuilder = new ResolvedRuleBuilder();
 189             resolvedRuleBuilder.setOrder(rule.getOrder());
 190             resolvedRuleBuilder.setName(rule.getName());
 191             resolvedRuleBuilder.setKey(new ResolvedRuleKey(rule.getName()));
 192
 193             List<Classifier> classifiers = new ArrayList<>();
 194             for (ClassifierRef cls : rule.getClassifierRef()) {
 195                 ClassifierBuilder classifierBuilder = new ClassifierBuilder();
 196                 classifierBuilder.setConnectionTracking(convertConnectionTracking(cls.getConnectionTracking()));
 197                 classifierBuilder.setDirection(cls.getDirection());
 198                 classifierBuilder.setKey(new ClassifierKey(cls.getName()));
 199                 classifierBuilder.setName(cls.getName());
 200                 ClassifierInstance classifierInstance = readClassifierInstance(tenant, cls.getInstanceName());
 201                 if (classifierInstance != null) {
 202                     classifierBuilder.setClassifierDefinitionId(classifierInstance.getClassifierDefinitionId());
 203                     classifierBuilder.setParameterValue(classifierInstance.getParameterValue());
 204                 }
 205                 classifiers.add(classifierBuilder.build());
 206             }
 207             resolvedRuleBuilder.setClassifier(classifiers);
 208
 209             List<Action> actions = new ArrayList<>();
 210             for (ActionRef act : rule.getActionRef()) {
 211                 ActionBuilder actionBuilder = new ActionBuilder();
 212                 actionBuilder.setName(act.getName());
 213                 actionBuilder.setKey(new ActionKey(act.getName()));
 214                 actionBuilder.setOrder(act.getOrder());
 215                 ActionInstance actionInstance = readActionInstance(tenant, act.getName());
 216                 if (actionInstance != null) {
 217                     actionBuilder.setActionDefinitionId(actionInstance.getActionDefinitionId());
 218                     actionBuilder.setParameterValue(actionInstance.getParameterValue());
 219                 }
 220                 actions.add(actionBuilder.build());
 221             }
 222             resolvedRuleBuilder.setAction(actions);
 223
 224             // add rule
 225             resolvedRules.add(resolvedRuleBuilder.build());
 226         }
 227         return resolvedRules;
 228     }
 229
 230     private static org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.resolved.policy.rev150828.has.classifiers.Classifier.ConnectionTracking convertConnectionTracking(
 231             ConnectionTracking connectionTracking) {
 232         if (connectionTracking == null) {
 233             return null;
 234         }
 235         return org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.resolved.policy.rev150828.has.classifiers.Classifier.ConnectionTracking
 236             .forValue(connectionTracking.getIntValue());
 237     }
 238
 239     private static ClassifierInstance readClassifierInstance(Tenant tenant, ClassifierName instanceName) {
 240         if (tenant.getPolicy() == null || tenant.getPolicy().getSubjectFeatureInstances() == null
 241                 || tenant.getPolicy().getSubjectFeatureInstances().getClassifierInstance() == null) {
 242             return null;
 243         }
 244         for (ClassifierInstance instance : tenant.getPolicy().getSubjectFeatureInstances().getClassifierInstance()) {
 245             if (instance.getName().equals(instanceName)) {
 246                 return instance;
 247             }
 248         }
 249         return null;
 250     }
 251
 252     private static ActionInstance readActionInstance(Tenant tenant, ActionName instanceName) {
 253         if (tenant.getPolicy() == null || tenant.getPolicy().getSubjectFeatureInstances() == null
 254                 || tenant.getPolicy().getSubjectFeatureInstances().getActionInstance() == null) {
 255             return null;
 256         }
 257         for (ActionInstance instance : tenant.getPolicy().getSubjectFeatureInstances().getActionInstance()) {
 258             if (instance.getName().equals(instanceName)) {
 259                 return instance;
 260             }
 261         }
 262         return null;
 263     }
 264
 265     private static EndpointIdentificationConstraints buildEndpointIdentificationConstraints(
 266             EndpointConstraint endpointConstraint) {
 267         if (isNullOrEmpty(endpointConstraint.getL3EpPrefixes())) {
 268             return null;
 269         }
 270         List<PrefixConstraint> prefixConstraints = new ArrayList<>();
 271         prefixConstraints.addAll(endpointConstraint.getL3EpPrefixes());
 272         L3EndpointIdentificationConstraintsBuilder l3EndpointIdentificationConstraintsBuilder =
 273                 new L3EndpointIdentificationConstraintsBuilder();
 274         l3EndpointIdentificationConstraintsBuilder.setPrefixConstraint(prefixConstraints);
 275         EndpointIdentificationConstraintsBuilder endpointIdentificationConstraintsBuilder =
 276                 new EndpointIdentificationConstraintsBuilder();
 277         endpointIdentificationConstraintsBuilder
 278             .setL3EndpointIdentificationConstraints(l3EndpointIdentificationConstraintsBuilder.build());
 279         return endpointIdentificationConstraintsBuilder.build();
 280     }
 281
 282     private static EndpointConditions buildConditionSet(ConditionSet conditionSet) {
 283         EndpointConditionsBuilder endpointConditionsBuilder = new EndpointConditionsBuilder();
 284
 285         if (isNullOrEmpty(conditionSet.getTypeAll()) && isNullOrEmpty(conditionSet.getTypeAny())
 286                 && isNullOrEmpty(conditionSet.getTypeNone())) {
 287             return null;
 288         }
 289
 290         if (!isNullOrEmpty(conditionSet.getTypeAll())) {
 291             List<AllCondition> allConditions = new ArrayList<>();
 292             for (ConditionName c : conditionSet.getTypeAll()) {
 293                 AllConditionBuilder allConditionBuilder = new AllConditionBuilder();
 294                 allConditionBuilder.setName(c);
 295                 allConditions.add(allConditionBuilder.build());
 296             }
 297             endpointConditionsBuilder.setAllCondition(allConditions);
 298         }
 299         if (!isNullOrEmpty(conditionSet.getTypeNone())) {
 300             List<NoneCondition> noneConditions = new ArrayList<>();
 301             for (ConditionName c : conditionSet.getTypeNone()) {
 302                 NoneConditionBuilder noneConditionBuilder = new NoneConditionBuilder();
 303                 noneConditionBuilder.setName(c);
 304                 noneConditions.add(noneConditionBuilder.build());
 305             }
 306             endpointConditionsBuilder.setNoneCondition(noneConditions);
 307         }
 308         if (!isNullOrEmpty(conditionSet.getTypeAny())) {
 309             Set<ConditionName> typeAnyMergedSet = new HashSet<>();
 310             for (Set<ConditionName> cSet : conditionSet.getTypeAny()) {
 311                 typeAnyMergedSet.addAll(cSet);
 312             }
 313             List<AnyCondition> anyConditions = new ArrayList<>();
 314             for (ConditionName c : typeAnyMergedSet) {
 315                 AnyConditionBuilder anyConditionBuilder = new AnyConditionBuilder();
 316                 anyConditionBuilder.setName(c);
 317                 anyConditions.add(anyConditionBuilder.build());
 318             }
 319             endpointConditionsBuilder.setAnyCondition(anyConditions);
 320         }
 321
 322         return endpointConditionsBuilder.build();
 323     }
 324
 325     private static <T> boolean isNullOrEmpty(Collection<T> collection) {
 326         return (collection == null || collection.isEmpty());
 327     }
 328 }