Creates a new {@link HttpHealthCheckedEndpointGroup} instance.

@deprecated Use {@link HttpHealthCheckedEndpointGroupBuilder}.
350599
@Deprecated
    public static HttpHealthCheckedEndpointGroup of(ClientFactory clientFactory,
                                                    EndpointGroup delegate,
                                                    String healthCheckPath,
                                                    Duration healthCheckRetryInterval) {
        return new HttpHealthCheckedEndpointGroupBuilder(delegate, healthCheckPath)
                .clientFactory(clientFactory)
                .retryInterval(healthCheckRetryInterval)
                .build();
    }
262916
public BoundRequestBuilder createRequest()
            throws HttpRequestCreateException {
        BoundRequestBuilder builder = null;

        getLogger().debug("AHC completeUrl " + requestUrl);

        try {

            switch (httpMethod) {
            case GET:
                builder = client.prepareGet(requestUrl);
                break;
            case POST:
                builder = client.preparePost(requestUrl);
                break;
            case PUT:
                builder = client.preparePut(requestUrl);
                break;
            case HEAD:
                builder = client.prepareHead(requestUrl);
                break;
            case OPTIONS:
                builder = client.prepareOptions(requestUrl);
                break;
            case DELETE:
                builder = client.prepareDelete(requestUrl);
                break;
            default:
                break;
            }

            PcHttpUtils.addHeaders(builder, this.httpHeaderMap);
            if (!Strings.isNullOrEmpty(postData)) {
                builder.setBody(postData);
                String charset = "";
                if (null!=this.httpHeaderMap) {
                    charset = this.httpHeaderMap.get("charset");
                }
                if(!Strings.isNullOrEmpty(charset)) {
                    builder.setBodyEncoding(charset);
                }
            }

        } catch (Exception t) {
            throw new HttpRequestCreateException(
                    "Error in creating request in Httpworker. "
                            + " If BoundRequestBuilder is null. Then fail to create.",
                    t);
        }

        return builder;

    }
1189876
private RestEndpointGroup getEndpointGroup(String commandLine) {
        if (commandLine == null) {
            return null;
        }
        StringTokenizer st = new StringTokenizer(commandLine);
        String operation = nextToken(st);
        // If the operation doesn't have a parser, then it's unknown.
        if (parsers.getParser(operation) == null) {
            return null;
        }
        // the operation is a HTTP method so the next token should be a resource path
        String requestUri = nextToken(st);
        return requestUri != null ? getHttpApiEndpointGroup(operation, requestUri) : null;
    }
341582
public static <GROUP extends Serializable> ExecutorConfig<GROUP> basicGroupable() {
        return new ExecutorConfig<GROUP>()
                    .withTaskIdAdapter((TaskIdAdapter<Groupable<GROUP>, GROUP, ?>) new DefaultGroupableTaskIdAdapter<GROUP>());
    }
310088
@Singleton
    @Requires(missingBeans = HttpTracing.class)
    HttpTracing httpTracing(Tracing tracing) {
        return HttpTracing.create(tracing);
    }
850125
public DnsAddressEndpointGroup build() {
        return new DnsAddressEndpointGroup(eventLoop(), minTtl(), maxTtl(),
                                           serverAddressStreamProvider(), backoff(),
                                           resolvedAddressTypes, hostname(), port);
    }
294742
public static RestEndpoint createDefault() {
        return new HttpClientRestEndpoint(HttpAsyncClients.createDefault(),
                Lists.newArrayList(
                        new TextSerializer(),
                        new ByteArraySerializer(), new GsonSerializer()),
                new DefaultErrorHandler());
    }
614010
public void setEndpointGroups(java.util.Collection<EndpointGroup> endpointGroups) {
        if (endpointGroups == null) {
            this.endpointGroups = null;
            return;
        }

        this.endpointGroups = new java.util.ArrayList<EndpointGroup>(endpointGroups);
    }
1210450
private Retrofit.Builder setEndpoint(Retrofit.Builder retrofitBuilder, String endpoint) {
    if (endpoint != null) {
      return retrofitBuilder.baseUrl(endpoint);
    }
    return retrofitBuilder;
  }
271944
@Deprecated
    public B service(PathMapping pathMapping, Service<HttpRequest, HttpResponse> service, String loggerName) {
        services.add(new ServiceConfig(pathMapping, service, loggerName));
        return self();
    }
381411
public void createGroup(String name, boolean isPrivate) {
		LinkedMultiValueMap<String, String> params = new LinkedMultiValueMap<String, String>();
		params.set("name",name);
		params.set("private", String.valueOf(isPrivate));
		restTemplate.postForEntity(buildUri("groups"), params, String.class);
	}
276355
public UserGroupCallback build() {
        UserGroupCallback callback = null;
        Properties properties = _propertiesBuilder.build();
        if (_userGroupCallbackClass != null) {
            callback = construct(properties);
        }
        if (callback == null && USER_CALLBACK_IMPL != null) {
            try {
                if ("props".equalsIgnoreCase(USER_CALLBACK_IMPL)) {
                    callback = new JBossUserGroupCallbackImpl(properties);
                } else {
                    callback = UserDataServiceProvider.getUserGroupCallback();
                }
            } catch (Throwable t) {
                // we might get here if on Karaf vs. JBoss
                // keep checkstyle happy ("at least one statement")
                t.getMessage();
            }
        }
        if (callback == null) {
            callback = new PropertiesUserGroupCallback(properties);
        }
        return callback;
    }
174357
@Deprecated
    @Override
    public HostConfiguration getHostConfiguration() {
        HostConfiguration hostconfig = new HostConfiguration();
        hostconfig.setHost(this.httphost);
        return hostconfig;
    }
880806
public HealthIndicatorRegistry createHealthIndicatorRegistry(
			Map<String, HealthIndicator> healthIndicators) {
		Assert.notNull(healthIndicators, "HealthIndicators must not be null");
		return initialize(new DefaultHealthIndicatorRegistry(), healthIndicators);
	}
510263
public final B healthCheckInterval(Duration healthCheckInterval) {
        requireNonNull(healthCheckInterval, "healthCheckInterval");
        checkArgument(!healthCheckInterval.isNegative(),
                      "healthCheckInterval: %s (expected: >= 0)", healthCheckInterval);
        this.healthCheckInterval = healthCheckInterval;
        return self();
    }
89799
def create_healthcheck(self,
		service_id, 
		version_number,
		name,
		host,
		method="HEAD",
		path="/",
		http_version="1.1",
		timeout=1000,
		check_interval=5000,
		expected_response=200,
		window=5,
		threshold=3,
		initial=1):
		""""""
		body = self._formdata({
			"name": name,
			"method": method,
			"host": host,
			"path": path,
			"http_version": http_version,
			"timeout": timeout,
			"check_interval": check_interval,
			"expected_response": expected_response,
			"window": window,
			"threshold": threshold,
			"initial": initial,
		}, FastlyHealthCheck.FIELDS)
		content = self._fetch("/service/%s/version/%d/healthcheck" % (service_id, version_number), method="POST", body=body)
		return FastlyHealthCheck(self, content)
686489
public static HttpHealthCheckedEndpointGroup of(EndpointGroup delegate,
                                                    String healthCheckPath) {
        return new HttpHealthCheckedEndpointGroupBuilder(delegate, healthCheckPath).build();
    }