下面列出了org.apache.http.client.config.CookieSpecs#org.apache.http.client.entity.UrlEncodedFormEntity 实例代码,或者点击链接到github查看源代码,也可以在右侧发表评论。
@Override
public void write(final TikaDocument tikaDocument) throws IOException {
final HttpPut put = new HttpPut(uri.resolve(tikaDocument.getId()));
final List<NameValuePair> params = new ArrayList<>();
params.add(new BasicNameValuePair(fields.forId(), tikaDocument.getId()));
params.add(new BasicNameValuePair(fields.forPath(), tikaDocument.getPath().toString()));
params.add(new BasicNameValuePair(fields.forText(), toString(tikaDocument.getReader())));
if (outputMetadata) {
parametrizeMetadata(tikaDocument.getMetadata(), params);
}
put.setEntity(new UrlEncodedFormEntity(params, StandardCharsets.UTF_8));
put(put);
}
/**
* Implement the equivalent of:
* curl -XPOST -u Administrator:password localhost:httpPort/pools/default/buckets \ -d bucketType=couchbase \
* -d name={@param bucketName} -d authType=sasl -d ramQuotaMB=200
**/
private boolean createBucket(String bucketName) {
CloseableHttpClient httpClient = HttpClientBuilder.create().build();
try {
HttpPost httpPost = new HttpPost("http://localhost:" + _couchbaseTestServer.getPort() + "/pools/default/buckets");
List<NameValuePair> params = new ArrayList<>(2);
params.add(new BasicNameValuePair("bucketType", "couchbase"));
params.add(new BasicNameValuePair("name", bucketName));
params.add(new BasicNameValuePair("authType", "sasl"));
params.add(new BasicNameValuePair("ramQuotaMB", "200"));
httpPost.setEntity(new UrlEncodedFormEntity(params, "UTF-8"));
//Execute and get the response.
HttpResponse response = httpClient.execute(httpPost);
log.info(String.valueOf(response.getStatusLine().getStatusCode()));
return true;
}
catch (Exception e) {
log.error("Failed to create bucket {}", bucketName, e);
return false;
}
}
/**
* 请求某个URL,带着参数列表。
* @param url
* @param nameValuePairs
* @return
* @throws ClientProtocolException
* @throws IOException
*/
protected String requestUrl(String url, List<NameValuePair> nameValuePairs) throws ClientProtocolException, IOException {
HttpPost httpPost = new HttpPost(url);
if(nameValuePairs!=null && nameValuePairs.size()>0){
httpPost.setEntity(new UrlEncodedFormEntity(nameValuePairs));
}
CloseableHttpResponse response = httpClient.execute(httpPost);
try {
if (response.getStatusLine().getStatusCode() == 200) {
HttpEntity entity = response.getEntity();
String content = EntityUtils.toString(entity);
EntityUtils.consume(entity);
return content;
}
else{
logger.warn("request the url: "+url+" , but return the status code is "+response.getStatusLine().getStatusCode());
return null;
}
}
finally{
response.close();
}
}
protected static MDSResult doPost(String scheme, String host, int port,
String path,
List<NameValuePair> postData) throws UnsupportedEncodingException {
URI uri = null;
try {
uri = URIUtils.createURI(scheme, host, port, path, null, null);
} catch (URISyntaxException e) {
e.printStackTrace();
throw new IllegalArgumentException(String.format("Can not post to mds: %s, %s, %d, %s", scheme, host, port, path), e);
}
Log.d(TAG, "doPost() uri: " + uri.toASCIIString());
HttpPost post = new HttpPost(uri);
UrlEncodedFormEntity entity = new UrlEncodedFormEntity(postData, "UTF-8");
post.setEntity(entity);
return MDSInterface2.doExecute(post);
}
/**
*
* @param url
* @param param
* @return
*/
public static String postForPay(String url, Map<String, Object> param) {
logger.info("POST 请求, url={},map={}", url, param.toString());
try {
HttpPost httpPost = new HttpPost(url.trim());
RequestConfig requestConfig = RequestConfig.custom().setConnectTimeout(TIMEOUT).setConnectionRequestTimeout(TIMEOUT).setSocketTimeout(TIMEOUT).build();
httpPost.setConfig(requestConfig);
List<NameValuePair> nvps = new ArrayList<NameValuePair>();
for (Map.Entry<String, Object> entry : param.entrySet()) {
nvps.add(new BasicNameValuePair(entry.getKey(), entry.getValue().toString()));
}
StringEntity se = new UrlEncodedFormEntity(nvps, CHARSET_UTF_8);
httpPost.setEntity(se);
HttpResponse httpResponse = HttpClientBuilder.create().build().execute(httpPost);
return EntityUtils.toString(httpResponse.getEntity(), CHARSET_UTF_8);
} catch (Exception e) {
logger.info("HTTP请求出错", e);
e.printStackTrace();
}
return "";
}
private HttpPost createPost(String url, MultiValueMap<String, String> params) throws UnsupportedEncodingException {
HttpPost post = new HttpPost(url);
List<NameValuePair> nvps = new ArrayList<NameValuePair>();
for (Map.Entry<String, List<String>> entry : params.entrySet()) {
String key = entry.getKey();
for (String value : entry.getValue()) {
nvps.add(new BasicNameValuePair(key, value));
}
}
post.setEntity(new UrlEncodedFormEntity(nvps));
return post;
}
@Test
public void testLaunchWithArguments() throws Exception {
repository.save(new TaskDefinition("myTask3", "foo3"));
this.registry.save("foo3", ApplicationType.task,
"1.0.0", new URI("file:src/test/resources/apps/foo-task"), null);
mockMvc.perform(post("/tasks/executions")
// .param("name", "myTask3")
.contentType(MediaType.APPLICATION_FORM_URLENCODED)
.content(EntityUtils.toString(new UrlEncodedFormEntity(Arrays.asList(
new BasicNameValuePair("name", "myTask3"),
new BasicNameValuePair("arguments",
"--foobar=jee --foobar2=jee2,foo=bar --foobar3='jee3 jee3'")))))
.accept(MediaType.APPLICATION_JSON))
.andDo(print())
.andExpect(status().isCreated());
ArgumentCaptor<AppDeploymentRequest> argumentCaptor = ArgumentCaptor.forClass(AppDeploymentRequest.class);
verify(this.taskLauncher, atLeast(1)).launch(argumentCaptor.capture());
AppDeploymentRequest request = argumentCaptor.getValue();
assertThat(request.getCommandlineArguments().size(), is(3 + 2)); // +2 for spring.cloud.task.executionid and spring.cloud.data.flow.platformname
// don't assume order in a list
assertThat(request.getCommandlineArguments(), hasItems("--foobar=jee", "--foobar2=jee2,foo=bar", "--foobar3='jee3 jee3'"));
assertEquals("myTask3", request.getDefinition().getProperties().get("spring.cloud.task.name"));
}
private void demo( String url ) throws IOException {
List<NameValuePair> parameters = new ArrayList<>();
parameters.add( new BasicNameValuePair( "user.name", "hdfs" ) );
parameters.add( new BasicNameValuePair( "jar", "wordcount/org.apache.hadoop-examples.jar" ) );
parameters.add( new BasicNameValuePair( "class", "org.apache.org.apache.hadoop.examples.WordCount" ) );
parameters.add( new BasicNameValuePair( "arg", "wordcount/input" ) );
parameters.add( new BasicNameValuePair( "arg", "wordcount/output" ) );
UrlEncodedFormEntity entity = new UrlEncodedFormEntity( parameters, StandardCharsets.UTF_8 );
HttpPost request = new HttpPost( url );
request.setEntity( entity );
HttpClientBuilder builder = HttpClientBuilder.create();
CloseableHttpClient client = builder.build();
HttpResponse response = client.execute( request );
System.out.println( EntityUtils.toString( response.getEntity() ) );
}
/**
* Checks that the server accepts a formencoded POST with an update and a timeout parameter.
*/
@Test
public void testUpdateForm_POST() throws Exception {
String update = "delete where { <monkey:pod> ?p ?o . }";
String location = Protocol.getStatementsLocation(TestServer.REPOSITORY_URL);
CloseableHttpClient httpclient = HttpClients.createDefault();
HttpPost post = new HttpPost(location);
List<NameValuePair> nvps = new ArrayList<>();
nvps.add(new BasicNameValuePair(Protocol.UPDATE_PARAM_NAME, update));
nvps.add(new BasicNameValuePair(Protocol.TIMEOUT_PARAM_NAME, "1"));
UrlEncodedFormEntity entity = new UrlEncodedFormEntity(nvps, Charsets.UTF_8);
post.setEntity(entity);
CloseableHttpResponse response = httpclient.execute(post);
System.out.println("Update Form Post Status: " + response.getStatusLine());
int statusCode = response.getStatusLine().getStatusCode();
assertEquals(true, statusCode >= 200 && statusCode < 400);
}
/**
* Computes the request payload.
*
* @return the payload containing the declared fields and files.
*/
public HttpEntity getEntity() {
if (hasFile) {
MultipartEntityBuilder builder = MultipartEntityBuilder.create();
for (Entry<String, Object> part : parameters.entrySet()) {
if (part.getValue() instanceof File) {
hasFile = true;
builder.addPart(part.getKey(), new FileBody((File) part.getValue()));
} else {
builder.addPart(part.getKey(), new StringBody(part.getValue().toString(), ContentType.APPLICATION_FORM_URLENCODED));
}
}
return builder.build();
} else {
try {
return new UrlEncodedFormEntity(getList(parameters), UTF_8);
} catch (UnsupportedEncodingException e) {
throw new RuntimeException(e);
}
}
}
private void addPostParams(HttpEntityEnclosingRequestBase request) throws UnsupportedEncodingException {
final MultipartEntityBuilder multipartBuilder = MultipartEntityBuilder.create();
List<NameValuePair> formParams = new ArrayList<>();
postVariables.forEach((name, values) -> values.forEach(value -> {
if (multipart) {
if (value.startsWith("@")) {
File f = new File(value.substring(1));
multipartBuilder.addBinaryBody(name, f, ContentType.DEFAULT_BINARY, f.getName());
} else {
multipartBuilder.addTextBody(name, value);
}
} else {
formParams.add(new BasicNameValuePair(name, value));
}
}));
if (multipart) {
request.setEntity(multipartBuilder.build());
} else {
request.setEntity(new UrlEncodedFormEntity(formParams));
}
}
protected boolean validateRecaptcha(ValidationContext context, boolean success, String captcha, String secret) {
HttpClient httpClient = context.getSession().getProvider(HttpClientProvider.class).getHttpClient();
HttpPost post = new HttpPost("https://www." + getRecaptchaDomain(context.getAuthenticatorConfig()) + "/recaptcha/api/siteverify");
List<NameValuePair> formparams = new LinkedList<>();
formparams.add(new BasicNameValuePair("secret", secret));
formparams.add(new BasicNameValuePair("response", captcha));
formparams.add(new BasicNameValuePair("remoteip", context.getConnection().getRemoteAddr()));
try {
UrlEncodedFormEntity form = new UrlEncodedFormEntity(formparams, "UTF-8");
post.setEntity(form);
HttpResponse response = httpClient.execute(post);
InputStream content = response.getEntity().getContent();
try {
Map json = JsonSerialization.readValue(content, Map.class);
Object val = json.get("success");
success = Boolean.TRUE.equals(val);
} finally {
content.close();
}
} catch (Exception e) {
ServicesLogger.LOGGER.recaptchaFailed(e);
}
return success;
}
/**
* Generates token.
*
* @param minutes expiration in minutes.
* @param credentials credentials.
* @return token response
* @throws URISyntaxException if invalid URL
* @throws IOException if accessing token fails
*/
public TokenResponse generateToken(int minutes, SimpleCredentials credentials) throws URISyntaxException, IOException {
HttpPost post = new HttpPost(rootUrl.toURI().resolve("tokens/generateToken"));
HashMap<String, String> params = new HashMap<>();
params.put("f", "json");
if (credentials != null) {
params.put("username", StringUtils.trimToEmpty(credentials.getUserName()));
params.put("password", StringUtils.trimToEmpty(credentials.getPassword()));
}
params.put("client", "requestip");
params.put("expiration", Integer.toString(minutes));
HttpEntity entity = new UrlEncodedFormEntity(params.entrySet().stream()
.map(e -> new BasicNameValuePair(e.getKey(), e.getValue())).collect(Collectors.toList()));
post.setEntity(entity);
try (CloseableHttpResponse httpResponse = httpClient.execute(post); InputStream contentStream = httpResponse.getEntity().getContent();) {
if (httpResponse.getStatusLine().getStatusCode()>=400) {
throw new HttpResponseException(httpResponse.getStatusLine().getStatusCode(), httpResponse.getStatusLine().getReasonPhrase());
}
String responseContent = IOUtils.toString(contentStream, "UTF-8");
ObjectMapper mapper = new ObjectMapper();
mapper.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false);
mapper.setSerializationInclusion(JsonInclude.Include.NON_NULL);
return mapper.readValue(responseContent, TokenResponse.class);
}
}
public String putInternal(String contents){
HttpPost httppost = new HttpPost("http://pastebin.com/api/api_post.php");
List<NameValuePair> params = new ArrayList<NameValuePair>();
params.add(new BasicNameValuePair("api_dev_key", DEV_KEY));
params.add(new BasicNameValuePair("api_paste_code", contents));
params.add(new BasicNameValuePair("api_option", "paste"));
if(isLoggedIn()) params.add(new BasicNameValuePair("api_user_key", userKey));
try {
httppost.setEntity(new UrlEncodedFormEntity(params, "UTF-8"));
HttpResponse response = httpclient.execute(httppost);
HttpEntity entity = response.getEntity();
if(entity != null) {
InputStream instream = entity.getContent();
return IOUtils.toString(instream, "UTF-8");
}
} catch(Exception e) {
e.printStackTrace();
}
return null;
}
/**
* 根据请求信息创建HttpEntityEnclosingRequestBase.
*
* @param cls 类型Class
* @param url URL
* @param headers Http请求头信息
* @param params 请求参数列表
* @return HttpEntityEnclosingRequestBase
*/
protected HttpEntityEnclosingRequestBase createEntityBase(final Class<? extends HttpEntityEnclosingRequestBase> cls, final String url,
final Map<String, String> headers, final Map<String, String> params) {
try {
final HttpEntityEnclosingRequestBase entityBase = ReflectUtils.newInstance(cls, url);
if (!CollectionUtils.isEmpty(headers)) {
headers.forEach((key, value) -> entityBase.addHeader(key, value));
}
final List<NameValuePair> pairs = covertParams2Nvps(params);
entityBase.setEntity(new UrlEncodedFormEntity(pairs, this.conf.getCharset()));
return entityBase;
} catch (final Throwable e) {
throw new HttpClientInvokeException(e.getMessage(), e);
}
}
/**
* Authenticate to external APIStore
*
* @param httpContext HTTPContext
*/
private boolean authenticateAPIM(APIStore store,HttpContext httpContext) throws APIManagementException {
try {
// create a post request to addAPI.
HttpClient httpclient = new DefaultHttpClient();
String storeEndpoint=store.getEndpoint();
if(store.getEndpoint().contains("/store")){
storeEndpoint=store.getEndpoint().split("store")[0]+"publisher"+APIConstants.APISTORE_LOGIN_URL;
}
else if(!generateEndpoint(store.getEndpoint())){
storeEndpoint=storeEndpoint+ APIConstants.APISTORE_LOGIN_URL;
}
HttpPost httppost = new HttpPost(storeEndpoint);
// Request parameters and other properties.
List<NameValuePair> params = new ArrayList<NameValuePair>(3);
params.add(new BasicNameValuePair(APIConstants.API_ACTION, APIConstants.API_LOGIN_ACTION));
params.add(new BasicNameValuePair(APIConstants.APISTORE_LOGIN_USERNAME, store.getUsername()));
params.add(new BasicNameValuePair(APIConstants.APISTORE_LOGIN_PASSWORD, store.getPassword()));
httppost.setEntity(new UrlEncodedFormEntity(params, "UTF-8"));
HttpResponse response = httpclient.execute(httppost, httpContext);
HttpEntity entity = response.getEntity();
String responseString = EntityUtils.toString(entity, "UTF-8");
boolean isError=Boolean.parseBoolean(responseString.split(",")[0].split(":")[1].split("}")[0].trim());
if (isError) {
String errorMsg=responseString.split(",")[1].split(":")[1].split("}")[0].trim();
throw new APIManagementException(" Authentication with external APIStore - "+store.getDisplayName()+ " failed due to "+errorMsg+".API publishing to APIStore- "+store.getDisplayName()+" failed.");
} else{
return true;
}
} catch (IOException e) {
throw new APIManagementException("Error while accessing the external store : "+ store.getDisplayName() +" : "+e.getMessage(), e);
}
}
/**
* Gets the hashmap turns it in HttpEntity nameValuePair.
*
* @param inputEntities
* @return
*/
private HttpEntity getEntities(HashMap<String, String> inputEntities) {
List<BasicNameValuePair> nameValuePairs = new ArrayList<BasicNameValuePair>(inputEntities.size());
Set<String> keys = inputEntities.keySet();
for (String key : keys) {
nameValuePairs.add(new BasicNameValuePair(key, inputEntities.get(key)));
}
try {
return new UrlEncodedFormEntity(nameValuePairs);
} catch (Exception e) {
e.printStackTrace();
}
return null;
}
@Override
public String postRequest(
final int max, final int numDice, final String subjectMessage, final String gameId)
throws IOException {
final String normalizedGameId = gameId.isBlank() ? "TripleA" : gameId;
String message = normalizedGameId + ":" + subjectMessage;
if (message.length() > MESSAGE_MAX_LENGTH) {
message = message.substring(0, MESSAGE_MAX_LENGTH - 1);
}
try (CloseableHttpClient httpClient =
HttpClientBuilder.create().setRedirectStrategy(new AdvancedRedirectStrategy()).build()) {
final HttpPost httpPost = new HttpPost(DICE_ROLLER_PATH);
final List<NameValuePair> params =
ImmutableList.of(
new BasicNameValuePair("numdice", String.valueOf(numDice)),
new BasicNameValuePair("numsides", String.valueOf(max)),
new BasicNameValuePair("subject", message),
new BasicNameValuePair("roller", getToAddress()),
new BasicNameValuePair("gm", getCcAddress()));
httpPost.setEntity(new UrlEncodedFormEntity(params, StandardCharsets.UTF_8));
httpPost.addHeader("User-Agent", "triplea/" + ClientContext.engineVersion());
final HttpHost hostConfig =
new HttpHost(diceRollerUri.getHost(), diceRollerUri.getPort(), diceRollerUri.getScheme());
HttpProxy.addProxy(httpPost);
try (CloseableHttpResponse response = httpClient.execute(hostConfig, httpPost)) {
return EntityUtils.toString(response.getEntity());
}
}
}
public void build(String jobName,Map<String,String> parameters) {
String fmt="http://%s:%s/job/%s/buildWithParameters";
CrumbEntity crumbEntity = getCrumb();
HttpPost httpPost = new HttpPost(String.format(fmt, jenKinsHost,jenKinsPort,jobName));
List<NameValuePair> formparams = new ArrayList<NameValuePair>();
for (String key : parameters.keySet()) {
formparams.add(new BasicNameValuePair(key, parameters.get(key)));
}
UrlEncodedFormEntity urlEntity = new UrlEncodedFormEntity(formparams, Consts.UTF_8);
CloseableHttpResponse rsp = null;
try {
httpPost.setEntity(urlEntity);
httpPost.addHeader(crumbEntity.getCrumbRequestField(),crumbEntity.getCrumb());
rsp = httpClient.execute(httpPost, this.getHttpClientContext());
} catch (Exception e) {
log.error(null, e);
}finally{
HttpUtil.close(rsp);
fmt=null;
crumbEntity=null;
httpPost=null;
formparams.clear();
parameters.clear();
formparams=null;
parameters=null;
}
}
public boolean submitOrderRequest(BuyTicketInfoModel buyTicketInfoModel,
TicketModel ticketModel) {
HttpUtil httpUtil = UserTicketStore.httpUtilStore
.get(buyTicketInfoModel.getUsername());
SimpleDateFormat shortSdf = new SimpleDateFormat("yyyy-MM-dd");
Calendar cal = Calendar.getInstance();
HttpPost httpPost = new HttpPost(apiConfig.getSubmitOrderRequest());
List<NameValuePair> formparams = new ArrayList<>();
formparams.add(new BasicNameValuePair("back_train_date", shortSdf.format(cal.getTime())));
formparams.add(new BasicNameValuePair("purpose_codes", "ADULT"));
formparams.add(new BasicNameValuePair("query_from_station_name",
Station.getNameByCode(buyTicketInfoModel.getTo())));
formparams.add(new BasicNameValuePair("query_to_station_name",
Station.getNameByCode(buyTicketInfoModel.getFrom())));
formparams.add(new BasicNameValuePair("secretStr", ticketModel.getSecret()));
formparams.add(new BasicNameValuePair("train_date", buyTicketInfoModel.getDate()));
formparams.add(new BasicNameValuePair("tour_flag", "dc"));
formparams.add(new BasicNameValuePair("undefined", ""));
UrlEncodedFormEntity urlEncodedFormEntity = new UrlEncodedFormEntity(formparams,
Consts.UTF_8);
httpPost.setEntity(urlEncodedFormEntity);
String response = httpUtil.post(httpPost);
Gson jsonResult = new Gson();
Map rsmap = jsonResult.fromJson(response, Map.class);
if (null != rsmap.get("status") && rsmap.get("status").toString().equals("true")) {
log.info("点击预定按钮成功");
return true;
} else if (null != rsmap.get("status") && rsmap.get("status").toString().equals("false")) {
String errMsg = rsmap.get("messages") + "";
log.error(errMsg);
}
return false;
}
/**
* Send post request to the {@link #getEndpointUrl()} with suffix as a url
* parameter.
*
* @param url
* suffix to the {@link #getEndpointUrl()}.
* @param parameters
* map of parameters that will be attached to the request
* @return response of the request
* @throws HttpResponseException
* @throws IOException
*/
protected String sendPostRequest(final String url, final Map<String, String> parameters)
throws HttpResponseException, IOException {
final HttpPost postRequest = new HttpPost(getEndpointUrl() + url);
final RequestConfig requestConfig = RequestConfig.custom().setConnectTimeout(getTimeout()).build();
postRequest.setConfig(requestConfig);
postRequest.addHeader(getxCsrfToken(), getCsrfToken());
postRequest.setEntity(new UrlEncodedFormEntity(createParametersList(parameters)));
final HttpResponse response = getHttpClient().execute(postRequest, getContext());
final String responseBody = new BasicResponseHandler().handleResponse(response);
return responseBody;
}
public String doPostLongWait(String url, List<NameValuePair> pairs, String charset) {
if (StringUtils.isBlank(url)) {
return null;
}
log.info(" post url=" + url);
try {
RequestConfig requestConfig = RequestConfig.custom()
.setSocketTimeout(300000)
.setConnectTimeout(30000).build();
HttpPost httpPost = new HttpPost(url);
httpPost.setConfig(requestConfig);
if (pairs != null && pairs.size() > 0) {
httpPost.setEntity(new UrlEncodedFormEntity(pairs, charset));
}
CloseableHttpResponse response = httpClient.execute(httpPost);
int statusCode = response.getStatusLine().getStatusCode();
if (statusCode != 200) {
httpPost.abort();
throw new RuntimeException("HttpClient,error status code :" + statusCode);
}
HttpEntity entity = response.getEntity();
String result = null;
if (entity != null) {
result = EntityUtils.toString(entity, charset);
}
EntityUtils.consume(entity);
response.close();
return result;
} catch (Exception e) {
log.error("to request addr=" + url + ", " + e.getMessage());
e.printStackTrace();
}
return null;
}
@Test
public void testLocalAuthentication() throws IOException {
// Test authentication required.
HttpGet get = new HttpGet("http://localhost:4567/info");
HttpResponse res = client.execute(hostPort, get);
System.out.println(IOUtils.toString(res.getEntity().getContent()));
assertThat(res.getStatusLine().getStatusCode(), is(401));
// Do local auth.
HttpPost post = new HttpPost("http://localhost:4567/login");
List<NameValuePair> postParams = new ArrayList<>();
postParams.add(new BasicNameValuePair("username", "hdfs"));
postParams.add(new BasicNameValuePair("password", "hdfs"));
post.setEntity(new UrlEncodedFormEntity(postParams, "UTF-8"));
HttpResponse res2 = client.execute(hostPort, post);
System.out.println(IOUtils.toString(res2.getEntity().getContent()));
assertThat(res2.getStatusLine().getStatusCode(), is(200));
// Use JWT to auth again.
Header tokenHeader = res2.getFirstHeader("Set-Cookie");
HttpGet get2 = new HttpGet("http://localhost:4567/threads");
get2.addHeader("Cookie", tokenHeader.getValue());
HttpResponse res3 = client.execute(hostPort, get2);
IOUtils.readLines(res3.getEntity().getContent()).clear();
assertThat(res3.getStatusLine().getStatusCode(), is(200));
// Check credentials exist.
HttpGet get3 = new HttpGet("http://localhost:4567/credentials");
get3.addHeader("Cookie", tokenHeader.getValue());
HttpResponse res4 = client.execute(hostPort, get3);
IOUtils.readLines(res4.getEntity().getContent()).clear();
assertThat(res4.getStatusLine().getStatusCode(), is(200));
}
public static HttpEntity createUrlEncodedFormEntity(Map<String, String> parameters) {
List<NameValuePair> nvps = new ArrayList<NameValuePair>(parameters.size());
for (Entry<String, String> entry : parameters.entrySet()) {
if (entry.getValue() != null) {
nvps.add(new BasicNameValuePair(entry.getKey(), entry.getValue()));
}
}
return new UrlEncodedFormEntity(nvps, Charset.forName("UTF-8"));
}
private OAuthClient.AccessTokenResponse getAccessTokenResponseWithQueryParams(String clientId, CloseableHttpClient client) throws Exception {
OAuthClient.AccessTokenResponse token;// This is a very simplified version of
HttpPost post = new HttpPost(oauth.getAccessTokenUrl() + "?client_id=" + clientId);
List<NameValuePair> parameters = new LinkedList<>();
parameters.add(new BasicNameValuePair(OAuth2Constants.GRANT_TYPE, OAuth2Constants.AUTHORIZATION_CODE));
parameters.add(new BasicNameValuePair(OAuth2Constants.CODE, oauth.getCurrentQuery().get(OAuth2Constants.CODE)));
parameters.add(new BasicNameValuePair(OAuth2Constants.REDIRECT_URI, oauth.getRedirectUri()));
UrlEncodedFormEntity formEntity = new UrlEncodedFormEntity(parameters, Charsets.UTF_8);
post.setEntity(formEntity);
return new OAuthClient.AccessTokenResponse(client.execute(post));
}
private String doPostLogin(String username, String password) throws Exception {
CloseableHttpClient httpclient = getHTTPClient(username, password);
List<NameValuePair> formparams = new ArrayList<NameValuePair>();
formparams.add(new BasicNameValuePair("username", username));
formparams.add(new BasicNameValuePair("password", password));
UrlEncodedFormEntity entity = new UrlEncodedFormEntity(formparams, Consts.UTF_8);
HttpPost httppost = new HttpPost(BASE_PATH + "/services/rest/auth/login");
httppost.setEntity(entity);
CloseableHttpResponse response = httpclient.execute(httppost);
try {
HttpEntity rent = response.getEntity();
if (rent != null) {
String respoBody = EntityUtils.toString(rent, "UTF-8");
System.out.println(respoBody);
return respoBody;
}
} finally {
response.close();
}
return null;
}
@Override
protected HttpRequestBase createRequest() {
HttpRequestBase request = super.createRequest();
List<NameValuePair> formData = new ArrayList<>();
formData.add(new BasicNameValuePair(FORM_PARAM_VALUE, pwd));
((HttpPost) request).setEntity(new UrlEncodedFormEntity(formData, StandardCharsets.UTF_8));
return request;
}
/**
* Handle the packaging and sending of a hearbeat call to a remote directory
*
* @param fromPlace the key of the place location sending
* @param toPlace the keyof the place location to receive
* @return status of operation
*/
public EmissaryResponse outboundHeartbeat(final String fromPlace, final String toPlace) {
final String directoryUrl = KeyManipulator.getServiceHostURL(toPlace);
final HttpPost method = new HttpPost(directoryUrl + CONTEXT + "/Heartbeat.action");
final String loc = KeyManipulator.getServiceLocation(toPlace);
final List<NameValuePair> nvps = new ArrayList<NameValuePair>();
nvps.add(new BasicNameValuePair(FROM_PLACE_NAME, fromPlace));
nvps.add(new BasicNameValuePair(TO_PLACE_NAME, loc));
method.setEntity(new UrlEncodedFormEntity(nvps, java.nio.charset.Charset.defaultCharset()));
return send(method);
}
public String requestHttpPost(String url_prex, String url, Map<String, String> params)
throws HttpException, IOException {
IdleConnectionMonitor();
url = url_prex + url;
HttpPost method = this.httpPostMethod(url);
List<NameValuePair> valuePairs = this.convertMap2PostParams(params);
UrlEncodedFormEntity urlEncodedFormEntity = new UrlEncodedFormEntity(valuePairs, Consts.UTF_8);
method.setEntity(urlEncodedFormEntity);
method.setConfig(requestConfig);
HttpResponse response = client.execute(method);
// System.out.println(method.getURI());
HttpEntity entity = response.getEntity();
if (entity == null) {
return "";
}
InputStream is = null;
String responseData = "";
try {
is = entity.getContent();
responseData = IOUtils.toString(is, "UTF-8");
} finally {
if (is != null) {
is.close();
}
}
return responseData;
}
public static HttpResult postStream(CloseableHttpClient client, Map<String, String> headers, String url, String encode, Map<String, Object> params) {
List<HttpEntity> entitys = new ArrayList<HttpEntity>();
if(null != params && !params.isEmpty()){
List<NameValuePair> pairs = packNameValuePair(params);
try {
HttpEntity entity = new UrlEncodedFormEntity(pairs, encode);
entitys.add(entity);
} catch (UnsupportedEncodingException e) {
e.printStackTrace();
}
}
return postStream(client, headers, url, encode, entitys);
}