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