Java tutorial
/* * Licensed to the Apache Software Foundation (ASF) under one * or more contributor license agreements. See the NOTICE file * distributed with this work for additional information * regarding copyright ownership. The ASF licenses this file * to you 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 org.apache.brooklyn.rest.client; import static com.google.common.base.Preconditions.checkNotNull; import java.lang.reflect.InvocationHandler; import java.lang.reflect.InvocationTargetException; import java.lang.reflect.Method; import java.lang.reflect.Proxy; import java.net.MalformedURLException; import java.net.URL; import javax.annotation.Nullable; import javax.ws.rs.core.Response; import com.google.common.base.Supplier; import com.google.common.base.Suppliers; import org.apache.http.auth.AuthScope; import org.apache.http.auth.Credentials; import org.apache.http.auth.UsernamePasswordCredentials; import org.apache.http.client.CredentialsProvider; import org.apache.http.client.config.RequestConfig; import org.apache.http.impl.client.BasicCredentialsProvider; import org.apache.http.impl.client.CloseableHttpClient; import org.apache.http.impl.client.HttpClients; import org.apache.http.impl.conn.PoolingHttpClientConnectionManager; import org.jboss.resteasy.client.ClientExecutor; import org.jboss.resteasy.client.ClientResponse; import org.jboss.resteasy.client.ProxyFactory; import org.jboss.resteasy.client.core.executors.ApacheHttpClient4Executor; import org.jboss.resteasy.specimpl.BuiltResponse; import org.jboss.resteasy.util.GenericType; import org.slf4j.Logger; import org.slf4j.LoggerFactory; import com.google.gson.Gson; import org.apache.brooklyn.rest.api.AccessApi; import org.apache.brooklyn.rest.api.ActivityApi; import org.apache.brooklyn.rest.api.ApplicationApi; import org.apache.brooklyn.rest.api.CatalogApi; import org.apache.brooklyn.rest.api.EffectorApi; import org.apache.brooklyn.rest.api.EntityApi; import org.apache.brooklyn.rest.api.EntityConfigApi; import org.apache.brooklyn.rest.api.LocationApi; import org.apache.brooklyn.rest.api.PolicyApi; import org.apache.brooklyn.rest.api.PolicyConfigApi; import org.apache.brooklyn.rest.api.ScriptApi; import org.apache.brooklyn.rest.api.SensorApi; import org.apache.brooklyn.rest.api.ServerApi; import org.apache.brooklyn.rest.api.UsageApi; import org.apache.brooklyn.rest.api.VersionApi; import org.apache.brooklyn.rest.client.util.http.BuiltResponsePreservingError; import org.apache.brooklyn.util.exceptions.Exceptions; import io.swagger.annotations.ApiOperation; /** * @author Adam Lowe */ @SuppressWarnings("deprecation") public class BrooklynApi { private final String target; private final ClientExecutor clientExecutor; private final int maxPoolSize; private final int timeOutInMillis; private static final Logger LOG = LoggerFactory.getLogger(BrooklynApi.class); /** * @deprecated since 0.9.0. Use {@link BrooklynApi#newInstance(String)} instead */ @Deprecated public BrooklynApi(URL endpoint) { this(checkNotNull(endpoint, "endpoint").toString()); } /** * @deprecated since 0.9.0. Use {@link BrooklynApi#newInstance(String)} instead */ @Deprecated public BrooklynApi(String endpoint) { // username/password cannot be null, but credentials can this(endpoint, null); } /** * @deprecated since 0.9.0. Use {@link BrooklynApi#newInstance(String, String, String)} instead */ @Deprecated public BrooklynApi(URL endpoint, String username, String password) { this(endpoint.toString(), new UsernamePasswordCredentials(username, password)); } /** * @deprecated since 0.9.0. Use {@link BrooklynApi#newInstance(String, String, String)} instead */ @Deprecated public BrooklynApi(String endpoint, String username, String password) { this(endpoint, new UsernamePasswordCredentials(username, password)); } /** * @deprecated since 0.9.0. Use {@link BrooklynApi#newInstance(String, String, String)} instead */ @Deprecated public BrooklynApi(URL endpoint, @Nullable Credentials credentials) { this(endpoint.toString(), credentials); } /** * Creates a BrooklynApi using an HTTP connection pool * * @deprecated since 0.9.0. Use {@link BrooklynApi#newInstance(String, String, String)} instead */ @Deprecated public BrooklynApi(String endpoint, @Nullable Credentials credentials) { this(endpoint, credentials, 20, 5000); } /** * Creates a BrooklynApi using a custom ClientExecutor * * @param endpoint the Brooklyn endpoint * @param clientExecutor the ClientExecutor * @see #getClientExecutor(org.apache.http.auth.Credentials) */ public BrooklynApi(URL endpoint, ClientExecutor clientExecutor) { this.target = checkNotNull(endpoint, "endpoint").toString(); this.maxPoolSize = -1; this.timeOutInMillis = -1; this.clientExecutor = checkNotNull(clientExecutor, "clientExecutor"); } /** * Creates a BrooklynApi using an HTTP connection pool * * @param endpoint the Brooklyn endpoint * @param credentials user credentials or null * @param maxPoolSize maximum pool size * @param timeOutInMillis connection timeout in milliseconds */ public BrooklynApi(String endpoint, @Nullable Credentials credentials, int maxPoolSize, int timeOutInMillis) { try { new URL(checkNotNull(endpoint, "endpoint")); } catch (MalformedURLException e) { throw new IllegalArgumentException(e); } this.target = endpoint; this.maxPoolSize = maxPoolSize; this.timeOutInMillis = timeOutInMillis; this.clientExecutor = getClientExecutor(credentials); } private Supplier<PoolingHttpClientConnectionManager> connectionManagerSupplier = Suppliers .memoize(new Supplier<PoolingHttpClientConnectionManager>() { @Override public PoolingHttpClientConnectionManager get() { PoolingHttpClientConnectionManager connManager = new PoolingHttpClientConnectionManager(); connManager.setMaxTotal(maxPoolSize); connManager.setDefaultMaxPerRoute(maxPoolSize); return connManager; } }); private Supplier<RequestConfig> reqConfSupplier = Suppliers.memoize(new Supplier<RequestConfig>() { @Override public RequestConfig get() { return RequestConfig.custom().setConnectTimeout(timeOutInMillis) .setConnectionRequestTimeout(timeOutInMillis).build(); } }); /** * Creates a ClientExecutor for this BrooklynApi */ protected ClientExecutor getClientExecutor(Credentials credentials) { CredentialsProvider provider = new BasicCredentialsProvider(); if (credentials != null) provider.setCredentials(AuthScope.ANY, credentials); CloseableHttpClient httpClient = HttpClients.custom().setDefaultCredentialsProvider(provider) .setDefaultRequestConfig(reqConfSupplier.get()) .setConnectionManager(connectionManagerSupplier.get()).build(); return new ApacheHttpClient4Executor(httpClient); } /** * Creates a BrooklynApi using an HTTP connection pool * * @param endpoint the Brooklyn endpoint * @return a new BrooklynApi instance */ public static BrooklynApi newInstance(String endpoint) { return new BrooklynApi(endpoint, null); } /** * Creates a BrooklynApi using an HTTP connection pool * * @param endpoint the Brooklyn endpoint * @param maxPoolSize maximum connection pool size * @param timeOutInMillis connection timeout in millisecond * @return a new BrooklynApi instance */ public static BrooklynApi newInstance(String endpoint, int maxPoolSize, int timeOutInMillis) { return new BrooklynApi(endpoint, null, maxPoolSize, timeOutInMillis); } /** * Creates a BrooklynApi using an HTTP connection pool * * @param endpoint the Brooklyn endpoint * @param username for authentication * @param password for authentication * @return a new BrooklynApi instance */ public static BrooklynApi newInstance(String endpoint, String username, String password) { return new BrooklynApi(endpoint, new UsernamePasswordCredentials(username, password)); } /** * Creates a BrooklynApi using an HTTP connection pool * * @param endpoint the Brooklyn endpoint * @param username for authentication * @param password for authentication * @param maxPoolSize maximum connection pool size * @param timeOutInMillis connection timeout in millisecond * @return a new BrooklynApi instance */ public static BrooklynApi newInstance(String endpoint, String username, String password, int maxPoolSize, int timeOutInMillis) { return new BrooklynApi(endpoint, new UsernamePasswordCredentials(username, password), maxPoolSize, timeOutInMillis); } @SuppressWarnings("unchecked") private <T> T proxy(Class<T> clazz) { final T result0 = ProxyFactory.create(clazz, target, clientExecutor); return (T) Proxy.newProxyInstance(clazz.getClassLoader(), new Class<?>[] { clazz }, new InvocationHandler() { @Override public Object invoke(Object proxy, Method method, Object[] args) throws Throwable { try { Object result1 = method.invoke(result0, args); Class<?> type = String.class; if (result1 instanceof Response) { Response resp = (Response) result1; if (isStatusCodeHealthy(resp.getStatus()) && method.isAnnotationPresent(ApiOperation.class)) { type = getClassFromMethodAnnotationOrDefault(method, type); } // wrap the original response so it self-closes result1 = BuiltResponsePreservingError.copyResponseAndClose(resp, type); } return result1; } catch (Throwable e) { if (e instanceof InvocationTargetException) { // throw the original exception e = ((InvocationTargetException) e).getTargetException(); } throw Exceptions.propagate(e); } } private boolean isStatusCodeHealthy(int code) { return (code >= 200 && code <= 299); } private Class<?> getClassFromMethodAnnotationOrDefault(Method method, Class<?> def) { Class<?> type; try { type = method.getAnnotation(ApiOperation.class).response(); } catch (Exception e) { type = def; LOG.debug("Unable to get class from annotation: {}. Defaulting to {}", e.getMessage(), def.getName()); Exceptions.propagateIfFatal(e); } return type; } }); } public ActivityApi getActivityApi() { return proxy(ActivityApi.class); } public ApplicationApi getApplicationApi() { return proxy(ApplicationApi.class); } public CatalogApi getCatalogApi() { return proxy(CatalogApi.class); } public EffectorApi getEffectorApi() { return proxy(EffectorApi.class); } public EntityConfigApi getEntityConfigApi() { return proxy(EntityConfigApi.class); } public EntityApi getEntityApi() { return proxy(EntityApi.class); } public LocationApi getLocationApi() { return proxy(LocationApi.class); } public PolicyConfigApi getPolicyConfigApi() { return proxy(PolicyConfigApi.class); } public PolicyApi getPolicyApi() { return proxy(PolicyApi.class); } public ScriptApi getScriptApi() { return proxy(ScriptApi.class); } public SensorApi getSensorApi() { return proxy(SensorApi.class); } public ServerApi getServerApi() { return proxy(ServerApi.class); } public UsageApi getUsageApi() { return proxy(UsageApi.class); } public VersionApi getVersionApi() { return proxy(VersionApi.class); } public AccessApi getAccessApi() { return proxy(AccessApi.class); } public static <T> T getEntity(Response response, Class<T> type) { if (response instanceof ClientResponse) { ClientResponse<?> clientResponse = (ClientResponse<?>) response; return clientResponse.getEntity(type); } else if (response instanceof BuiltResponse) { // Handle BuiltResponsePreservingError turning objects into Strings if (response.getEntity() instanceof String && !type.equals(String.class)) { return new Gson().fromJson(response.getEntity().toString(), type); } } // Last-gasp attempt. return type.cast(response.getEntity()); } public static <T> T getEntity(Response response, GenericType<T> type) { if (response instanceof ClientResponse) { ClientResponse<?> clientResponse = (ClientResponse<?>) response; return clientResponse.getEntity(type); } else if (response instanceof BuiltResponse) { // Handle BuiltResponsePreservingError turning objects into Strings if (response.getEntity() instanceof String) { return new Gson().fromJson(response.getEntity().toString(), type.getGenericType()); } } // Last-gasp attempt. return type.getType().cast(response.getEntity()); } /** * @deprecated since 0.8.0-incubating. Use {@link #getEntity(Response, GenericType)} instead. */ @Deprecated public static <T> T getEntityGeneric(Response response, GenericType<T> type) { return getEntity(response, type); } }