HONEYCOMB-100: introduce default 5s timeout

in TranslateUtils.getReplyFor* calls

Change-Id: Iac2bb428ea6adcc8d3da2238db1dec708df550f0
Signed-off-by: Marek Gradzki <mgradzki@cisco.com>

4 files changed, 125 insertions, 19 deletions

diff --git a/v3po/vpp-translate-utils/src/main/java/io/fd/honeycomb/v3po/translate/v3po/util/AbstractInterfaceTypeCustomizer.java b/v3po/vpp-translate-utils/src/main/java/io/fd/honeycomb/v3po/translate/v3po/util/AbstractInterfaceTypeCustomizer.java
index e1a5bf2bc..fd08472d7 100644
--- a/v3po/vpp-translate-utils/src/main/java/io/fd/honeycomb/v3po/translate/v3po/util/AbstractInterfaceTypeCustomizer.java
+++ b/v3po/vpp-translate-utils/src/main/java/io/fd/honeycomb/v3po/translate/v3po/util/AbstractInterfaceTypeCustomizer.java
@@ -65,14 +65,14 @@ public abstract class AbstractInterfaceTypeCustomizer<D extends DataObject>
      */
     @Override
     public final void writeCurrentAttributes(@Nonnull final InstanceIdentifier<D> id, @Nonnull final D dataAfter,
-                                       @Nonnull final WriteContext writeContext) throws WriteFailedException.CreateFailedException {
+                                       @Nonnull final WriteContext writeContext) throws WriteFailedException {
         checkProperInterfaceType(writeContext, id);
         writeInterface(id, dataAfter, writeContext);
     }
 
     protected abstract void writeInterface(final InstanceIdentifier<D> id, final D dataAfter,
                                            final WriteContext writeContext)
-        throws WriteFailedException.CreateFailedException;
+        throws WriteFailedException;
 
     // Validation for update and delete is not necessary
 
