Update docs

Author: ethanhann

docs-src/configuration.md

@@ -13,7 +13,8 @@ Configuration is accomplished by modifying the appsettings.json file that comes
       "UseCompression": false,
       "PrimaryQueueConsumers":  16,
       "SecondaryQueueConsumers": 4,
-      "QueueName": "InEngine:Queue",
+      "QueueDriver": "redis",
+      "QueueName": "InEngineQueue",
       "RedisHost": "localhost",
       "RedisPort": 6379,
       "RedisDb": 0,
@@ -39,6 +40,7 @@ Configuration is accomplished by modifying the appsettings.json file that comes
 | UseCompression            | bool      | A situation performance optimization that compresses queued messages. |
 | PrimaryQueueConsumers     | string    | The number of consumers to schedule for the secondary queue.          |
 | SecondaryQueueConsumers   | string    | The number of consumers to schedule for the secondary queue.          |
+| QueueDriver               | string    | The driver to use to interact with a queue data store.                |
 | QueueName                 | string    | The base name of the queue, used to form the Redis Queue keys.        |
 | RedisHost                 | string    | The Redis hostname to connect to.                                     |
 | RedisPort                 | integer   | Redis's port.                                                         |

docs-src/index.md

@@ -5,18 +5,16 @@ InEngine.NET allows commands to be [queued](queuing), [scheduled](scheduling), a
 InEngine.NET uses a plugin system to dynamically load .NET assemblies and execute code. 
 It also has a built-in command for launching external non-.NET programs.
 
-Get started by pulling the latest binaries from the [latest release](https://github.com/InEngine-NET/InEngine.NET/releases) on GitHub.
+Get started by pulling the binaries from the [latest release](https://github.com/InEngine-NET/InEngine.NET/releases) on GitHub.
 
-Then run a [command](commands):
+Then run a command the **echo** command from the core plugin:
 
 ```bash
 inengine.exe -pInEngine.Core echo --text"Hello, world"
 ```
 Or if you\'re a Linux or Mac OS X fan (like me!), use the **inengine** shell script ([Mono](http://www.mono-project.com/download/) required.):
 
 ```bash
-# or if you\'re a Linux fan like me... 
-
 inengine -pInEngine.Core echo --text"Hello, world"
 ```
 
@@ -32,7 +30,11 @@ Now run a command in a container:
 docker run --rm inengine -pInEngine.Core echo --text"Hello, world"
 ``` 
 
-Want to queue our example echo command to run in (possibly) another server?
+## 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:
 
@@ -48,11 +50,11 @@ Use the core plugin's **queue:consume** command of course:
 inengine.exe -pInEngine.Core queue:consume
 ``` 
 
-But what if I want to run some non-.NET code?
+## How do I run non-.NET commands?
 
-Use the core plugin's **proc** command to execute any program you like.
+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. 
 
-Create a hello world python script called **helloworld.py**:
+For example, create a python script called **helloworld.py** that contains this:
 
 ```python
 print 'Hello, world!'

docs-src/queuing.md

@@ -2,10 +2,22 @@
 
 InEngine.NET's queue functionality allows for commands to be run in the background with a simple publish/consume model. 
 
-## Prerequisites
+## Queue Drivers
 
-Redis is required to use the InEngine.NET queue feature. 
-It can be installed on Ubuntu with this command:
+To make use of queue features, a queue driver must be specified in [appsettings.json](configuration).
+These are the available drivers...
+
+### File
+
+The file driver writes queued messages to the file system. 
+It is useful for testing and development, but probably not suitable for production.
+
+### Redis
+
+Redis is suitable for production use. 
+InEngine.NET utilizes Redis' durable queue features which mean messages will not be lost if InEngine.NET unexpectedly fails. 
+
+Redis can be installed on Ubuntu with this command:
 
 ```bash
 sudo apt-get install redis-server
@@ -19,24 +31,80 @@ sudo service redis start
 
 <div class="alert alert-info">
 It is highly recommended to <a href="https://redis.io/topics/security#authentication-feature">set a password</a> for Redis.
-</div>
+</div> 
+
+### Sync
+
+The sync driver causes the publish command to run a published command synchronously.
+All other queue commands and methods are not supported and will throw an exception if called.
+This driver can be useful for plugin development and testing.
 
 ## Publishing Commands
 
-### From Code
+### With C# Classes
 
 [Commands](commands) can be published programmatically with the **InEngine.Core.Queuing.Queue** class:
 
 ```c#
 Queue.Make().Publish(new MyCommand());
 ```
 
-Or publish to the secondary queue:
+Or publish to the secondary queue by passing true to the Make method:
 
 ```c#
 Queue.Make(true).Publish(new MyCommand());
 ```
 
+!!! note "Do I have to use Queue.Make()?"
+    Queue.Make() is a factory method that autoloads the queue settings from appsettings.json, creates the appropriate queue driver, and returns an instance of Queue.
+    You can create your own Queue object an initialize it if you want.
+    At the very least you can assign the object returned by Queue.Make() to a local variable or load it into a DI container for later use.
+
+### With Lambda Expressions
+
+Lambda expressions, aka anonymous functions, can be queued.
+The disadvantage to queuing lambdas is that the helpful functionality available in **InEngine.Core.AbstractCommand** is not available.  
+
+This is how you queue a lambda:
+
+```c#
+Queue.Make().Publish(() => Console.WriteLine("Hello, world!"));
+```
+
+Here is a neat shortcut for commands without parameters:
+
+```c#
+Queue.Make().Publish(() => Foo.Bar());
+// Can be rewritten as...
+Queue.Make().Publish(Foo.Bar);
+```
+
+### Sequentially In a Chain
+
+Chained commands run in the order specified.
+This is useful for when order matters.
+
+Also, if one command in the chain fails, then subsequent commands are not run at all.
+This affords the opportunity to add additional code that records which command failed, then resuming the command chain where it left off.
+
+Here is a an example of how to chain an imaginary file transfer command together:
+
+```c#
+Subject.Publish(new[] {
+    new MyFileTransfer(filePath1),
+    new MyFileTransfer(filePath2),
+    new MyFileTransfer(filePath3),
+});
+```
+
+
+```c#
+Subject.Publish(new List<AbstractCommand>() {
+    new AlwaysSucceed(),
+    new Echo() { VerbatimText = "Hello, world!"},
+});
+```
+
 ### From the Command Line
 
 Commands can be published from the command line as well.
@@ -104,7 +172,7 @@ The **queue:length** command shows a quick summary of pending, in-progress, and
 inengine.exe -pInEngine.Core queue:length
 ```
 
-### Peek at Commands
+### Peek at Queued Commands
 
 The **queue:peek** command allows for queued commands to be inspected: