Examples with XStream com.thoughtworks.xstream.XStream used on opensource projects

Example 81 with XStream

use of com.thoughtworks.xstream.XStream in project cloudstack by apache.

the class ApiXmlDocReader method main.

public static void main(String[] args) {
    String newFile = null;
    String oldFile = null;
    String dirName = "";
    LinkedHashMap<String, Command> commands = new LinkedHashMap<String, Command>();
    LinkedHashMap<String, Command> oldCommands = new LinkedHashMap<String, Command>();
    ArrayList<Command> addedCommands = new ArrayList<Command>();
    ArrayList<Command> removedCommands = new ArrayList<Command>();
    HashMap<String, Command> stableCommands = new HashMap<String, Command>();
    HashMap<String, Object> jsonOut = new HashMap<String, Object>();
    Gson gson = new Gson();
    XStream xs = new XStream(new DomDriver());
    xs.alias("command", Command.class);
    xs.alias("arg", Argument.class);
    List<String> argsList = Arrays.asList(args);
    Iterator<String> iter = argsList.iterator();
    while (iter.hasNext()) {
        String arg = iter.next();
        // populate the file names
        if (arg.equals("-new")) {
            newFile = iter.next();
        }
        if (arg.equals("-old")) {
            oldFile = iter.next();
        }
        if (arg.equals("-d")) {
            dirName = iter.next();
        }
    }
    try {
        try (ObjectInputStream inOld = xs.createObjectInputStream(new FileReader(oldFile))) {
            while (true) {
                Command c1 = (Command) inOld.readObject();
                oldCommands.put(c1.getName(), c1);
            }
        } catch (EOFException ex) {
        // EOF exception shows that there is no more objects in ObjectInputStream, so do nothing here
        }
        try (ObjectInputStream inNew = xs.createObjectInputStream(new FileReader(newFile))) {
            while (true) {
                Command c = (Command) inNew.readObject();
                commands.put(c.getName(), c);
            }
        } catch (EOFException ex) {
        // EOF exception shows that there is no more objects in ObjectInputStream, so do nothing here
        }
    } catch (Exception ex) {
        ex.printStackTrace();
    }
    // Check if any commands got added in new version
    for (Map.Entry<String, Command> entry : commands.entrySet()) {
        if (!oldCommands.containsKey(entry.getKey())) {
            addedCommands.add(entry.getValue());
        } else {
            stableCommands.put(entry.getValue().getName(), entry.getValue());
        }
    }
    // Check if any commands were removed in new version
    for (Map.Entry<String, Command> entry : oldCommands.entrySet()) {
        if (!commands.containsKey(entry.getKey())) {
            removedCommands.add(entry.getValue());
            if (stableCommands.get(entry.getKey()) != null) {
                stableCommands.remove(entry.getKey());
            }
        }
    }
    try (FileWriter fstream = new FileWriter(dirName + "/diff.txt");
        BufferedWriter out = new BufferedWriter(fstream);
        FileWriter jfstream = new FileWriter(dirName + "/diff.json");
        BufferedWriter json = new BufferedWriter(jfstream)) {
        // Print added commands
        out.write("Added commands:\n");
        ArrayList<HashMap<String, Object>> addedCmds = new ArrayList<HashMap<String, Object>>();
        for (Command c : addedCommands) {
            HashMap<String, Object> addedCmd = new HashMap<String, Object>();
            if (c.getDescription() != null && !c.getDescription().isEmpty()) {
                out.write("\n    " + c.getName() + " (" + c.getDescription() + ")\n");
                addedCmd.put("description", c.getDescription());
            } else {
                out.write("\n    " + c.getName() + "\n");
            }
            addedCmd.put("name", c.getName());
            addedCmds.add(addedCmd);
        }
        jsonOut.put("commands_added", addedCmds);
        // Print removed commands
        out.write("\nRemoved commands:\n");
        ArrayList<HashMap<String, Object>> removedCmds = new ArrayList<HashMap<String, Object>>();
        for (Command c : removedCommands) {
            HashMap<String, Object> removedCmd = new HashMap<String, Object>();
            if (c.getDescription() != null && !c.getDescription().isEmpty()) {
                out.write("\n\t" + c.getName() + " (" + c.getDescription() + ")\n");
                removedCmd.put("description", c.getDescription());
            } else {
                out.write("\n\t" + c.getName() + "\n");
            }
            removedCmd.put("name", c.getName());
            removedCmds.add(removedCmd);
        }
        jsonOut.put("commands_removed", removedCmds);
        out.write("\nChanges in command type (sync versus async)\n");
        ArrayList<HashMap<String, Object>> syncChangeCmds = new ArrayList<HashMap<String, Object>>();
        // Verify if the command was sync and became async and vice versa
        for (Map.Entry<String, Command> entry : stableCommands.entrySet()) {
            if (commands.get(entry.getKey()).isAsync() != oldCommands.get(entry.getKey()).isAsync()) {
                HashMap<String, Object> syncChangeCmd = new HashMap<String, Object>();
                String type = "Sync";
                if (commands.get(entry.getKey()).isAsync()) {
                    type = "Async";
                }
                syncChangeCmd.put("name", entry.getValue().getName());
                syncChangeCmd.put("sync_type", type);
                syncChangeCmds.add(syncChangeCmd);
                out.write("\n\t" + entry.getValue().getName() + " became " + type);
            }
        }
        jsonOut.put("commands_sync_changed", syncChangeCmds);
        // Print differences between commands arguments
        out.write("\n\nChanges in commands arguments:\n");
        ArrayList<HashMap<String, Object>> argsChangeCmds = new ArrayList<HashMap<String, Object>>();
        for (String key : stableCommands.keySet()) {
            ArrayList<Argument> newReqArgs = new ArrayList<Argument>();
            ArrayList<Argument> removedReqArgs = new ArrayList<Argument>();
            HashMap<String, Argument> stableReqArgs = new HashMap<String, Argument>();
            ArrayList<Argument> newRespArgs = new ArrayList<Argument>();
            ArrayList<Argument> removedRespArgs = new ArrayList<Argument>();
            HashMap<String, Object> argsChangeCmd = new HashMap<String, Object>();
            Command newCommand = commands.get(key);
            Command oldCommand = oldCommands.get(key);
            // Check if any request arguments were added in new version
            for (Argument arg : newCommand.getRequest()) {
                if (oldCommand.getReqArgByName(arg.getName()) == null) {
                    if (!(arg.getName().equals("page") || arg.getName().equals("pagesize") || arg.getName().equals("keyword"))) {
                        newReqArgs.add(arg);
                    }
                } else {
                    stableReqArgs.put(arg.getName(), arg);
                }
            }
            // Check if any request arguments were removed in new version
            for (Argument arg : oldCommand.getRequest()) {
                if (newCommand.getReqArgByName(arg.getName()) == null) {
                    removedReqArgs.add(arg);
                    if (stableReqArgs.get(arg.getName()) != null) {
                        stableReqArgs.remove(arg.getName());
                    }
                }
            }
            // Compare stable request arguments of old and new version
            for (Iterator<String> i = stableReqArgs.keySet().iterator(); i.hasNext(); ) {
                String argName = i.next();
                if ((oldCommand.getReqArgByName(argName) != null) && (newCommand.getReqArgByName(argName) != null)) {
                    if (oldCommand.getReqArgByName(argName).isRequired().equals(newCommand.getReqArgByName(argName).isRequired())) {
                        i.remove();
                    }
                }
            }
            // Check if any response arguments were added in new version
            if (newCommand.getResponse() != null && oldCommand.getResponse() != null) {
                for (Argument arg : newCommand.getResponse()) {
                    if (oldCommand.getResArgByName(arg.getName()) == null) {
                        newRespArgs.add(arg);
                    }
                }
                // Check if any response arguments were removed in new version
                for (Argument arg : oldCommand.getResponse()) {
                    if (newCommand.getResArgByName(arg.getName()) == null) {
                        removedRespArgs.add(arg);
                    }
                }
            }
            if (newReqArgs.size() != 0 || newRespArgs.size() != 0 || removedReqArgs.size() != 0 || removedRespArgs.size() != 0 || stableReqArgs.size() != 0) {
                StringBuffer commandInfo = new StringBuffer();
                commandInfo.append("\n\t" + key);
                out.write(commandInfo.toString());
                out.write("\n");
                argsChangeCmd.put("name", key);
                // Request
                if (newReqArgs.size() != 0 || removedReqArgs.size() != 0 || stableReqArgs.size() != 0) {
                    HashMap<String, Object> requestChanges = new HashMap<String, Object>();
                    StringBuffer request = new StringBuffer();
                    request.append("\n\t\tRequest:\n");
                    out.write(request.toString());
                    if (newReqArgs.size() != 0) {
                        StringBuffer newParameters = new StringBuffer();
                        newParameters.append("\n\t\t\tNew parameters: ");
                        ArrayList<HashMap<String, Object>> newRequestParams = new ArrayList<HashMap<String, Object>>();
                        for (Argument newArg : newReqArgs) {
                            HashMap<String, Object> newRequestParam = new HashMap<String, Object>();
                            String isRequiredParam = "optional";
                            if (newArg.isRequired()) {
                                isRequiredParam = "required";
                            }
                            newRequestParam.put("name", newArg.getName());
                            newRequestParam.put("required", newArg.isRequired());
                            newRequestParams.add(newRequestParam);
                            newParameters.append(newArg.getName() + " (" + isRequiredParam + "), ");
                        }
                        requestChanges.put("params_new", newRequestParams);
                        newParameters.delete(newParameters.length() - 2, newParameters.length() - 1);
                        out.write(newParameters.toString());
                        out.write("\n");
                    }
                    if (removedReqArgs.size() != 0) {
                        StringBuffer removedParameters = new StringBuffer();
                        removedParameters.append("\n\t\t\tRemoved parameters: ");
                        ArrayList<HashMap<String, Object>> removedRequestParams = new ArrayList<HashMap<String, Object>>();
                        for (Argument removedArg : removedReqArgs) {
                            HashMap<String, Object> removedRequestParam = new HashMap<String, Object>();
                            removedRequestParam.put("name", removedArg.getName());
                            removedRequestParams.add(removedRequestParam);
                            removedParameters.append(removedArg.getName() + ", ");
                        }
                        requestChanges.put("params_removed", removedRequestParams);
                        removedParameters.delete(removedParameters.length() - 2, removedParameters.length() - 1);
                        out.write(removedParameters.toString());
                        out.write("\n");
                    }
                    if (stableReqArgs.size() != 0) {
                        StringBuffer changedParameters = new StringBuffer();
                        changedParameters.append("\n\t\t\tChanged parameters: ");
                        ArrayList<HashMap<String, Object>> changedRequestParams = new ArrayList<HashMap<String, Object>>();
                        for (Argument stableArg : stableReqArgs.values()) {
                            HashMap<String, Object> changedRequestParam = new HashMap<String, Object>();
                            String newRequired = "optional";
                            String oldRequired = "optional";
                            changedRequestParam.put("required_old", false);
                            changedRequestParam.put("required_new", false);
                            if ((oldCommand.getReqArgByName(stableArg.getName()) != null) && (oldCommand.getReqArgByName(stableArg.getName()).isRequired() == true)) {
                                oldRequired = "required";
                                changedRequestParam.put("required_old", true);
                            }
                            if ((newCommand.getReqArgByName(stableArg.getName()) != null) && (newCommand.getReqArgByName(stableArg.getName()).isRequired() == true)) {
                                newRequired = "required";
                                changedRequestParam.put("required_new", true);
                            }
                            changedRequestParam.put("name", stableArg.getName());
                            changedRequestParams.add(changedRequestParam);
                            changedParameters.append(stableArg.getName() + " (old version - " + oldRequired + ", new version - " + newRequired + "), ");
                        }
                        requestChanges.put("params_changed", changedRequestParams);
                        changedParameters.delete(changedParameters.length() - 2, changedParameters.length() - 1);
                        out.write(changedParameters.toString());
                        out.write("\n");
                    }
                    argsChangeCmd.put("request", requestChanges);
                }
                // Response
                if (newRespArgs.size() != 0 || removedRespArgs.size() != 0) {
                    HashMap<String, Object> responseChanges = new HashMap<String, Object>();
                    StringBuffer changedResponseParams = new StringBuffer();
                    changedResponseParams.append("\n\t\tResponse:\n");
                    out.write(changedResponseParams.toString());
                    if (newRespArgs.size() != 0) {
                        ArrayList<HashMap<String, Object>> newResponseParams = new ArrayList<HashMap<String, Object>>();
                        StringBuffer newRespParams = new StringBuffer();
                        newRespParams.append("\n\t\t\tNew parameters: ");
                        for (Argument newArg : newRespArgs) {
                            HashMap<String, Object> newResponseParam = new HashMap<String, Object>();
                            newResponseParam.put("name", newArg.getName());
                            newResponseParams.add(newResponseParam);
                            newRespParams.append(newArg.getName() + ", ");
                        }
                        responseChanges.put("params_new", newResponseParams);
                        newRespParams.delete(newRespParams.length() - 2, newRespParams.length() - 1);
                        out.write(newRespParams.toString());
                        out.write("\n");
                    }
                    if (removedRespArgs.size() != 0) {
                        ArrayList<HashMap<String, Object>> removedResponseParams = new ArrayList<HashMap<String, Object>>();
                        StringBuffer removedRespParams = new StringBuffer();
                        removedRespParams.append("\n\t\t\tRemoved parameters: ");
                        for (Argument removedArg : removedRespArgs) {
                            HashMap<String, Object> removedResponseParam = new HashMap<String, Object>();
                            removedResponseParam.put("name", removedArg.getName());
                            removedResponseParams.add(removedResponseParam);
                            removedRespParams.append(removedArg.getName() + ", ");
                        }
                        responseChanges.put("params_removed", removedResponseParams);
                        removedRespParams.delete(removedRespParams.length() - 2, removedRespParams.length() - 1);
                        out.write(removedRespParams.toString());
                        out.write("\n");
                    }
                    argsChangeCmd.put("response", responseChanges);
                }
                argsChangeCmds.add(argsChangeCmd);
            }
        }
        jsonOut.put("commands_args_changed", argsChangeCmds);
        json.write(gson.toJson(jsonOut));
    } catch (IOException e) {
        e.printStackTrace();
    }
}

