| /* |
| * 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.sling.testing.clients; |
| |
| import com.google.common.base.Strings; |
| import org.apache.commons.lang3.StringUtils; |
| import org.apache.http.HttpHost; |
| import org.apache.http.annotation.ThreadSafe; |
| import org.apache.http.auth.AuthScope; |
| import org.apache.http.auth.UsernamePasswordCredentials; |
| import org.apache.http.client.AuthCache; |
| import org.apache.http.client.CookieStore; |
| import org.apache.http.client.CredentialsProvider; |
| import org.apache.http.client.utils.URIUtils; |
| import org.apache.http.impl.auth.BasicScheme; |
| import org.apache.http.impl.client.BasicAuthCache; |
| import org.apache.http.impl.client.BasicCookieStore; |
| import org.apache.http.impl.client.BasicCredentialsProvider; |
| |
| import java.net.URI; |
| import java.net.URISyntaxException; |
| import java.util.Map; |
| import java.util.concurrent.ConcurrentHashMap; |
| |
| @ThreadSafe |
| public class SlingClientConfig { |
| |
| /** |
| * Base URI of the server under test. |
| */ |
| protected final URI url; |
| |
| /** |
| * Name of the user that will be used to authenticate the requests. |
| */ |
| protected final String user; |
| |
| /** |
| * Password of the user that will be used to authenticate the requests. |
| */ |
| protected final String password; |
| |
| /** |
| * The cookie store |
| */ |
| protected final CookieStore cookieStore; |
| |
| /** |
| * The credentials provider |
| */ |
| protected final CredentialsProvider credsProvider; |
| |
| /** |
| * AuthCache for preemptive auth |
| */ |
| protected final AuthCache authCache; |
| |
| |
| /** |
| * Extra values to be used in interceptors, custom auth mechanisms, etc. |
| */ |
| protected final Map<String, String> values; |
| |
| |
| protected SlingClientConfig(URI url, String user, String password, |
| CookieStore cookieStore, |
| CredentialsProvider credentialsProvider, AuthCache authCache) { |
| this.url = url; |
| this.user = user; |
| this.password = password; |
| |
| this.cookieStore = cookieStore; |
| this.credsProvider = credentialsProvider; |
| this.authCache = authCache; |
| |
| this.values = new ConcurrentHashMap<String, String>(); |
| } |
| |
| /** |
| * @return the base URL that the sling client is pointing to. It should always end with a "/" |
| */ |
| public URI getUrl() { |
| return url; |
| } |
| |
| /** |
| * @return the user that the client is using. |
| */ |
| public String getUser() { |
| return user; |
| } |
| |
| /** |
| * @return the user that the client is using. |
| */ |
| public String getPassword() { |
| return password; |
| } |
| |
| /** |
| * <p>Get the map of extra custom values configured on the client</p> |
| * <p>These may be used by interceptors, for example</p> |
| * |
| * @return the reference to the map |
| */ |
| public Map<String, String> getValues() { |
| return values; |
| } |
| |
| /** |
| * @return a reference to the cookie store used by the client |
| */ |
| public CookieStore getCookieStore() { |
| return cookieStore; |
| } |
| |
| /** |
| * @return the reference to the CredentialsProvider used by the client |
| */ |
| public CredentialsProvider getCredsProvider() { |
| return credsProvider; |
| } |
| |
| /** |
| * @return the reference the AuthCache used by the client |
| */ |
| public AuthCache getAuthCache() { |
| return authCache; |
| } |
| |
| public static class Builder { |
| protected URI url; |
| |
| protected String user; |
| |
| protected String password; |
| |
| protected CookieStore cookieStore; |
| |
| protected CredentialsProvider credsProvider; |
| |
| protected AuthCache authCache; |
| |
| protected boolean preemptiveAuth = true; |
| |
| protected Builder() { |
| } |
| |
| public static Builder create() { |
| return new Builder(); |
| } |
| |
| public Builder setUrl(String url) throws URISyntaxException { |
| return setUrl(new URI(url)); |
| } |
| |
| public Builder setUrl(URI url) { |
| this.url = url; |
| // Add / as path if none is present |
| if (Strings.isNullOrEmpty(this.url.getPath()) || !this.url.getPath().endsWith("/")) { |
| this.url = this.url.resolve(Strings.nullToEmpty(this.url.getPath()) + "/"); |
| } |
| return this; |
| } |
| |
| public Builder setUser(String user) { |
| this.user = user; |
| return this; |
| } |
| |
| public Builder setPassword(String password) { |
| this.password = password; |
| return this; |
| } |
| |
| public Builder setCredentialsProvider(CredentialsProvider credsProvider) { |
| this.credsProvider = credsProvider; |
| return this; |
| } |
| |
| public Builder setAuthCache(AuthCache authCache) { |
| this.authCache = authCache; |
| return this; |
| } |
| |
| public Builder setPreemptiveAuth(boolean preemptiveAuth) { |
| this.preemptiveAuth = preemptiveAuth; |
| return this; |
| } |
| |
| public Builder setCookieStore(CookieStore cookieStore) { |
| this.cookieStore = cookieStore; |
| return this; |
| } |
| |
| public SlingClientConfig build() { |
| // Create default CredentialsProvider if not set |
| if (credsProvider == null) { |
| credsProvider = new BasicCredentialsProvider(); |
| if (StringUtils.isNotEmpty(this.user)) { |
| HttpHost targetHost = URIUtils.extractHost(this.url); |
| credsProvider.setCredentials(new AuthScope(targetHost.getHostName(), targetHost.getPort()), |
| new UsernamePasswordCredentials(this.user, this.password)); |
| } |
| } |
| |
| // Create default AuthCache for basic if not set |
| if (authCache == null) { |
| BasicScheme basicScheme = new BasicScheme(); |
| authCache = new BasicAuthCache(); |
| authCache.put(URIUtils.extractHost(url), basicScheme); |
| } |
| |
| // if preemptive auth is disabled, force auth cache to be null |
| if (!this.preemptiveAuth) { |
| authCache = null; |
| } |
| |
| // Create default CookieStore if not set |
| if (cookieStore == null) { |
| cookieStore = new BasicCookieStore(); |
| } |
| |
| return new SlingClientConfig(url, user, password, cookieStore, credsProvider, authCache); |
| } |
| } |
| } |