com.netflix.hystrix.strategy.properties.HystrixProperty Java Examples

@Override
public ThreadPoolExecutor getThreadPool(HystrixThreadPoolKey threadPoolKey,
    HystrixProperty<Integer> corePoolSize,
    HystrixProperty<Integer> maximumPoolSize,
    HystrixProperty<Integer> keepAliveTime, TimeUnit unit,
    BlockingQueue<Runnable> workQueue) {
  return existingConcurrencyStrategy != null
      ? existingConcurrencyStrategy.getThreadPool(threadPoolKey, corePoolSize,
      maximumPoolSize, keepAliveTime, unit, workQueue)
      : super.getThreadPool(threadPoolKey, corePoolSize, maximumPoolSize,
          keepAliveTime, unit, workQueue);
}
 

@Override
public ThreadPoolExecutor getThreadPool(HystrixThreadPoolKey threadPoolKey,
										HystrixProperty<Integer> corePoolSize,
										HystrixProperty<Integer> maximumPoolSize,
										HystrixProperty<Integer> keepAliveTime, TimeUnit unit,
										BlockingQueue<Runnable> workQueue) {
	return this.delegate.getThreadPool(threadPoolKey, corePoolSize, maximumPoolSize,
			keepAliveTime, unit, workQueue);
}
 

@Override
public ThreadPoolExecutor getThreadPool(HystrixThreadPoolKey threadPoolKey,
                                        HystrixProperty<Integer> corePoolSize,
                                        HystrixProperty<Integer> maximumPoolSize,
                                        HystrixProperty<Integer> keepAliveTime, TimeUnit unit,
                                        BlockingQueue<Runnable> workQueue) {
    return this.delegate.getThreadPool(threadPoolKey, corePoolSize, maximumPoolSize,
            keepAliveTime, unit, workQueue);
}
 

@Override
public ThreadPoolExecutor getThreadPool(HystrixThreadPoolKey threadPoolKey,
                                        HystrixProperty<Integer> corePoolSize,
                                        HystrixProperty<Integer> maximumPoolSize,
                                        HystrixProperty<Integer> keepAliveTime, TimeUnit unit,
                                        BlockingQueue<Runnable> workQueue) {
    return this.delegate.getThreadPool(threadPoolKey, corePoolSize, maximumPoolSize,
        keepAliveTime, unit, workQueue);
}
 

@Override
public ThreadPoolExecutor getThreadPool(HystrixThreadPoolKey threadPoolKey, HystrixProperty<Integer> corePoolSize,
    HystrixProperty<Integer> maximumPoolSize, HystrixProperty<Integer> keepAliveTime, TimeUnit unit,
    BlockingQueue<Runnable> workQueue) {
    return existingConcurrencyStrategy != null
        ? existingConcurrencyStrategy.getThreadPool(threadPoolKey, corePoolSize, maximumPoolSize, keepAliveTime,
            unit, workQueue)
        : super.getThreadPool(threadPoolKey, corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue);
}
 

@Override
public ThreadPoolExecutor getThreadPool(HystrixThreadPoolKey threadPoolKey,
                                        HystrixProperty<Integer> corePoolSize,
                                        HystrixProperty<Integer> maximumPoolSize,
                                        HystrixProperty<Integer> keepAliveTime, TimeUnit unit,
                                        BlockingQueue<Runnable> workQueue) {
    return this.delegate.getThreadPool(threadPoolKey, corePoolSize, maximumPoolSize,
            keepAliveTime, unit, workQueue);
}
 

@Override
public ThreadPoolExecutor getThreadPool(HystrixThreadPoolKey threadPoolKey,
                                        HystrixProperty<Integer> corePoolSize,
                                        HystrixProperty<Integer> maximumPoolSize,
                                        HystrixProperty<Integer> keepAliveTime,
                                        TimeUnit unit, BlockingQueue<Runnable> workQueue) {
    return this.delegate.getThreadPool(threadPoolKey, corePoolSize, maximumPoolSize, keepAliveTime,
            unit, workQueue);
}
 

@Override
public ThreadPoolExecutor getThreadPool(HystrixThreadPoolKey threadPoolKey,
                                        HystrixProperty<Integer> corePoolSize,
                                        HystrixProperty<Integer> maximumPoolSize,
                                        HystrixProperty<Integer> keepAliveTime,
                                        TimeUnit unit, BlockingQueue<Runnable> workQueue) {
    return this.delegate.getThreadPool(threadPoolKey, corePoolSize, maximumPoolSize, keepAliveTime,
            unit, workQueue);
}
 

