JsonRpcServlet.java

/*
 * Licensed to the Apache Software Foundation (ASF) under one
 * or more contributor license agreements. See the NOTICE file
 * distributed with this work for additional information
 * regarding copyright ownership. The ASF licenses this file
 * to you 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 org.apache.shindig.social.opensocial.service;

import org.apache.shindig.auth.SecurityToken;
import org.apache.shindig.common.util.JsonConversionUtil;
import org.apache.shindig.social.ResponseError;
import org.apache.shindig.social.opensocial.spi.DataCollection;
import org.apache.shindig.social.opensocial.spi.RestfulCollection;

import com.google.common.collect.Lists;
import org.apache.commons.io.IOUtils;
import org.apache.commons.lang.StringUtils;
import org.json.JSONArray;
import org.json.JSONException;
import org.json.JSONObject;

import java.io.IOException;
import java.util.List;
import java.util.concurrent.Future;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

/**
 * JSON-RPC handler servlet.
 */
public class JsonRpcServlet extends ApiServlet {

  @Override
  protected void doGet(HttpServletRequest servletRequest,
      HttpServletResponse servletResponse)
      throws ServletException, IOException {
    SecurityToken token = getSecurityToken(servletRequest);
    if (token == null) {
      sendSecurityError(servletResponse);
      return;
    }

    try {
      setCharacterEncodings(servletRequest, servletResponse);
      JSONObject request = JsonConversionUtil.fromRequest(servletRequest);
      dispatch(request, servletRequest, servletResponse, token);
    } catch (JSONException je) {
      // FIXME
    }
  }

  @Override
  protected void doPost(HttpServletRequest servletRequest,
      HttpServletResponse servletResponse)
      throws ServletException, IOException {
    SecurityToken token = getSecurityToken(servletRequest);
    if (token == null) {
      sendSecurityError(servletResponse);
      return;
    }

    setCharacterEncodings(servletRequest, servletResponse);
    servletResponse.setContentType("application/json");

    try {
      String content = IOUtils.toString(servletRequest.getInputStream(),
          servletRequest.getCharacterEncoding());
      if ((content.indexOf('[') != -1) && content.indexOf('[') < content.indexOf('{')) {
        // Is a batch
        JSONArray batch = new JSONArray(content);
        dispatchBatch(batch, servletRequest, servletResponse, token);
      } else {
        JSONObject request = new JSONObject(content);
        dispatch(request, servletRequest, servletResponse, token);
      }
    } catch (JSONException je) {
      sendBadRequest(je, servletResponse);
    }
  }

  protected void dispatchBatch(JSONArray batch, HttpServletRequest servletRequest,
      HttpServletResponse servletResponse, SecurityToken token) throws JSONException, IOException {
    // Use linked hash map to preserve order
    List<Future<?>> responses = Lists.newArrayListWithExpectedSize(batch.length());

    // Gather all Futures.  We do this up front so that
    // the first call to get() comes after all futures are created,
    // which allows for implementations that batch multiple Futures
    // into single requests.
    for (int i = 0; i < batch.length(); i++) {
      JSONObject batchObj = batch.getJSONObject(i);
      RpcRequestItem requestItem = new RpcRequestItem(batchObj, token, jsonConverter);
      responses.add(handleRequestItem(requestItem, servletRequest));
    }

    // Resolve each Future into a response.
    // TODO: should use shared deadline across each request
    JSONArray result = new JSONArray();
    for (int i = 0; i < batch.length(); i++) {
      JSONObject batchObj = batch.getJSONObject(i);
      String key = null;
      if (batchObj.has("id")) {
        key = batchObj.getString("id");
      }
      result.put(getJSONResponse(key, getResponseItem(responses.get(i))));
    }
    servletResponse.getWriter().write(result.toString());
  }

  protected void dispatch(JSONObject request, HttpServletRequest servletRequest,
      HttpServletResponse servletResponse, SecurityToken token) throws JSONException, IOException {
    String key = null;
    if (request.has("id")) {
      key = request.getString("id");
    }
    RpcRequestItem requestItem = new RpcRequestItem(request, token, jsonConverter);

    // Resolve each Future into a response.
    // TODO: should use shared deadline across each request
    ResponseItem response = getResponseItem(handleRequestItem(requestItem, servletRequest));
    JSONObject result = getJSONResponse(key, response);
    servletResponse.getWriter().write(result.toString());
  }

  private JSONObject getJSONResponse(String key, ResponseItem responseItem) throws JSONException {
    JSONObject result = new JSONObject();
    if (key != null) {
      result.put("id", key);
    }
    if (responseItem.getError() != null) {
      result.put("error", getErrorJson(responseItem));
    } else {
      Object response = responseItem.getResponse();
      JSONObject converted = (JSONObject) jsonConverter.convertToJson(response);

      if (response instanceof RestfulCollection) {
        // FIXME this is a little hacky because of the field names in the RestfulCollection
        converted.put("list", converted.remove("entry"));
        result.put("data", converted);
      } else if (response instanceof DataCollection) {
        if (converted.has("entry")) {
          result.put("data", converted.get("entry"));
        }
      } else {
        result.put("data", converted);
      }
    }
    return result;
  }

  // TODO(doll): Refactor the responseItem so that the fields on it line up with this format.
  // Then we can use the general converter to output the response to the client and we won't
  // be harcoded to json.
  private JSONObject getErrorJson(ResponseItem responseItem) throws JSONException {
    JSONObject error = new JSONObject();
    error.put("code", responseItem.getError().getHttpErrorCode());

    String message = responseItem.getError().toString();
    if (StringUtils.isNotBlank(responseItem.getErrorMessage())) {
      message += ": " + responseItem.getErrorMessage();
    }
    error.put("message", message);
    return error;
  }

  @Override
  protected void sendError(HttpServletResponse servletResponse, ResponseItem responseItem)
      throws IOException {
    try {
      JSONObject error = getErrorJson(responseItem);
      servletResponse.getWriter().write(error.toString());
    } catch (JSONException je) {
      // This really shouldn't ever happen
      servletResponse.sendError(HttpServletResponse.SC_INTERNAL_SERVER_ERROR,
          "Error generating error response " + je.getMessage());
    }
  }

  private void sendBadRequest(Throwable t, HttpServletResponse response) throws IOException {
    sendError(response, new ResponseItem(ResponseError.BAD_REQUEST,
        "Invalid batch - " + t.getMessage()));
  }
}