com.netflix.hystrix.HystrixObservableCommand Java Examples

@Override
public void onConstruct(EnhancedInstance objInst, Object[] allArguments) {
    String commandIdentify = "";

    if (HystrixCommand.class.isAssignableFrom(objInst.getClass())) {
        HystrixCommand hystrixCommand = (HystrixCommand) objInst;
        commandIdentify = hystrixCommand.getCommandKey().name();
    } else if (HystrixCollapser.class.isAssignableFrom(objInst.getClass())) {
        HystrixCollapser hystrixCollapser = (HystrixCollapser) objInst;
        commandIdentify = hystrixCollapser.getCollapserKey().name();
    } else if (HystrixObservableCollapser.class.isAssignableFrom(objInst.getClass())) {
        HystrixObservableCollapser hystrixObservableCollapser = (HystrixObservableCollapser) objInst;
        commandIdentify = hystrixObservableCollapser.getCollapserKey().name();
    } else if (HystrixObservableCommand.class.isAssignableFrom(objInst.getClass())) {
        HystrixObservableCommand hystrixObservableCommand = (HystrixObservableCommand) objInst;
        commandIdentify = hystrixObservableCommand.getCommandKey().name();
    }

    objInst.setSkyWalkingDynamicField(new EnhanceRequireObjectCache(OPERATION_NAME_PREFIX + commandIdentify));
}
 

public HttpResourceObservableCommand(HttpClient<ByteBuf, ByteBuf> httpClient,
                                     HttpClientRequest<ByteBuf> httpRequest, String hystrixCacheKey,
                                     Map<String, Object> requestProperties,
                                     FallbackHandler<T> fallbackHandler,
                                     ResponseValidator<HttpClientResponse<ByteBuf>> validator,
                                     Class<? extends T> classType,
                                     HystrixObservableCommand.Setter setter) {
    super(setter);
    this.httpClient = httpClient;
    this.fallbackHandler = fallbackHandler;
    this.validator = validator;
    this.httpRequest = httpRequest;
    this.hystrixCacheKey = hystrixCacheKey;
    this.classType = classType;
    this.requestProperties = requestProperties;
}
 

private <T> HystrixObservableCommand<T> createCommand(Publisher<T> toRun, Function fallback) {
	HystrixObservableCommand.Setter setter = HystrixObservableCommand.Setter.withGroupKey(HystrixCommandGroupKey.Factory.asKey(id))
			.andCommandPropertiesDefaults(commandPropertiesSetter);
	HystrixObservableCommand<T> command = new HystrixObservableCommand<T>(setter) {
		@Override
		protected Observable<T> construct() {
			return RxReactiveStreams.toObservable(toRun);
		}

		@Override
		protected Observable<T> resumeWithFallback() {
			if(fallback == null) {
				super.resumeWithFallback();
			}
			return RxReactiveStreams.toObservable((Publisher)fallback.apply(this.getExecutionException()));
		}
	};
	return command;
}
 

@Test
public void testGetCacheKeyWithContextInitializedConsumer() {

  Invocation invocation = Mockito.mock(Invocation.class);
  Mockito.when(invocation.getOperationMeta()).thenReturn(Mockito.mock(OperationMeta.class));
  Mockito.when(invocation.getOperationMeta().getMicroserviceQualifiedName()).thenReturn("test1");
  HystrixCommandProperties.Setter setter = HystrixCommandProperties.Setter()
      .withRequestCacheEnabled(true)
      .withRequestLogEnabled(false);

  BizkeeperCommand bizkeeperCommand = new ConsumerBizkeeperCommand("groupname", invocation,
      HystrixObservableCommand.Setter
          .withGroupKey(CommandKey.toHystrixCommandGroupKey("groupname", invocation))
          .andCommandKey(CommandKey.toHystrixCommandKey("groupname", invocation))
          .andCommandPropertiesDefaults(setter));

  HystrixRequestContext.initializeContext();
  String cacheKey = bizkeeperCommand.getCacheKey();
  Assert.assertNotNull(cacheKey);
}
 

