/**
 * 上传文件
 * 也可以和数据post一起提交 监听progress
 * @param requestBody
 * @param uIchangeListener
 */
public void uploadPost2ServerProgress(Context context,String url, RequestBody requestBody,
                                      MyCallBack myCallBack, final UIchangeListener uIchangeListener){

    ProgressRequestBody progressRequestBody=ProgressHelper.addProgressRequestListener(requestBody, new UIProgressRequestListener() {
        @Override
        public void onUIRequestProgress(long bytesWrite, long contentLength, boolean done) {
            uIchangeListener.progressUpdate(bytesWrite,contentLength,done);
        }
    });

    Request request=new Request.Builder()
            .tag(context)
            .post(progressRequestBody)
            .url(url)
            .build();

    postData2Server(request,myCallBack);

}
 

static Request buildRequest(HttpHeaders headers, byte[] content, URI uri, HttpMethod method)
		throws MalformedURLException {

	com.squareup.okhttp.MediaType contentType = getContentType(headers);
	RequestBody body = (content.length > 0 ||
			com.squareup.okhttp.internal.http.HttpMethod.requiresRequestBody(method.name()) ?
			RequestBody.create(contentType, content) : null);

	Request.Builder builder = new Request.Builder().url(uri.toURL()).method(method.name(), body);
	for (Map.Entry<String, List<String>> entry : headers.entrySet()) {
		String headerName = entry.getKey();
		for (String headerValue : entry.getValue()) {
			builder.addHeader(headerName, headerValue);
		}
	}
	return builder.build();
}
 

public byte[] postString(String url, String json) throws IOException {
	ResponseBody body = null;
	try {
		RequestBody postBody = RequestBody.create(JSON, json);
		Request request = new Request.Builder().url(url).post(postBody).build();
		Response response = httpClient.newCall(request).execute();
		if (response.isSuccessful()) {
			body = response.body();
			byte[] res = body.bytes();
			return res;
		} else {
			logger.error("http post error.{}", response.message());
		}
	} finally {
		if (body != null) {
			body.close();
		}
	}
	return null;
}
 

public byte[] postBytes(String url, byte[] bytes) throws IOException {
	ResponseBody body = null;
	try {
		RequestBody postBody = RequestBody.create(JSON, bytes);
		Request request = new Request.Builder().url(url).post(postBody).build();
		Response response = httpClient.newCall(request).execute();
		if (response.isSuccessful()) {
			body = response.body();
			byte[] res = body.bytes();
			return res;
		} else {
			logger.error("http post error.{}", response.message());
		}
	} finally {
		if (body != null) {
			body.close();
		}
	}
	return null;
}
 

@Around("call(* com.squareup.okhttp.OkHttpClient+.newCall(..))")
public Object onOkHttpNew(ProceedingJoinPoint joinPoint) throws Throwable {
    if (!Configuration.httpMonitorEnable || joinPoint.getArgs().length != 1) {
        return joinPoint.proceed();
    }
    Object[] args = joinPoint.getArgs();
    Request request = (Request) args[0];

    //url
    URL url = request.url();
    if (GlobalConfig.isExcludeHost(url.getHost())) {
        return joinPoint.proceed();
    }
    RespBean bean = new RespBean();
    bean.setUrl(url.toString());
    bean.setStartTimestamp(System.currentTimeMillis());
    startTimeStamp.add(bean);
    return joinPoint.proceed();
}
 

public byte[] get(String url) throws Exception {
	ResponseBody body = null;
	try {
		Request request = new Request.Builder().url(url).build();
		Response response = httpClient.newCall(request).execute();
		if (response.isSuccessful()) {
			body = response.body();
			byte[] res = body.bytes();
			return res;
		} else {
			logger.error("http get url={} error.{}", url, response.message());
		}
	} finally {
		if (body != null) {
			body.close();
		}
	}
	return null;
}
 

protected void basePost(String url, Map<String, String> params, CallbackListener<T> listener)
{
    if (params == null) {
       baseGet(url,listener);return;
    }
    FormEncodingBuilder builder = new FormEncodingBuilder();
    Set<Map.Entry<String, String>> entrySet = params.entrySet();
    for (Map.Entry<String, String> entry : entrySet) {
        builder.add(entry.getKey(), entry.getValue());
    }
    RequestBody requestBody = builder.build();
    Request request = new Request.Builder()
            .url(url)
            .post(requestBody)
            .tag(url)
            .build();
    doRequest(request, listener);
}
 

