• Home
• cn.leancloud
• leancloud-common
• 0.2.7
• source code
• PaasClient.java

×

Project download

Many resources are needed to download a project. Please understand that we have to compensate our server costs. Thank you in advance.
Project price only 1 $

You can buy this project and download/modify it how often you want.

com.avos.avoscloud.PaasClient Maven / Gradle / Ivy

package com.avos.avoscloud;

import java.io.File;
import java.io.IOException;
import java.net.CookieHandler;
import java.net.URI;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.Comparator;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.WeakHashMap;
import java.util.concurrent.TimeUnit;

import com.alibaba.fastjson.JSON;
import com.avos.avoscloud.internal.InternalCache;
import com.avos.avoscloud.internal.InternalConfigurationController;
import com.avos.avoscloud.okhttp.Call;
import com.avos.avoscloud.okhttp.Interceptor;
import com.avos.avoscloud.okhttp.MediaType;
import com.avos.avoscloud.okhttp.OkHttpClient;
import com.avos.avoscloud.okhttp.Request;
import com.avos.avoscloud.okhttp.RequestBody;
import com.avos.avoscloud.okhttp.Response;
import com.avos.avoscloud.okhttp.ResponseBody;
import com.avos.avoscloud.okhttp.internal.framed.Header;
import com.avos.avoscloud.okio.Buffer;
import com.avos.avoscloud.okio.BufferedSource;
import com.avos.avoscloud.okio.ForwardingSource;
import com.avos.avoscloud.okio.Okio;
import com.avos.avoscloud.okio.Source;


public class PaasClient {
  private static final CookieHandler cookieHandler = new CookieHandler() {
    @Override
    public Map> get(URI uri, Map> map) throws IOException {
      return Collections.emptyMap();
    }

    @Override
    public void put(URI uri, Map> map) throws IOException {

    }
  };

  private final String apiVersion;

  protected static String sessionTokenField = "X-LC-Session";
  private final AVOSServices service;
  private boolean isProduction = true;

  private static final String defaultEncoding = "UTF-8";
  public static final String defaultContentType = "application/json";
  public static final String DEFAULT_FAIL_STRING = "request failed!!!";

  private AVACL defaultACL;

  private volatile AVHttpClient httpClient;
  private static boolean lastModifyEnabled = false;
  private static String REQUEST_STATIS_HEADER = "X-Android-RS";

  static Map serviceClientMap = new HashMap();
  static Map internalObjectsForEventuallySave = Collections
      .synchronizedMap(new HashMap());

  private static Map lastModify = Collections
      .synchronizedMap(new WeakHashMap());

  void setProduction(boolean production) {
    isProduction = production;
  }

  protected static PaasClient sharedInstance(AVOSServices service) {
    PaasClient instance = serviceClientMap.get(service);
    if (instance == null) {
      instance = new PaasClient(service);
      serviceClientMap.put(service, instance);
    }
    return instance;
  }

  public static PaasClient storageInstance() {
    return sharedInstance(AVOSServices.API);
  }

  public static PaasClient cloudInstance() {
    return sharedInstance(AVOSServices.ENGINE);
  }

  public static PaasClient statistisInstance() {
    return sharedInstance(AVOSServices.STATS);
  }

  AVACL getDefaultACL() {
    return defaultACL;
  }

  void setDefaultACL(AVACL acl) {
    defaultACL = acl;
  }

  public Map userHeaderMap() {
    AVUser user = AVUser.getCurrentUser();
    if (user != null) {
      return user.headerMap();
    }
    return null;
  }

  private PaasClient(AVOSServices service) {
    apiVersion = "1.1";
    this.service = service;
  }

  protected void updateHeaders(Request.Builder builder, Map header,
      boolean needRequestStatistic) throws AVException {
    if (!InternalConfigurationController.globalInstance().getAppConfiguration().isConfigured()) {
      throw new AVException(AVException.NOT_INITIALIZED,
          "You must call AVOSCloud.initialize before using the AVOSCloud library");
    }
    // if the field isnt exist, the server will assume it's true
    builder.header("X-LC-Prod", isProduction ? "1" : "0");
    AVUser currAVUser = AVUser.getCurrentUser();
    builder.header(sessionTokenField,
        (currAVUser != null && currAVUser.getSessionToken() != null) ? currAVUser.getSessionToken()
            : "");
    builder.header("Accept", defaultContentType);
    builder.header("Content-Type", defaultContentType);
    builder.header("User-Agent", InternalConfigurationController.globalInstance()
        .getClientConfiguration().getUserAgent());
    builder.header("X-LC-Sign", InternalConfigurationController.globalInstance()
        .getInternalRequestSign().requestSign());

    for (Map.Entry entry : InternalConfigurationController.globalInstance()
        .getAppConfiguration().getRequestHeaders().entrySet()) {
      builder.header(entry.getKey(), entry.getValue());
    }

    if (header != null) {
      for (Map.Entry entry : header.entrySet()) {
        builder.header(entry.getKey(), entry.getValue());
      }
    }

    if (needRequestStatistic) {
      builder.header(REQUEST_STATIS_HEADER, "1");
    }
  }

