@Override public Database apply(Exception e) { throw SpannerExceptionFactory.newSpannerException(e); } });
@Override public Instance apply(Exception e) { throw SpannerExceptionFactory.newSpannerException(e); } });
@Override public Instance apply(Exception e) { throw SpannerExceptionFactory.newSpannerException(e); } });
/** * Creates a new exception based on {@code cause}. * * <p>Intended for internal library use; user code should use {@link * #newSpannerException(ErrorCode, String)} instead of this method. */ public static SpannerException newSpannerException(Throwable cause) { return newSpannerException(null, cause); }
@Override public T next() { try { return iterator.next(); } catch (Exception e) { throw SpannerExceptionFactory.newSpannerException(e); } }
@Override public boolean hasNext() { try { return iterator.hasNext(); } catch (Exception e) { throw SpannerExceptionFactory.newSpannerException(e); } }
private PooledSession take() throws SpannerException { SessionOrError s = Uninterruptibles.takeUninterruptibly(waiter); if (s.e != null) { throw newSpannerException(s.e); } return s.session; } }
private static long nextBackOffMillis(BackOff backoff) throws SpannerException { try { return backoff.nextBackOffMillis(); } catch (IOException e) { throw newSpannerException(ErrorCode.INTERNAL, e.getMessage(), e); } }
@Override public void close(@Nullable String message) { try { stream.cancel(); } catch (Exception e) { throw SpannerExceptionFactory.newSpannerException(e); } } }
ResultSetMetadata getMetadata() throws SpannerException { if (metadata == null) { if (!ensureReady(StreamValue.METADATA)) { throw newSpannerException(ErrorCode.INTERNAL, "Stream closed without sending metadata"); } } return metadata; }
@Override public Session answer(InvocationOnMock invocation) throws Throwable { insidePrepare.countDown(); releasePrepare.await(); throw SpannerExceptionFactory.newSpannerException(new RuntimeException()); } })
@Override public Session answer(InvocationOnMock invocation) throws Throwable { insideCreation.countDown(); releaseCreation.await(); throw SpannerExceptionFactory.newSpannerException(new RuntimeException()); } });
private Struct consumeSingleRow(ResultSet resultSet) { if (!resultSet.next()) { return null; } Struct row = resultSet.getCurrentRowAsStruct(); if (resultSet.next()) { throw newSpannerException(ErrorCode.INTERNAL, "Multiple rows returned for single key"); } return row; } }
private static <R, M> Operation<R, M> failed( SpannerRpc rpc, String name, Status status, M metadata, Parser<R, M> parser, ApiClock clock) { SpannerException e = SpannerExceptionFactory.newSpannerException( ErrorCode.fromRpcStatus(status), status.getMessage(), null); return new Operation<R, M>(rpc, name, metadata, null, e, true, parser, clock); }
@Test public void runAbort() { when(txn.isAborted()).thenReturn(true); long backoffMillis = 100L; when(txn.getRetryDelayInMillis(any(BackOff.class))).thenReturn(backoffMillis); runTransaction(SpannerExceptionFactory.newSpannerException(ErrorCode.ABORTED, "")); verify(sleeper, times(1)).backoffSleep(any(Context.class), eq(backoffMillis)); }
@Test public void poolWorksWhenSessionNotFound() { Session mockSession1 = mockSession(); Session mockSession2 = mockSession(); doThrow(SpannerExceptionFactory.newSpannerException(ErrorCode.NOT_FOUND, "Session not found")) .when(mockSession1) .prepareReadWriteTransaction(); when(client.createSession(db)).thenReturn(mockSession1).thenReturn(mockSession2); pool = createPool(); assertThat(((PooledSession) pool.getReadWriteSession()).delegate).isEqualTo(mockSession2); }
@Test public void creationExceptionPropagatesToReadSession() { when(client.createSession(db)) .thenThrow(SpannerExceptionFactory.newSpannerException(ErrorCode.INTERNAL, "")); pool = createPool(); expectedException.expect(isSpannerException(ErrorCode.INTERNAL)); pool.getReadSession(); }
@Test public void abortWithoutRetryInfo() { Status status = Status.fromCodeValue(Status.Code.ABORTED.value()); SpannerException e = SpannerExceptionFactory.newSpannerException(new StatusRuntimeException(status)); assertThat(e).isInstanceOf(AbortedException.class); assertThat(((AbortedException) e).getRetryDelayInMillis()).isEqualTo(-1L); }
@Test public void metadataFailure() { SpannerException t = SpannerExceptionFactory.newSpannerException(ErrorCode.DEADLINE_EXCEEDED, "outatime"); consumer.onError(t); expectedException.expect(isSpannerException(ErrorCode.DEADLINE_EXCEEDED)); expectedException.expectMessage("outatime"); resultSet.next(); }
@Test public void abortWithoutDuration() { Metadata.Key<RetryInfo> key = ProtoUtils.keyForProto(RetryInfo.getDefaultInstance()); Status status = Status.fromCodeValue(Status.Code.ABORTED.value()); Metadata trailers = new Metadata(); trailers.put(key, RetryInfo.getDefaultInstance()); SpannerException e = SpannerExceptionFactory.newSpannerException(new StatusRuntimeException(status, trailers)); assertThat(e).isInstanceOf(AbortedException.class); assertThat(((AbortedException) e).getRetryDelayInMillis()).isEqualTo(-1L); } }