| // 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 com.cloud.api.doc; | |
| import java.io.File; | |
| import java.io.FileInputStream; | |
| import java.io.FileNotFoundException; | |
| import java.io.FileOutputStream; | |
| import java.io.FileWriter; | |
| import java.io.IOException; | |
| import java.io.ObjectOutputStream; | |
| import java.lang.reflect.Field; | |
| import java.util.*; | |
| import java.util.zip.ZipEntry; | |
| import java.util.zip.ZipOutputStream; | |
| import com.cloud.utils.IteratorUtil; | |
| import com.cloud.utils.ReflectUtil; | |
| import org.apache.cloudstack.api.*; | |
| import org.apache.log4j.Logger; | |
| import com.cloud.alert.AlertManager; | |
| import org.apache.cloudstack.api.APICommand; | |
| import org.apache.cloudstack.api.response.AsyncJobResponse; | |
| import org.apache.cloudstack.api.response.HostResponse; | |
| import org.apache.cloudstack.api.response.IPAddressResponse; | |
| import org.apache.cloudstack.api.response.SecurityGroupResponse; | |
| import org.apache.cloudstack.api.response.SnapshotResponse; | |
| import org.apache.cloudstack.api.response.StoragePoolResponse; | |
| import org.apache.cloudstack.api.response.TemplateResponse; | |
| import org.apache.cloudstack.api.response.UserVmResponse; | |
| import org.apache.cloudstack.api.response.VolumeResponse; | |
| import com.cloud.serializer.Param; | |
| import com.google.gson.annotations.SerializedName; | |
| import com.thoughtworks.xstream.XStream; | |
| import org.reflections.Reflections; | |
| public class ApiXmlDocWriter { | |
| public static final Logger s_logger = Logger.getLogger(ApiXmlDocWriter.class.getName()); | |
| private static final short DOMAIN_ADMIN_COMMAND = 4; | |
| private static final short USER_COMMAND = 8; | |
| private static Map<String, Class<?>> _apiNameCmdClassMap = new HashMap<String, Class<?>>(); | |
| private static LinkedHashMap<Object, String> all_api_commands = new LinkedHashMap<Object, String>(); | |
| private static LinkedHashMap<Object, String> domain_admin_api_commands = new LinkedHashMap<Object, String>(); | |
| private static LinkedHashMap<Object, String> regular_user_api_commands = new LinkedHashMap<Object, String>(); | |
| private static TreeMap<Object, String> all_api_commands_sorted = new TreeMap<Object, String>(); | |
| private static TreeMap<Object, String> domain_admin_api_commands_sorted = new TreeMap<Object, String>(); | |
| private static TreeMap<Object, String> regular_user_api_commands_sorted = new TreeMap<Object, String>(); | |
| private static String dirName = ""; | |
| private static final List<String> _asyncResponses = setAsyncResponses(); | |
| private static List<String> setAsyncResponses() { | |
| List<String> asyncResponses = new ArrayList<String>(); | |
| asyncResponses.add(TemplateResponse.class.getName()); | |
| asyncResponses.add(VolumeResponse.class.getName()); | |
| //asyncResponses.add(LoadBalancerResponse.class.getName()); | |
| asyncResponses.add(HostResponse.class.getName()); | |
| asyncResponses.add(IPAddressResponse.class.getName()); | |
| asyncResponses.add(StoragePoolResponse.class.getName()); | |
| asyncResponses.add(UserVmResponse.class.getName()); | |
| asyncResponses.add(SecurityGroupResponse.class.getName()); | |
| //asyncResponses.add(ExternalLoadBalancerResponse.class.getName()); | |
| asyncResponses.add(SnapshotResponse.class.getName()); | |
| return asyncResponses; | |
| } | |
| public static void main(String[] args) { | |
| Set<Class<?>> cmdClasses = ReflectUtil.getClassesWithAnnotation(APICommand.class, new String[]{"org.apache.cloudstack.api", "com.cloud.api"}); | |
| for(Class<?> cmdClass: cmdClasses) { | |
| String apiName = cmdClass.getAnnotation(APICommand.class).name(); | |
| if (_apiNameCmdClassMap.containsKey(apiName)) { | |
| System.out.println("Warning, API Cmd class " + cmdClass.getName() + " has non-unique apiname" + apiName); | |
| continue; | |
| } | |
| _apiNameCmdClassMap.put(apiName, cmdClass); | |
| } | |
| LinkedProperties preProcessedCommands = new LinkedProperties(); | |
| String[] fileNames = null; | |
| 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("-f")) { | |
| fileNames = iter.next().split(","); | |
| } | |
| if (arg.equals("-d")) { | |
| dirName = iter.next(); | |
| } | |
| } | |
| if ((fileNames == null) || (fileNames.length == 0)) { | |
| System.out.println("Please specify input file(s) separated by coma using -f option"); | |
| System.exit(2); | |
| } | |
| for (String fileName : fileNames) { | |
| try { | |
| FileInputStream in = new FileInputStream(fileName); | |
| preProcessedCommands.load(in); | |
| } catch (FileNotFoundException ex) { | |
| System.out.println("Can't find file " + fileName); | |
| System.exit(2); | |
| } catch (IOException ex1) { | |
| System.out.println("Error reading from file " + ex1); | |
| System.exit(2); | |
| } | |
| } | |
| Iterator<?> propertiesIterator = preProcessedCommands.keys.iterator(); | |
| // Get command classes and response object classes | |
| while (propertiesIterator.hasNext()) { | |
| String key = (String) propertiesIterator.next(); | |
| String preProcessedCommand = preProcessedCommands.getProperty(key); | |
| int splitIndex = preProcessedCommand.lastIndexOf(";"); | |
| String commandRoleMask = preProcessedCommand.substring(splitIndex + 1); | |
| Class<?> cmdClass = _apiNameCmdClassMap.get(key); | |
| if (cmdClass == null) { | |
| System.out.println("Check, is this api part of another build profile? Null value for key: " + key + " preProcessedCommand=" + preProcessedCommand); | |
| continue; | |
| } | |
| String commandName = cmdClass.getName(); | |
| all_api_commands.put(key, commandName); | |
| short cmdPermissions = 1; | |
| if (commandRoleMask != null) { | |
| cmdPermissions = Short.parseShort(commandRoleMask); | |
| } | |
| if ((cmdPermissions & DOMAIN_ADMIN_COMMAND) != 0) { | |
| domain_admin_api_commands.put(key, commandName); | |
| } | |
| if ((cmdPermissions & USER_COMMAND) != 0) { | |
| regular_user_api_commands.put(key, commandName); | |
| } | |
| } | |
| // Login and logout commands are hardcoded | |
| all_api_commands.put("login", "login"); | |
| domain_admin_api_commands.put("login", "login"); | |
| regular_user_api_commands.put("login", "login"); | |
| all_api_commands.put("logout", "logout"); | |
| domain_admin_api_commands.put("logout", "logout"); | |
| regular_user_api_commands.put("logout", "logout"); | |
| all_api_commands_sorted.putAll(all_api_commands); | |
| domain_admin_api_commands_sorted.putAll(domain_admin_api_commands); | |
| regular_user_api_commands_sorted.putAll(regular_user_api_commands); | |
| try { | |
| // Create object writer | |
| XStream xs = new XStream(); | |
| xs.alias("command", Command.class); | |
| xs.alias("arg", Argument.class); | |
| String xmlDocDir = dirName + "/xmldoc"; | |
| String rootAdminDirName = xmlDocDir + "/root_admin"; | |
| String domainAdminDirName = xmlDocDir + "/domain_admin"; | |
| String regularUserDirName = xmlDocDir + "/regular_user"; | |
| (new File(rootAdminDirName)).mkdirs(); | |
| (new File(domainAdminDirName)).mkdirs(); | |
| (new File(regularUserDirName)).mkdirs(); | |
| ObjectOutputStream out = xs.createObjectOutputStream(new FileWriter(dirName + "/commands.xml"), "commands"); | |
| ObjectOutputStream rootAdmin = xs.createObjectOutputStream(new FileWriter(rootAdminDirName + "/" + "rootAdminSummary.xml"), "commands"); | |
| ObjectOutputStream rootAdminSorted = xs.createObjectOutputStream(new FileWriter(rootAdminDirName + "/" + "rootAdminSummarySorted.xml"), "commands"); | |
| ObjectOutputStream domainAdmin = xs.createObjectOutputStream(new FileWriter(domainAdminDirName + "/" + "domainAdminSummary.xml"), "commands"); | |
| ObjectOutputStream outDomainAdminSorted = xs.createObjectOutputStream(new FileWriter(domainAdminDirName + "/" + "domainAdminSummarySorted.xml"), "commands"); | |
| ObjectOutputStream regularUser = xs.createObjectOutputStream(new FileWriter(regularUserDirName + "/regularUserSummary.xml"), "commands"); | |
| ObjectOutputStream regularUserSorted = xs.createObjectOutputStream(new FileWriter(regularUserDirName + "/regularUserSummarySorted.xml"), "commands"); | |
| // Write commands in the order they are represented in commands.properties.in file | |
| Iterator<?> it = all_api_commands.keySet().iterator(); | |
| while (it.hasNext()) { | |
| String key = (String) it.next(); | |
| // Write admin commands | |
| if (key.equals("login")) { | |
| writeLoginCommand(out); | |
| writeLoginCommand(rootAdmin); | |
| writeLoginCommand(domainAdmin); | |
| writeLoginCommand(regularUser); | |
| ObjectOutputStream singleRootAdminCommandOs = xs.createObjectOutputStream(new FileWriter(rootAdminDirName + "/" + "login" + ".xml"), "command"); | |
| writeLoginCommand(singleRootAdminCommandOs); | |
| singleRootAdminCommandOs.close(); | |
| ObjectOutputStream singleDomainAdminCommandOs = xs.createObjectOutputStream(new FileWriter(domainAdminDirName + "/" + "login" + ".xml"), "command"); | |
| writeLoginCommand(singleDomainAdminCommandOs); | |
| singleDomainAdminCommandOs.close(); | |
| ObjectOutputStream singleRegularUserCommandOs = xs.createObjectOutputStream(new FileWriter(regularUserDirName + "/" + "login" + ".xml"), "command"); | |
| writeLoginCommand(singleRegularUserCommandOs); | |
| singleRegularUserCommandOs.close(); | |
| } else if (key.equals("logout")) { | |
| writeLogoutCommand(out); | |
| writeLogoutCommand(rootAdmin); | |
| writeLogoutCommand(domainAdmin); | |
| writeLogoutCommand(regularUser); | |
| ObjectOutputStream singleRootAdminCommandOs = xs.createObjectOutputStream(new FileWriter(rootAdminDirName + "/" + "logout" + ".xml"), "command"); | |
| writeLogoutCommand(singleRootAdminCommandOs); | |
| singleRootAdminCommandOs.close(); | |
| ObjectOutputStream singleDomainAdminCommandOs = xs.createObjectOutputStream(new FileWriter(domainAdminDirName + "/" + "logout" + ".xml"), "command"); | |
| writeLogoutCommand(singleDomainAdminCommandOs); | |
| singleDomainAdminCommandOs.close(); | |
| ObjectOutputStream singleRegularUserCommandOs = xs.createObjectOutputStream(new FileWriter(regularUserDirName + "/" + "logout" + ".xml"), "command"); | |
| writeLogoutCommand(singleRegularUserCommandOs); | |
| singleRegularUserCommandOs.close(); | |
| } else { | |
| writeCommand(out, key); | |
| writeCommand(rootAdmin, key); | |
| // Write single commands to separate xml files | |
| if (!key.equals("login")) { | |
| ObjectOutputStream singleRootAdminCommandOs = xs.createObjectOutputStream(new FileWriter(rootAdminDirName + "/" + key + ".xml"), "command"); | |
| writeCommand(singleRootAdminCommandOs, key); | |
| singleRootAdminCommandOs.close(); | |
| } | |
| if (domain_admin_api_commands.containsKey(key)) { | |
| writeCommand(domainAdmin, key); | |
| ObjectOutputStream singleDomainAdminCommandOs = xs.createObjectOutputStream(new FileWriter(domainAdminDirName + "/" + key + ".xml"), "command"); | |
| writeCommand(singleDomainAdminCommandOs, key); | |
| singleDomainAdminCommandOs.close(); | |
| } | |
| if (regular_user_api_commands.containsKey(key)) { | |
| writeCommand(regularUser, key); | |
| ObjectOutputStream singleRegularUserCommandOs = xs.createObjectOutputStream(new FileWriter(regularUserDirName + "/" + key + ".xml"), "command"); | |
| writeCommand(singleRegularUserCommandOs, key); | |
| singleRegularUserCommandOs.close(); | |
| } | |
| } | |
| } | |
| // Write sorted commands | |
| it = all_api_commands_sorted.keySet().iterator(); | |
| while (it.hasNext()) { | |
| String key = (String) it.next(); | |
| if (key.equals("login")) { | |
| writeLoginCommand(rootAdminSorted); | |
| writeLoginCommand(outDomainAdminSorted); | |
| writeLoginCommand(regularUserSorted); | |
| } else if (key.equals("logout")) { | |
| writeLogoutCommand(rootAdminSorted); | |
| writeLogoutCommand(outDomainAdminSorted); | |
| writeLogoutCommand(regularUserSorted); | |
| } else { | |
| writeCommand(rootAdminSorted, key); | |
| if (domain_admin_api_commands.containsKey(key)) { | |
| writeCommand(outDomainAdminSorted, key); | |
| } | |
| if (regular_user_api_commands.containsKey(key)) { | |
| writeCommand(regularUserSorted, key); | |
| } | |
| } | |
| } | |
| out.close(); | |
| rootAdmin.close(); | |
| rootAdminSorted.close(); | |
| domainAdmin.close(); | |
| outDomainAdminSorted.close(); | |
| regularUser.close(); | |
| regularUserSorted.close(); | |
| // write alerttypes to xml | |
| writeAlertTypes(xmlDocDir); | |
| // gzip directory with xml doc | |
| // zipDir(dirName + "xmldoc.zip", xmlDocDir); | |
| // Delete directory | |
| // deleteDir(new File(xmlDocDir)); | |
| } catch (Exception ex) { | |
| ex.printStackTrace(); | |
| System.exit(2); | |
| } | |
| } | |
| private static void writeCommand(ObjectOutputStream out, String command) throws ClassNotFoundException, IOException { | |
| Class<?> clas = Class.forName(all_api_commands.get(command)); | |
| ArrayList<Argument> request = new ArrayList<Argument>(); | |
| ArrayList<Argument> response = new ArrayList<Argument>(); | |
| // Create a new command, set name/description/usage | |
| Command apiCommand = new Command(); | |
| apiCommand.setName(command); | |
| APICommand impl = clas.getAnnotation(APICommand.class); | |
| if (impl == null) { | |
| impl = clas.getSuperclass().getAnnotation(APICommand.class); | |
| } | |
| if (impl == null) { | |
| throw new IllegalStateException(String.format("An %1$s annotation is required for class %2$s.", | |
| APICommand.class.getCanonicalName(), clas.getCanonicalName())); | |
| } | |
| if (impl.includeInApiDoc()) { | |
| String commandDescription = impl.description(); | |
| if (commandDescription != null && !commandDescription.isEmpty()) { | |
| apiCommand.setDescription(commandDescription); | |
| } else { | |
| System.out.println("Command " + apiCommand.getName() + " misses description"); | |
| } | |
| String commandUsage = impl.usage(); | |
| if (commandUsage != null && !commandUsage.isEmpty()) { | |
| apiCommand.setUsage(commandUsage); | |
| } | |
| //Set version when the API is added | |
| if(!impl.since().isEmpty()){ | |
| apiCommand.setSinceVersion(impl.since()); | |
| } | |
| boolean isAsync = ReflectUtil.isCmdClassAsync(clas, | |
| new Class<?>[] {BaseAsyncCmd.class, BaseAsyncCreateCmd.class}); | |
| apiCommand.setAsync(isAsync); | |
| Set<Field> fields = ReflectUtil.getAllFieldsForClass(clas, | |
| new Class<?>[] {BaseCmd.class, BaseAsyncCmd.class, BaseAsyncCreateCmd.class}); | |
| request = setRequestFields(fields); | |
| // Get response parameters | |
| Class<?> responseClas = impl.responseObject(); | |
| Field[] responseFields = responseClas.getDeclaredFields(); | |
| response = setResponseFields(responseFields, responseClas); | |
| apiCommand.setRequest(request); | |
| apiCommand.setResponse(response); | |
| out.writeObject(apiCommand); | |
| } else { | |
| s_logger.debug("Command " + command + " is not exposed in api doc"); | |
| } | |
| } | |
| private static void writeLoginCommand(ObjectOutputStream out) throws ClassNotFoundException, IOException { | |
| ArrayList<Argument> request = new ArrayList<Argument>(); | |
| ArrayList<Argument> response = new ArrayList<Argument>(); | |
| // Create a new command, set name and description | |
| Command apiCommand = new Command(); | |
| apiCommand.setName("login"); | |
| apiCommand | |
| .setDescription("Logs a user into the CloudStack. A successful login attempt will generate a JSESSIONID cookie value that can be passed in subsequent Query command calls until the \"logout\" command has been issued or the session has expired."); | |
| // Generate request | |
| request.add(new Argument("username", "Username", true)); | |
| request.add(new Argument("password", "Hashed password (Default is MD5). If you wish to use any other hashing algorithm, you would need to write a custom authentication adapter See Docs section.", true)); | |
| request.add(new Argument("domain", "path of the domain that the user belongs to. Example: domain=/com/cloud/internal. If no domain is passed in, the ROOT domain is assumed.", false)); | |
| request.add(new Argument("domainId", "id of the domain that the user belongs to. If both domain and domainId are passed in, \"domainId\" parameter takes precendence", false)); | |
| apiCommand.setRequest(request); | |
| // Generate response | |
| response.add(new Argument("username", "Username")); | |
| response.add(new Argument("userid", "User id")); | |
| response.add(new Argument("password", "Password")); | |
| response.add(new Argument("domainid", "domain ID that the user belongs to")); | |
| response.add(new Argument("timeout", "the time period before the session has expired")); | |
| response.add(new Argument("account", "the account name the user belongs to")); | |
| response.add(new Argument("firstname", "first name of the user")); | |
| response.add(new Argument("lastname", "last name of the user")); | |
| response.add(new Argument("type", "the account type (admin, domain-admin, read-only-admin, user)")); | |
| response.add(new Argument("timezone", "user time zone")); | |
| response.add(new Argument("timezoneoffset", "user time zone offset from UTC 00:00")); | |
| response.add(new Argument("sessionkey", "Session key that can be passed in subsequent Query command calls")); | |
| apiCommand.setResponse(response); | |
| out.writeObject(apiCommand); | |
| } | |
| private static void writeLogoutCommand(ObjectOutputStream out) throws ClassNotFoundException, IOException { | |
| ArrayList<Argument> request = new ArrayList<Argument>(); | |
| ArrayList<Argument> response = new ArrayList<Argument>(); | |
| // Create a new command, set name and description | |
| Command apiCommand = new Command(); | |
| apiCommand.setName("logout"); | |
| apiCommand.setDescription("Logs out the user"); | |
| // Generate request - no request parameters | |
| apiCommand.setRequest(request); | |
| // Generate response | |
| response.add(new Argument("description", "success if the logout action succeeded")); | |
| apiCommand.setResponse(response); | |
| out.writeObject(apiCommand); | |
| } | |
| private static ArrayList<Argument> setRequestFields(Set<Field> fields) { | |
| ArrayList<Argument> arguments = new ArrayList<Argument>(); | |
| Set<Argument> requiredArguments = new HashSet<Argument>(); | |
| Set<Argument> optionalArguments = new HashSet<Argument>(); | |
| Argument id = null; | |
| for (Field f : fields) { | |
| Parameter parameterAnnotation = f.getAnnotation(Parameter.class); | |
| if (parameterAnnotation != null && parameterAnnotation.expose() && parameterAnnotation.includeInApiDoc()) { | |
| Argument reqArg = new Argument(parameterAnnotation.name()); | |
| reqArg.setRequired(parameterAnnotation.required()); | |
| if (!parameterAnnotation.description().isEmpty()) { | |
| reqArg.setDescription(parameterAnnotation.description()); | |
| } | |
| if (parameterAnnotation.type() == BaseCmd.CommandType.LIST || parameterAnnotation.type() == BaseCmd.CommandType.MAP) { | |
| reqArg.setType(parameterAnnotation.type().toString().toLowerCase()); | |
| } | |
| if(!parameterAnnotation.since().isEmpty()){ | |
| reqArg.setSinceVersion(parameterAnnotation.since()); | |
| } | |
| if (reqArg.isRequired()) { | |
| if (parameterAnnotation.name().equals("id")) { | |
| id = reqArg; | |
| } else { | |
| requiredArguments.add(reqArg); | |
| } | |
| } else { | |
| optionalArguments.add(reqArg); | |
| } | |
| } | |
| } | |
| // sort required and optional arguments here | |
| if (id != null) { | |
| arguments.add(id); | |
| } | |
| arguments.addAll(IteratorUtil.asSortedList(requiredArguments)); | |
| arguments.addAll(IteratorUtil.asSortedList(optionalArguments)); | |
| return arguments; | |
| } | |
| private static ArrayList<Argument> setResponseFields(Field[] responseFields, Class<?> responseClas) { | |
| ArrayList<Argument> arguments = new ArrayList<Argument>(); | |
| ArrayList<Argument> sortedChildlessArguments = new ArrayList<Argument>(); | |
| ArrayList<Argument> sortedArguments = new ArrayList<Argument>(); | |
| Argument id = null; | |
| for (Field responseField : responseFields) { | |
| SerializedName nameAnnotation = responseField.getAnnotation(SerializedName.class); | |
| if (nameAnnotation != null) { | |
| Param paramAnnotation = responseField.getAnnotation(Param.class); | |
| Argument respArg = new Argument(nameAnnotation.value()); | |
| boolean hasChildren = false; | |
| if (paramAnnotation != null && paramAnnotation.includeInApiDoc()) { | |
| String description = paramAnnotation.description(); | |
| Class fieldClass = paramAnnotation.responseObject(); | |
| if (description != null && !description.isEmpty()) { | |
| respArg.setDescription(description); | |
| } | |
| if(!paramAnnotation.since().isEmpty()){ | |
| respArg.setSinceVersion(paramAnnotation.since()); | |
| } | |
| if (fieldClass != null) { | |
| Class<?> superClass = fieldClass.getSuperclass(); | |
| if (superClass != null) { | |
| String superName = superClass.getName(); | |
| if (superName.equals(BaseResponse.class.getName())) { | |
| ArrayList<Argument> fieldArguments = new ArrayList<Argument>(); | |
| Field[] fields = fieldClass.getDeclaredFields(); | |
| fieldArguments = setResponseFields(fields, fieldClass); | |
| respArg.setArguments(fieldArguments); | |
| hasChildren = true; | |
| } | |
| } | |
| } | |
| } | |
| if (paramAnnotation != null && paramAnnotation.includeInApiDoc()) { | |
| if (nameAnnotation.value().equals("id")) { | |
| id = respArg; | |
| } else { | |
| if (hasChildren) { | |
| respArg.setName(nameAnnotation.value() + "(*)"); | |
| sortedArguments.add(respArg); | |
| } else { | |
| sortedChildlessArguments.add(respArg); | |
| } | |
| } | |
| } | |
| } | |
| } | |
| Collections.sort(sortedArguments); | |
| Collections.sort(sortedChildlessArguments); | |
| if (id != null) { | |
| arguments.add(id); | |
| } | |
| arguments.addAll(sortedChildlessArguments); | |
| arguments.addAll(sortedArguments); | |
| if (responseClas.getName().equalsIgnoreCase(AsyncJobResponse.class.getName())) { | |
| Argument jobIdArg = new Argument("jobid", "the ID of the async job"); | |
| arguments.add(jobIdArg); | |
| } else if (_asyncResponses.contains(responseClas.getName())) { | |
| Argument jobIdArg = new Argument("jobid", "the ID of the latest async job acting on this object"); | |
| Argument jobStatusArg = new Argument("jobstatus", "the current status of the latest async job acting on this object"); | |
| arguments.add(jobIdArg); | |
| arguments.add(jobStatusArg); | |
| } | |
| return arguments; | |
| } | |
| private static void zipDir(String zipFileName, String dir) throws Exception { | |
| File dirObj = new File(dir); | |
| ZipOutputStream out = new ZipOutputStream(new FileOutputStream(zipFileName)); | |
| addDir(dirObj, out); | |
| out.close(); | |
| } | |
| static void addDir(File dirObj, ZipOutputStream out) throws IOException { | |
| File[] files = dirObj.listFiles(); | |
| byte[] tmpBuf = new byte[1024]; | |
| String pathToDir = dirName; | |
| for (int i = 0; i < files.length; i++) { | |
| if (files[i].isDirectory()) { | |
| addDir(files[i], out); | |
| continue; | |
| } | |
| FileInputStream in = new FileInputStream(files[i].getPath()); | |
| out.putNextEntry(new ZipEntry(files[i].getPath().substring(pathToDir.length()))); | |
| int len; | |
| while ((len = in.read(tmpBuf)) > 0) { | |
| out.write(tmpBuf, 0, len); | |
| } | |
| out.closeEntry(); | |
| in.close(); | |
| } | |
| } | |
| private static void deleteDir(File dir) { | |
| if (dir.isDirectory()) { | |
| String[] children = dir.list(); | |
| for (int i = 0; i < children.length; i++) { | |
| deleteDir(new File(dir, children[i])); | |
| } | |
| } | |
| dir.delete(); | |
| } | |
| 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()) { | |
| String name = f.getName().substring(11); | |
| Alert alert = new Alert(name, f.getInt(null)); | |
| out.writeObject(alert); | |
| } | |
| out.close(); | |
| } 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); | |
| } | |
| } | |
| private static class LinkedProperties extends Properties { | |
| private final LinkedList<Object> keys = new LinkedList<Object>(); | |
| @Override | |
| public Enumeration<Object> keys() { | |
| return Collections.<Object> enumeration(keys); | |
| } | |
| @Override | |
| public Object put(Object key, Object value) { | |
| // System.out.println("Adding key" + key); | |
| keys.add(key); | |
| return super.put(key, value); | |
| } | |
| } | |
| } |