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