private int fetchUrl(OkHttpClient client, String url) {
    Request request = new Request.Builder()
            .url(url)
            .build();

    try {
        Response response = client.newCall(request).execute();
        Log.d(TAG, "fetchUrl:response:" + response.body().string());

        if (response.code() != 200) {
            return GcmNetworkManager.RESULT_FAILURE;
        }
    } catch (IOException e) {
        Log.e(TAG, "fetchUrl:error" + e.toString());
        return GcmNetworkManager.RESULT_FAILURE;
    }

    return GcmNetworkManager.RESULT_SUCCESS;
}
 

public Response postRequest(String url, String body, Headers headers)
    throws TencentCloudSDKException {
  MediaType contentType = MediaType.parse(headers.get("Content-Type"));
  Request request = null;
  try {
    request =
        new Request.Builder()
            .url(url)
            .post(RequestBody.create(contentType, body))
            .headers(headers)
            .build();
  } catch (IllegalArgumentException e) {
    throw new TencentCloudSDKException(e.getClass().getName() + "-" + e.getMessage());
  }

  return this.doRequest(request);
}
 

public Optional<Response> saveIntegrationPluginOfType(SaveSCMPluginConfigRequest saveSCMPluginConfigRequest) throws JsonProcessingException {

        HttpUrl httpUrl = getSaveIntegrationPluginConfigURL(saveSCMPluginConfigRequest);
        MediaType mediaType = MediaType.parse("application/json");
        Request httpRequest = buildPutRequest(httpUrl, mediaType, saveSCMPluginConfigRequest.getRequestBody());
        try {
            Response response = client.newCall(httpRequest).execute();
            if(!response.isSuccessful()){
                log.error(String.format("Error when attempting to save %s plugin integration for API %s version %s", saveSCMPluginConfigRequest.getScmProvider(), saveSCMPluginConfigRequest.getApi(),saveSCMPluginConfigRequest.getVersion()));
                log.error("Error response: "+response.body().string());
                response.body().close();
            }
            return Optional.ofNullable(response);
        } catch (IOException e) {
            log.error(String.format("Error when attempting to save %s plugin integration for API %s. Error message %s", saveSCMPluginConfigRequest.getScmProvider(), saveSCMPluginConfigRequest.getApi(), e.getMessage()));
            return Optional.empty();
        }

    }
 

@Override
public void getVerifySMS(String phone, String pwd) {
    model.getVerifySMS(phone, pwd, new ResultCallback<String>() {
        @Override
        public void onError(Request request, Exception e) {
            view.showVerifyError(e.getMessage());
        }

        @Override
        public void onResponse(String response) {
            if (response.equalsIgnoreCase("true")) {
                view.showVerifySuccerss();
            }
        }
    });
}
 

Response executeWithAuthRetry(URI uri, Map<String, ? extends Credentials> credentials, HttpTransferListener listener,
    List<ContentRange> ranges) throws IOException {
  Request request = buildRequest(uri, credentials, ranges);
  listener.initiating(request);
  Response response = this.okHttpClient.newCall(request).execute();
  for (int i = 0; i < 10; i++) {
    final int code = response.code();
    if (!((code == HTTP_UNAUTHORIZED || code == HTTP_PROXY_AUTH) && containsBasic(response.challenges()))) {
      break;
    }
    // if we are receiving a basic authorization challenges, set header and retry
    final String host = response.request().uri().getHost();
    this.basicChallengeReceived.add(host);
    final Credentials creds = credentials.get(host);
    if (creds == null) {
      break;
    }
    final String name = code == HTTP_UNAUTHORIZED ? "Authorization" : "Proxy-Authorization";
    request = response.request().newBuilder().header(name, creds.basic()).build();
    response = this.okHttpClient.newCall(request).execute();
  }
  return response;
}
 

public byte[] postBytes(String url, byte[] bytes) throws IOException {
	ResponseBody body = null;
	try {
		RequestBody postBody = RequestBody.create(JSON, bytes);
		Request request = new Request.Builder().url(url).post(postBody).build();
		Response response = httpClient.newCall(request).execute();
		if (response.isSuccessful()) {
			body = response.body();
			byte[] res = body.bytes();
			return res;
		} else {
			logger.error("http post error.{}", response.message());
		}
	} finally {
		if (body != null) {
			body.close();
		}
	}
	return null;
}
 

@Override
public void getFollowers(String uid, int page) {
    model.getFollowers(uid, page, new ResultCallback<List<FollowEntity>>() {
        @Override
        public void onError(Request request, Exception e) {
            view.showError();
        }

        @Override
        public void onResponse(List<FollowEntity> response) {
            view.showFollows(response);
        }
    });


}
 