Example 82 with XStream

use of com.thoughtworks.xstream.XStream in project cloudstack by apache.

the class ApiXmlDocWriter method writeAlertTypes.

private static void writeAlertTypes(String dirName) {
    XStream xs = new XStream();
    xs.alias("alert", Alert.class);
    try (ObjectOutputStream out = xs.createObjectOutputStream(new FileWriter(dirName + "/alert_types.xml"), "alerts")) {
        for (Field f : AlertManager.class.getFields()) {
            if (f.getClass().isAssignableFrom(Number.class)) {
                String name = f.getName().substring(11);
                Alert alert = new Alert(name, f.getInt(null));
                out.writeObject(alert);
            }
        }
    } catch (IOException e) {
        s_logger.error("Failed to create output stream to write an alert types ", e);
    } catch (IllegalAccessException e) {
        s_logger.error("Failed to read alert fields ", e);
    }
}

Example 83 with XStream

use of com.thoughtworks.xstream.XStream in project cloudstack by apache.

the class ApiXmlDocWriter method main.

public static void main(String[] args) {
    Set<Class<?>> cmdClasses = ReflectUtil.getClassesWithAnnotation(APICommand.class, new String[] { "org.apache.cloudstack.api", "com.cloud.api", "com.cloud.api.commands", "com.globo.globodns.cloudstack.api", "org.apache.cloudstack.network.opendaylight.api", "com.cloud.api.commands.netapp", "org.apache.cloudstack.api.command.admin.zone", "org.apache.cloudstack.network.contrail.api.command" });
    for (Class<?> cmdClass : cmdClasses) {
        if (cmdClass.getAnnotation(APICommand.class) == null) {
            System.out.println("Warning, API Cmd class " + cmdClass.getName() + " has no APICommand annotation ");
            continue;
        }
        String apiName = cmdClass.getAnnotation(APICommand.class).name();
        if (s_apiNameCmdClassMap.containsKey(apiName)) {
            // handle API cmd separation into admin cmd and user cmd with the common api name
            Class<?> curCmd = s_apiNameCmdClassMap.get(apiName);
            if (curCmd.isAssignableFrom(cmdClass)) {
                // api_cmd map always keep the admin cmd class to get full response and parameters
                s_apiNameCmdClassMap.put(apiName, cmdClass);
            } else if (cmdClass.isAssignableFrom(curCmd)) {
                // just skip this one without warning
                continue;
            } else {
                System.out.println("Warning, API Cmd class " + cmdClass.getName() + " has non-unique apiname " + apiName);
                continue;
            }
        } else {
            s_apiNameCmdClassMap.put(apiName, cmdClass);
        }
    }
    System.out.printf("Scanned and found %d APIs\n", s_apiNameCmdClassMap.size());
    List<String> argsList = Arrays.asList(args);
    Iterator<String> iter = argsList.iterator();
    while (iter.hasNext()) {
        String arg = iter.next();
        if (arg.equals("-d")) {
            s_dirName = iter.next();
        }
    }
    for (Map.Entry<String, Class<?>> entry : s_apiNameCmdClassMap.entrySet()) {
        Class<?> cls = entry.getValue();
        s_allApiCommands.put(entry.getKey(), cls.getName());
    }
    s_allApiCommandsSorted.putAll(s_allApiCommands);
    try {
        // Create object writer
        XStream xs = new XStream();
        xs.alias("command", Command.class);
        xs.alias("arg", Argument.class);
        String xmlDocDir = s_dirName + "/xmldoc";
        String rootAdminDirName = xmlDocDir + "/apis";
        (new File(rootAdminDirName)).mkdirs();
        ObjectOutputStream out = xs.createObjectOutputStream(new FileWriter(s_dirName + "/commands.xml"), "commands");
        ObjectOutputStream rootAdmin = xs.createObjectOutputStream(new FileWriter(rootAdminDirName + "/" + "apiSummary.xml"), "commands");
        ObjectOutputStream rootAdminSorted = xs.createObjectOutputStream(new FileWriter(rootAdminDirName + "/" + "apiSummarySorted.xml"), "commands");
        Iterator<?> it = s_allApiCommands.keySet().iterator();
        while (it.hasNext()) {
            String key = (String) it.next();
            // Write admin commands
            writeCommand(out, key);
            writeCommand(rootAdmin, key);
            // Write single commands to separate xml files
            ObjectOutputStream singleRootAdminCommandOs = xs.createObjectOutputStream(new FileWriter(rootAdminDirName + "/" + key + ".xml"), "command");
            writeCommand(singleRootAdminCommandOs, key);
            singleRootAdminCommandOs.close();
        }
        // Write sorted commands
        it = s_allApiCommandsSorted.keySet().iterator();
        while (it.hasNext()) {
            String key = (String) it.next();
            writeCommand(rootAdminSorted, key);
        }
        out.close();
        rootAdmin.close();
        rootAdminSorted.close();
        // write alerttypes to xml
        writeAlertTypes(xmlDocDir);
    } catch (Exception ex) {
        ex.printStackTrace();
        System.exit(2);
    }
}

