public Observable<R> toObservableWithStateCopiedInto(final AbstractCommand<R> commandToCopyStateInto) { final AtomicBoolean completionLogicRun = new AtomicBoolean(false); return cachedObservable .doOnError(new Action1<Throwable>() { @Override public void call(Throwable throwable) { if (completionLogicRun.compareAndSet(false, true)) { commandCompleted(commandToCopyStateInto); } } }) .doOnCompleted(new Action0() { @Override public void call() { if (completionLogicRun.compareAndSet(false, true)) { commandCompleted(commandToCopyStateInto); } } }) .doOnUnsubscribe(new Action0() { @Override public void call() { if (completionLogicRun.compareAndSet(false, true)) { commandUnsubscribed(commandToCopyStateInto); } } }); }
commandCollapser.mapResponseToRequests(o, shardRequests).doOnError(new Action1<Throwable>() {
@Test public void testSubscribe(){ List<Integer> expected = Arrays.asList( 10, 9, 9, 8, 7, 6, 6, 5, 5, 5, 4, 3, 3, 2, 2, 1, 1, 0); final AtomicInteger i = new AtomicInteger(); Observable.from(expected).doOnNext(x -> { logger.info("print " + x); i.set(x); }).doOnError(e -> logger.error(e.getMessage())).subscribe(); logger.info("last"); assertTrue(i.get()==0); }
@Test public void testSubscribeException() { try { List<Integer> expected = Arrays.asList(10, 9, 9, 8, 7, 6, 6, 5, 5, 5, 4, 3, 3, 2, 2, 1, 1, 0); Observable.from(expected).doOnNext(x -> { logger.info("print " + x); throw new RuntimeException(); }).doOnError(e -> logger.error(e.getMessage())).subscribe(); logger.info("last"); fail(); } catch (Exception e) { } } /**
/** * Completely delete an index. */ public Observable deleteApplication() { String idString = applicationId(applicationScope.getApplication()); final TermQueryBuilder tqb = QueryBuilders.termQuery(APPLICATION_ID_FIELDNAME, idString); final String[] indexes = getIndexes(); //Added For Graphite Metrics return Observable.from( indexes ).flatMap( index -> { final ListenableActionFuture<DeleteByQueryResponse> response = esProvider.getClient().prepareDeleteByQuery( alias.getWriteAlias() ).setQuery( tqb ).execute(); response.addListener( new ActionListener<DeleteByQueryResponse>() { @Override public void onResponse( DeleteByQueryResponse response ) { checkDeleteByQueryResponse( tqb, response ); } @Override public void onFailure( Throwable e ) { logger.error( "Failed on delete index", e.getMessage() ); } } ); return Observable.from( response ); } ).doOnError( t -> logger.error( "Failed on delete application", t.getMessage() ) ); }
@Test public void testThreadContextOnTimeout() { final AtomicBoolean isInitialized = new AtomicBoolean(); new TimeoutCommand().toObservable() .doOnError(new Action1<Throwable>() { @Override public void call(Throwable throwable) { isInitialized.set(HystrixRequestContext.isCurrentThreadInitialized()); } }) .materialize() .toBlocking().single(); System.out.println("initialized = " + HystrixRequestContext.isCurrentThreadInitialized()); System.out.println("initialized inside onError = " + isInitialized.get()); assertEquals(true, isInitialized.get()); }
.doOnError(new Action1<Throwable>() { @Override public void call(Throwable t) {
.doOnError(markExceptionThrown) .doOnTerminate(singleSemaphoreRelease) .doOnUnsubscribe(singleSemaphoreRelease);
@Override public void run( ProgressObserver observer ) { final int version = migrationInfoSerialization.getVersion( getName() ); if ( version == getMaxVersion() ) { if (logger.isDebugEnabled()) { logger.debug("Skipping Migration Plugin: {}", getName()); } return; } observer.start(); AtomicInteger count = new AtomicInteger(); //get old app infos to migrate final Observable<Entity> oldAppInfos = getOldAppInfos(); oldAppInfos.doOnNext( oldAppInfoEntity -> { migrateAppInfo( oldAppInfoEntity, observer ); count.incrementAndGet(); } ) //we want a doOnError to catch something going wrong, otherwise we'll mark as complete .doOnError( error -> { logger.error( "Unable to migrate applications, an error occurred. Please try again", error ); observer.failed( getMaxVersion(), "Unable to migrate applications", error ); } ) //if we complete successfully, set the version and notify the observer .doOnCompleted( () -> { migrationInfoSerialization.setVersion( getName(), getMaxVersion() ); observer.complete(); } ).subscribe();//let this run through since it handles errors }
}).doOnError(throwable -> logger.error("Failed while sending", throwable)); }, 10);
@Override public void write(final ChannelHandlerContext ctx, Object msg, ChannelPromise promise) throws Exception { if (msg instanceof Observable) { Observable msgO = (Observable) msg; final TestWriteSubscriber testSubscriber = new TestWriteSubscriber(promise); msgO.doOnNext(new Action1() { @Override public void call(Object o) { final ChannelPromise channelPromise = ctx.newPromise(); testSubscriber.allPromises.add(channelPromise); if (o instanceof String) { o = Unpooled.buffer().writeBytes(((String) o).getBytes()); } else if (o instanceof byte[]) { o = Unpooled.buffer().writeBytes((byte[]) o); } ctx.write(o, channelPromise); } }).doOnError(new Action1<Throwable>() { @Override public void call(Throwable throwable) { ctx.fireExceptionCaught(throwable); } }).subscribe(testSubscriber); writeObservableSubscribers.add(testSubscriber); } else { super.write(ctx, msg, promise); } } }
@Override public void call(Subscriber<? super PooledConnection<R, W>> subscriber) { final long startTimeNanos = Clock.newStartTimeNanos(); if (limitDeterminationStrategy.acquireCreationPermit(startTimeNanos, NANOSECONDS)) { Observable<Connection<R, W>> newConnObsv = hostConnector.getConnectionProvider() .newConnectionRequest(); newConnObsv.map(new Func1<Connection<R, W>, PooledConnection<R, W>>() { @Override public PooledConnection<R, W> call(Connection<R, W> connection) { return PooledConnection.create(PooledConnectionProviderImpl.this, maxIdleTimeMillis, connection); } }).doOnError(new Action1<Throwable>() { @Override public void call(Throwable throwable) { limitDeterminationStrategy.releasePermit(); /*Before connect we acquired.*/ } }).unsafeSubscribe(subscriber); } else { idleConnectionsHolder.poll() .switchIfEmpty(Observable.<PooledConnection<R, W>>error( new PoolExhaustedException("Client connection pool exhausted."))) .unsafeSubscribe(subscriber); } } });
.doOnError(throwable -> {
observer.update(getMaxVersion(), "running update for " + index); }) .doOnError(t -> { observer.failed(getMaxVersion(),"failed to update",t); })
.doOnError(new Action1<Throwable>() { @Override public void call(Throwable throwable) {
.doOnError(new Action1<Throwable>() { @Override public void call(Throwable ex) {
/** * Tests working with observers */ @Test( expected = TestException.class ) public void throwOnSubscribeObservableNewThread() throws Exception { final ReThrowObserver exceptionObserver = new ReThrowObserver(); Observable.range( 0, 1 ).map(integer -> { throw new TestException("I throw and exception"); }) .doOnError(t -> exceptionObserver.onError(t)) .subscribeOn(Schedulers.newThread()) .subscribe(exceptionObserver); for(int i =0; i<5; i++) { exceptionObserver.checkResult(); Thread.sleep(200); } }
.doOnError(LogErrorAction.INSTANCE)
command.toObservable().doOnError(new Action1<Throwable>() {
command.toObservable().doOnError(new Action1<Throwable>() {