@Test
public void testConstructConsumer() {

  Invocation invocation = Mockito.mock(Invocation.class);
  Mockito.when(invocation.getOperationMeta()).thenReturn(Mockito.mock(OperationMeta.class));
  Mockito.when(invocation.getOperationMeta().getMicroserviceQualifiedName()).thenReturn("test1");
  HystrixCommandProperties.Setter setter = HystrixCommandProperties.Setter()
      .withRequestCacheEnabled(true)
      .withRequestLogEnabled(false);

  BizkeeperCommand bizkeeperCommand = new ConsumerBizkeeperCommand("groupname", invocation,
      HystrixObservableCommand.Setter
          .withGroupKey(CommandKey.toHystrixCommandGroupKey("groupname", invocation))
          .andCommandKey(CommandKey.toHystrixCommandKey("groupname", invocation))
          .andCommandPropertiesDefaults(setter));

  Observable<Response> response = bizkeeperCommand.construct();
  Assert.assertNotNull(response);
}
 

@Test
public void testResumeWithFallbackConsumer() {

  Invocation invocation = Mockito.mock(Invocation.class);
  Mockito.when(invocation.getOperationMeta()).thenReturn(Mockito.mock(OperationMeta.class));
  Mockito.when(invocation.getOperationMeta().getMicroserviceQualifiedName()).thenReturn("test1");
  HystrixCommandProperties.Setter setter = HystrixCommandProperties.Setter()
      .withRequestCacheEnabled(true)
      .withRequestLogEnabled(false);

  BizkeeperCommand bizkeeperCommand = new ConsumerBizkeeperCommand("groupname", invocation,
      HystrixObservableCommand.Setter
          .withGroupKey(CommandKey.toHystrixCommandGroupKey("groupname", invocation))
          .andCommandKey(CommandKey.toHystrixCommandKey("groupname", invocation))
          .andCommandPropertiesDefaults(setter));

  Observable<Response> observe = bizkeeperCommand.resumeWithFallback();
  Assert.assertNotNull(observe);
}
 

@Test
public void testGetCacheKeyWithContextInitializedProvider() {

  Invocation invocation = Mockito.mock(Invocation.class);
  Mockito.when(invocation.getOperationMeta()).thenReturn(Mockito.mock(OperationMeta.class));
  Mockito.when(invocation.getOperationMeta().getMicroserviceQualifiedName()).thenReturn("test1");
  HystrixCommandProperties.Setter setter = HystrixCommandProperties.Setter()
      .withRequestCacheEnabled(true)
      .withRequestLogEnabled(false);

  BizkeeperCommand bizkeeperCommand = new ProviderBizkeeperCommand("groupname", invocation,
      HystrixObservableCommand.Setter
          .withGroupKey(CommandKey.toHystrixCommandGroupKey("groupname", invocation))
          .andCommandKey(CommandKey.toHystrixCommandKey("groupname", invocation))
          .andCommandPropertiesDefaults(setter));

  HystrixRequestContext.initializeContext();
  String cacheKey = bizkeeperCommand.getCacheKey();
  Assert.assertNotNull(cacheKey);
}
 

@Test
public void testConstructProvider() {

  Invocation invocation = Mockito.mock(Invocation.class);
  Mockito.when(invocation.getOperationMeta()).thenReturn(Mockito.mock(OperationMeta.class));
  Mockito.when(invocation.getOperationMeta().getMicroserviceQualifiedName()).thenReturn("test1");
  HystrixCommandProperties.Setter setter = HystrixCommandProperties.Setter()
      .withRequestCacheEnabled(true)
      .withRequestLogEnabled(false);

  BizkeeperCommand bizkeeperCommand = new ProviderBizkeeperCommand("groupname", invocation,
      HystrixObservableCommand.Setter
          .withGroupKey(CommandKey.toHystrixCommandGroupKey("groupname", invocation))
          .andCommandKey(CommandKey.toHystrixCommandKey("groupname", invocation))
          .andCommandPropertiesDefaults(setter));

  Observable<Response> response = bizkeeperCommand.construct();
  Assert.assertNotNull(response);
}
 