static Observable<File> downloadFile(final String url, final String path) {
  return Observable.create(subscriber -> {
    final Request request = new Request.Builder().url(url).build();
    try {
      if (!subscriber.isUnsubscribed()) {
        final File file = new File(path);
        if (!file.exists()) {
          // noinspection ResultOfMethodCallIgnored
          file.getParentFile().mkdirs();
          Timber.i("downloadFile: Downloading " + file.getName());
          final Response response = sClient.newCall(request).execute();
          final BufferedSink sink = Okio.buffer(Okio.sink(file));
          sink.writeAll(response.body().source());
          sink.close();
        } else Timber.i("downloadFile: Retrieved from cache " + file.getName());

        subscriber.onNext(file);
        subscriber.onCompleted();
      }
    } catch (IOException e) {
      subscriber.onError(new DownloadException(e));
    }
  });
}
 

/**
 * Let user see the recent operation logs of the projects which he is member
 * of.</br>
 * <b>URL</b>: /logs</br>
 * <b>Method</b>: GET
 *
 * @param lines
 *            (The number of logs to be shown, default is 10 if lines,
 *            start_time, end_time are not provided)
 * @param startTime
 *            (The start time of logs to be shown in unix timestap)
 * @param endTime
 *            (The end time of logs to be shown in unix timestap)
 * @return required logs.
 * @throws IOException
 * @throws HarborClientException
 */
public List<Log> getLogs(String lines, String startTime, String endTime) throws IOException, HarborClientException {
	logger.debug("get logs lines %s, start time %s, end time %s", lines, startTime, endTime);
	List<NameValuePair> qparams = new ArrayList<>();
	qparams.add(new BasicNameValuePair("lines", lines));
	qparams.add(new BasicNameValuePair("start_time", startTime));
	qparams.add(new BasicNameValuePair("end_time", endTime));
	qparams.removeIf(o -> Objects.isNull(o.getValue()));
	String url = getBaseUrl() + "/logs?" + URLEncodedUtils.format(qparams, "UTF-8");
	Request request = new Request.Builder().url(url).get().build();
	Response response = okhttpClient.newCall(request).execute();
	logger.debug(String.format(REQUEST_RESPONSE_INFO, request, response));
	if (response.code() != 200) {
		throw new HarborClientException(String.valueOf(response.code()), response.message());
	}
	return mapper.readValue(response.body().string(), new TypeReference<List<Log>>() {
	});
}
 

@Override
protected Integer doInBackground(String... url) {
    try {
        Log.d(TAG, "Processing URL: " + url[0]);
        Request request = new Request.Builder()
                .header("User-Agent", "Mozilla/5.0 (jamorham)")
                .header("Connection", "close")
                .url(url[0])
                .build();

        client.setConnectTimeout(15, TimeUnit.SECONDS);
        client.setReadTimeout(30, TimeUnit.SECONDS);
        client.setWriteTimeout(30, TimeUnit.SECONDS);

        final Response response = client.newCall(request).execute();
        if (!response.isSuccessful()) throw new IOException("Unexpected code " + response);
        body = response.body().bytes();
    } catch (Exception e) {
        Log.d(TAG, "Exception in background task: " + e.toString());
    }
    return body.length;
}
 

public String getDefinition(SwaggerHubRequest swaggerHubRequest) throws MojoExecutionException {
    HttpUrl httpUrl = getDownloadUrl(swaggerHubRequest);
    MediaType mediaType = MediaType.parse("application/" + swaggerHubRequest.getFormat());

    Request requestBuilder = buildGetRequest(httpUrl, mediaType);

    final String jsonResponse;
    try {
        final Response response = client.newCall(requestBuilder).execute();
        if (!response.isSuccessful()) {
            throw new MojoExecutionException(
                    String.format("Failed to download definition: %s", response.body().string())
            );
        } else {
            jsonResponse = response.body().string();
        }
    } catch (IOException e) {
        throw new MojoExecutionException("Failed to download definition", e);
    }
    return jsonResponse;
}
 

@NonNull
private synchronized Response renewTokenAndProceed(Chain chain, Request originalRequest) throws
        IOException {
    if (mTokenStorage.hasTokenExpired()) {
        try {
            Token token = mAuthenticationService.refreshToken(Constants.GRANT_TYPE_REFRESH_TOKEN,
                    mTokenStorage.getRefreshToken());
            mTokenStorage.updateToken(token);
        } catch (RetrofitError error) {
            if (error.getResponse() == null || isServerError(error.getResponse())) {
                throw new RuntimeException(
                        "Failed to renew token, empty response/server error: " + error.getCause());
            } else {
                throw new RuntimeException("Failed to renew token, unknown cause: " + error.getCause());
            }
        }
    }
    return addHeaderAndProceedWithChain(chain, originalRequest);
}
 