diff --git a/v3po/vpp-translate-utils/src/main/java/io/fd/honeycomb/v3po/translate/v3po/util/TranslateUtils.java b/v3po/vpp-translate-utils/src/main/java/io/fd/honeycomb/v3po/translate/v3po/util/TranslateUtils.java
index d44bf8fd5..1a6a50133 100644
--- a/v3po/vpp-translate-utils/src/main/java/io/fd/honeycomb/v3po/translate/v3po/util/TranslateUtils.java
+++ b/v3po/vpp-translate-utils/src/main/java/io/fd/honeycomb/v3po/translate/v3po/util/TranslateUtils.java
@@ -39,30 +39,53 @@ import org.openvpp.jvpp.dto.JVppReply;
 public final class TranslateUtils {
 
     public static final Splitter COLON_SPLITTER = Splitter.on(':');
+    public static final int DEFAULT_TIMEOUT_IN_SECONDS = 5;
 
     private TranslateUtils() {
     }
 
-    public static <REP extends JVppReply<?>> REP getReply(Future<REP> future) throws VppBaseCallException {
+    public static <REP extends JVppReply<?>> REP getReplyForWrite(@Nonnull Future<REP> future,
+                                                                  @Nonnull final InstanceIdentifier<?> replyType)
+        throws VppBaseCallException, WriteTimeoutException {
+        return getReplyForWrite(future, replyType, DEFAULT_TIMEOUT_IN_SECONDS);
+    }
+
+    public static <REP extends JVppReply<?>> REP getReplyForWrite(@Nonnull Future<REP> future,
+                                                                  @Nonnull final InstanceIdentifier<?> replyType,
+                                                                  @Nonnegative final int timeoutInSeconds)
+        throws VppBaseCallException, WriteTimeoutException {
         try {
-            return future.get();
-        } catch (InterruptedException e) {
-            Thread.currentThread().interrupt();
-            throw new IllegalStateException("Interrupted", e);
-        } catch (ExecutionException e) {
-            // Execution exception could generally contains any exception
-            // when using exceptions instead of return codes just rethrow it for processing on corresponding place
-            if (e instanceof ExecutionException && (e.getCause() instanceof VppBaseCallException)) {
-                throw (VppBaseCallException) (e.getCause());
-            }
-            throw new IllegalStateException(e);
+            return getReply(future, timeoutInSeconds);
+        } catch (TimeoutException e) {
+            throw new WriteTimeoutException(replyType, e);
         }
     }
 
+    public static <REP extends JVppReply<?>> REP getReplyForRead(@Nonnull Future<REP> future,
+                                                                 @Nonnull final InstanceIdentifier<?> replyType)
+        throws VppBaseCallException, ReadTimeoutException {
+        return getReplyForRead(future, replyType, DEFAULT_TIMEOUT_IN_SECONDS);
+    }
+
+    public static <REP extends JVppReply<?>> REP getReplyForRead(@Nonnull Future<REP> future,
+                                                                 @Nonnull final InstanceIdentifier<?> replyType,
+                                                                 @Nonnegative final int timeoutInSeconds)
+        throws VppBaseCallException, ReadTimeoutException {
+        try {
+            return getReply(future, timeoutInSeconds);
+        } catch (TimeoutException e) {
+            throw new ReadTimeoutException(replyType, e);
+        }
+    }
+
+    public static <REP extends JVppReply<?>> REP getReply(@Nonnull Future<REP> future)
+        throws TimeoutException, VppBaseCallException {
+        return getReply(future, DEFAULT_TIMEOUT_IN_SECONDS);
+    }
+
     public static <REP extends JVppReply<?>> REP getReply(@Nonnull Future<REP> future,
-                                                          @Nonnull final InstanceIdentifier<?> replyType,
                                                           @Nonnegative final int timeoutInSeconds)
-        throws ReadTimeoutException, VppBaseCallException {
+        throws TimeoutException, VppBaseCallException {
         try {
             checkArgument(timeoutInSeconds > 0, "Timeout cannot be < 0");
             return future.get(timeoutInSeconds, TimeUnit.SECONDS);
@@ -72,12 +95,10 @@ public final class TranslateUtils {
         } catch (ExecutionException e) {
             // Execution exception could generally contains any exception
             // when using exceptions instead of return codes just rethrow it for processing on corresponding place
-            if (e.getCause() instanceof VppBaseCallException) {
+            if (e instanceof ExecutionException && (e.getCause() instanceof VppBaseCallException)) {
                 throw (VppBaseCallException) (e.getCause());
             }
             throw new IllegalStateException(e);
-        } catch (TimeoutException e) {
-            throw new ReadTimeoutException(replyType, e);
         }
     }
 
@@ -188,6 +209,7 @@ public final class TranslateUtils {
 
     /**
      * Reverses bytes in the byte array
+     *
      * @param bytes input array
      * @return reversed array
      */
diff --git a/v3po/vpp-translate-utils/src/main/java/io/fd/honeycomb/v3po/translate/v3po/util/WriteTimeoutException.java b/v3po/vpp-translate-utils/src/main/java/io/fd/honeycomb/v3po/translate/v3po/util/WriteTimeoutException.java
new file mode 100644
index 000000000..9516459b2
--- /dev/null
+++ b/v3po/vpp-translate-utils/src/main/java/io/fd/honeycomb/v3po/translate/v3po/util/WriteTimeoutException.java
@@ -0,0 +1,33 @@
+/*
+ * Copyright (c) 2016 Cisco and/or its affiliates.
+ *
+ * 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.fd.honeycomb.v3po.translate.v3po.util;
+
+import com.google.common.annotations.Beta;
+import io.fd.honeycomb.v3po.translate.write.WriteFailedException;
+import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
+
+/**
+ * Thrown when write method invocation times out.
+ */
+@Beta
+public class WriteTimeoutException extends WriteFailedException {
+
+    public WriteTimeoutException(final InstanceIdentifier<?> id, final Throwable cause) {
+        super(id, cause);
+    }
+
+}
diff --git a/v3po/vpp-translate-utils/src/test/java/io/fd/honeycomb/v3po/translate/v3po/util/TranslateUtilsTest.java b/v3po/vpp-translate-utils/src/test/java/io/fd/honeycomb/v3po/translate/v3po/util/TranslateUtilsTest.java
index 89e7d9d89..334887430 100644
--- a/v3po/vpp-translate-utils/src/test/java/io/fd/honeycomb/v3po/translate/v3po/util/TranslateUtilsTest.java
+++ b/v3po/vpp-translate-utils/src/test/java/io/fd/honeycomb/v3po/translate/v3po/util/TranslateUtilsTest.java
@@ -3,12 +3,62 @@ package io.fd.honeycomb.v3po.translate.v3po.util;
 import static io.fd.honeycomb.v3po.translate.v3po.util.TranslateUtils.reverseBytes;
 import static org.junit.Assert.assertArrayEquals;
 import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertTrue;
+import static org.junit.Assert.fail;
+import static org.mockito.Matchers.anyLong;
+import static org.mockito.Matchers.eq;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.when;
 
+import java.util.concurrent.Future;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.TimeoutException;
 import org.junit.Test;
 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.Ipv4AddressNoZone;
+import org.opendaylight.yangtools.yang.binding.DataContainer;
+import org.opendaylight.yangtools.yang.binding.DataObject;
+import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
+import org.openvpp.jvpp.dto.JVppReply;
 
 public class TranslateUtilsTest {
 
+    private static class AnDataObject implements DataObject {
+        @Override
+        public Class<? extends DataContainer> getImplementedInterface() {
+            return null;
+        }
+    }
+
+    @Test
+    public void testGetReplyForWriteTimeout() throws Exception {
+        final Future<JVppReply<?>> future = mock(Future.class);
+        when(future.get(anyLong(), eq(TimeUnit.SECONDS))).thenThrow(TimeoutException.class);
+        final InstanceIdentifier<AnDataObject> replyType = InstanceIdentifier.create(AnDataObject.class);
+        try {
+            TranslateUtils.getReplyForWrite(future, replyType);
+        } catch (WriteTimeoutException e) {
+            assertTrue(e.getCause() instanceof TimeoutException);
+            assertEquals(replyType, e.getFailedId());
+            return;
+        }
+        fail("WriteTimeoutException was expected");
+    }
+
+    @Test
+    public void testGetReplyForReadTimeout() throws Exception {
+        final Future<JVppReply<?>> future = mock(Future.class);
+        final InstanceIdentifier<AnDataObject> replyType = InstanceIdentifier.create(AnDataObject.class);
+        when(future.get(anyLong(), eq(TimeUnit.SECONDS))).thenThrow(TimeoutException.class);
+        try {
+            TranslateUtils.getReplyForRead(future, replyType);
+        } catch (ReadTimeoutException e) {
+            assertTrue(e.getCause() instanceof TimeoutException);
+            assertEquals(replyType, e.getFailedId());
+            return;
+        }
+        fail("ReadTimeoutException was expected");
+    }
+
     @Test
     public void testIpv4NoZone() throws Exception {
         final Ipv4AddressNoZone ipv4Addr = new Ipv4AddressNoZone("192.168.1.1");
@@ -83,4 +133,5 @@ public class TranslateUtilsTest {
     public void testByteToBooleanFailed() {
         TranslateUtils.byteToBoolean((byte) 123);
     }
+
 }
\ No newline at end of file