@Test
public void testResumeWithFallbackProvider() {

  Invocation invocation = Mockito.mock(Invocation.class);
  Mockito.when(invocation.getOperationMeta()).thenReturn(Mockito.mock(OperationMeta.class));
  Mockito.when(invocation.getOperationMeta().getMicroserviceQualifiedName()).thenReturn("test1");
  HystrixCommandProperties.Setter setter = HystrixCommandProperties.Setter()
      .withRequestCacheEnabled(true)
      .withRequestLogEnabled(false);

  BizkeeperCommand bizkeeperCommand = new ProviderBizkeeperCommand("groupname", invocation,
      HystrixObservableCommand.Setter
          .withGroupKey(CommandKey.toHystrixCommandGroupKey("groupname", invocation))
          .andCommandKey(CommandKey.toHystrixCommandKey("groupname", invocation))
          .andCommandPropertiesDefaults(setter));

  Observable<Response> observe = bizkeeperCommand.resumeWithFallback();
  Assert.assertNotNull(observe);
}
 

public void toObservable() throws Exception {
    final String name = "Pinpoint";
    final String expectedMessage = HystrixTestHelper.sayHello(name);
    HystrixObservableCommand<String> helloObservableCommand = SayHelloObservableCommand.create(commandGroup, name);
    String actualMessage = helloObservableCommand.toObservable()
            .toBlocking()
            .single();
    Assert.assertEquals(expectedMessage, actualMessage);

    HystrixTestHelper.waitForSpanDataFlush();
}
 

public void observe() throws Exception {
    final String name = "Pinpoint";
    final String expectedMessage = HystrixTestHelper.sayHello(name);
    HystrixObservableCommand<String> helloObservableCommand = SayHelloObservableCommand.create(commandGroup, name);
    String actualMessage = helloObservableCommand.observe()
            .toBlocking()
            .single();
    Assert.assertEquals(expectedMessage, actualMessage);

    HystrixTestHelper.waitForSpanDataFlush();
}
 

public void observeWithException(Exception expectedException) throws Exception {
    final String name = "Pinpoint";
    final String expectedFallbackMessage = HystrixTestHelper.fallbackHello(name);
    HystrixObservableCommand<String> helloObservableCommand = SayHelloObservableCommand.createForException(commandGroup, name, expectedException);
    String actualMessage = helloObservableCommand.observe()
            .toBlocking()
            .single();
    Assert.assertEquals(expectedFallbackMessage, actualMessage);

    HystrixTestHelper.waitForSpanDataFlush();
}
 

public void observeWithTimeout() throws Exception {
    // reducing this too much will make the actual task to not be scheduled at all
    final int timeoutMs = 100;
    final String name = "Pinpoint";
    final String expectedFallbackMessage = HystrixTestHelper.fallbackHello(name);
    HystrixObservableCommand<String> helloObservableCommand = SayHelloObservableCommand.createForTimeout(commandGroup, name, timeoutMs);
    String actualMessage = helloObservableCommand.observe()
            .toBlocking()
            .single();
    Assert.assertEquals(expectedFallbackMessage, actualMessage);

    HystrixTestHelper.waitForSpanDataFlush(timeoutMs);
}
 

public void observeWithShortCircuit() throws Exception {
    final String name = "Pinpoint";
    final String expectedFallbackMessage = HystrixTestHelper.fallbackHello(name);
    HystrixObservableCommand<String> helloObservableCommand = SayHelloObservableCommand.createForShortCircuit(commandGroup, name);
    String actualMessage = helloObservableCommand.observe()
            .toBlocking()
            .single();
    Assert.assertEquals(expectedFallbackMessage, actualMessage);

    HystrixTestHelper.waitForSpanDataFlush();
}
 

public <T> Mono<T> run(Mono<T> toRun, Function<Throwable, Mono<T>> fallback) {
	HystrixObservableCommand<T> command = createCommand(toRun, fallback);

	return Mono.create(s -> {
		Subscription sub = command.toObservable().subscribe(s::success, s::error, s::success);
		s.onCancel(sub::unsubscribe);
	});
}
 