Example 84 with XStream

use of com.thoughtworks.xstream.XStream in project cloudstack by apache.

the class RegionsApiUtil method makeDomainAPICall.

/**
     * Makes an api call using region service end_point, api command and params
     * Returns Domain object on success
     * @param region
     * @param command
     * @param params
     * @return
     */
protected static RegionDomain makeDomainAPICall(Region region, String command, List<NameValuePair> params) {
    try {
        String url = buildUrl(buildParams(command, params), region);
        HttpClient client = new HttpClient();
        HttpMethod method = new GetMethod(url);
        if (client.executeMethod(method) == 200) {
            InputStream is = method.getResponseBodyAsStream();
            XStream xstream = new XStream(new DomDriver());
            //Translate response to Domain object
            xstream.alias("domain", RegionDomain.class);
            xstream.aliasField("id", RegionDomain.class, "uuid");
            xstream.aliasField("parentdomainid", RegionDomain.class, "parentUuid");
            xstream.aliasField("networkdomain", DomainVO.class, "networkDomain");
            try (ObjectInputStream in = xstream.createObjectInputStream(is)) {
                return (RegionDomain) in.readObject();
            } catch (IOException e) {
                s_logger.error(e.getMessage());
                return null;
            }
        } else {
            return null;
        }
    } catch (HttpException e) {
        s_logger.error(e.getMessage());
        return null;
    } catch (IOException e) {
        s_logger.error(e.getMessage());
        return null;
    } catch (ClassNotFoundException e) {
        s_logger.error(e.getMessage());
        return null;
    }
}

