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