Update docs

Author: ethanhann

docs-src/commands.md

@@ -147,14 +147,29 @@ public override void Run()
 }
 ```
 
-### Executing Arbitrary Processes
+### Running non-.NET Commands
 
 It isn't necessary to create C# classes to utilize InEngine.NET.
-Arbitrary commands can be run, with an argument list by leveraging the InEngine.Core plugin's **proc** command.
-The command lists directory contents using "ls" with the "-lhp" switches:
+Arbitrary commands can be run, with an argument list by leveraging the InEngine.Core plugin's **exec** command.
+
+This command prints the version of python:
 
 ```bash
-inengine.exe proc -c"/bin/ls" -a"-lhp"
+inengine.exe exec -e"python" -a"--version"
+```
+
+Whitelist the "php" command in the [appsettings.json](configuration) file:
+
+```json
+{
+  "InEngine": {
+    // ...
+    "ExecWhitelist": {
+      "ls": "ls"
+    }
+    // ...
+  }
+}
 ```
 
 ## View Commands
@@ -174,7 +189,9 @@ inengine.exe
 
 ## View a Command's Help Text
 
-Run the command with the -h or --help arguments.
+Run the command with the -h or --help arguments to see help text.
+
+This command prints the publish command's help text, from the core plugin:
 
 ```bash
 inengine.exe queue:publish -h

docs-src/index.md

@@ -7,7 +7,7 @@ It also has a built-in command for launching external non-.NET programs.
 
 Get started by pulling the binaries from the [latest release](https://github.com/InEngine-NET/InEngine.NET/releases) on GitHub.
 
-Then run a command the **echo** command from the core plugin:
+Then run the **echo** command from the core plugin:
 
 ```bash
 inengine.exe echo --text"Hello, world"
@@ -32,8 +32,6 @@ docker run --rm inengine echo --text"Hello, world"
 
 ## How does queueing work?
 
-There are a lot of [queuing](queuing) features, but this is the gist...
-
 Want to queue our example echo command to run in the background or possibly on another server?
 
 Use the core plugin's **queue:publish** command:
@@ -44,24 +42,47 @@ inengine.exe queue:publish --command-plugin=InEngine.Core --command-verb=echo --
 
 How do we consume that queued echo command?
 
-Use the core plugin's **queue:consume** command of course:
+Use the core plugin's **queue:consume** command:
 
 ```bash
 inengine.exe queue:consume
 ``` 
 
 ## How do I run non-.NET commands?
 
-There is a special **proc** command in the core plugin that allows for the execution of any program you can run at the command line. 
+There is a special **exec** command in the core plugin that allows for the execution of any program you can run at the command line. 
 
 For example, create a python script called **helloworld.py** that contains this:
 
 ```python
 print 'Hello, world!'
 ```
 
-Now execute it with the **proc** command:
+Whitelist the "python" command in the [appsettings.json](configuration) file:
+
+```json
+{
+  "InEngine": {
+    // ...
+    "ExecWhitelist": {
+      "python": "/usr/bin/python"
+    }
+    // ...
+  }
+}
+```
+
+Now execute it with the **exec** command:
+
+```bash
+inengine exe --command=python --args=helloworld.py
+```
+
+Why would you want to do this?
+It opens up the possibility of running shell scripts, ETLs, Java programs, etc. in the background or on a schedule. 
+
+The example python script can be queued:
 
 ```bash
-inengine proc --command=/usr/bin/python --args=helloworld.py
+inengine queue:publish --command-plugin=InEngine.Core --command-verb=exec --args="executable=python" "args=helloworld.py"
 ```

docs-src/queuing.md

@@ -93,6 +93,19 @@ Enqueue.Command(() => Console.WriteLine("Hello, world!"))
        .Dispatch();
 ```
 
+### With the "exec" Command
+
+The **exec** command allows for external programs to be executed.
+
+```bash
+inengine queue:publish --command-plugin=InEngine.Core --command-verb=exe --args="command=/usr/bin/python" "args=--version"
+```
+
+!!! note "Do not include "--" for the command and args parameters."
+    This is purely to make parsing easier internally.
+
+
+    
 ### Sequentially In a Chain
 
 Chained commands run in the order specified.