Example 85 with XStream

use of com.thoughtworks.xstream.XStream in project cloudstack by apache.

the class RegionsApiUtil method makeUserAccountAPICall.

/**
     * Makes an api call using region service end_point, api command and params
     * Returns UserAccount object on success
     * @param region
     * @param command
     * @param params
     * @return
     */
protected static UserAccount makeUserAccountAPICall(Region region, String command, List<NameValuePair> params) {
    try {
        String url = buildUrl(buildParams(command, params), region);
        HttpClient client = new HttpClient();
        HttpMethod method = new GetMethod(url);
        if (client.executeMethod(method) == 200) {
            InputStream is = method.getResponseBodyAsStream();
            XStream xstream = new XStream(new DomDriver());
            xstream.alias("useraccount", UserAccountVO.class);
            xstream.aliasField("id", UserAccountVO.class, "uuid");
            try (ObjectInputStream in = xstream.createObjectInputStream(is)) {
                return (UserAccountVO) in.readObject();
            } catch (IOException e) {
                s_logger.error(e.getMessage());
                return null;
            }
        } else {
            return null;
        }
    } catch (HttpException e) {
        s_logger.error(e.getMessage());
        return null;
    } catch (IOException e) {
        s_logger.error(e.getMessage());
        return null;
    } catch (ClassNotFoundException e) {
        s_logger.error(e.getMessage());
        return null;
    }
}