001 /*
002 * SonarQube, open source software quality management tool.
003 * Copyright (C) 2008-2014 SonarSource
004 * mailto:contact AT sonarsource DOT com
005 *
006 * SonarQube is free software; you can redistribute it and/or
007 * modify it under the terms of the GNU Lesser General Public
008 * License as published by the Free Software Foundation; either
009 * version 3 of the License, or (at your option) any later version.
010 *
011 * SonarQube is distributed in the hope that it will be useful,
012 * but WITHOUT ANY WARRANTY; without even the implied warranty of
013 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
014 * Lesser General Public License for more details.
015 *
016 * You should have received a copy of the GNU Lesser General Public License
017 * along with this program; if not, write to the Free Software Foundation,
018 * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
019 */
020 package org.sonar.wsclient.connectors;
021
022 import org.apache.http.HttpEntity;
023 import org.apache.http.HttpException;
024 import org.apache.http.HttpHost;
025 import org.apache.http.HttpRequest;
026 import org.apache.http.HttpRequestInterceptor;
027 import org.apache.http.HttpResponse;
028 import org.apache.http.HttpStatus;
029 import org.apache.http.auth.AuthScheme;
030 import org.apache.http.auth.AuthScope;
031 import org.apache.http.auth.AuthState;
032 import org.apache.http.auth.Credentials;
033 import org.apache.http.auth.UsernamePasswordCredentials;
034 import org.apache.http.client.CredentialsProvider;
035 import org.apache.http.client.methods.HttpDelete;
036 import org.apache.http.client.methods.HttpEntityEnclosingRequestBase;
037 import org.apache.http.client.methods.HttpGet;
038 import org.apache.http.client.methods.HttpPost;
039 import org.apache.http.client.methods.HttpPut;
040 import org.apache.http.client.methods.HttpRequestBase;
041 import org.apache.http.client.protocol.ClientContext;
042 import org.apache.http.entity.StringEntity;
043 import org.apache.http.impl.auth.BasicScheme;
044 import org.apache.http.impl.client.DefaultHttpClient;
045 import org.apache.http.params.CoreConnectionPNames;
046 import org.apache.http.params.HttpConnectionParams;
047 import org.apache.http.params.HttpParams;
048 import org.apache.http.protocol.BasicHttpContext;
049 import org.apache.http.protocol.ExecutionContext;
050 import org.apache.http.protocol.HttpContext;
051 import org.apache.http.util.EntityUtils;
052 import org.sonar.wsclient.Host;
053 import org.sonar.wsclient.services.AbstractQuery;
054 import org.sonar.wsclient.services.CreateQuery;
055 import org.sonar.wsclient.services.DeleteQuery;
056 import org.sonar.wsclient.services.Query;
057 import org.sonar.wsclient.services.UpdateQuery;
058
059 import java.io.IOException;
060 import java.io.UnsupportedEncodingException;
061
062 /**
063 * @since 2.1
064 */
065 public class HttpClient4Connector extends Connector {
066
067 private Host server;
068 private DefaultHttpClient client;
069
070 public HttpClient4Connector(Host server) {
071 this.server = server;
072 initClient();
073 }
074
075 public DefaultHttpClient getHttpClient() {
076 return client;
077 }
078
079 @Override
080 public String execute(Query<?> query) {
081 return executeRequest(newGetMethod(query));
082 }
083
084 @Override
085 public String execute(CreateQuery<?> query) {
086 return executeRequest(newPostMethod(query));
087 }
088
089 @Override
090 public String execute(UpdateQuery<?> query) {
091 return executeRequest(newPutMethod(query));
092 }
093
094 @Override
095 public String execute(DeleteQuery query) {
096 return executeRequest(newDeleteMethod(query));
097 }
098
099 private String executeRequest(HttpRequestBase request) {
100 String json = null;
101 try {
102 BasicHttpContext context = createLocalContext(client);
103 HttpResponse response = client.execute(request, context);
104 HttpEntity entity = response.getEntity();
105 if (entity != null) {
106 if (response.getStatusLine().getStatusCode() == HttpStatus.SC_OK) {
107 json = EntityUtils.toString(entity);
108
109 } else if (response.getStatusLine().getStatusCode() != HttpStatus.SC_NOT_FOUND) {
110 throw new ConnectionException("HTTP error: " + response.getStatusLine().getStatusCode()
111 + ", msg: " + response.getStatusLine().getReasonPhrase()
112 + ", query: " + request.toString());
113 }
114 }
115
116 } catch (IOException e) {
117 throw new ConnectionException("Query: " + request.getURI(), e);
118
119 } finally {
120 request.releaseConnection();
121 }
122 return json;
123 }
124
125 public void close() {
126 if (client != null) {
127 client.getConnectionManager().shutdown();
128 }
129 }
130
131 private void initClient() {
132 client = new DefaultHttpClient();
133 HttpParams params = client.getParams();
134 HttpConnectionParams.setConnectionTimeout(params, AbstractQuery.DEFAULT_TIMEOUT_MILLISECONDS);
135 HttpConnectionParams.setSoTimeout(params, AbstractQuery.DEFAULT_TIMEOUT_MILLISECONDS);
136 if (server.getUsername() != null) {
137 client.getCredentialsProvider()
138 .setCredentials(AuthScope.ANY, new UsernamePasswordCredentials(server.getUsername(), server.getPassword()));
139 }
140 }
141
142 private BasicHttpContext createLocalContext(DefaultHttpClient client) {
143 BasicHttpContext localcontext = new BasicHttpContext();
144
145 if (server.getUsername() != null) {
146 // Generate BASIC scheme object and stick it to the local
147 // execution context
148 BasicScheme basicAuth = new BasicScheme();
149 localcontext.setAttribute(PreemptiveAuth.ATTRIBUTE, basicAuth);
150
151 // Add as the first request interceptor
152 client.addRequestInterceptor(new PreemptiveAuth(), 0);
153 }
154 return localcontext;
155 }
156
157 private HttpGet newGetMethod(Query<?> query) {
158 HttpGet get = new HttpGet(server.getHost() + query.getUrl());
159 initRequest(get, query);
160 return get;
161 }
162
163 private HttpDelete newDeleteMethod(DeleteQuery query) {
164 HttpDelete delete = new HttpDelete(server.getHost() + query.getUrl());
165 initRequest(delete, query);
166 return delete;
167 }
168
169 private HttpPost newPostMethod(CreateQuery<?> query) {
170 HttpPost post = new HttpPost(server.getHost() + query.getUrl());
171 initRequest(post, query);
172 setRequestEntity(post, query);
173 return post;
174 }
175
176 private HttpPut newPutMethod(UpdateQuery<?> query) {
177 HttpPut put = new HttpPut(server.getHost() + query.getUrl());
178 initRequest(put, query);
179 setRequestEntity(put, query);
180 return put;
181 }
182
183 private void setRequestEntity(HttpEntityEnclosingRequestBase request, AbstractQuery<?> query) {
184 if (query.getBody() != null) {
185 try {
186 request.setEntity(new StringEntity(query.getBody(), "UTF-8"));
187 } catch (UnsupportedEncodingException e) {
188 throw new ConnectionException("Encoding is not supported", e);
189 }
190 }
191 }
192
193 private void initRequest(HttpRequestBase request, AbstractQuery query) {
194 request.setHeader("Accept", "application/json");
195 if (query.getLocale() != null) {
196 request.setHeader("Accept-Language", query.getLocale());
197 }
198 request.getParams().setParameter(CoreConnectionPNames.CONNECTION_TIMEOUT, query.getTimeoutMilliseconds());
199 request.getParams().setParameter(CoreConnectionPNames.SO_TIMEOUT, query.getTimeoutMilliseconds());
200 }
201
202 static final class PreemptiveAuth implements HttpRequestInterceptor {
203
204 static final String ATTRIBUTE = "preemptive-auth";
205
206 public void process(
207 final HttpRequest request,
208 final HttpContext context) throws HttpException {
209
210 AuthState authState = (AuthState) context.getAttribute(ClientContext.TARGET_AUTH_STATE);
211
212 // If no auth scheme available yet, try to initialize it preemptively
213 if (authState.getAuthScheme() == null) {
214 AuthScheme authScheme = (AuthScheme) context.getAttribute(ATTRIBUTE);
215 CredentialsProvider credsProvider = (CredentialsProvider) context.getAttribute(ClientContext.CREDS_PROVIDER);
216 HttpHost targetHost = (HttpHost) context.getAttribute(ExecutionContext.HTTP_TARGET_HOST);
217 if (authScheme != null) {
218 Credentials creds = credsProvider.getCredentials(
219 new AuthScope(
220 targetHost.getHostName(),
221 targetHost.getPort()));
222 if (creds == null) {
223 throw new HttpException("No credentials for preemptive authentication");
224 }
225 authState.setAuthScheme(authScheme);
226 authState.setCredentials(creds);
227 }
228 }
229 }
230 }
231 }