public void toObservableWithException(Exception expectedException) throws Exception {
    final String name = "Pinpoint";
    final String expectedFallbackMessage = HystrixTestHelper.fallbackHello(name);
    HystrixObservableCommand<String> helloObservableCommand = SayHelloObservableCommand.createForException(commandGroup, name, expectedException);
    String actualMessage = helloObservableCommand.toObservable()
            .toBlocking()
            .single();
    Assert.assertEquals(expectedFallbackMessage, actualMessage);

    HystrixTestHelper.waitForSpanDataFlush();
}
 

public void toObservableWithTimeout() throws Exception {
    // reducing this too much will make the actual task to not be scheduled at all
    final int timeoutMs = 100;
    final String name = "Pinpoint";
    final String expectedFallbackMessage = HystrixTestHelper.fallbackHello(name);
    HystrixObservableCommand<String> helloObservableCommand = SayHelloObservableCommand.createForTimeout(commandGroup, name, timeoutMs);
    String actualMessage = helloObservableCommand.toObservable()
            .toBlocking()
            .single();
    Assert.assertEquals(expectedFallbackMessage, actualMessage);

    HystrixTestHelper.waitForSpanDataFlush(timeoutMs);
}
 

public void toObservableWithShortCircuit() throws Exception {
    final String name = "Pinpoint";
    final String expectedFallbackMessage = HystrixTestHelper.fallbackHello(name);
    HystrixObservableCommand<String> helloObservableCommand = SayHelloObservableCommand.createForShortCircuit(commandGroup, name);
    String actualMessage = helloObservableCommand.toObservable()
            .toBlocking()
            .single();
    Assert.assertEquals(expectedFallbackMessage, actualMessage);

    HystrixTestHelper.waitForSpanDataFlush();
}
 

@Override
protected HystrixObservableCommand<Bookmark> createCommand(Collection<CollapsedRequest<Bookmark, Video>> requests) {
    List<Video> videos = new ArrayList<>();
    for (CollapsedRequest<Bookmark, Video> r : requests) {
        videos.add(r.getArgument());
    }
    return new BookmarksCommand(videos, loadBalancer);
}
 

public Observable<ResultCommandPair<T>> toResultCommandPairObservable() {
    Observable<ResultCommandPair<T>> rootObservable = null;
    for (final HystrixObservableCommand<T> command : hystrixCommands) {
        Observable<ResultCommandPair<T>> observable = command.toObservable().map(new Func1<T, ResultCommandPair<T>>() {
            @Override
            public ResultCommandPair<T> call(T result) {
                return new ResultCommandPair<T>(result, command);
            }
        });
        rootObservable = rootObservable == null ? observable : rootObservable.onErrorResumeNext(observable);
    }
    return rootObservable;
}
 

public Observable<T> toObservable() {
    Observable<T> rootObservable = null;
    for (final HystrixObservableCommand<T> command : hystrixCommands) {
        Observable<T> observable = command.toObservable();
        rootObservable = rootObservable == null ? observable : rootObservable.onErrorResumeNext(observable);
    }
    return rootObservable;
}
 

HystrixObservableCommandChain<T> createHystrixCommandChain() {
    List<HystrixObservableCommand<T>> commands = new ArrayList<HystrixObservableCommand<T>>(2);
    if (cacheProvider != null) {
        commands.add(new CacheObservableCommand<T>(cacheProvider.getCacheProvider(), cacheProvider.getKey(), cacheHystrixCacheKey,
                requestProperties, template.cacheHystrixProperties()));
    }
    commands.add(new HttpResourceObservableCommand<T>(client, httpRequest, hystrixCacheKey, requestProperties, template.fallbackHandler(),
            template.responseValidator(), template.getClassType(), template.hystrixProperties()));

    return new HystrixObservableCommandChain<T>(commands);
}
 

