openflowjava/openflow-protocol-impl/src/main/java/org/opendaylight/openflowjava/protocol/impl/deserialization/factories/ErrorMessageFactory.java

   1 /*
   2  * Copyright (c) 2013 Pantheon Technologies s.r.o. 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.openflowjava.protocol.impl.deserialization.factories;
   9
  10 import static org.opendaylight.yangtools.yang.common.netty.ByteBufUtils.readUint32;
  11
  12 import edu.umd.cs.findbugs.annotations.SuppressFBWarnings;
  13 import io.netty.buffer.ByteBuf;
  14 import java.util.Objects;
  15 import org.opendaylight.openflowjava.protocol.api.extensibility.DeserializerRegistry;
  16 import org.opendaylight.openflowjava.protocol.api.extensibility.DeserializerRegistryInjector;
  17 import org.opendaylight.openflowjava.protocol.api.extensibility.OFDeserializer;
  18 import org.opendaylight.openflowjava.protocol.api.util.EncodeConstants;
  19 import org.opendaylight.openflowjava.util.ExperimenterDeserializerKeyFactory;
  20 import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.common.types.rev130731.BadActionCode;
  21 import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.common.types.rev130731.BadInstructionCode;
  22 import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.common.types.rev130731.BadMatchCode;
  23 import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.common.types.rev130731.BadRequestCode;
  24 import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.common.types.rev130731.ErrorType;
  25 import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.common.types.rev130731.FlowModFailedCode;
  26 import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.common.types.rev130731.GroupModFailedCode;
  27 import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.common.types.rev130731.HelloFailedCode;
  28 import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.common.types.rev130731.MeterModFailedCode;
  29 import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.common.types.rev130731.PortModFailedCode;
  30 import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.common.types.rev130731.QueueOpFailedCode;
  31 import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.common.types.rev130731.RoleRequestFailedCode;
  32 import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.common.types.rev130731.SwitchConfigFailedCode;
  33 import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.common.types.rev130731.TableFeaturesFailedCode;
  34 import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.common.types.rev130731.TableModFailedCode;
  35 import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.protocol.rev130731.ErrorMessage;
  36 import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.protocol.rev130731.ErrorMessageBuilder;
  37
  38 /**
  39  * Translates Error messages.
  40  *
  41  * @author michal.polkorab
  42  * @author timotej.kubas
  43  */
  44 public class ErrorMessageFactory implements OFDeserializer<ErrorMessage>,
  45         DeserializerRegistryInjector {
  46
  47     private static final String UNKNOWN_CODE = "UNKNOWN_CODE";
  48     private static final String UNKNOWN_TYPE = "UNKNOWN_TYPE";
  49     private DeserializerRegistry registry;
  50
  51     @Override
  52     @SuppressFBWarnings("UWF_FIELD_NOT_INITIALIZED_IN_CONSTRUCTOR") // FB doesn't recognize Objects.requireNonNull
  53     public ErrorMessage deserialize(ByteBuf rawMessage) {
  54         Objects.requireNonNull(registry);
  55
  56         int startIndex = rawMessage.readerIndex();
  57         ErrorMessageBuilder builder = new ErrorMessageBuilder()
  58                 .setVersion(EncodeConstants.OF_VERSION_1_3)
  59                 .setXid(readUint32(rawMessage));
  60         int type = rawMessage.readUnsignedShort();
  61         ErrorType errorType = ErrorType.forValue(type);
  62         if (ErrorType.EXPERIMENTER.equals(errorType)) {
  63             OFDeserializer<ErrorMessage> deserializer = registry.getDeserializer(
  64                     ExperimenterDeserializerKeyFactory.createExperimenterErrorDeserializerKey(
  65                             EncodeConstants.OF13_VERSION_ID, rawMessage.getUnsignedInt(
  66                                     rawMessage.readerIndex() + EncodeConstants.SIZE_OF_SHORT_IN_BYTES)));
  67             rawMessage.readerIndex(startIndex);
  68             return deserializer.deserialize(rawMessage);
  69         }
  70         decodeType(builder, errorType, type);
  71         decodeCode(rawMessage, builder, errorType);
  72         int remainingBytes = rawMessage.readableBytes();
  73         if (remainingBytes > 0) {
  74             byte[] data = new byte[remainingBytes];
  75             rawMessage.readBytes(data);
  76             builder.setData(data);
  77         }
  78         return builder.build();
  79     }
  80
  81     private static void decodeType(ErrorMessageBuilder builder, ErrorType type, int readValue) {
  82         if (type != null) {
  83             builder.setType(type.getIntValue());
  84             builder.setTypeString(type.name());
  85         } else {
  86             builder.setType(readValue);
  87             builder.setTypeString(UNKNOWN_TYPE);
  88         }
  89     }
  90
  91     private static void decodeCode(ByteBuf rawMessage, ErrorMessageBuilder builder,
  92             ErrorType type) {
  93         int code = rawMessage.readUnsignedShort();
  94         if (type != null) {
  95             switch (type) {
  96                 case HELLOFAILED: {
  97                     HelloFailedCode errorCode = HelloFailedCode.forValue(code);
  98                     if (errorCode != null) {
  99                         setCode(builder, errorCode.getIntValue(), errorCode.name());
 100                     } else {
 101                         setUnknownCode(builder, code);
 102                     }
 103                     break;
 104                 }
 105                 case BADREQUEST: {
 106                     BadRequestCode errorCode = BadRequestCode.forValue(code);
 107                     if (errorCode != null) {
 108                         setCode(builder, errorCode.getIntValue(), errorCode.name());
 109                     } else {
 110                         setUnknownCode(builder, code);
 111                     }
 112                     break;
 113                 }
 114                 case BADACTION: {
 115                     BadActionCode errorCode = BadActionCode.forValue(code);
 116                     if (errorCode != null) {
 117                         setCode(builder, errorCode.getIntValue(), errorCode.name());
 118                     } else {
 119                         setUnknownCode(builder, code);
 120                     }
 121                     break;
 122                 }
 123                 case BADINSTRUCTION: {
 124                     BadInstructionCode errorCode = BadInstructionCode.forValue(code);
 125                     if (errorCode != null) {
 126                         setCode(builder, errorCode.getIntValue(), errorCode.name());
 127                     } else {
 128                         setUnknownCode(builder, code);
 129                     }
 130                     break;
 131                 }
 132                 case BADMATCH: {
 133                     BadMatchCode errorCode = BadMatchCode.forValue(code);
 134                     if (errorCode != null) {
 135                         setCode(builder, errorCode.getIntValue(), errorCode.name());
 136                     } else {
 137                         setUnknownCode(builder, code);
 138                     }
 139                     break;
 140                 }
 141                 case FLOWMODFAILED: {
 142                     FlowModFailedCode errorCode = FlowModFailedCode.forValue(code);
 143                     if (errorCode != null) {
 144                         setCode(builder, errorCode.getIntValue(), errorCode.name());
 145                     } else {
 146                         setUnknownCode(builder, code);
 147                     }
 148                     break;
 149                 }
 150                 case GROUPMODFAILED: {
 151                     GroupModFailedCode errorCode = GroupModFailedCode.forValue(code);
 152                     if (errorCode != null) {
 153                         setCode(builder, errorCode.getIntValue(), errorCode.name());
 154                     } else {
 155                         setUnknownCode(builder, code);
 156                     }
 157                     break;
 158                 }
 159                 case PORTMODFAILED: {
 160                     PortModFailedCode errorCode = PortModFailedCode.forValue(code);
 161                     if (errorCode != null) {
 162                         setCode(builder, errorCode.getIntValue(), errorCode.name());
 163                     } else {
 164                         setUnknownCode(builder, code);
 165                     }
 166                     break;
 167                 }
 168                 case TABLEMODFAILED: {
 169                     TableModFailedCode errorCode = TableModFailedCode.forValue(code);
 170                     if (errorCode != null) {
 171                         setCode(builder, errorCode.getIntValue(), errorCode.name());
 172                     } else {
 173                         setUnknownCode(builder, code);
 174                     }
 175                     break;
 176                 }
 177                 case QUEUEOPFAILED: {
 178                     QueueOpFailedCode errorCode = QueueOpFailedCode.forValue(code);
 179                     if (errorCode != null) {
 180                         setCode(builder, errorCode.getIntValue(), errorCode.name());
 181                     } else {
 182                         setUnknownCode(builder, code);
 183                     }
 184                     break;
 185                 }
 186                 case SWITCHCONFIGFAILED: {
 187                     SwitchConfigFailedCode errorCode = SwitchConfigFailedCode.forValue(code);
 188                     if (errorCode != null) {
 189                         setCode(builder, errorCode.getIntValue(), errorCode.name());
 190                     } else {
 191                         setUnknownCode(builder, code);
 192                     }
 193                     break;
 194                 }
 195                 case ROLEREQUESTFAILED: {
 196                     RoleRequestFailedCode errorCode = RoleRequestFailedCode.forValue(code);
 197                     if (errorCode != null) {
 198                         setCode(builder, errorCode.getIntValue(), errorCode.name());
 199                     } else {
 200                         setUnknownCode(builder, code);
 201                     }
 202                     break;
 203                 }
 204                 case METERMODFAILED: {
 205                     MeterModFailedCode errorCode = MeterModFailedCode.forValue(code);
 206                     if (errorCode != null) {
 207                         setCode(builder, errorCode.getIntValue(), errorCode.name());
 208                     } else {
 209                         setUnknownCode(builder, code);
 210                     }
 211                     break;
 212                 }
 213                 case TABLEFEATURESFAILED: {
 214                     TableFeaturesFailedCode errorCode = TableFeaturesFailedCode.forValue(code);
 215                     if (errorCode != null) {
 216                         setCode(builder, errorCode.getIntValue(), errorCode.name());
 217                     } else {
 218                         setUnknownCode(builder, code);
 219                     }
 220                     break;
 221                 }
 222                 default:
 223                     setUnknownCode(builder, code);
 224                     break;
 225             }
 226         } else {
 227             setUnknownCode(builder, code);
 228         }
 229     }
 230
 231     private static void setUnknownCode(ErrorMessageBuilder builder, int readValue) {
 232         builder.setCode(readValue);
 233         builder.setCodeString(UNKNOWN_CODE);
 234     }
 235
 236     private static void setCode(ErrorMessageBuilder builder, int code, String codeString) {
 237         builder.setCode(code);
 238         builder.setCodeString(codeString);
 239     }
 240
 241     @Override
 242     public void injectDeserializerRegistry(DeserializerRegistry deserializerRegistry) {
 243         this.registry = deserializerRegistry;
 244     }
 245
 246 }