/**
 * Gets a list of buckets containing aggregate information about data in the
 * indicated counter.  The number of buckets is determined by the bucket size
 * and date/time range specified.
 * @param tenantId
 * @param counterId
 * @param from
 * @param to
 * @param bucketSize
 */
@SuppressWarnings("nls")
public List<BucketDataPointBean> getCounterData(String tenantId, String counterId, Date from, Date to,
        BucketSizeType bucketSize) {
    try {
        StringBuilder params = new StringBuilder();
        params.append("?")
            .append("start=")
            .append(from.getTime())
            .append("&end=")
            .append(to.getTime())
            .append("&bucketDuration=")
            .append(bucketSize.getValue());
        URL endpoint = serverUrl.toURI().resolve("counters/" + counterId + "/stats" + params.toString()).toURL(); //$NON-NLS-1$
        Request request = new Request.Builder()
                .url(endpoint)
                .header("Accept", "application/json") //$NON-NLS-1$ //$NON-NLS-2$
                .header("Hawkular-Tenant", tenantId) //$NON-NLS-1$
                .build();
        Response response = httpClient.newCall(request).execute();
        if (response.code() >= 400) {
            throw hawkularMetricsError(response);
        }
        if (response.code() == 204) {
            return Collections.EMPTY_LIST;
        }
        String responseBody = response.body().string();
        return readMapper.reader(new TypeReference<List<BucketDataPointBean>>() {}).readValue(responseBody);
    } catch (URISyntaxException | IOException e) {
        throw new RuntimeException(e);
    }
}
 

@Override
public String getDestinationId(Request request) {
    final URL httpUrl = request.url();
    if (httpUrl == null || httpUrl.getHost() == null) {
        return "Unknown";
    }
    final int port = EndPointUtils.getPort(httpUrl.getPort(), httpUrl.getDefaultPort());
    return HostAndPort.toHostAndPortString(httpUrl.getHost(), port);
}
 

public boolean connect(String url) {
  OkHttpClient httpClient = new OkHttpClient();
  Request request = new Request.Builder().url(url).addHeader("sec-websocket-protocol", "echo-protocol").build();
  WebSocketCall.create(httpClient, request).enqueue(new WXWebSocketListener(url));

  return true;
}
 

public void downloadSpecs() throws Exception {
	Request request = new Request.Builder()
		.url(mLocation)
		.build();

	Response response = mClient.newCall(request).execute();
	if (!response.isSuccessful()) {
		throw new IOException("Unexpected code " + response);
	}

	mRawXml = response.body().string();

	DocumentBuilderFactory dbf = DocumentBuilderFactory.newInstance();
	DocumentBuilder db = dbf.newDocumentBuilder();
	InputSource source = new InputSource(new StringReader(mRawXml));
	Document doc;
	try {
		doc = db.parse(source);
	}
	catch (SAXParseException e) {
		return;
	}
	XPath xPath = XPathFactory.newInstance().newXPath();

	mProperties.put("xml_icon_url", xPath.compile("//icon/url").evaluate(doc));
	generateIconUrl();
	mProperties.put("xml_friendly_name", xPath.compile("//friendlyName").evaluate(doc));
}
 

static String postKV(String url) throws IOException {

		RequestBody formBody = new FormEncodingBuilder().add("platform", "android").add("name", "bug").build();

		Request request = new Request.Builder().url(url).post(formBody).build();

		Response response = client.newCall(request).execute();
		System.out.println("post KV response =" + response.isSuccessful());
		if (response.isSuccessful()) {
			return response.body().string();
		} else {
			throw new IOException("Unexpected code " + response);
		}
	}
 

private static Request buildRequest(String authorization, String oxdId, String userId, String userSecret, String state, String nonce, DevelopersApi client) {

        final String json = "{\"oxd_id\":\"" + oxdId + "\",\"username\":\"" + userId + "\",\"password\":\"" + userSecret
                + "\",\"state\":\"" + state + "\",\"nonce\":\"" + nonce + "\"}";

        final RequestBody reqBody = RequestBody.create(MediaType.parse("application/json; charset=utf-8"), json);

        return new Request.Builder()
                .addHeader("Authorization", authorization)
                .addHeader("Content-Type", "application/json")
                .addHeader("Accept", "application/json")
                .method("POST", reqBody)
                .url(client.getApiClient().getBasePath() + AUTH_CODE_ENDPOINT).build();

    }
 