private Observable<RibbonResponse<Observable<T>>> convertToRibbonResponse(
        final HystrixObservableCommandChain<T> commandChain, final Observable<ResultCommandPair<T>> hystrixNotificationObservable) {
    return Observable.create(new OnSubscribe<RibbonResponse<Observable<T>>>() {
        @Override
        public void call(
                final Subscriber<? super RibbonResponse<Observable<T>>> t1) {
            final Subject<T, T> subject = ReplaySubject.create();
            hystrixNotificationObservable.materialize().subscribe(new Action1<Notification<ResultCommandPair<T>>>() {
                AtomicBoolean first = new AtomicBoolean(true);

                @Override
                public void call(Notification<ResultCommandPair<T>> notification) {
                    if (first.compareAndSet(true, false)) {
                        HystrixObservableCommand<T> command = notification.isOnError() ? commandChain.getLastCommand() : notification.getValue().getCommand();
                        t1.onNext(new ResponseWithSubject<T>(subject, command));
                        t1.onCompleted();
                    }
                    if (notification.isOnNext()) {
                        subject.onNext(notification.getValue().getResult());
                    } else if (notification.isOnCompleted()) {
                        subject.onCompleted();
                    } else { // onError
                        subject.onError(notification.getThrowable());
                    }
                }
            });
        }
    });
}
 

/**
 * this is build HystrixObservableCommand.Setter.
 *
 * @param hystrixHandle {@linkplain HystrixHandle}
 * @return {@linkplain HystrixObservableCommand.Setter}
 */
public static HystrixObservableCommand.Setter build(final HystrixHandle hystrixHandle) {

    if (hystrixHandle.getMaxConcurrentRequests() == 0) {
        hystrixHandle.setMaxConcurrentRequests(GatewayConstant.MAX_CONCURRENT_REQUESTS);
    }
    if (hystrixHandle.getErrorThresholdPercentage() == 0) {
        hystrixHandle.setErrorThresholdPercentage(GatewayConstant.ERROR_THRESHOLD_PERCENTAGE);
    }
    if (hystrixHandle.getRequestVolumeThreshold() == 0) {
        hystrixHandle.setRequestVolumeThreshold(GatewayConstant.REQUEST_VOLUME_THRESHOLD);
    }
    if (hystrixHandle.getSleepWindowInMilliseconds() == 0) {
        hystrixHandle.setSleepWindowInMilliseconds(GatewayConstant.SLEEP_WINDOW_INMILLISECONDS);
    }

    HystrixCommandGroupKey groupKey = HystrixCommandGroupKey.Factory.asKey(hystrixHandle.getGroupKey());

    HystrixCommandKey commandKey = HystrixCommandKey.Factory.asKey(hystrixHandle.getCommandKey());

    final HystrixCommandProperties.Setter propertiesSetter =
            HystrixCommandProperties.Setter()
                    .withExecutionTimeoutInMilliseconds(hystrixHandle.getTimeout())
                    .withCircuitBreakerEnabled(true)
                    .withExecutionIsolationStrategy(HystrixCommandProperties.ExecutionIsolationStrategy.SEMAPHORE)
                    .withExecutionIsolationSemaphoreMaxConcurrentRequests(hystrixHandle.getMaxConcurrentRequests())
                    .withCircuitBreakerErrorThresholdPercentage(hystrixHandle.getErrorThresholdPercentage())
                    .withCircuitBreakerRequestVolumeThreshold(hystrixHandle.getRequestVolumeThreshold())
                    .withCircuitBreakerSleepWindowInMilliseconds(hystrixHandle.getSleepWindowInMilliseconds());

    return HystrixObservableCommand.Setter
            .withGroupKey(groupKey)
            .andCommandKey(commandKey)
            .andCommandPropertiesDefaults(propertiesSetter);
}
 

@Bean
public Customizer<ReactiveHystrixCircuitBreakerFactory> defaultConfig() {
	return factory -> factory.configureDefault(id -> {
		return HystrixObservableCommand.Setter.withGroupKey(HystrixCommandGroupKey.Factory.asKey(id))
				.andCommandPropertiesDefaults(HystrixCommandProperties.Setter()
						.withExecutionTimeoutInMilliseconds(3000));

	});
}
 

public <T> Flux<T> run(Flux<T> toRun, Function<Throwable, Flux<T>> fallback) {
	HystrixObservableCommand<T> command = createCommand(toRun, fallback);

	return Flux.create(s -> {
		Subscription sub = command.toObservable().subscribe(s::next, s::error, s::complete);
		s.onCancel(sub::unsubscribe);
	});
}
 

