@Test
public void simple() {
Request request = fromArgs("http://example.com").createRequest();
assertEquals("GET", request.method());
assertEquals("http://example.com/", request.url().toString());
assertNull(request.body());
}
@Test
public void put() throws IOException {
Request request = fromArgs("-X", "PUT", "-d", "foo", "http://example.com").createRequest();
assertEquals("PUT", request.method());
assertEquals("http://example.com/", request.url().toString());
assertEquals(3, request.body().contentLength());
}
@Override
public Response intercept(Chain chain) throws IOException {
Request request = chain.request();
long t1 = System.nanoTime();
L.i(
TAG,
"Sending request="
+ request.url()
+ " connection="
+ chain.connection()
+ " head="
+ request.headers()
+ " request=");
Response response = chain.proceed(request);
long t2 = System.nanoTime();
L.i(
TAG,
"Received response="
+ response.request().url()
+ " connect time="
+ ((t2 - t1) / 1e6d)
+ " head="
+ response.headers()
+ " tostring"
+ response.toString());
return response;
}
@Test
public void headerSplitWithDate() {
Request request =
fromArgs("-H", "If-Modified-Since: Mon, 18 Aug 2014 15:16:06 GMT", "http://example.com")
.createRequest();
assertEquals("Mon, 18 Aug 2014 15:16:06 GMT", request.header("If-Modified-Since"));
}
@Test
public void userAgent() {
Request request = fromArgs("-A", "foo", "http://example.com").createRequest();
assertEquals("GET", request.method());
assertEquals("http://example.com/", request.url().toString());
assertEquals("foo", request.header("User-Agent"));
assertNull(request.body());
}
@Test
public void dataPut() {
Request request = fromArgs("-d", "foo", "-X", "PUT", "http://example.com").createRequest();
RequestBody body = request.body();
assertEquals("PUT", request.method());
assertEquals("http://example.com/", request.url().toString());
assertEquals("application/x-www-form-urlencoded; charset=utf-8", body.contentType().toString());
assertEquals("foo", bodyAsString(body));
}
@Test
public void contentTypeHeader() {
Request request =
fromArgs("-d", "foo", "-H", "Content-Type: application/json", "http://example.com")
.createRequest();
RequestBody body = request.body();
assertEquals("POST", request.method());
assertEquals("http://example.com/", request.url().toString());
assertEquals("application/json; charset=utf-8", body.contentType().toString());
assertEquals("foo", bodyAsString(body));
}
@Override
public Request authenticate(Route route, Response response) throws IOException {
Request authenticated = innerAuthenticator.authenticate(route, response);
if (authenticated != null) {
String authorizationValue = authenticated.header("Authorization");
if (authorizationValue != null && innerAuthenticator instanceof CachingAuthenticator) {
authCache.put(authenticated.url().host(), (CachingAuthenticator) innerAuthenticator);
}
}
return authenticated;
}
@Override
public Response intercept(Chain chain) throws IOException {
Request original = chain.request();
Request request =
chain
.request()
.newBuilder()
.headers(computeHeaders())
.method(original.method(), original.body())
.build();
return chain.proceed(request);
}
@Override
public Response intercept(Interceptor.Chain chain) throws IOException {
Request request = chain.request();
request =
(request
.newBuilder()
.header("X-Auth-Token", X_AUTH_TOKEN)
.header("X-Response-Control", "minified"))
.method(request.method(), request.body())
.build();
return chain.proceed(request);
}
@Override
public Response intercept(Chain chain) throws IOException {
RealInterceptorChain realChain = (RealInterceptorChain) chain;
Request request = realChain.request();
StreamAllocation streamAllocation = realChain.streamAllocation();
// We need the network to satisfy this request. Possibly for validating a conditional GET.
boolean doExtensiveHealthChecks = !request.method().equals("GET");
HttpStream httpStream = streamAllocation.newStream(client, doExtensiveHealthChecks);
RealConnection connection = streamAllocation.connection();
return realChain.proceed(request, streamAllocation, httpStream, connection);
}
@Override
public long open(DataSpec dataSpec) throws HttpDataSourceException {
this.dataSpec = dataSpec;
this.bytesRead = 0;
this.bytesSkipped = 0;
Request request = makeRequest(dataSpec);
try {
response = okHttpClient.newCall(request).execute();
responseByteStream = response.body().byteStream();
} catch (IOException e) {
throw new HttpDataSourceException(
"Unable to connect to " + dataSpec.uri.toString(), e, dataSpec);
}
int responseCode = response.code();
// Check for a valid response code.
if (!response.isSuccessful()) {
Map<String, List<String>> headers = request.headers().toMultimap();
closeConnectionQuietly();
throw new InvalidResponseCodeException(responseCode, headers, dataSpec);
}
// Check for a valid content type.
MediaType mediaType = response.body().contentType();
String contentType = mediaType != null ? mediaType.toString() : null;
if (contentTypePredicate != null && !contentTypePredicate.evaluate(contentType)) {
closeConnectionQuietly();
throw new InvalidContentTypeException(contentType, dataSpec);
}
// If we requested a range starting from a non-zero position and received a 200 rather than a
// 206, then the server does not support partial requests. We'll need to manually skip to the
// requested position.
bytesToSkip = responseCode == 200 && dataSpec.position != 0 ? dataSpec.position : 0;
// Determine the length of the data to be read, after skipping.
long contentLength = response.body().contentLength();
bytesToRead =
dataSpec.length != C.LENGTH_UNBOUNDED
? dataSpec.length
: contentLength != -1 ? contentLength - bytesToSkip : C.LENGTH_UNBOUNDED;
opened = true;
if (listener != null) {
listener.onTransferStart();
}
return bytesToRead;
}
@Override
public Response intercept(Chain chain) throws IOException {
Request request = chain.request();
Request modifiedRequest =
request
.newBuilder()
.addHeader(
"Authorization",
"Basic "
+ Base64.getEncoder()
.encodeToString(
(credentials.getUsername() + ":" + credentials.getPassword())
.getBytes()))
.build();
return chain.proceed(modifiedRequest);
}
@Override
public Response intercept(Chain chain) throws IOException {
String paramValue;
Request request = chain.request();
if (location == "query") {
String newQuery = request.url().uri().getQuery();
paramValue = paramName + "=" + apiKey;
if (newQuery == null) {
newQuery = paramValue;
} else {
newQuery += "&" + paramValue;
}
URI newUri;
try {
newUri =
new URI(
request.url().uri().getScheme(),
request.url().uri().getAuthority(),
request.url().uri().getPath(),
newQuery,
request.url().uri().getFragment());
} catch (URISyntaxException e) {
throw new IOException(e);
}
request = request.newBuilder().url(newUri.toURL()).build();
} else if (location == "header") {
request = request.newBuilder().addHeader(paramName, apiKey).build();
}
return chain.proceed(request);
}
@Override
public Response intercept(Chain chain) throws IOException {
Request request = chain.request();
// Build new request
Request.Builder builder = request.newBuilder();
builder.header("Accept", "application/json");
String token = oauthToken.get();
if (Utils.isNotNullOrEmpty(token)) {
setAuthHeader(builder, token);
}
request = builder.build();
Response response = chain.proceed(request);
// If response is Forbidden or Unauthorized, try to obtain a token via authorize() or via
// config.
if (response.code() != 401 && response.code() != 403) {
return response;
} else if (Utils.isNotNullOrEmpty(config.getUsername())
&& Utils.isNotNullOrEmpty(config.getPassword())) {
synchronized (client) {
token = authorize();
if (token != null) {
oauthToken.set(token);
}
}
} else if (Utils.isNotNullOrEmpty(config.getOauthToken())) {
token = config.getOauthToken();
oauthToken.set(token);
}
// If token was obtain, then retry request using the obtained token.
if (Utils.isNotNullOrEmpty(token)) {
// Close the previous response to prevent leaked connections.
response.body().close();
setAuthHeader(builder, token);
request = builder.build();
return chain.proceed(request); // repeat request with new token
} else {
return response;
}
}
@Override
public Response intercept(Interceptor.Chain chain) throws IOException {
Request request = chain.request();
long t1 = System.nanoTime();
Log.v(
"CS_SDK",
String.format(
"Sending request %s on %s%n%s", request.url(), chain.connection(), request.headers()));
Response response = chain.proceed(request);
long t2 = System.nanoTime();
Log.v(
"CS_SDK",
String.format(
"Received response for %s in %.1fms%n%s",
response.request().url(), (t2 - t1) / 1e6d, response.headers()));
return response;
}
@Override
public T call() throws Exception {
Request request = null;
Response response = null;
Exception exception = null;
Call call = null;
try {
MNSLog.logD("[call] - ");
if (context.getCancellationHandler().isCancelled()) {
throw new InterruptedIOException("This task is cancelled!");
}
Request.Builder requestBuilder = new Request.Builder();
// build request url
String url = message.buildCanonicalURL();
MNSUtils.signRequest(message);
requestBuilder = requestBuilder.url(url);
// set request headers
for (String key : message.getHeaders().keySet()) {
requestBuilder = requestBuilder.addHeader(key, message.getHeaders().get(key));
}
String contentType = message.getHeaders().get(MNSHeaders.CONTENT_TYPE);
String content = message.getContent();
// set request body
if (message.getContent() != null) {
MNSUtils.assertTrue(contentType != null, "Content type can't be null when send data!");
requestBuilder =
requestBuilder.method(
message.getMethod().toString(),
new ProgressTouchableRequestBody(
message.getContent().getBytes(), contentType, context.getProgressCallback()));
} else {
switch (message.getMethod()) {
case PUT:
requestBuilder =
requestBuilder.method(
message.getMethod().toString(), RequestBody.create(null, new byte[0]));
break;
case GET:
requestBuilder = requestBuilder.get();
break;
case HEAD:
requestBuilder = requestBuilder.head();
break;
case DELETE:
requestBuilder = requestBuilder.delete();
break;
default:
break;
}
}
request = requestBuilder.build();
if (MNSLog.isEnableLog()) {
MNSLog.logD("request url: " + request.url());
Map<String, List<String>> headerMap = request.headers().toMultimap();
for (String key : headerMap.keySet()) {
MNSLog.logD("requestHeader " + key + ": " + headerMap.get(key).get(0));
}
}
call = client.newCall(request);
context.getCancellationHandler().setCall(call);
// send request
response = call.execute();
if (MNSLog.isEnableLog()) {
MNSLog.logD("response code: " + response.code() + " for url: " + request.url());
Map<String, List<String>> headerMap = response.headers().toMultimap();
for (String key : headerMap.keySet()) {
MNSLog.logD("responseHeader " + key + ": " + headerMap.get(key).get(0));
}
}
} catch (Exception e) {
MNSLog.logE("Encounter local execpiton: " + e.toString());
if (MNSLog.isEnableLog()) {
e.printStackTrace();
}
exception = new ClientException(e.getMessage(), e);
}
if (exception == null && (response.code() == 203 || response.code() >= 300)) {
try {
exception = ResponseParsers.parseResponseErrorXML(response);
} catch (IOException e) {
exception = new ClientException(e.getMessage(), e);
}
} else if (exception == null) {
try {
T result = responseParser.parse(response);
if (context.getCompletedCallback() != null) {
context.getCompletedCallback().onSuccess(context.getRequest(), result);
}
return result;
} catch (IOException e) {
exception = new ClientException(e.getMessage(), e);
}
}
// reconstruct exception caused by manually cancelling
if ((call != null && call.isCanceled()) || context.getCancellationHandler().isCancelled()) {
exception = new ClientException("Task is cancelled!", exception.getCause(), true);
}
if (exception instanceof ClientException) {
if (context.getCompletedCallback() != null) {
context
.getCompletedCallback()
.onFailure(context.getRequest(), (ClientException) exception, null);
}
} else {
if (context.getCompletedCallback() != null) {
context
.getCompletedCallback()
.onFailure(context.getRequest(), null, (ServiceException) exception);
}
}
throw exception;
}
private boolean doesHaveUserAgent(Request request) {
return request.headers().get(HEADER_USER_AGENT) != null;
}
