mdsalutil/mdsalutil-api/src/main/java/org/opendaylight/genius/mdsalutil/actions/ActionNxConntrack.java

   1 /*
   2  * Copyright © 2016, 2017 Red Hat, Inc. and others.
   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.genius.mdsalutil.actions;
   9
  10 import java.util.ArrayList;
  11 import java.util.Collections;
  12 import java.util.List;
  13 import java.util.stream.Collectors;
  14
  15 import org.opendaylight.genius.mdsalutil.ActionInfo;
  16 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.IpAddress;
  17 import org.opendaylight.yang.gen.v1.urn.opendaylight.action.types.rev131112.action.list.Action;
  18 import org.opendaylight.yang.gen.v1.urn.opendaylight.action.types.rev131112.action.list.ActionBuilder;
  19 import org.opendaylight.yang.gen.v1.urn.opendaylight.action.types.rev131112.action.list.ActionKey;
  20 import org.opendaylight.yang.gen.v1.urn.opendaylight.openflowplugin.extension.nicira.action.rev140714.nodes.node.table.flow.instructions.instruction.instruction.apply.actions._case.apply.actions.action.action.NxActionConntrackNodesNodeTableFlowApplyActionsCaseBuilder;
  21 import org.opendaylight.yang.gen.v1.urn.opendaylight.openflowplugin.extension.nicira.action.rev140714.nx.action.conntrack.grouping.NxConntrackBuilder;
  22 import org.opendaylight.yang.gen.v1.urn.opendaylight.openflowplugin.extension.nicira.action.rev140714.nx.action.conntrack.grouping.nx.conntrack.CtActions;
  23 import org.opendaylight.yang.gen.v1.urn.opendaylight.openflowplugin.extension.nicira.action.rev140714.nx.action.conntrack.grouping.nx.conntrack.CtActionsBuilder;
  24 import org.opendaylight.yang.gen.v1.urn.opendaylight.openflowplugin.extension.nicira.action.rev140714.ofpact.actions.ofpact.actions.NxActionCtMarkCaseBuilder;
  25 import org.opendaylight.yang.gen.v1.urn.opendaylight.openflowplugin.extension.nicira.action.rev140714.ofpact.actions.ofpact.actions.NxActionNatCaseBuilder;
  26 import org.opendaylight.yang.gen.v1.urn.opendaylight.openflowplugin.extension.nicira.action.rev140714.ofpact.actions.ofpact.actions.nx.action.ct.mark._case.NxActionCtMarkBuilder;
  27 import org.opendaylight.yang.gen.v1.urn.opendaylight.openflowplugin.extension.nicira.action.rev140714.ofpact.actions.ofpact.actions.nx.action.nat._case.NxActionNatBuilder;
  28
  29 /**
  30  * NX conntrack action.
  31  */
  32 public class ActionNxConntrack extends ActionInfo {
  33     private static final long serialVersionUID = 1L;
  34
  35     private final int flags;
  36     private final long zoneSrc;
  37     private final int conntrackZone;
  38     private final short recircTable;
  39     private final List<NxCtAction> ctActions = new ArrayList<>();
  40
  41     public ActionNxConntrack(int flags, long zoneSrc, int conntrackZone, short recircTable) {
  42         this(0, flags, zoneSrc, conntrackZone, recircTable, Collections.emptyList());
  43     }
  44
  45     public ActionNxConntrack(int flags, long zoneSrc, int conntrackZone, short recircTable,
  46             List<NxCtAction> ctActions) {
  47         this(0, flags, zoneSrc, conntrackZone, recircTable, ctActions);
  48     }
  49
  50     public ActionNxConntrack(int actionKey, int flags, long zoneSrc, int conntrackZone, short recircTable) {
  51         this(actionKey, flags, zoneSrc, conntrackZone, recircTable, Collections.emptyList());
  52     }
  53
  54     public ActionNxConntrack(int actionKey, int flags, long zoneSrc, int conntrackZone, short recircTable,
  55             List<NxCtAction> ctActions) {
  56         super(actionKey);
  57         this.flags = flags;
  58         this.zoneSrc = zoneSrc;
  59         this.conntrackZone = conntrackZone;
  60         this.recircTable = recircTable;
  61         this.ctActions.addAll(ctActions);
  62     }
  63
  64     @Override
  65     public Action buildAction() {
  66         return buildAction(getActionKey());
  67     }
  68
  69     @Override
  70     public Action buildAction(int newActionKey) {
  71         NxConntrackBuilder ctb = new NxConntrackBuilder()
  72                 .setFlags(flags)
  73                 .setZoneSrc(zoneSrc)
  74                 .setConntrackZone(conntrackZone)
  75                 .setRecircTable(recircTable);
  76         ctb.setCtActions(this.ctActions.stream().map(NxCtAction::buildCtActions).collect(Collectors.toList()));
  77         ActionBuilder ab = new ActionBuilder();
  78         ab.setAction(new NxActionConntrackNodesNodeTableFlowApplyActionsCaseBuilder()
  79                 .setNxConntrack(ctb.build()).build());
  80         ab.setKey(new ActionKey(newActionKey));
  81         return ab.build();
  82     }
  83
  84     public int getFlags() {
  85         return flags;
  86     }
  87
  88     public long getZoneSrc() {
  89         return zoneSrc;
  90     }
  91
  92     public int getConntrackZone() {
  93         return conntrackZone;
  94     }
  95
  96     public short getRecircTable() {
  97         return recircTable;
  98     }
  99
 100     public List<NxCtAction> getCtActions() {
 101         return ctActions;
 102     }
 103
 104     @Override
 105     public boolean equals(Object other) {
 106         if (this == other) {
 107             return true;
 108         }
 109         if (other == null || getClass() != other.getClass()) {
 110             return false;
 111         }
 112         if (!super.equals(other)) {
 113             return false;
 114         }
 115
 116         ActionNxConntrack that = (ActionNxConntrack) other;
 117
 118         if (flags != that.flags) {
 119             return false;
 120         }
 121         if (zoneSrc != that.zoneSrc) {
 122             return false;
 123         }
 124         if (conntrackZone != that.conntrackZone) {
 125             return false;
 126         }
 127         if (recircTable != that.recircTable) {
 128             return false;
 129         }
 130         return ctActions.equals(that.ctActions);
 131     }
 132
 133     @Override
 134     public int hashCode() {
 135         int result = super.hashCode();
 136         result = 31 * result + flags;
 137         result = 31 * result + (int) (zoneSrc ^ zoneSrc >>> 32);
 138         result = 31 * result + conntrackZone;
 139         result = 31 * result + recircTable;
 140         result = 31 * result + ctActions.hashCode();
 141         return result;
 142     }
 143
 144     @Override
 145     public String toString() {
 146         return "ActionNxConntrack [flags=" + flags + ", zoneSrc=" + zoneSrc + ", conntrackZone=" + conntrackZone
 147                 + ", recircTable=" + recircTable + ", ctActions=" + ctActions + ", getActionKey()=" + getActionKey()
 148                 + "]";
 149     }
 150
 151     public interface NxCtAction {
 152         CtActions buildCtActions();
 153     }
 154
 155     public static class NxNat implements NxCtAction {
 156         private final int flags;
 157         private final int rangePresent;
 158         private final IpAddress ipAddressMin;
 159         private final IpAddress ipAddressMax;
 160         private final int portMin;
 161         private final int portMax;
 162
 163         public NxNat(int actionKey, int flags, int natType, IpAddress ipAddressMin,
 164                 IpAddress ipAddressMax,int portMin, int portMax) {
 165             this.flags = flags;
 166             this.rangePresent = natType;
 167             this.ipAddressMin = ipAddressMin;
 168             this.ipAddressMax = ipAddressMax;
 169             this.portMin = portMin;
 170             this.portMax = portMax;
 171         }
 172
 173         public int getFlags() {
 174             return flags;
 175         }
 176
 177         public int getRangePresent() {
 178             return rangePresent;
 179         }
 180
 181         public IpAddress getIpAddressMin() {
 182             return ipAddressMin;
 183         }
 184
 185         public IpAddress getIpAddressMax() {
 186             return ipAddressMax;
 187         }
 188
 189         public int getPortMin() {
 190             return portMin;
 191         }
 192
 193         public int getPortMax() {
 194             return portMax;
 195         }
 196
 197         @Override
 198         public CtActions buildCtActions() {
 199             NxActionNatBuilder nxActionNatBuilder = new NxActionNatBuilder()
 200                     .setFlags(flags)
 201                     .setRangePresent(rangePresent)
 202                     .setIpAddressMin(ipAddressMin)
 203                     .setIpAddressMax(ipAddressMax)
 204                     .setPortMin(portMin)
 205                     .setPortMax(portMax);
 206
 207             CtActionsBuilder ctActionsBuilder = new CtActionsBuilder();
 208             NxActionNatCaseBuilder caseBuilder = new NxActionNatCaseBuilder();
 209             caseBuilder.setNxActionNat(nxActionNatBuilder.build());
 210             ctActionsBuilder.setOfpactActions(caseBuilder.build());
 211             return ctActionsBuilder.build();
 212         }
 213
 214         @Override
 215         public boolean equals(Object other) {
 216             if (this == other) {
 217                 return true;
 218             }
 219             if (other == null || getClass() != other.getClass()) {
 220                 return false;
 221             }
 222
 223             NxNat that = (NxNat) other;
 224
 225             if (flags != that.flags) {
 226                 return false;
 227             }
 228             if (rangePresent != that.rangePresent) {
 229                 return false;
 230             }
 231             if (ipAddressMin != null ? !ipAddressMin.equals(that.ipAddressMin) : that.ipAddressMin != null) {
 232                 return false;
 233             }
 234             if (ipAddressMax != null ? !ipAddressMax.equals(that.ipAddressMax) : that.ipAddressMax != null) {
 235                 return false;
 236             }
 237             if (portMin != that.portMin) {
 238                 return false;
 239             }
 240             return portMax == that.portMax;
 241         }
 242
 243         @Override
 244         public int hashCode() {
 245             int result = flags;
 246             result = 31 * result + rangePresent;
 247             result = 31 * result + ipAddressMin.hashCode();
 248             result = 31 * result + ipAddressMax.hashCode();
 249             result = 31 * result + portMin;
 250             result = 31 * result + portMax;
 251             return result;
 252         }
 253
 254         @Override
 255         public String toString() {
 256             return "NxNat [flags=" + flags + ", rangePresent=" + rangePresent + ", ipAddressMin=" + ipAddressMin
 257                     + ", ipAddressMax=" + ipAddressMax + ", portMin=" + portMin + ", portMax=" + portMax + "]";
 258         }
 259     }
 260
 261     public static class NxCtMark implements NxCtAction {
 262         private final long ctMark;
 263
 264         public NxCtMark(long ctMark) {
 265             this.ctMark = ctMark;
 266         }
 267
 268         @Override
 269         public CtActions buildCtActions() {
 270             NxActionCtMarkBuilder nxActionCtMarkBuilder = new NxActionCtMarkBuilder()
 271                     .setCtMark(ctMark);
 272
 273             CtActionsBuilder ctActionsBuilder = new CtActionsBuilder();
 274             NxActionCtMarkCaseBuilder caseBuilder = new NxActionCtMarkCaseBuilder();
 275             caseBuilder.setNxActionCtMark(nxActionCtMarkBuilder.build());
 276             ctActionsBuilder.setOfpactActions(caseBuilder.build());
 277             return ctActionsBuilder.build();
 278         }
 279
 280         @Override
 281         public boolean equals(Object other) {
 282             if (this == other) {
 283                 return true;
 284             }
 285             if (other == null || getClass() != other.getClass()) {
 286                 return false;
 287             }
 288
 289             NxCtMark that = (NxCtMark) other;
 290
 291             return ctMark == that.ctMark;
 292         }
 293
 294         @Override
 295         public int hashCode() {
 296             return 31 * (int) (ctMark ^ (ctMark >>> 32));
 297         }
 298     }
 299 }