Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
  /*
   * Copyright (C) 2011 ritwik.net
   *
   * 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 org.json.other.server;
 
 import java.util.List;
 import java.util.Map;
 import java.util.Set;
 
 
 
 public final class Base64JsonRpcExecutor implements RpcIntroSpection {
 
 
     private static final Pattern METHOD_PATTERN = Pattern
             .compile("([_a-zA-Z][_a-zA-Z0-9]*)\\.([_a-zA-Z][_a-zA-Z0-9]*)");
 
     private final Map<StringHandleEntry<?>> handlers;
 
     private final TypeChecker typeChecker;
     private volatile boolean locked;
 
     public Base64JsonRpcExecutor() {
         this(new AllowAllTypeChecker());
     }
 
     @SuppressWarnings("unchecked")
     public Base64JsonRpcExecutor(TypeChecker typeChecker) {
         this. = typeChecker;
         this. = new HashMap<StringHandleEntry<?>>();
         addHandler("system"thisRpcIntroSpection.class);
     }
 
     public boolean isLocked() {
         return ;
     }
 
     public <T> void addHandler(String name, T handlerClass<T>... classes) {
         if () {
             throw new JsonRpcException("executor has been locked, can't add more handlers");
         }
 
         synchronized () {
             HandleEntry<T> handleEntry = new HandleEntry<T>(handlerclasses);
             if (this..containsKey(name)) {
                 throw new IllegalArgumentException("handler already exists");
             }
             this..put(namehandleEntry);
         }
     }
 
     public void execute(JsonRpcServerTransport transport) {
         if (!) {
             synchronized () {
                  = true;
             }
         }
 
         String methodName = null;
         JsonArray params = null;
 
         JsonObject resp = new JsonObject();
        resp.addProperty("jsonrpc""2.0");
        String errorMessage = null;
        Integer errorCode = null;
        String errorData = null;
        JsonObject req = null;
        try {
            String requestData = transport.readRequest();
            JsonParser parser = new JsonParser();
            req = (JsonObjectparser.parse(new StringReader(requestData));
        } catch (Throwable t) {
            errorCode = .;
            errorMessage = "unable to parse json-rpc request";
            errorData = getStackTrace(t);
            sendError(transportresperrorCodeerrorMessageerrorData);
            return;
        }
        try {
            assert req != null;
            resp.add("id"req.get("id"));
            methodName = req.getAsJsonPrimitive("method").getAsString();
            params = (JsonArrayreq.get("params");
            if (params == null) {
                params = new JsonArray();
            }
        } catch (Throwable t) {
            errorCode = .;
            errorMessage = "unable to read request";
            errorData = getStackTrace(t);
            sendError(transportresperrorCodeerrorMessageerrorData);
            return;
        }
        try {
            JsonElement result = executeMethod(methodNameparams);
            resp.add("result"result);
        } catch (Throwable t) {
            if (t instanceof JsonRpcRemoteException) {
                sendError(transportresp, (JsonRpcRemoteExceptiont);
                return;
            }
            errorCode = JsonRpcErrorCodes.getServerError(1);
            errorMessage = t.getMessage();
            errorData = getStackTrace(t);
            sendError(transportresperrorCodeerrorMessageerrorData);
            return;
        }
        try {
            String responseData = resp.toString();
            transport.writeResponse(responseData);
        } catch (Exception e) {
        }
    }
    private void sendError(JsonRpcServerTransport transportJsonObject respJsonRpcRemoteException e) {
        sendError(transportrespe.getCode(), e.getMessage(), e.getData());
    }
    private void sendError(JsonRpcServerTransport transportJsonObject respInteger codeString messageString data) {
        JsonObject error = new JsonObject();
        if (code != null) {
            error.addProperty("code"code);
        }
        if (message != null) {
            error.addProperty("message"message);
        }
        if (data != null) {
            error.addProperty("data"data);
        }
        resp.add("error"error);
        resp.remove("result");
        String responseData = resp.toString();
        try {
            transport.writeResponse(responseData);
        } catch (Exception e) {
        	e.printStackTrace();
        }
    }
    private String getStackTrace(Throwable t) {
        StringWriter str = new StringWriter();
        PrintWriter w = new PrintWriter(str);
        t.printStackTrace(w);
        w.close();
        return str.toString();
    }
    private JsonElement executeMethod(String methodNameJsonArray paramsthrows Throwable {
        try {
            Matcher mat = .matcher(methodName);
            if (!mat.find()) {
                throw new JsonRpcRemoteException(."invalid method name"null);
            }
            String handleName = mat.group(1);
            methodName = mat.group(2);
            HandleEntry<?> handleEntry = .get(handleName);
            if (handleEntry == null) {
                throw new JsonRpcRemoteException(."no such method exists"null);
            }
            Method executableMethod = null;
            for (Method m : handleEntry.getMethods()) {
                if (!m.getName().equals(methodName)) {
                    continue;
                }
                if (canExecute(mparams)) {
                    executableMethod = m;
                    break;
                }
            }
            if (executableMethod == null) {
                throw new JsonRpcRemoteException(."no such method exists"null);
            }
            Object result = executableMethod.invoke(
                    handleEntry.getHandler(), getParameters(executableMethodparams));
            return new Gson().toJsonTree(result);
        } catch (Throwable t) {
            if (t instanceof InvocationTargetException) {
                t = ((InvocationTargetExceptiont).getTargetException();
            }
            if (t instanceof JsonRpcRemoteException) {
                throw (JsonRpcRemoteExceptiont;
            }
            throw new JsonRpcRemoteException(JsonRpcErrorCodes.getServerError(0), t.getMessage(), getStackTrace(t));
        }
    }
    public boolean canExecute(Method methodJsonArray params) {
        if (method.getParameterTypes().length != params.size()) {
            return false;
        }
        return true;
    }
    public Object[] getParameters(Method methodJsonArray params) {
        List<Objectlist = new ArrayList<Object>();
        Gson gson = new Gson();
        Class<?>[] types = method.getParameterTypes();
        for (int i = 0; i < types.lengthi++) {
            JsonElement p = params.get(i);
            Object o = gson.fromJson(p.toString(), types[i]);
            list.add(o);
        }
        return list.toArray();
    }
    public String[] listMethods() {
        Set<Stringmethods = new TreeSet<String>();
        for (String name : this..keySet()) {
            HandleEntry<?> handleEntry = this..get(name);
            for (String method : handleEntry.getSignatures().keySet()) {
                methods.add(name + "." + method);
            }
        }
        String[] arr = new String[methods.size()];
        return methods.toArray(arr);
    }
    public String[] methodSignature(String method) {
        if (method == null) {
            throw new NullPointerException("method");
        }
        Matcher mat = .matcher(method);
        if (!mat.find()) {
            throw new IllegalArgumentException("invalid method name");
        }
        String handleName = mat.group(1);
        String methodName = mat.group(2);
        Set<Stringsignatures = new TreeSet<String>();
        HandleEntry<?> handleEntry = .get(handleName);
        if (handleEntry == null) {
            throw new IllegalArgumentException("no such method exists");
        }
        for (Method m : handleEntry.getMethods()) {
            if (!m.getName().equals(methodName)) {
                continue;
            }
            String[] sign = handleEntry.getSignatures().get(m.getName());
            StringBuffer buff = new StringBuffer(sign[0]);
            for (int i = 1; i < sign.lengthi++) {
                buff.append(",").append(sign[i]);
            }
            signatures.add(buff.toString());
        }
        if (signatures.size() == 0) {
            throw new IllegalArgumentException("no such method exists");
        }
        String[] arr = new String[signatures.size()];
        return signatures.toArray(arr);
    }
	public RpcCache getRpcCache() {
		return null;
	}
	public void setRpcCache(RpcCache rpcCache) {
		// TODO Auto-generated method stub
	}
New to GrepCode? Check out our FAQ X