added utility class used to generate parameter whitelist

Author: glicht

README.md

@@ -46,5 +46,22 @@ Target jar will be created at: `build/lib`. Jar will be named: `aws-xray-paramet
 
 It is possible to configure a custom parameter whitelist file instead of the default one provided with the package. This can be done either via a the environment variable: `AWS_XRAY_WHITELIST_URL` or the System property: `alt.aws.xray.whitelist.url`. The System property takes precedence over the environment variable. Value should be set to a resource path as specified by [Class.getResource()](https://docs.oracle.com/javase/8/docs/api/java/lang/Class.html#getResource-java.lang.String-). For example: `/com/myconpany/mypackage/MyParameterWhitelist.json`.
 
-**Note**: If setting the System property programmatically, you need to set this before using the AWS SDK. The configuration is evaluated once upon first usage of the AWS SDK.  
+**Note**: If setting the System property programmatically, you need to set this before using the AWS SDK. The configuration is evaluated once, upon first usage of the AWS SDK.  
 
+# Generating Your Own Parameter Whitelist
+
+Source code includes a utility class which can be used to generate parameter whitelists for additional services. The class is under the test source tree and requires compiling the project from source to run. Class name: `com.github.functionalone.xray.handlers.GenerateParameterWhitelist`. The class uses parameters which are passed via java system properties. The following properties are used:
+
+```
+gen.file: [output file name, default to whitelist.json]
+gen.class: <class to generate whitelist for, example: com.amazonaws.services.s3.AmazonS3Client'>
+gen.service: <service name, example: 'Amazon S3'>
+gen.params: <parameter names comma separated, example: BucketName,Key,VersionId,Prefix>
+gen.verbose: [true|false, default:false, will print more info on stdout regarding what is being done]
+```
+
+There is a gradle task: `generateWhitelist` which can be used to run the class. For example the S3 parameter whitelist was generated using the following command line:
+
+```
+./gradlew -Dgen.class=com.amazonaws.services.s3.AmazonS3Client -Dgen.service="Amazon S3" -Dgen.params=BucketName,Key,VersionId,Prefix,SourceBucketName,SourceKey,DestinationBucketName,DestinationKey generateWhitelist
+```

build.gradle

@@ -37,7 +37,8 @@ dependencies {
     // Use JUnit test framework
     testImplementation (
     	'junit:junit:4.12',
-    	'com.amazonaws:aws-java-sdk-dynamodb:1.11.259',
+    	'com.amazonaws:aws-java-sdk-dynamodb:1.11.268',
+    	'com.amazonaws:aws-java-sdk-kinesis:1.11.268',
     )
 }
 
@@ -126,6 +127,15 @@ test {
     systemProperty "aws-xray-whitelist.s3-bucket", System.getProperty("aws-xray-whitelist.s3-bucket")
 }
 
+task generateWhitelist (type:JavaExec) {
+
+    main = "com.github.functionalone.xray.handlers.GenerateParameterWhitelist"
+    classpath = sourceSets.test.runtimeClasspath 
+
+    /* Pass all system proprties*/
+    systemProperties System.getProperties()    
+}
+
 
 
 jar {

src/test/java/com/github/functionalone/xray/handlers/GenerateParameterWhitelist.java

@@ -0,0 +1,99 @@
+package com.github.functionalone.xray.handlers;
+
+import java.io.BufferedOutputStream;
+import java.io.File;
+import java.io.FileOutputStream;
+import java.lang.reflect.Method;
+import java.lang.reflect.Modifier;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+
+import com.fasterxml.jackson.databind.ObjectMapper;
+import com.fasterxml.jackson.databind.node.ArrayNode;
+import com.fasterxml.jackson.databind.node.ObjectNode;
+
+public class GenerateParameterWhitelist {
+
+    public static final String USAGE = "This program will generate a parameter whitelise based upon reflection. Paramaters are read from the System properties:\n"
+            + "gen.file: [output file name, default to whitelist.json]\n"
+            + "gen.class: <class to generate whitelist for, example: 'com.amazonaws.services.s3.AmazonS3Client'>\n"
+            + "gen.service: <service name, example: 'Amazon S3'>\n"
+            + "gen.params: <parameter names comma separated, example: BucketName,Key,VersionId,Prefix>\n"
+            + "gen.verbose: [true|false, default:false, will print more info on stdout regarding what is being done]";
+
+    private static String capitalizeFirst(String input) {
+        return input.substring(0, 1).toUpperCase() + input.substring(1);
+    }
+    
+    private static boolean VERBOSE = false;
+    
+    private static void debug(String msg) {
+        if(VERBOSE) {
+            System.out.println(msg);
+        }
+    }
+
+    /**
+     * Uses system properties as parameters. See usage string.
+     * 
+     * @param args
+     */
+    public static void main(String[] args) throws Exception {
+        String file = System.getProperty("gen.file", "whitelist.json"), serviceClass = System.getProperty("gen.class"),
+                serviceName = System.getProperty("gen.service"), paramsStr = System.getProperty("gen.params");
+        VERBOSE = Boolean.parseBoolean(System.getProperty("gen.verbose", "false"));
+        if (null == serviceClass || null == serviceName || null == paramsStr) {
+            System.err.println("\n\nMissing system parameters in order to run!!!\n\n" + USAGE);
+            System.exit(1);
+            return;
+        }
+        List<String> paramsList = Arrays.asList(paramsStr.split(","));
+        File f = new File(file);        
+        ObjectMapper mapper = new ObjectMapper();
+        ObjectNode root = (ObjectNode) mapper.createObjectNode();
+        ObjectNode serviceNode = (ObjectNode) mapper.createObjectNode();
+        root.put(serviceName, serviceNode);
+        ObjectNode operations = (ObjectNode) mapper.createObjectNode();
+        serviceNode.put("operations", operations);        
+        List<String> noParamMethods = new ArrayList<String>();
+        Class cls = Class.forName(serviceClass);
+        Method[] methods = cls.getDeclaredMethods();
+        for (Method method : methods) {
+            if (Modifier.isPublic(method.getModifiers())) {
+                Class[] params = method.getParameterTypes();
+                if (params.length == 1 && params[0].getName().endsWith("Request")) {
+                    Class p = params[0];
+                    debug("Processing Method: " + method.getName() + " with param: " + p.getSimpleName());
+                    Method[] paramMethods = p.getMethods();
+                    ObjectNode paramsNode = (ObjectNode) mapper.createObjectNode();
+                    ArrayNode request_parameters = (ArrayNode) mapper.createArrayNode();
+                    paramsNode.put("request_parameters", request_parameters);
+                    boolean hasParam = false;
+                    for (Method paramMethod : paramMethods) {
+                        String pName = paramMethod.getName();
+                        if (pName.startsWith("get")) {
+                            pName = pName.substring("get".length());
+                            if (paramsList.contains(pName)) {
+                                debug("\t param name: " + pName);
+                                hasParam = true;
+                                request_parameters.add(pName);
+                            }
+                        }
+                    }
+                    if (!hasParam) {
+                        noParamMethods.add(method.getName());
+                    } else {
+                        operations.put(capitalizeFirst(method.getName()), paramsNode);
+                    }
+                }
+            }
+        }
+        System.out.println("Methods without params: " + noParamMethods);
+        BufferedOutputStream bout = new BufferedOutputStream(new FileOutputStream(f));
+        bout.write(mapper.writerWithDefaultPrettyPrinter().writeValueAsBytes(root));
+        bout.close();
+        System.out.println("Json paramter whitelist written to file: " + f.getAbsolutePath());
+    }
+
+}