Merge pull request #3 from intergral/config_auth

Config auth

Author: Umaaz

agent-api/src/main/java/com/intergral/deep/agent/api/auth/BasicAuthProvider.java

@@ -39,6 +39,6 @@ public Map<String, String> provide() {
     }
     final String encodedString = Base64.getEncoder()
         .encodeToString(String.format("%s:%s", userName, password).getBytes());
-    return Collections.singletonMap("authorization", encodedString);
+    return Collections.singletonMap("authorization", "basic%20" + encodedString);
   }
 }

api/src/main/java/com/intergral/deep/api/IDeepLoader.java

@@ -25,9 +25,10 @@ public interface IDeepLoader {
   /**
    * Load the Deep agent into the provided process id.
    *
-   * @param pid    the current process id
-   * @param config the config to use
+   * @param pid     the current process id
+   * @param config  the config to use
+   * @param jarPath the full path to the jar to load (or {@code null} to auto discover the jar)
    * @throws Throwable if loader fails
    */
-  void load(final String pid, final String config) throws Throwable;
+  void load(final String pid, final String config, final String jarPath) throws Throwable;
 }

deep/src/main/java/com/intergral/deep/Deep.java

@@ -24,17 +24,38 @@
 import java.lang.reflect.Constructor;
 import java.lang.reflect.Method;
 