  public synchronized AVHttpClient clientInstance() {
    if (httpClient == null) {
      httpClient = new AVHttpClient();
    }
    httpClient.setConnectTimeout(InternalConfigurationController.globalInstance()
        .getClientConfiguration().getNetworkTimeoutInMills(), TimeUnit.MILLISECONDS);
    return httpClient;
  }

  public String buildUrl(final String path) {
    return String.format("%s/%s/%s", InternalConfigurationController.globalInstance()
        .getAppConfiguration().getServerUrl(service), apiVersion, path);
  }

  public String buildUrl(final String path, AVRequestParams params) {
    String endPoint = buildUrl(path);
    if (params == null || params.isEmpty()) {
      return endPoint;
    } else {
      return params.getWholeUrl(endPoint);
    }

  }

  private String batchUrl() {
    return String.format("%s/%s/batch", InternalConfigurationController.globalInstance()
        .getAppConfiguration().getServerUrl(service), apiVersion);
  }

  private String batchSaveRelativeUrl() {
    return "batch/save";
  }

  private AsyncHttpResponseHandler createGetHandler(GenericObjectCallback callback,
      AVQuery.CachePolicy policy, String absoluteURLString) {
    AsyncHttpResponseHandler handler =
        new GetHttpResponseHandler(callback, policy, absoluteURLString);
    return handler;
  }

  private AsyncHttpResponseHandler createPostHandler(GenericObjectCallback callback) {
    AsyncHttpResponseHandler handler = new PostHttpResponseHandler(callback);
    return handler;
  }

  public String getApiVersion() {
    return apiVersion;
  }

  public String getObject(final String relativePath, final AVRequestParams parameters,
      final boolean sync, final Map header, final GenericObjectCallback callback,
      final AVQuery.CachePolicy policy, final long maxAgeInMilliseconds) {
    final String absoluteURLString = buildUrl(relativePath, parameters);


    final String absolutURLString = generateQueryPath(relativePath, parameters);
    final String lastModifyTime = getLastModify(absolutURLString);
    switch (policy) {
      default:
      case IGNORE_CACHE:
        getObject(relativePath, parameters, sync, header, callback, policy);
        break;
      case CACHE_ONLY:
        InternalConfigurationController.globalInstance().getCache()
            .get(absolutURLString, maxAgeInMilliseconds, lastModifyTime, callback);
        break;
      case NETWORK_ONLY:
        getObject(relativePath, parameters, sync, header, callback, policy);
        break;
      case CACHE_ELSE_NETWORK:
        InternalConfigurationController
            .globalInstance()
            .getCache()
            .get(absolutURLString, maxAgeInMilliseconds, lastModifyTime,
                new GenericObjectCallback() {
                  @Override
                  public void onSuccess(String content, AVException e) {
                    callback.onSuccess(content, e);
                  }

                  @Override
                  public void onFailure(Throwable error, String content) {
                    getObject(relativePath, parameters, sync, header, callback, policy);
                  }
                });
        break;
      case NETWORK_ELSE_CACHE:
        getObject(relativePath, parameters, sync, header, new GenericObjectCallback() {
          @Override
          public void onSuccess(String content, AVException e) {
            callback.onSuccess(content, e);
          }

          @Override
          public void onFailure(Throwable error, String content) {
            InternalCache cacheManager =
                InternalConfigurationController.globalInstance().getCache();
            if (cacheManager.hasValidCache(absolutURLString, lastModifyTime, maxAgeInMilliseconds)) {
              cacheManager.get(absolutURLString, maxAgeInMilliseconds, lastModifyTime, callback);
            } else {
              callback.onFailure(error, content);
            }
          }
        }, policy);
        break;
      case CACHE_THEN_NETWORK:
        InternalConfigurationController
            .globalInstance()
            .getCache()
            .get(absolutURLString, maxAgeInMilliseconds, lastModifyTime,
                new GenericObjectCallback() {
                  @Override
                  public void onSuccess(String content, AVException e) {
                    callback.onSuccess(content, e);
                    getObject(relativePath, parameters, sync, header, callback, policy);
                  }

                  @Override
                  public void onFailure(Throwable error, String content) {
                    callback.onFailure(error, content);
                    getObject(relativePath, parameters, sync, header, callback, policy);
                  }
                });
        break;
    }
    return absoluteURLString;
  }

