com/android/statementservice/retriever/URLFetcher.java

/*
 * Copyright (C) 2015 The Android Open Source Project
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package com.android.statementservice.retriever;

import android.util.Log;

import com.android.volley.Cache;
import com.android.volley.NetworkResponse;
import com.android.volley.toolbox.HttpHeaderParser;

import java.io.BufferedInputStream;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.net.HttpURLConnection;
import java.net.URL;
import java.util.HashMap;
import java.util.List;
import java.util.Locale;
import java.util.Map;

/**
 * Helper class for fetching HTTP or HTTPS URL.
 *
 * Visible for testing.
 *
 * @hide
 */
public class URLFetcher {
    private static final String TAG = URLFetcher.class.getSimpleName();

    private static final long DO_NOT_CACHE_RESULT = 0L;
    private static final int INPUT_BUFFER_SIZE_IN_BYTES = 1024;

    /**
     * Fetches the specified url and returns the content and ttl.
     *
     * <p>
     * Retry {@code retry} times if the connection failed or timed out for any reason.
     * HTTP error code (e.g. 404/500) won't be retried.
     *
     * @throws IOException if it can't retrieve the content due to a network problem.
     * @throws AssociationServiceException if the URL scheme is not http or https or the content
     * length exceeds {code fileSizeLimit}.
     */
    public WebContent getWebContentFromUrlWithRetry(URL url, long fileSizeLimit,
            int connectionTimeoutMillis, int backoffMillis, int retry)
                    throws AssociationServiceException, IOException, InterruptedException {
        if (retry <= 0) {
            throw new IllegalArgumentException("retry should be a postive inetger.");
        }
        while (retry > 0) {
            try {
                return getWebContentFromUrl(url, fileSizeLimit, connectionTimeoutMillis);
            } catch (IOException e) {
                retry--;
                if (retry == 0) {
                    throw e;
                }
            }

            Thread.sleep(backoffMillis);
        }

        // Should never reach here.
        return null;
    }

    /**
     * Fetches the specified url and returns the content and ttl.
     *
     * @throws IOException if it can't retrieve the content due to a network problem.
     * @throws AssociationServiceException if the URL scheme is not http or https or the content
     * length exceeds {code fileSizeLimit}.
     */
    public WebContent getWebContentFromUrl(URL url, long fileSizeLimit, int connectionTimeoutMillis)
            throws AssociationServiceException, IOException {
        final String scheme = url.getProtocol().toLowerCase(Locale.US);
        if (!scheme.equals("http") && !scheme.equals("https")) {
            throw new IllegalArgumentException("The url protocol should be on http or https.");
        }

        HttpURLConnection connection = null;
        try {
            connection = (HttpURLConnection) url.openConnection();
            connection.setInstanceFollowRedirects(true);
            connection.setConnectTimeout(connectionTimeoutMillis);
            connection.setReadTimeout(connectionTimeoutMillis);
            connection.setUseCaches(true);
            connection.setInstanceFollowRedirects(false);
            connection.addRequestProperty("Cache-Control", "max-stale=60");

            if (connection.getResponseCode() != HttpURLConnection.HTTP_OK) {
                Log.e(TAG, "The responses code is not 200 but "  + connection.getResponseCode());
                return new WebContent("", DO_NOT_CACHE_RESULT);
            }

            if (connection.getContentLength() > fileSizeLimit) {
                Log.e(TAG, "The content size of the url is larger than "  + fileSizeLimit);
                return new WebContent("", DO_NOT_CACHE_RESULT);
            }

            Long expireTimeMillis = getExpirationTimeMillisFromHTTPHeader(
                    connection.getHeaderFields());

            return new WebContent(inputStreamToString(
                    connection.getInputStream(), connection.getContentLength(), fileSizeLimit),
                expireTimeMillis);
        } finally {
            if (connection != null) {
                connection.disconnect();
            }
        }
    }

    /**
     * Visible for testing.
     * @hide
     */
    public static String inputStreamToString(InputStream inputStream, int length, long sizeLimit)
            throws IOException, AssociationServiceException {
        if (length < 0) {
            length = 0;
        }
        ByteArrayOutputStream baos = new ByteArrayOutputStream(length);
        BufferedInputStream bis = new BufferedInputStream(inputStream);
        byte[] buffer = new byte[INPUT_BUFFER_SIZE_IN_BYTES];
        int len = 0;
        while ((len = bis.read(buffer)) != -1) {
            baos.write(buffer, 0, len);
            if (baos.size() > sizeLimit) {
                throw new AssociationServiceException("The content size of the url is larger than "
                        + sizeLimit);
            }
        }
        return baos.toString("UTF-8");
    }

    /**
     * Parses the HTTP headers to compute the ttl.
     *
     * @param headers a map that map the header key to the header values. Can be null.
     * @return the ttl in millisecond or null if the ttl is not specified in the header.
     */
    private Long getExpirationTimeMillisFromHTTPHeader(Map<String, List<String>> headers) {
        if (headers == null) {
            return null;
        }
        Map<String, String> joinedHeaders = joinHttpHeaders(headers);

        NetworkResponse response = new NetworkResponse(null, joinedHeaders);
        Cache.Entry cachePolicy = HttpHeaderParser.parseCacheHeaders(response);

        if (cachePolicy == null) {
            // Cache is disabled, set the expire time to 0.
            return DO_NOT_CACHE_RESULT;
        } else if (cachePolicy.ttl == 0) {
            // Cache policy is not specified, set the expire time to 0.
            return DO_NOT_CACHE_RESULT;
        } else {
            // cachePolicy.ttl is actually the expire timestamp in millisecond.
            return cachePolicy.ttl;
        }
    }

    /**
     * Converts an HTTP header map of the format provided by {@linkHttpUrlConnection} to a map of
     * the format accepted by {@link HttpHeaderParser}. It does this by joining all the entries for
     * a given header key with ", ".
     */
    private Map<String, String> joinHttpHeaders(Map<String, List<String>> headers) {
        Map<String, String> joinedHeaders = new HashMap<String, String>();
        for (Map.Entry<String, List<String>> entry : headers.entrySet()) {
            List<String> values = entry.getValue();
            if (values.size() == 1) {
                joinedHeaders.put(entry.getKey(), values.get(0));
            } else {
                joinedHeaders.put(entry.getKey(), Utils.joinStrings(", ", values));
            }
        }
        return joinedHeaders;
    }
}