/*
* Copyright 2013 Netflix, Inc.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package feign.ribbon;
import com.google.common.base.Objects;
import com.netflix.loadbalancer.AbstractLoadBalancer;
import com.netflix.loadbalancer.Server;
import java.net.URI;
import feign.Request;
import feign.RequestTemplate;
import feign.Target;
import static com.google.common.base.Objects.equal;
import static com.netflix.client.ClientFactory.getNamedLoadBalancer;
import static feign.Util.checkNotNull;
import static java.lang.String.format;
/**
* Basic integration for {@link com.netflix.loadbalancer.ILoadBalancer loadbalancer-aware} targets.
* Using this will enable dynamic url discovery via ribbon including incrementing server request counts.
* <br>
* Ex.
* <pre>
* MyService api = Feign.create(LoadBalancingTarget.create(MyService.class, "http://myAppProd"))
* </pre>
* Where {@code myAppProd} is the ribbon loadbalancer name and {@code myAppProd.ribbon.listOfServers} configuration
* is set.
*
* @param <T> corresponds to {@link feign.Target#type()}
*/
public class LoadBalancingTarget<T> implements Target<T> {
/**
* creates a target which dynamically derives urls from a {@link com.netflix.loadbalancer.ILoadBalancer loadbalancer}.
*
* @param type corresponds to {@link feign.Target#type()}
* @param schemeName naming convention is {@code https://name} or {@code http://name} where
* name corresponds to {@link com.netflix.client.ClientFactory#getNamedLoadBalancer(String)}
*/
public static <T> LoadBalancingTarget<T> create(Class<T> type, String schemeName) {
URI asUri = URI.create(schemeName);
return new LoadBalancingTarget<T>(type, asUri.getScheme(), asUri.getHost());
}
private final String name;
private final String scheme;
private final Class<T> type;
private final AbstractLoadBalancer lb;
protected LoadBalancingTarget(Class<T> type, String scheme, String name) {
this.type = checkNotNull(type, "type");
this.scheme = checkNotNull(scheme, "scheme");
this.name = checkNotNull(name, "name");
this.lb = AbstractLoadBalancer.class.cast(getNamedLoadBalancer(name()));
}
@Override public Class<T> type() {
return type;
}
@Override public String name() {
return name;
}
@Override public String url() {
return name;
}
/**
* current load balancer for the target.
*/
public AbstractLoadBalancer lb() {
return lb;
}
@Override public Request apply(RequestTemplate input) {
Server currentServer = lb.chooseServer(null);
String url = format("%s://%s", scheme, currentServer.getHostPort());
input.insert(0, url);
try {
return input.request();
} finally {
lb.getLoadBalancerStats().incrementNumRequests(currentServer);
}
}
@Override public int hashCode() {
return Objects.hashCode(type, name);
}
@Override public boolean equals(Object obj) {
if (obj == null)
return false;
if (this == obj)
return true;
if (LoadBalancingTarget.class != obj.getClass())
return false;
LoadBalancingTarget<?> that = LoadBalancingTarget.class.cast(obj);
return equal(this.type, that.type) && equal(this.name, that.name);
}
}