protected RollingConcurrencyStream(final HystrixEventStream<HystrixCommandExecutionStarted> inputEventStream, final int numBuckets, final int bucketSizeInMs) { final List<Integer> emptyRollingMaxBuckets = new ArrayList<Integer>(); for (int i = 0; i < numBuckets; i++) { emptyRollingMaxBuckets.add(0); } rollingMaxStream = inputEventStream .observe() .map(getConcurrencyCountFromEvent) .window(bucketSizeInMs, TimeUnit.MILLISECONDS) .flatMap(reduceStreamToMax) .startWith(emptyRollingMaxBuckets) .window(numBuckets, 1) .flatMap(reduceStreamToMax) .share() .onBackpressureDrop(); }
protected RollingDistributionStream(final HystrixEventStream<Event> stream, final int numBuckets, final int bucketSizeInMs, final Func2<Histogram, Event, Histogram> addValuesToBucket) { final List<Histogram> emptyDistributionsToStart = new ArrayList<Histogram>(); for (int i = 0; i < numBuckets; i++) { emptyDistributionsToStart.add(CachedValuesHistogram.getNewHistogram()); } final Func1<Observable<Event>, Observable<Histogram>> reduceBucketToSingleDistribution = new Func1<Observable<Event>, Observable<Histogram>>() { @Override public Observable<Histogram> call(Observable<Event> bucket) { return bucket.reduce(CachedValuesHistogram.getNewHistogram(), addValuesToBucket); } }; rollingDistributionStream = stream .observe() .window(bucketSizeInMs, TimeUnit.MILLISECONDS) //stream of unaggregated buckets .flatMap(reduceBucketToSingleDistribution) //stream of aggregated Histograms .startWith(emptyDistributionsToStart) //stream of aggregated Histograms that starts with n empty .window(numBuckets, 1) //windowed stream: each OnNext is a stream of n Histograms .flatMap(reduceWindowToSingleDistribution) //reduced stream: each OnNext is a single Histogram .map(cacheHistogramValues) //convert to CachedValueHistogram (commonly-accessed values are cached) .share() .onBackpressureDrop(); }
/** * @deprecated Not for public use. Please use {@link #getInstance()}. This facilitates better stream-sharing * @param intervalInMilliseconds milliseconds between data emissions */ @Deprecated //deprecated in 1.5.4. public HystrixUtilizationStream(final int intervalInMilliseconds) { this.intervalInMilliseconds = intervalInMilliseconds; this.allUtilizationStream = Observable.interval(intervalInMilliseconds, TimeUnit.MILLISECONDS) .map(getAllUtilization) .doOnSubscribe(new Action0() { @Override public void call() { isSourceCurrentlySubscribed.set(true); } }) .doOnUnsubscribe(new Action0() { @Override public void call() { isSourceCurrentlySubscribed.set(false); } }) .share() .onBackpressureDrop(); }
/** * @deprecated Not for public use. Please use {@link #getInstance()}. This facilitates better stream-sharing * @param intervalInMilliseconds milliseconds between data emissions */ @Deprecated //deprecated in 1.5.4. public HystrixConfigurationStream(final int intervalInMilliseconds) { this.intervalInMilliseconds = intervalInMilliseconds; this.allConfigurationStream = Observable.interval(intervalInMilliseconds, TimeUnit.MILLISECONDS) .map(getAllConfig) .doOnSubscribe(new Action0() { @Override public void call() { isSourceCurrentlySubscribed.set(true); } }) .doOnUnsubscribe(new Action0() { @Override public void call() { isSourceCurrentlySubscribed.set(false); } }) .share() .onBackpressureDrop(); }
protected BucketedRollingCounterStream(HystrixEventStream<Event> stream, final int numBuckets, int bucketSizeInMs, final Func2<Bucket, Event, Bucket> appendRawEventToBucket, final Func2<Output, Bucket, Output> reduceBucket) { super(stream, numBuckets, bucketSizeInMs, appendRawEventToBucket); Func1<Observable<Bucket>, Observable<Output>> reduceWindowToSummary = new Func1<Observable<Bucket>, Observable<Output>>() { @Override public Observable<Output> call(Observable<Bucket> window) { return window.scan(getEmptyOutputValue(), reduceBucket).skip(numBuckets); } }; this.sourceStream = bucketedStream //stream broken up into buckets .window(numBuckets, 1) //emit overlapping windows of buckets .flatMap(reduceWindowToSummary) //convert a window of bucket-summaries into a single summary .doOnSubscribe(new Action0() { @Override public void call() { isSourceCurrentlySubscribed.set(true); } }) .doOnUnsubscribe(new Action0() { @Override public void call() { isSourceCurrentlySubscribed.set(false); } }) .share() //multiple subscribers should get same data .onBackpressureDrop(); //if there are slow consumers, data should not buffer }
private HystrixDashboardStream(int delayInMs) { this.delayInMs = delayInMs; this.singleSource = Observable.interval(delayInMs, TimeUnit.MILLISECONDS) .map(new Func1<Long, DashboardData>() { @Override public DashboardData call(Long timestamp) { return new DashboardData( HystrixCommandMetrics.getInstances(), HystrixThreadPoolMetrics.getInstances(), HystrixCollapserMetrics.getInstances() ); } }) .doOnSubscribe(new Action0() { @Override public void call() { isSourceCurrentlySubscribed.set(true); } }) .doOnUnsubscribe(new Action0() { @Override public void call() { isSourceCurrentlySubscribed.set(false); } }) .share() .onBackpressureDrop(); }
protected BucketedCumulativeCounterStream(HystrixEventStream<Event> stream, int numBuckets, int bucketSizeInMs, Func2<Bucket, Event, Bucket> reduceCommandCompletion, Func2<Output, Bucket, Output> reduceBucket) { super(stream, numBuckets, bucketSizeInMs, reduceCommandCompletion); this.sourceStream = bucketedStream .scan(getEmptyOutputValue(), reduceBucket) .skip(numBuckets) .doOnSubscribe(new Action0() { @Override public void call() { isSourceCurrentlySubscribed.set(true); } }) .doOnUnsubscribe(new Action0() { @Override public void call() { isSourceCurrentlySubscribed.set(false); } }) .share() //multiple subscribers should get same data .onBackpressureDrop(); //if there are slow consumers, data should not buffer }
@Override public void onStart() { super.onStart(); _subscriptions = new CompositeSubscription(); Observable<Object> tapEventEmitter = _rxBus.toObserverable().share(); _subscriptions// .add(tapEventEmitter.subscribe(new Action1<Object>() { @Override public void call(Object event) { if (event instanceof RxBusDemoFragment.TapEvent) { _showTapText(); } } })); Observable<Object> debouncedEmitter = tapEventEmitter.debounce(1, TimeUnit.SECONDS); Observable<List<Object>> debouncedBufferEmitter = tapEventEmitter.buffer(debouncedEmitter); _subscriptions// .add(debouncedBufferEmitter// .observeOn(AndroidSchedulers.mainThread())// .subscribe(new Action1<List<Object>>() { @Override public void call(List<Object> taps) { _showTapCount(taps.size()); } })); }
final Observable<Event> events = unicastEvents.share();
protected Observable<InstanceInfo.Builder> resolveMutable() { return resultObservable.share(); } }
public static Observable<Boolean> fromConnectivityManager(Context context) { return Observable.create(new BroadcastObservable(context)).share(); }
protected RollingConcurrencyStream(final HystrixEventStream<HystrixCommandExecutionStarted> inputEventStream, final int numBuckets, final int bucketSizeInMs) { final List<Integer> emptyRollingMaxBuckets = new ArrayList<Integer>(); for (int i = 0; i < numBuckets; i++) { emptyRollingMaxBuckets.add(0); } rollingMaxStream = inputEventStream .observe() .map(getConcurrencyCountFromEvent) .window(bucketSizeInMs, TimeUnit.MILLISECONDS) .flatMap(reduceStreamToMax) .startWith(emptyRollingMaxBuckets) .window(numBuckets, 1) .flatMap(reduceStreamToMax) .share() .onBackpressureDrop(); }
public static void main(String[] args) { System.out.println(Observable.interval(1, 1, TimeUnit.MILLISECONDS) .take(2000) .share() .onBackpressureLatest() .subscribeOn(Schedulers.io()) .observeOn(Schedulers.computation(), 16) .doOnNext(System.out::println) .toList() .toBlocking() .last().size()); } }
@Override public Observable<Message<?>> subscribe(String destination, String consumerGroup, Class<?> messagePayloadType) { Tuple<String, String> nameAndConsumerGroup = Tuple.of(destination, consumerGroup); subjectByNameAndGroup.computeIfAbsent(nameAndConsumerGroup, k -> Observable.<Message<?>>create(subscriber -> { this.register(destination, consumerGroup, new EventHubProcessor(subscriber::onNext, messagePayloadType, getCheckpointConfig(), getMessageConverter())); subscriber.add(Subscriptions.create(() -> unregister(destination, consumerGroup))); }).share()); return subjectByNameAndGroup.get(nameAndConsumerGroup); } }
@Override public Observable<Message<?>> subscribe(String destination, String consumerGroup, Class<?> messagePayloadType) { Tuple<String, String> nameAndConsumerGroup = Tuple.of(destination, consumerGroup); subjectByNameAndGroup.computeIfAbsent(nameAndConsumerGroup, k -> Observable.<Message<?>>create(subscriber -> { this.register(destination, consumerGroup, new EventHubProcessor(subscriber::onNext, messagePayloadType, getCheckpointConfig(), getMessageConverter())); subscriber.add(Subscriptions.create(() -> unregister(destination, consumerGroup))); }).share()); return subjectByNameAndGroup.get(nameAndConsumerGroup); }
@Override public Observable<Message<?>> subscribe(String destination, String consumerGroup, Class<?> messagePayloadType) { Tuple<String, String> nameAndConsumerGroup = Tuple.of(destination, consumerGroup); subjectByNameAndGroup.computeIfAbsent(nameAndConsumerGroup, k -> Observable.<Message<?>>create(subscriber -> { this.register(destination, consumerGroup, new EventHubProcessor(subscriber::onNext, messagePayloadType, getCheckpointConfig(), getMessageConverter())); subscriber.add(Subscriptions.create(() -> unregister(destination, consumerGroup))); }).share()); return subjectByNameAndGroup.get(nameAndConsumerGroup); }
@Override public Observable<Message<?>> subscribe(String destination, String consumerGroup, Class<?> messagePayloadType) { Tuple<String, String> nameAndConsumerGroup = Tuple.of(destination, consumerGroup); subjectByNameAndGroup.computeIfAbsent(nameAndConsumerGroup, k -> Observable.<Message<?>>create(subscriber -> { this.register(destination, consumerGroup, new EventHubProcessor(subscriber::onNext, messagePayloadType, getCheckpointConfig(), getMessageConverter())); subscriber.add(Subscriptions.create(() -> unregister(destination, consumerGroup))); }).share()); return subjectByNameAndGroup.get(nameAndConsumerGroup); } }
public static Observable<String> from(Func0<Socket> socketCreator, long quietTimeoutMs, long reconnectDelayMs, Charset charset, Scheduler scheduler) { return strings(socketCreator, charset) // // additional timeout appears to be necessary for certain use // cases like when the server side does not close the socket .timeout(quietTimeoutMs + 100, TimeUnit.MILLISECONDS) // .subscribeOn(scheduler) // // if any exception occurs retry .retryWhen(RetryWhen // .delay(reconnectDelayMs, TimeUnit.MILLISECONDS) // .build()) // // all subscribers use the same stream .share(); }
public CachingSelfInfoResolver(SelfInfoResolver delegate) { this.delegateObservable = delegate.resolve(); this.cachingSubject = BehaviorSubject.create(); control = Observable.<InstanceInfo>never() .doOnSubscribe(new Action0() { @Override public void call() { subscription = delegateObservable.subscribe(cachingSubject); } }) .doOnUnsubscribe(new Action0() { @Override public void call() { if (subscription != null) { subscription.unsubscribe(); } } }) .share(); }
Observable<PGNotification> observe(String channel, long pollingPeriod) { return Observable.<PGNotification>create(subscriber -> { try { Connection connection = DriverManager .getConnection("jdbc:postgresql:db"); subscriber.add(Subscriptions.create(() -> closeQuietly(connection))); listenOn(connection, channel); Jdbc42Connection pgConn = (Jdbc42Connection) connection; pollForNotifications(pollingPeriod, pgConn) .subscribe(Subscribers.wrap(subscriber)); } catch (Exception e) { subscriber.onError(e); } }).share(); }