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