@Override
public ThreadPoolExecutor getThreadPool(HystrixThreadPoolKey threadPoolKey,
                                        HystrixProperty<Integer> corePoolSize,
                                        HystrixProperty<Integer> maximumPoolSize,
                                        HystrixProperty<Integer> keepAliveTime, TimeUnit unit,
                                        BlockingQueue<Runnable> workQueue) {
    return existingConcurrencyStrategy != null
            ? existingConcurrencyStrategy.getThreadPool(threadPoolKey, corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue)
            : super.getThreadPool(threadPoolKey, corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue);
}
 

@Override
public ThreadPoolExecutor getThreadPool(HystrixThreadPoolKey threadPoolKey,
                                        HystrixProperty<Integer> corePoolSize,
                                        HystrixProperty<Integer> maximumPoolSize,
                                        HystrixProperty<Integer> keepAliveTime, TimeUnit unit,
                                        BlockingQueue<Runnable> workQueue) {
    return existingConcurrencyStrategy != null
            ? existingConcurrencyStrategy.getThreadPool(threadPoolKey, corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue)
            : super.getThreadPool(threadPoolKey, corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue);
}
 

@Override
public ThreadPoolExecutor getThreadPool(HystrixThreadPoolKey threadPoolKey,
                                        HystrixProperty<Integer> corePoolSize,
                                        HystrixProperty<Integer> maximumPoolSize,
                                        HystrixProperty<Integer> keepAliveTime, TimeUnit unit,
                                        BlockingQueue<Runnable> workQueue) {
    return existingConcurrencyStrategy != null
            ? existingConcurrencyStrategy.getThreadPool(threadPoolKey, corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue)
            : super.getThreadPool(threadPoolKey, corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue);
}
 

@Override
public ThreadPoolExecutor getThreadPool(HystrixThreadPoolKey threadPoolKey,
                                        HystrixProperty<Integer> corePoolSize,
                                        HystrixProperty<Integer> maximumPoolSize,
                                        HystrixProperty<Integer> keepAliveTime, TimeUnit unit,
                                        BlockingQueue<Runnable> workQueue) {
    return existingConcurrencyStrategy != null
            ? existingConcurrencyStrategy.getThreadPool(threadPoolKey, corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue)
            : super.getThreadPool(threadPoolKey, corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue);
}
 

@Override
public ThreadPoolExecutor getThreadPool(HystrixThreadPoolKey threadPoolKey,
										HystrixProperty<Integer> corePoolSize,
										HystrixProperty<Integer> maximumPoolSize,
										HystrixProperty<Integer> keepAliveTime, TimeUnit unit,
										BlockingQueue<Runnable> workQueue) {
	return existingConcurrencyStrategy != null
		? existingConcurrencyStrategy.getThreadPool(threadPoolKey, corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue)
		: super.getThreadPool(threadPoolKey, corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue);
}
 

/**
 * {@inheritDoc}
 */
@Override
public ThreadPoolExecutor getThreadPool(HystrixThreadPoolKey threadPoolKey,
                                        HystrixProperty<Integer> corePoolSize,
                                        HystrixProperty<Integer> maximumPoolSize,
                                        HystrixProperty<Integer> keepAliveTime, TimeUnit unit,
                                        BlockingQueue<Runnable> workQueue) {
    return delegate.getThreadPool(threadPoolKey, corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue);
}
 

@Override
public ThreadPoolExecutor getThreadPool(HystrixThreadPoolKey threadPoolKey, HystrixProperty<Integer> corePoolSize,
										HystrixProperty<Integer> maximumPoolSize,
										HystrixProperty<Integer> keepAliveTime, TimeUnit unit,
										BlockingQueue<Runnable> workQueue) {
	return this.delegate.getThreadPool(threadPoolKey, corePoolSize, maximumPoolSize, keepAliveTime, unit,
		workQueue);
}
 

@Override
public ThreadPoolExecutor getThreadPool(HystrixThreadPoolKey threadPoolKey, HystrixProperty<Integer> corePoolSize,
		HystrixProperty<Integer> maximumPoolSize, HystrixProperty<Integer> keepAliveTime, TimeUnit unit,
		BlockingQueue<Runnable> workQueue) {
	return hystrixStrategyMapping.getHystrixStrategies(threadPoolKey)
								 .getHystrixConcurrencyStrategy()
								 .getThreadPool(threadPoolKey, corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue);
}
 

@Override
public HystrixProperty<Integer> fallbackIsolationSemaphoreMaxConcurrentRequests() {
	/*
	 * Astrix does not use the fallback of HystrixCommand to do any unsafe operations, and
	 * we always want to call the getFallback method to get proper handling of a failed
	 * service invocation in Astrix, see HystrixCommandFacade/HystrixObservableCommandFacade.
	 *
	 */
	return HystrixProperty.Factory.asProperty(Integer.MAX_VALUE);
}
 