  String generateQueryPath(final String relativePath, final AVRequestParams parameters) {
    return buildUrl(relativePath, parameters);
  }

  public void getObject(final String relativePath, AVRequestParams parameters, boolean sync,
      Map inputHeader, GenericObjectCallback callback, AVQuery.CachePolicy policy) {
    getObject(relativePath, parameters, sync, inputHeader, callback, policy,
        (!policy.equals(AVQuery.CachePolicy.CACHE_ONLY)) && isLastModifyEnabled());
  }

  public void getObject(final String relativePath, final AVRequestParams parameters,
      final boolean sync, final Map inputHeader, GenericObjectCallback callback,
      final AVQuery.CachePolicy policy, final boolean fetchRetry) {
    Map myHeader = inputHeader;
    if (inputHeader == null) {
      myHeader = new HashMap();
    }
    updateHeaderForPath(relativePath, parameters, myHeader);

    String url = buildUrl(relativePath, parameters);
    AsyncHttpResponseHandler handler = createGetHandler(callback, policy, url);
    if (InternalConfigurationController.globalInstance().getInternalLogger().isDebugEnabled()) {
      dumpHttpGetRequest(buildUrl(relativePath),
          parameters == null ? null : parameters.getDumpQueryString());
    }
    AVHttpClient client = clientInstance();
    Request.Builder builder = new Request.Builder();
    builder.url(url).get();
    try {
      updateHeaders(builder, myHeader, callback != null && callback.isRequestStatisticNeed());
    } catch (AVException e) {
      processException(e, callback);
    }
    client.execute(builder.build(), sync, handler);
  }

  public void getObject(final String relativePath, AVRequestParams parameters, boolean sync,
      Map header, GenericObjectCallback callback) {
    getObject(relativePath, parameters, sync, header, callback, AVQuery.CachePolicy.IGNORE_CACHE);
  }

  public void putObject(final String relativePath, String object, boolean sync,
      Map header, GenericObjectCallback callback, String objectId,
      String _internalId) {
    putObject(relativePath, object, sync, false, header, callback, objectId, _internalId);
  }


  public void putObject(final String relativePath, String object, boolean sync,
      boolean isEventually, Map header, GenericObjectCallback callback,
      String objectId, String _internalId) {
    try {
      if (isEventually) {
        File archivedFile = archiveRequest("put", relativePath, object, objectId, _internalId);
        handleArchivedRequest(archivedFile, sync, callback);
      } else {
        String url = buildUrl(relativePath);
        AsyncHttpResponseHandler handler = createPostHandler(callback);
        if (InternalConfigurationController.globalInstance().getInternalLogger().isDebugEnabled()) {
          dumpHttpPutRequest(header, url, object);
        }
        AVHttpClient client = clientInstance();
        Request.Builder builder = new Request.Builder();
        builder.url(url).put(RequestBody.create(AVHttpClient.JSON, object));
        updateHeaders(builder, header, callback != null && callback.isRequestStatisticNeed());
        client.execute(builder.build(), sync, handler);
      }
    } catch (Exception exception) {
      processException(exception, callback);
    }
  }

  private void processException(Exception e, GenericObjectCallback cb) {
    if (cb != null) {
      cb.onFailure(e, null);
    }
  }

  // path=/1/classes/Parent/a1QCssTp7r
  Map batchItemMap(String method, String path, Object body, Map params) {
    // String myPath = String.format("/%s/%s",
    // PaasClient.sharedInstance().apiVersion, path);
    Map result = new HashMap();
    result.put("method", method);
    result.put("path", path);
    result.put("body", body);
    if (params != null) {
      result.put("params", params);
    }
    return result;
  }

  Map batchItemMap(String method, String path, Object body) {
    return this.batchItemMap(method, path, body, null);
  }

  @Deprecated
  List