+/**
+ * This is the main entry point to deep when using the API. All calls to deep should precede with a call to this class.
+ * <p>
+ * To start deep first configure the instance.
+ * <code>
+ * Deep.config().start();
+ * </code>
+ * <p>
+ * To use a deep API use
+ * <code>
+ * Deep.getInstance().<IDeep>api()
+ * </code>
+ */
 public class Deep {
 
   private static Deep DEEP_INSTANCE = null;
   private Object deepService = null;
   private Object reflection = null;
 
 
+  /**
+   * This is a shortcut for {@code Deep.config().start()}
+   */
   public static void start() {
     Deep.config().start();
   }
 
+  /**
+   * This will create an instance of DEEP allowing access to the APIs from inside deep agent.
+   *
+   * @return {@link Deep}
+   */
   public static Deep getInstance() {
     if (DEEP_INSTANCE != null) {
       return DEEP_INSTANCE;
@@ -44,29 +65,49 @@ public static Deep getInstance() {
     return DEEP_INSTANCE;
   }
 
+  /**
+   * This is the main point to start with deep. Call this to create a config builder and to customise the config of deep before starting
+   * it.
+   *
+   * @return {@link DeepConfigBuilder}
+   */
   public static DeepConfigBuilder config() {
     return new DeepConfigBuilder();
   }
 
-  public void startWithConfig(final String config) {
-    getInstance().startDeep(config);
+  /**
+   * This allows deep to be started with the parsed config
+   *
+   * @param config as a string
+   */
+  void startWithConfig(final String config, final String jarPath) {
+    getInstance().startDeep(config, jarPath);
+  }
+
+  /**
+   * This allows deep to be started with the parsed config builder
+   *
+   * @param builder the config to use
+   */
+  public void start(final DeepConfigBuilder builder) {
+    builder.start();
   }
 
-  private void startDeep(final String config) {
+  private void startDeep(final String config, final String jarPath) {
     try {
-      loadAgent(config);
+      loadAgent(config, jarPath);
 
       loadAPI();
     } catch (Throwable t) {
       t.printStackTrace();
     }
   }
 
-  private void loadAgent(final String config) throws Throwable {
+  private void loadAgent(final String config, final String jarPath) throws Throwable {
     final IDeepLoader loader = getLoader();
     final String pid = getPid();
 
-    loader.load(pid, config);
+    loader.load(pid, config, jarPath);
   }
 
 
@@ -123,6 +164,8 @@ private void loadAPI() {
 
   /**
    * Get an instance of the API to allow calling NerdVision directly
+   * <p>
+   * This uses T as the type {@link IDeep} is not loaded so this class cannot use it.
    *
    * @param <T> this should be {@link IDeep}
    * @return the new instance or {@link IDeep}
@@ -138,12 +181,14 @@ public <T> T api() {
   }
 
 
-  private void setProxyService(Object service) {
-    final IDeepHook hook = (IDeepHook) service;
-    this.deepService = hook.deepService();
-    this.reflection = hook.reflectionService();
-  }
-
+  /**
+   * Get an instance of the Reflection api used in deep.
+   * <p>
+   * This uses T as the type {@link com.intergral.deep.agent.api.reflection.IReflection} is not loaded so this class cannot use it.
+   *
+   * @return the {@link com.intergral.deep.agent.api.reflection.IReflection} service
+   * @param <T> this should be {@link com.intergral.deep.agent.api.reflection.IReflection}
+   */
   public <T> T reflection() {
     loadAPI();
     if (this.reflection == null) {
@@ -152,4 +197,10 @@ public <T> T reflection() {
     //noinspection unchecked
     return (T) reflection;
   }
+
+  private void setProxyService(Object service) {
+    final IDeepHook hook = (IDeepHook) service;
+    this.deepService = hook.deepService();
+    this.reflection = hook.reflectionService();
+  }
 }

deep/src/main/java/com/intergral/deep/DeepConfigBuilder.java

@@ -23,16 +23,82 @@
 public class DeepConfigBuilder {
 
   private final Map<String, Object> config = new HashMap<>();
+  private String jarPath;
 
+  /**
+   * Start Deep using this config
+   */
   public void start() {
-    Deep.getInstance().startWithConfig(this.build());
+    Deep.getInstance().startWithConfig(this.build(), this.jarPath);
+  }
+
+  /**
+   * This allows for overriding the path to the deep agent jar. This is useful when embedding deep into complex applications such as OSGI.
+   *
+   * @param path the full path to the agent jar file
+   * @return {this}
+   */
+  public DeepConfigBuilder setJarPath(final String path) {
+    this.jarPath = path;
+    return this;
+  }
+
+
+  /**
+   * Set a config value for deep. For the possible keys see the docs on config.
+   *
+   * @param key the key for the config value
+   * @param value the value as a string object
+   * @return {this{}}
+   */
+  public DeepConfigBuilder setValue(final String key, final String value) {
+    this.config.put(key, value);
+    return this;
+  }
+
+
+  /**
+   * Set a config value for deep. For the possible keys see the docs on config.
+   *
+   * @param key the key for the config value
+   * @param value the value as a boolean
+   * @return {this{}}
+   */
+  public DeepConfigBuilder setValue(final String key, final boolean value) {
+    this.config.put(key, value);
+    return this;
   }
 
-  public DeepConfigBuilder setValue(final String key, final Object value) {
+
+  /**
+   * Set a config value for deep. For the possible keys see the docs on config.
+   *
+   * @param key the key for the config value
+   * @param value the value as an int
+   * @return {this{}}
+   */
+  public DeepConfigBuilder setValue(final String key, final int value) {
     this.config.put(key, value);
     return this;
   }
 
+
+  /**
+   * Set a config value for deep. For the possible keys see the docs on config.
+   *
+   * @param key the key for the config value
+   * @param value the value as a double
+   * @return {this{}}
+   */
+  public DeepConfigBuilder setValue(final String key, final double value) {
+    this.config.put(key, value);
+    return this;
+  }
+
+  /**
+   * Converts this object into a string that can be used by the attachment process
+   * @return a string for this config
+   */
   private String build() {
     return this.configAsArgs(this.config);
   }

deep/src/main/java/com/intergral/deep/DeepLoader.java

@@ -29,8 +29,8 @@
 public class DeepLoader implements IDeepLoader {
 
   @Override
-  public void load(final String pid, final String config) {
-    final File agentJar = getAgentJar();
+  public void load(final String pid, final String config, final String jarPath) {
+    final File agentJar = getAgentJar(jarPath);
     final File tools = getToolsJar();
     if (agentJar == null) {
       throw new RuntimeException("Cannot find jar.");
@@ -60,8 +60,8 @@ private File getToolsJar() {
    *
    * @return the {@link File} object for the agent
    */
-  private File getAgentJar() {
-    final InputStream resourceAsStream = getAgentJarStream();
+  private File getAgentJar(final String jarPath) {
+    final InputStream resourceAsStream = getAgentJarStream(jarPath);
     final String pathname = extractLibrary(resourceAsStream);
     if (pathname != null) {
       return new File(pathname);
@@ -75,9 +75,9 @@ private File getAgentJar() {
    *
    * @return the stream to use, or {@code null}
    */
-  private InputStream getAgentJarStream() {
+  private InputStream getAgentJarStream(final String jarPath) {
     // this is pretty much just for testing, see Example
-    final String property = System.getProperty("deep.jar.path");
+    final String property = System.getProperty("deep.jar.path", jarPath);
     if (property != null) {
       try {
         return new FileInputStream(property);