@Override
public HystrixProperty<ExecutionIsolationStrategy> executionIsolationStrategy() {
	// Don't allow change isolation strategy at runtime
	if (this.isolationStrategy != null) {
		return HystrixProperty.Factory.asProperty(this.isolationStrategy); 
	}
	return HystrixProperty.Factory.asProperty(ExecutionIsolationStrategy.THREAD);
}
 

@Override
public int getPoolQueueSizeRejectionThreshold() {
	return Optional.ofNullable(HystrixThreadPoolMetrics.getInstance(poolKey))
			.map(HystrixThreadPoolMetrics::getProperties)
			.map(HystrixThreadPoolProperties::queueSizeRejectionThreshold)
			.map(HystrixProperty::<Integer>get)
			.orElse(0);
}
 

private HystrixProperty<Integer> getProperty(String propertyPrefix, String command, HystrixCommandKey key,
    String instanceProperty, Integer builderOverrideValue,
    Integer defaultValue) {
  return forInteger()
      .add(propertyPrefix + "." + command + "." + key.name() + "." + instanceProperty, null)
      .add(propertyPrefix + "." + command + "." + serviceKey(key.name()) + "." + instanceProperty,
          null)
      .add(propertyPrefix + "." + command + "." + typeKey(key.name()) + "." + instanceProperty,
          builderOverrideValue == null ? defaultValue : builderOverrideValue)
      .build();
}
 

private HystrixProperty<Boolean> getProperty(String propertyPrefix, String command, HystrixCommandKey key,
    String instanceProperty, Boolean builderOverrideValue, Boolean defaultValue) {
  return forBoolean()
      .add(propertyPrefix + "." + command + "." + key.name() + "." + instanceProperty, null)
      .add(propertyPrefix + "." + command + "." + serviceKey(key.name()) + "." + instanceProperty,
          null)
      .add(propertyPrefix + "." + command + "." + typeKey(key.name()) + "." + instanceProperty,
          builderOverrideValue == null ? defaultValue : builderOverrideValue)
      .build();
}
 

@Override
public ThreadPoolExecutor getThreadPool(HystrixThreadPoolKey threadPoolKey,
                                        HystrixProperty<Integer> corePoolSize,
                                        HystrixProperty<Integer> maximumPoolSize,
                                        HystrixProperty<Integer> keepAliveTime, TimeUnit unit,
                                        BlockingQueue<Runnable> workQueue) {
    if (MultiConfigId.hasMultiSourceId(threadPoolKey)) {
        return strategies.get(MultiConfigId.readFrom(threadPoolKey))
                         .getThreadPool(MultiConfigId.decode(threadPoolKey), corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue);
    }
    else {
        return underlying().map(strategy -> strategy.getThreadPool(threadPoolKey, corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue))
                           .orElseGet(() -> super.getThreadPool(threadPoolKey, corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue));
    }
}
 

@Override
public ThreadPoolExecutor getThreadPool(HystrixThreadPoolKey threadPoolKey,
                                        HystrixProperty<Integer> corePoolSize,
                                        HystrixProperty<Integer> maximumPoolSize,
                                        HystrixProperty<Integer> keepAliveTime,
                                        TimeUnit unit, BlockingQueue<Runnable> workQueue) {
    return this.delegate.getThreadPool(threadPoolKey, corePoolSize, maximumPoolSize, keepAliveTime,
            unit, workQueue);
}
 

@Override
public ThreadPoolExecutor getThreadPool(HystrixThreadPoolKey threadPoolKey,
		HystrixProperty<Integer> corePoolSize,
		HystrixProperty<Integer> maximumPoolSize,
		HystrixProperty<Integer> keepAliveTime, TimeUnit unit,
		BlockingQueue<Runnable> workQueue) {
	return existingConcurrencyStrategy != null
			? existingConcurrencyStrategy.getThreadPool(threadPoolKey, corePoolSize,
					maximumPoolSize, keepAliveTime, unit, workQueue)
			: super.getThreadPool(threadPoolKey, corePoolSize, maximumPoolSize,
					keepAliveTime, unit, workQueue);
}
 

@Override
public HystrixProperty<Integer> executionTimeoutInMilliseconds() {
	return executionTimeoutInMilliseconds;
}
 

@Override
public HystrixProperty<Integer> circuitBreakerErrorThresholdPercentage() {
	return circuitBreakerErrorThresholdPercentage;
}
 

@Override
public HystrixProperty<Integer> circuitBreakerSleepWindowInMilliseconds() {
	return circuitBreakerSleepWindowInMilliseconds;
}
 

@Override
public HystrixProperty<Integer> executionIsolationSemaphoreMaxConcurrentRequests() {
	return executionIsolationSemaphoreMaxConcurrentRequests;
}
 

@Override
public HystrixProperty<Integer> coreSize() {
	return coreSize;
}
 

@Override
public HystrixProperty<Boolean> executionIsolationThreadInterruptOnTimeout() {
	return executionIsolationThreadInterruptOnTimeout;
}