/**
* 将用户登录名展示在actionbar上，长度大于14用。。。表示
*
* @return
*/
public static String showTitileName() {
if (StringUtils.isNotEmpty(HttpClientUtil.getAccount().getName())) {
if (HttpClientUtil.getAccount().getName().length() <= 14) {
return HttpClientUtil.getAccount().getName();
} else {
return StringUtils.substring(HttpClientUtil.getAccount().getName(), 0, 14) + "..";
}
}
return null;
}
/**
* Set the maximum number of connections that can be open at any given time. If http client was
* created outside the operation is not allowed.
*/
public void setMaxTotalConnections(int max) {
if (internalClient) {
HttpClientUtil.setMaxConnections(httpClient, max);
} else {
throw new UnsupportedOperationException("Client was created outside of HttpSolrServer");
}
}
/**
* Create a new client object using multiple string values in a Collection instead of a standard
* zkHost connection string. Note that this method will not be used if there is only one String
* argument - that will use {@link #CloudSolrServer(String)} instead.
*
* @param zkHosts A Java Collection (List, Set, etc) of HOST:PORT strings, one for each host in
* the zookeeper ensemble. Note that with certain Collection types like HashSet, the order of
* hosts in the final connect string may not be in the same order you added them.
* @param chroot A chroot value for zookeeper, starting with a forward slash. If no chroot is
* required, use null.
* @param httpClient the {@link HttpClient} instance to be used for all requests. The provided
* httpClient should use a multi-threaded connection manager.
* @throws IllegalArgumentException if the chroot value does not start with a forward slash.
* @see #CloudSolrServer(String)
*/
public CloudSolrServer(Collection<String> zkHosts, String chroot, HttpClient httpClient) {
StringBuilder zkBuilder = new StringBuilder();
int lastIndexValue = zkHosts.size() - 1;
int i = 0;
for (String zkHost : zkHosts) {
zkBuilder.append(zkHost);
if (i < lastIndexValue) {
zkBuilder.append(",");
}
i++;
}
if (chroot != null) {
if (chroot.startsWith("/")) {
zkBuilder.append(chroot);
} else {
throw new IllegalArgumentException("The chroot must start with a forward slash.");
}
}
/* Log the constructed connection string and then initialize. */
log.info("Final constructed zkHost string: " + zkBuilder.toString());
this.zkHost = zkBuilder.toString();
this.clientIsInternal = httpClient == null;
this.myClient = httpClient == null ? HttpClientUtil.createClient(null) : httpClient;
this.lbServer = new LBHttpSolrServer(myClient);
this.lbServer.setRequestWriter(new BinaryRequestWriter());
this.lbServer.setParser(new BinaryResponseParser());
this.updatesToLeaders = true;
shutdownLBHttpSolrServer = true;
}
@Override
protected void updateContext(final ProxyRepository repository, final RemoteStorageContext ctx) {
getLogger()
.info(
"Remote storage settings change detected for ProxyRepository ID=\""
+ repository.getId()
+ "\" (\""
+ repository.getName()
+ "\"), updating HttpClient...");
// reset current http client, if exists
HttpClientUtil.release(CTX_KEY, ctx);
// and create a new one
HttpClientUtil.configure(CTX_KEY, ctx, getLogger());
}
public static String sendSSLPost(String url) throws ClientProtocolException, IOException {
String line = null;
StringBuilder stringBuilder = new StringBuilder();
CloseableHttpClient httpClient = HttpClientUtil.createSSLClientDefault();
HttpGet getdd = new HttpGet();
HttpPost httpPost = new HttpPost(url);
httpPost.addHeader("Content-type", "application/x-www-form-urlencoded");
// httpPost.setEntity(new StringEntity(JSON.toJSONString(param), "UTF-8"));
HttpResponse response = httpClient.execute(httpPost);
if (response.getStatusLine().getStatusCode() == 200) {
org.apache.http.HttpEntity httpEntity = response.getEntity();
if (httpEntity != null) {
try {
BufferedReader bufferedReader =
new BufferedReader(new InputStreamReader(httpEntity.getContent(), "UTF-8"), 8 * 1024);
while ((line = bufferedReader.readLine()) != null) {
stringBuilder.append(line);
}
} catch (Exception e) {
}
}
}
return stringBuilder.toString();
}
private HttpRequestBase asHttpRequest(HttpRemoteRequest request) throws IOException {
HttpRemoteRequest.Method method = request.getMethod();
if (method == HttpRemoteRequest.Method.GET) {
return HttpClientUtil.createGetMethod(request.getTarget(), request.getParameters());
}
if (method == HttpRemoteRequest.Method.POST) {
if (CollectionUtil.isEmpty(request.getBinaryItems())) {
return HttpClientUtil.createPostMethod(request.getTarget(), request.getParameters());
}
return HttpClientUtil.createMultipartPostMethod(
request.getTarget(),
request.getParameters(),
request.getBinaryItems(),
request.getUploadFileCallback());
}
throw new IllegalArgumentException("未知Method:" + method);
}
/**
* Allow server->client communication to be compressed. Currently gzip and deflate are supported.
* If the server supports compression the response will be compressed. This method is only allowed
* if the http client is of type DefatulHttpClient.
*/
public void setAllowCompression(boolean allowCompression) {
if (httpClient instanceof DefaultHttpClient) {
HttpClientUtil.setAllowCompression((DefaultHttpClient) httpClient, allowCompression);
} else {
throw new UnsupportedOperationException(
"HttpClient instance was not of type DefaultHttpClient");
}
}
/**
* @param zkHost A zookeeper client endpoint.
* @param updatesToLeaders If true, sends updates only to shard leaders.
* @param httpClient the {@link HttpClient} instance to be used for all requests. The provided
* httpClient should use a multi-threaded connection manager.
* @see #CloudSolrServer(String) for full description and details on zkHost
*/
public CloudSolrServer(String zkHost, boolean updatesToLeaders, HttpClient httpClient) {
this.zkHost = zkHost;
this.clientIsInternal = httpClient == null;
this.myClient = httpClient == null ? HttpClientUtil.createClient(null) : httpClient;
this.lbServer = new LBHttpSolrServer(myClient);
this.lbServer.setRequestWriter(new BinaryRequestWriter());
this.lbServer.setParser(new BinaryResponseParser());
this.updatesToLeaders = updatesToLeaders;
shutdownLBHttpSolrServer = true;
lbServer.addQueryParams(STATE_VERSION);
}
@Test
public void testGetRawStream() throws SolrServerException, IOException {
try (CloseableHttpClient client = HttpClientUtil.createClient(null)) {
HttpSolrClient solrClient =
new HttpSolrClient(jetty.getBaseUrl().toString() + "/collection1", client, null);
QueryRequest req = new QueryRequest();
NamedList response = solrClient.request(req);
InputStream stream = (InputStream) response.get("stream");
assertNotNull(stream);
stream.close();
}
}
@Test
public void testCompression() throws Exception {
try (HttpSolrClient client = new HttpSolrClient(jetty.getBaseUrl().toString() + "/debug/foo")) {
SolrQuery q = new SolrQuery("*:*");
// verify request header gets set
DebugServlet.clear();
try {
client.query(q);
} catch (ParseException ignored) {
}
assertNull(DebugServlet.headers.get("Accept-Encoding"));
client.setAllowCompression(true);
try {
client.query(q);
} catch (ParseException ignored) {
}
assertNotNull(DebugServlet.headers.get("Accept-Encoding"));
client.setAllowCompression(false);
try {
client.query(q);
} catch (ParseException ignored) {
}
assertNull(DebugServlet.headers.get("Accept-Encoding"));
}
// verify server compresses output
HttpGet get =
new HttpGet(jetty.getBaseUrl().toString() + "/collection1" + "/select?q=foo&wt=xml");
get.setHeader("Accept-Encoding", "gzip");
CloseableHttpClient httpclient = HttpClientUtil.createClient(null);
HttpEntity entity = null;
try {
HttpResponse response = httpclient.execute(get);
entity = response.getEntity();
Header ceheader = entity.getContentEncoding();
assertEquals("gzip", ceheader.getValue());
} finally {
if (entity != null) {
entity.getContent().close();
}
httpclient.close();
}
// verify compressed response can be handled
try (HttpSolrClient client =
new HttpSolrClient(jetty.getBaseUrl().toString() + "/collection1")) {
client.setAllowCompression(true);
SolrQuery q = new SolrQuery("foo");
QueryResponse response = client.query(q);
assertEquals(0, response.getStatus());
}
}
/**
* Set cookies via interceptor Change the request via an interceptor Ensure cookies are actually
* set and that request is actually changed
*/
@Test
public void testInterceptors() {
DebugServlet.clear();
HttpClientUtil.addRequestInterceptor(changeRequestInterceptor);
HttpClientUtil.addRequestInterceptor(cookieSettingRequestInterceptor);
try (HttpSolrClient server = new HttpSolrClient(jetty.getBaseUrl().toString() + "/debug/foo")) {
SolrQuery q = new SolrQuery("foo");
q.setParam("a", "\u1234");
try {
server.query(q, random().nextBoolean() ? METHOD.POST : METHOD.GET);
} catch (Throwable t) {
}
// Assert cookies from UseContextCallback
assertNotNull(DebugServlet.cookies);
boolean foundCookie = false;
for (javax.servlet.http.Cookie cookie : DebugServlet.cookies) {
if (cookieName.equals(cookie.getName()) && cookieValue.equals(cookie.getValue())) {
foundCookie = true;
break;
}
}
assertTrue(foundCookie);
// Assert request changes by ChangeRequestCallback
assertEquals("\u1234", DebugServlet.parameters.get("a")[0]);
assertEquals("\u4321", DebugServlet.parameters.get("b")[0]);
} catch (IOException ex) {
throw new RuntimeException(ex);
} finally {
HttpClientUtil.removeRequestInterceptor(changeRequestInterceptor);
HttpClientUtil.removeRequestInterceptor(cookieSettingRequestInterceptor);
}
}
@Test
public void testSetParametersExternalClient() throws IOException {
try (CloseableHttpClient httpClient = HttpClientUtil.createClient(null);
HttpSolrClient solrClient = new HttpSolrClient(jetty.getBaseUrl().toString(), httpClient)) {
try {
solrClient.setMaxTotalConnections(1);
fail("Operation should not succeed.");
} catch (UnsupportedOperationException ignored) {
}
try {
solrClient.setDefaultMaxConnectionsPerHost(1);
fail("Operation should not succeed.");
} catch (UnsupportedOperationException ignored) {
}
}
}
private void accessService() {
String spath;
Set<String> srs = services.keySet();
List<String> srsadds;
for (String sr : srs) {
if (services.get(sr) != null && services.get(sr).size() > 0) {
srsadds = new ArrayList<>();
srsadds.addAll(services.get(sr));
Collections.shuffle(srsadds);
spath = "http://" + srsadds.get(0) + ":8080" + sr;
System.out.println("access path=" + spath);
String res = "";
try {
res = HttpClientUtil.getMethod(spath);
} catch (Exception e) {
e.printStackTrace();
}
System.out.println("res=" + res);
} else {
System.out.println("access path " + sr + ",没有服务提供者");
}
}
}
public HttpSolrServer(String baseURL, HttpClient client, ResponseParser parser) {
this.baseUrl = baseURL;
if (baseUrl.endsWith("/")) {
baseUrl = baseUrl.substring(0, baseUrl.length() - 1);
}
if (baseUrl.indexOf('?') >= 0) {
throw new RuntimeException(
"Invalid base url for solrj. The base URL must not contain parameters: " + baseUrl);
}
if (client != null) {
httpClient = client;
internalClient = false;
} else {
internalClient = true;
ModifiableSolrParams params = new ModifiableSolrParams();
params.set(HttpClientUtil.PROP_MAX_CONNECTIONS, 128);
params.set(HttpClientUtil.PROP_MAX_CONNECTIONS_PER_HOST, 32);
params.set(HttpClientUtil.PROP_FOLLOW_REDIRECTS, followRedirects);
httpClient = HttpClientUtil.createClient(params);
}
this.parser = parser;
}
/**
* Executes the HTTP request.
*
* <p>In case of any exception thrown by HttpClient, it will release the connection. In other
* cases it is the duty of caller to do it, or process the input stream.
*
* @param repository to execute the HTTP method fpr
* @param request resource store request that triggered the HTTP request
* @param httpRequest HTTP request to be executed
* @return response of making the request
* @throws RemoteStorageException If an error occurred during execution of HTTP request
*/
private HttpResponse executeRequest(
final ProxyRepository repository,
final ResourceStoreRequest request,
final HttpUriRequest httpRequest)
throws RemoteStorageException {
final URI methodUri = httpRequest.getURI();
if (getLogger().isDebugEnabled()) {
getLogger()
.debug(
"Invoking HTTP "
+ httpRequest.getMethod()
+ " method against remote location "
+ methodUri);
}
final RemoteStorageContext ctx = getRemoteStorageContext(repository);
final HttpClient httpClient = HttpClientUtil.getHttpClient(CTX_KEY, ctx);
httpRequest.setHeader("user-agent", formatUserAgentString(ctx, repository));
httpRequest.setHeader("accept", "*/*");
httpRequest.setHeader("accept-language", "en-us");
httpRequest.setHeader("accept-encoding", "gzip,deflate,identity");
httpRequest.setHeader("cache-control", "no-cache");
// HTTP keep alive should not be used, except when NTLM is used
final Boolean isNtlmUsed = HttpClientUtil.isNTLMAuthenticationUsed(CTX_KEY, ctx);
if (isNtlmUsed == null || !isNtlmUsed) {
httpRequest.setHeader("Connection", "close");
httpRequest.setHeader("Proxy-Connection", "close");
}
HttpResponse httpResponse = null;
try {
httpResponse = httpClient.execute(httpRequest);
final int statusCode = httpResponse.getStatusLine().getStatusCode();
final Header httpServerHeader = httpResponse.getFirstHeader("server");
checkForRemotePeerAmazonS3Storage(
repository, httpServerHeader == null ? null : httpServerHeader.getValue());
Header proxyReturnedErrorHeader = httpResponse.getFirstHeader(NEXUS_MISSING_ARTIFACT_HEADER);
boolean proxyReturnedError =
proxyReturnedErrorHeader != null && Boolean.valueOf(proxyReturnedErrorHeader.getValue());
if (statusCode == HttpStatus.SC_FORBIDDEN) {
throw new RemoteAccessDeniedException(
repository, methodUri.toASCIIString(), httpResponse.getStatusLine().getReasonPhrase());
} else if (statusCode == HttpStatus.SC_UNAUTHORIZED) {
throw new RemoteAuthenticationNeededException(
repository, httpResponse.getStatusLine().getReasonPhrase());
} else if (statusCode == HttpStatus.SC_OK && proxyReturnedError) {
throw new RemoteStorageException(
"Invalid artifact found, most likely a proxy redirected to an HTML error page.");
}
return httpResponse;
} catch (RemoteStorageException ex) {
release(httpResponse);
throw ex;
} catch (ClientProtocolException ex) {
release(httpResponse);
throw new RemoteStorageException(
"Protocol error while executing "
+ httpRequest.getMethod()
+ " method. [repositoryId=\""
+ repository.getId()
+ "\", requestPath=\""
+ request.getRequestPath()
+ "\", remoteUrl=\""
+ methodUri.toASCIIString()
+ "\"]",
ex);
} catch (IOException ex) {
release(httpResponse);
throw new RemoteStorageException(
"Transport error while executing "
+ httpRequest.getMethod()
+ " method [repositoryId=\""
+ repository.getId()
+ "\", requestPath=\""
+ request.getRequestPath()
+ "\", remoteUrl=\""
+ methodUri.toASCIIString()
+ "\"]",
ex);
}
}
@Override
protected String getS3FlagKey() {
return HttpClientUtil.getS3FlagKey(CTX_KEY);
}
public void testHttpGet() {
String url = "http://www.runoob.com/java/java-regular-expressions.html";
System.out.println(HttpClientUtil.httpGetRequest(url));
}
/**
* HttpConnectionParams.setConnectionTimeout
*
* @param timeout Timeout in milliseconds
*/
public void setConnectionTimeout(int timeout) {
HttpClientUtil.setConnectionTimeout(httpClient, timeout);
}
/**
* Configure whether the client should follow redirects or not.
*
* <p>This defaults to false under the assumption that if you are following a redirect to get to a
* Solr installation, something is misconfigured somewhere.
*/
public void setFollowRedirects(boolean followRedirects) {
this.followRedirects = true;
HttpClientUtil.setFollowRedirects(httpClient, followRedirects);
}
/**
* Set SoTimeout (read timeout). This is desirable for queries, but probably not for indexing.
*
* @param timeout Timeout in milliseconds
*/
public void setSoTimeout(int timeout) {
HttpClientUtil.setSoTimeout(httpClient, timeout);
}
