Add exceptions hierarchy

Author: xxlabaza

CHANGELOG.md

@@ -13,6 +13,16 @@ and this project adheres to [Semantic Versioning](http://semver.org/spec/v2.0.0.
 - Add EPMD server.
 - Add more unit and integration tests.
 
+## [0.1.0](https://github.com/appulse-projects/epmd-java/releases/tag/0.1.0) - 2018-01-29
+
+### Added
+
+- Serialization/Deserialization exceptions in `Core`.
+
+### Changed
+
+- Fixed `RegistrationResult` length (it doesn't have this by spec).
+
 ## [0.0.2](https://github.com/appulse-projects/epmd-java/releases/tag/0.0.2) - 2018-01-28
 
 ### Changed

core/pom.xml

@@ -25,7 +25,7 @@ limitations under the License.
   <parent>
     <groupId>io.appulse</groupId>
     <artifactId>epmd-java</artifactId>
-    <version>0.0.2</version>
+    <version>0.1.0</version>
   </parent>
 
   <groupId>io.appulse.epmd.java</groupId>

core/src/main/java/io/appulse/epmd/java/core/mapper/deserializer/DataDeserializer.java

@@ -17,6 +17,7 @@
 package io.appulse.epmd.java.core.mapper.deserializer;
 
 import io.appulse.epmd.java.core.mapper.DataSerializable;
+import io.appulse.epmd.java.core.mapper.deserializer.exception.DeserializationException;
 import io.appulse.utils.Bytes;
 
 /**
@@ -27,8 +28,13 @@
 class DataDeserializer implements Deserializer {
 
   @Override
-  public <T> T deserialize (Bytes bytes, Class<T> type) throws Exception {
-    T result = type.newInstance();
+  public <T> T deserialize (Bytes bytes, Class<T> type) throws DeserializationException {
+    T result;
+    try {
+      result = type.newInstance();
+    } catch (IllegalAccessException | InstantiationException ex) {
+      throw new DeserializationException(ex);
+    }
     ((DataSerializable) result).read(bytes);
     return result;
   }

core/src/main/java/io/appulse/epmd/java/core/mapper/deserializer/Deserializer.java

@@ -16,6 +16,7 @@
 
 package io.appulse.epmd.java.core.mapper.deserializer;
 
+import io.appulse.epmd.java.core.mapper.deserializer.exception.DeserializationException;
 import io.appulse.utils.Bytes;
 
 /**
@@ -25,7 +26,7 @@
  */
 interface Deserializer {
 
-  <T> T deserialize (Bytes buffer, Class<T> type) throws Exception;
+  <T> T deserialize (Bytes buffer, Class<T> type) throws DeserializationException;
 
   boolean isApplicable (Class<?> type);
 }

core/src/main/java/io/appulse/epmd/java/core/mapper/deserializer/EnumDeserializer.java

@@ -18,20 +18,22 @@
 
 import static java.nio.charset.StandardCharsets.ISO_8859_1;
 import static java.util.Arrays.asList;
+import static java.util.Optional.empty;
+import static java.util.Optional.ofNullable;
 
+import java.lang.reflect.InvocationTargetException;
 import java.lang.reflect.Method;
 import java.lang.reflect.Modifier;
-
 import java.util.Collections;
 import java.util.HashSet;
 import java.util.Optional;
 import java.util.Set;
 import java.util.stream.Stream;
 
+import io.appulse.epmd.java.core.mapper.deserializer.exception.DeserializationException;
+import io.appulse.epmd.java.core.mapper.deserializer.exception.EnumUnknownValueException;
 import io.appulse.utils.Bytes;
 
-import lombok.val;
-
 /**
  *
  * @author Artem Labazin
@@ -57,44 +59,62 @@ class EnumDeserializer implements Deserializer {
 
   @Override
   @SuppressWarnings("unchecked")
-  public <T> T deserialize (Bytes bytes, Class<T> type) throws Exception {
-    val string = bytes.getString(ISO_8859_1);
-
-    val constants = type.getEnumConstants();
-    Optional<Object> constant = Stream.of(constants)
-        .map(it -> (Enum<?>) it)
-        .filter(it -> it.name().equals(string))
-        .findAny()
-        .map(it -> (Object) it);
+  public <T> T deserialize (Bytes bytes, Class<T> type) throws DeserializationException {
+    String string = bytes.getString(ISO_8859_1);
+    T[] constants = type.getEnumConstants();
 
+    Optional<Object> constant = findConstant(constants, string);
     if (constant.isPresent()) {
       return (T) constant.get();
     }
 
-    Optional<Method> optional = Stream.of(type.getDeclaredMethods())
-        .filter(it -> Modifier.isStatic(it.getModifiers()))
-        .filter(it -> Modifier.isPublic(it.getModifiers()))
-        .filter(it -> it.getParameterCount() == 1)
-        .filter(it -> it.getParameterTypes()[0] == String.class)
-        .filter(it -> it.getReturnType() == type)
-        .filter(it -> ENUM_CREATE_METHODS_NAMES.contains(it.getName()))
-        .findAny();
-
-    if (optional.isPresent()) {
-      Method method = optional.get();
-      return (T) method.invoke(null, string);
+    Optional<Object> methodResult = getByMethod(type, string);
+    if (methodResult.isPresent()) {
+      return (T) methodResult.get();
     }
 
     Optional<T> undefined = Stream.of(constants)
         .filter(it -> ENUM_UNKNOWN_VALUE.contains(it.toString()))
         .findAny();
 
     return undefined
-        .orElseThrow(() -> new RuntimeException("Unknown enum value " + string));
+        .orElseThrow(() -> new EnumUnknownValueException(string));
   }
 
   @Override
   public boolean isApplicable (Class<?> type) {
     return type.isEnum();
   }
+
+  private Optional<Object> findConstant (Object[] constants, String string) {
+    return Stream.of(constants)
+        .map(it -> (Enum<?>) it)
+        .filter(it -> it.name().equals(string))
+        .findAny()
+        .map(it -> (Object) it);
+  }
+
+  private Optional<Object> getByMethod (Class<?> type, String string) {
+    Optional<Method> optional = Stream.of(type.getDeclaredMethods())
+        .filter(it -> Modifier.isStatic(it.getModifiers()))
+        .filter(it -> Modifier.isPublic(it.getModifiers()))
+        .filter(it -> it.getParameterCount() == 1)
+        .filter(it -> it.getParameterTypes()[0] == String.class)
+        .filter(it -> it.getReturnType() == type)
+        .filter(it -> ENUM_CREATE_METHODS_NAMES.contains(it.getName()))
+        .findAny();
+
+    if (!optional.isPresent()) {
+      return empty();
+    }
+
+    Method method = optional.get();
+    Object result = null;
+    try {
+      result = method.invoke(null, string);
+    } catch (IllegalAccessException | InvocationTargetException ex) {
+      throw new DeserializationException(ex);
+    }
+    return ofNullable(result);
+  }
 }

core/src/main/java/io/appulse/epmd/java/core/mapper/deserializer/MessageDeserializer.java

@@ -24,6 +24,10 @@
 import java.util.List;
 
 import io.appulse.epmd.java.core.mapper.Message;
+import io.appulse.epmd.java.core.mapper.deserializer.exception.InvalidReceivedMessageLengthException;
+import io.appulse.epmd.java.core.mapper.deserializer.exception.InvalidReceivedMessageTagException;
+import io.appulse.epmd.java.core.mapper.deserializer.exception.NoApplicableDeserializerException;
+import io.appulse.epmd.java.core.mapper.exception.MessageAnnotationMissingException;
 import io.appulse.epmd.java.core.model.Tag;
 import io.appulse.utils.Bytes;
 
@@ -50,24 +54,34 @@ public final class MessageDeserializer {
   public <T> T deserialize (byte[] bytes, Class<T> type) {
     val buffer = ofNullable(bytes)
         .map(Bytes::wrap)
-        .orElseThrow(RuntimeException::new);
+        .orElseThrow(NullPointerException::new);
 
     val annotation = ofNullable(type)
         .map(it -> it.getAnnotation(Message.class))
-        .orElseThrow(RuntimeException::new);
+        .orElseThrow(MessageAnnotationMissingException::new);
 
-    val lengthBytes = annotation.lengthBytes();
-    if (lengthBytes > 0 && asInteger(buffer.getBytes(lengthBytes)) != buffer.remaining()) {
-      throw new RuntimeException();
+    if (annotation.lengthBytes() > 0) {
+      val receivedMessageLength = asInteger(buffer.getBytes(annotation.lengthBytes()));
+      if (receivedMessageLength != buffer.remaining()) {
+        val message = String.format("Expected length is %d - %d bytes, but actual length is %d bytes.",
+                                    annotation.lengthBytes(), receivedMessageLength, buffer.remaining());
+        throw new InvalidReceivedMessageLengthException(message);
+      }
     }
-    if (annotation.value() != UNDEFINED && annotation.value() != Tag.of(buffer.getByte())) {
-      throw new RuntimeException();
+
+    if (annotation.value() != UNDEFINED) {
+      val tag = Tag.of(buffer.getByte());
+      if (annotation.value() != tag) {
+        val message = String.format("Expected tag is: %s, but actual tag is: %s",
+                                    annotation.value(), tag);
+        throw new InvalidReceivedMessageTagException(message);
+      }
     }
 
     return DESERIALIZERS.stream()
         .filter(it -> it.isApplicable(type))
         .findAny()
-        .orElseThrow(RuntimeException::new)
+        .orElseThrow(NoApplicableDeserializerException::new)
         .deserialize(buffer, type);
   }
 }

core/src/main/java/io/appulse/epmd/java/core/mapper/deserializer/exception/DeserializationException.java

@@ -0,0 +1,43 @@
+/*
+ * Copyright 2018 the original author or authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package io.appulse.epmd.java.core.mapper.deserializer.exception;
+
+/**
+ *
+ * @author Artem Labazin
+ * @since 0.1.0
+ */
+public class DeserializationException extends RuntimeException {
+
+  private static final long serialVersionUID = -6918027649527350593L;
+
+  public DeserializationException () {
+    super();
+  }
+
+  public DeserializationException (String message) {
+    super(message);
+  }
+
+  public DeserializationException (String message, Throwable cause) {
+    super(message, cause);
+  }
+
+  public DeserializationException (Throwable cause) {
+    super(cause);
+  }
+}

core/src/main/java/io/appulse/epmd/java/core/mapper/deserializer/exception/EnumUnknownValueException.java

@@ -0,0 +1,43 @@
+/*
+ * Copyright 2018 the original author or authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package io.appulse.epmd.java.core.mapper.deserializer.exception;
+
+/**
+ *
+ * @author Artem Labazin
+ * @since 0.1.0
+ */
+public class EnumUnknownValueException extends DeserializationException {
+
+  private static final long serialVersionUID = 1696232532905750930L;
+
+  public EnumUnknownValueException () {
+    super();
+  }
+
+  public EnumUnknownValueException (String message) {
+    super(message);
+  }
+
+  public EnumUnknownValueException (String message, Throwable cause) {
+    super(message, cause);
+  }
+
+  public EnumUnknownValueException (Throwable cause) {
+    super(cause);
+  }
+}

core/src/main/java/io/appulse/epmd/java/core/mapper/deserializer/exception/InvalidReceivedMessageLengthException.java

@@ -0,0 +1,43 @@
+/*
+ * Copyright 2018 the original author or authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package io.appulse.epmd.java.core.mapper.deserializer.exception;
+
+/**
+ *
+ * @author Artem Labazin
+ * @since 0.1.0
+ */
+public class InvalidReceivedMessageLengthException extends DeserializationException {
+
+  private static final long serialVersionUID = 1625435783124656623L;
+
+  public InvalidReceivedMessageLengthException () {
+    super();
+  }
+
+  public InvalidReceivedMessageLengthException (String message) {
+    super(message);
+  }
+
+  public InvalidReceivedMessageLengthException (String message, Throwable cause) {
+    super(message, cause);
+  }
+
+  public InvalidReceivedMessageLengthException (Throwable cause) {
+    super(cause);
+  }
+}