@Advice.OnMethodEnter(suppress = Throwable.class)
private static void onBeforeExecute(@Advice.FieldValue(value = "originalRequest", typing = Assigner.Typing.DYNAMIC, readOnly = false) @Nullable Object originalRequest,
                                    @Advice.Local("span") Span span) {

    if (tracer == null || tracer.getActive() == null) {
        return;
    }
    final AbstractSpan<?> parent = tracer.getActive();

    if (originalRequest == null) {
        return;
    }

    if (originalRequest instanceof com.squareup.okhttp.Request) {
        com.squareup.okhttp.Request request = (com.squareup.okhttp.Request) originalRequest;
        HttpUrl httpUrl = request.httpUrl();
        span = HttpClientHelper.startHttpClientSpan(parent, request.method(), httpUrl.toString(), httpUrl.scheme(),
            OkHttpClientHelper.computeHostName(httpUrl.host()), httpUrl.port());
        if (span != null) {
            span.activate();
            if (headerSetterHelperManager != null) {
                TextHeaderSetter<Request.Builder> headerSetter = headerSetterHelperManager.getForClassLoaderOfClass(Request.class);
                if (headerSetter != null) {
                    Request.Builder builder = ((com.squareup.okhttp.Request) originalRequest).newBuilder();
                    span.propagateTraceContext(builder, headerSetter);
                    originalRequest = builder.build();
                }
            }
        }
    }
}
 

@Advice.OnMethodEnter(suppress = Throwable.class)
private static void onBeforeEnqueue(@Advice.Origin Class<? extends Call> clazz,
                                    @Advice.FieldValue(value = "originalRequest", typing = Assigner.Typing.DYNAMIC, readOnly = false) @Nullable Request originalRequest,
                                    @Advice.Argument(value = 0, readOnly = false) @Nullable Callback callback,
                                    @Advice.Local("span") Span span) {
    if (tracer == null || tracer.getActive() == null || callbackWrapperCreator == null) {
        return;
    }

    final WrapperCreator<Callback> wrapperCreator = callbackWrapperCreator.getForClassLoaderOfClass(clazz);
    if (originalRequest == null || callback == null || wrapperCreator == null) {
        return;
    }

    final AbstractSpan<?> parent = tracer.getActive();

    Request request = originalRequest;
    URL url = request.url();
    span = HttpClientHelper.startHttpClientSpan(parent, request.method(), url.toString(), url.getProtocol(),
        OkHttpClientHelper.computeHostName(url.getHost()), url.getPort());
    if (span != null) {
        span.activate();
        if (headerSetterHelperManager != null) {
            TextHeaderSetter<Request.Builder> headerSetter = headerSetterHelperManager.getForClassLoaderOfClass(Request.class);
            if (headerSetter != null) {
                Request.Builder builder = originalRequest.newBuilder();
                span.propagateTraceContext(builder, headerSetter);
                originalRequest = builder.build();
            }
        }
        callback = wrapperCreator.wrap(callback, span);
    }
}
 

@Override
public void post(final String url, final String json,
                 final Net.Parser<T> parser,
                 final Net.Callback<T> callback, final Object tag) {
    Request request = new Request.Builder()
            .url(url).post(createJsonBody(json)).build();
    call(request, parser, callback, tag);
}
 

@Override
protected Request doBuildRequest() {
    RequestBody body = buildBody();
    return newBuilder()
            .method(httpMethod, body)
            .build();
}
 

public void sendHttpMessage(final UPID recipient, final Message message) throws IOException
{
    if (closed.get()) {
        return;
    }

    checkNotNull(recipient, "recipient is null");
    checkNotNull(message, "message is null");
    checkArgument(recipient.getHost() != null, "%s is not a valid recipient for %s", recipient, message);
    checkArgument(recipient.getPort() > 0, "%s is not a valid recipient for %s", recipient, message);
    final String path = format("/%s/%s", recipient.getId(), message.getDescriptorForType().getFullName());
    final URL url = new URL("http", recipient.getHost(), recipient.getPort(), path);

    final UUID tag = UUID.randomUUID();
    inFlight.put(tag, SettableFuture.<Void>create());

    final RequestBody body = RequestBody.create(PROTOBUF_MEDIATYPE, message.toByteArray());
    final Request request = new Request.Builder()
        .header("Libprocess-From", sender)
        .url(url)
        .post(body)
        .tag(tag)
        .build();

    LOG.debug("Sending from %s to URL %s: %s", sender, url, message);
    client.newCall(request).enqueue(this);
}