/**
 * this is build HystrixObservableCommand.Setter.
 *
 * @param hystrixHandle {@linkplain HystrixHandle}
 * @return {@linkplain HystrixObservableCommand.Setter}
 */
public static HystrixObservableCommand.Setter build(final HystrixHandle hystrixHandle) {
    if (hystrixHandle.getMaxConcurrentRequests() == 0) {
        hystrixHandle.setMaxConcurrentRequests(Constants.MAX_CONCURRENT_REQUESTS);
    }
    if (hystrixHandle.getErrorThresholdPercentage() == 0) {
        hystrixHandle.setErrorThresholdPercentage(Constants.ERROR_THRESHOLD_PERCENTAGE);
    }
    if (hystrixHandle.getRequestVolumeThreshold() == 0) {
        hystrixHandle.setRequestVolumeThreshold(Constants.REQUEST_VOLUME_THRESHOLD);
    }
    if (hystrixHandle.getSleepWindowInMilliseconds() == 0) {
        hystrixHandle.setSleepWindowInMilliseconds(Constants.SLEEP_WINDOW_INMILLISECONDS);
    }
    HystrixCommandGroupKey groupKey = HystrixCommandGroupKey.Factory.asKey(hystrixHandle.getGroupKey());
    HystrixCommandKey commandKey = HystrixCommandKey.Factory.asKey(hystrixHandle.getCommandKey());
    final HystrixCommandProperties.Setter propertiesSetter =
            HystrixCommandProperties.Setter()
                    .withExecutionTimeoutInMilliseconds((int) hystrixHandle.getTimeout())
                    .withCircuitBreakerEnabled(true)
                    .withExecutionIsolationStrategy(HystrixCommandProperties.ExecutionIsolationStrategy.SEMAPHORE)
                    .withExecutionIsolationSemaphoreMaxConcurrentRequests(hystrixHandle.getMaxConcurrentRequests())
                    .withCircuitBreakerErrorThresholdPercentage(hystrixHandle.getErrorThresholdPercentage())
                    .withCircuitBreakerRequestVolumeThreshold(hystrixHandle.getRequestVolumeThreshold())
                    .withCircuitBreakerSleepWindowInMilliseconds(hystrixHandle.getSleepWindowInMilliseconds());
    return HystrixObservableCommand.Setter
            .withGroupKey(groupKey)
            .andCommandKey(commandKey)
            .andCommandPropertiesDefaults(propertiesSetter);
}
 

@Override
public HystrixObservableCommand.Setter create(Target<?> target, MethodMetadata methodMetadata) {
    String groupKey = target.name();
    String commandKey = methodMetadata.configKey();
    return HystrixObservableCommand.Setter
            .withGroupKey(HystrixCommandGroupKey.Factory.asKey(groupKey))
            .andCommandKey(HystrixCommandKey.Factory.asKey(commandKey));
}
 

private CloudReactiveFeign.SetterFactory getSetterFactoryWithTimeoutDisabled() {
      return (target, methodMetadata) -> {
	String groupKey = target.name();
	HystrixCommandKey commandKey = HystrixCommandKey.Factory.asKey(methodMetadata.configKey());
	return HystrixObservableCommand.Setter
			.withGroupKey(HystrixCommandGroupKey.Factory.asKey(groupKey))
			.andCommandKey(commandKey)
			.andCommandPropertiesDefaults(HystrixCommandProperties.Setter()
					.withExecutionTimeoutEnabled(false)
			);
};
  }
 

@Override
protected BizkeeperCommand createBizkeeperCommand(Invocation invocation) {
  HystrixCommandProperties.Setter setter = HystrixCommandProperties.Setter()
      .withRequestCacheEnabled(false)
      .withRequestLogEnabled(false);
  setCommonProperties(invocation, setter);

  BizkeeperCommand command = new ProviderBizkeeperCommand(groupname, invocation,
      HystrixObservableCommand.Setter
          .withGroupKey(CommandKey.toHystrixCommandGroupKey(groupname, invocation))
          .andCommandKey(CommandKey.toHystrixCommandKey(groupname, invocation))
          .andCommandPropertiesDefaults(setter));
  return command;
}