cjbottaro · cjbottaro · Jul 2, 2019 · Jul 7, 2019 · Jul 7, 2019 · Jul 7, 2019
diff --git a/Architecture.md b/Architecture.md
diff --git a/CHANGELOG.md b/CHANGELOG.md
@@ -1,26 +1,37 @@
 # faktory_worker_ex changes
 
-## 0.8.0
------------
+## 1.0.0
+Detailed info in the linked pull requests.
+
+* Basically an entire rewrite. (PR [#68](https://github.com/cjbottaro/faktory_worker_ex/pull/68))
+* Granular control over starting workers. (PR [#64](https://github.com/cjbottaro/faktory_worker_ex/pull/64))
+* Graceful shutdown. (PR [#43](https://github.com/cjbottaro/faktory_worker_ex/pull/43), [#56](https://github.com/cjbottaro/faktory_worker_ex/pull/56), [#63](https://github.com/cjbottaro/faktory_worker_ex/pull/63))
+* Internally respect "reserve_for" (PR [#63](https://github.com/cjbottaro/faktory_worker_ex/pull/63))
+* --no-start command line option (PR [#62](https://github.com/cjbottaro/faktory_worker_ex/pull/62))
+* Move protocol functions to `Faktory.Client` (PR [#61](https://github.com/cjbottaro/faktory_worker_ex/pull/61))
+* Erlang modules don't expose `__info__/1`. (PR [#58](https://github.com/cjbottaro/faktory_worker_ex/pull/58))
+* Make Faktory.push/2 a low level API. (PR [#57](https://github.com/cjbottaro/faktory_worker_ex/pull/57))
+* Make Faktory.push/2 return errors. (PR [#57](https://github.com/cjbottaro/faktory_worker_ex/pull/57))
 * Use GenStage instead of BlockingQueue. (PR [#36](https://github.com/cjbottaro/faktory_worker_ex/pull/36))
 * Find the right job module when jobtype doesn't match module name. (PR [#35](https://github.com/cjbottaro/faktory_worker_ex/pull/35))
-* Graceful shutdown on SIGTERM. (PR [#41](https://github.com/cjbottaro/faktory_worker_ex/pull/41))
+* Implement Redis Serialization Protocol (RESP). (PR [#40](https://github.com/cjbottaro/faktory_worker_ex/pull/40))
+* Handle `quiet` and `terminate` from Faktory server. (PR [#42](https://github.com/cjbottaro/faktory_worker_ex/pull/42))
+* `priority_queues: false`. See module documentation on `Faktory.Worker`. (PR [#44](https://github.com/cjbottaro/faktory_worker_ex/pull/44))
+* Specify job options on `use Faktory.Job`. (PR [#45](https://github.com/cjbottaro/faktory_worker_ex/pull/45))
+* Support for Elixir 1.9 releases. (PR [#46](https://github.com/cjbottaro/faktory_worker_ex/pull/46))
 * Use Jason instead of Poison.
 
 
 ## 0.7.1
------------
 * Fix `mix faktory` not respecting CLI args.
 
 ## 0.7.0
------------
 * The great simplication refactor; everything done in this version is to reduce conceptual complexity and make the code easier to read and understand.
 * Changed to a queue based architecture (reduces number of connections to Faktory server).
 * No more Genservers, the components of a worker (producer, consumers, reporter) are all supervised tasks. Jobs are also run in tasks (spawned by the consumers).
 * Removed `retryable_ex`; workers will retry when fetching, acking, and failing jobs, but all else is up to the user now.
 
 ## 0.6.0
------------
 * (breaking) Configuration simplified (again); see readme.
 * Can override `jobtype` for enqueuing to workers in other languages.
 * Simplified supervision; removed all custom supervisor modules.
@@ -30,15 +41,13 @@
 * Faktory 0.9.3
 
 ## 0.5.0
------------
 * (breaking) Simplified middleware; no longer pass the `chain` arg.
 * (breaking) Completely rewrote configuration system. See `Faktory.Configuration`.
 * (breaking) Removed `set/1` and `set/2` in favor of passing `options` to `perform_async/2`.
 * (breaking) `perform_async/2` argument order reversed (`options` is 2nd arg now).
 * Can enqueue to different Faktory servers via `perform_async/2`.
 
 ## 0.4.0
------------
 * Faktory 0.6.x support @acj @valo
 * Authentication support @acj
 * TLS support @acj
@@ -48,11 +57,9 @@
 * Update protocol to handle `$-1\r\n` @valo
 
 ## 0.3.0
------------
 * Configure with Mix Config and callback.
 * Independently configurable logger.
 * Connection pooling for workers.
 
 ## 0.2.1
------------
 * Start having a changelog.
diff --git a/README.md b/README.md
@@ -2,102 +2,207 @@
 
 Elixir worker for Faktory ([blog](http://www.mikeperham.com/2017/10/24/introducing-faktory/)) ([github](https://github.com/contribsys/faktory)).
 
-## Installation
+This is an Elixir library, so you should be reading the documentation
+on Hexdocs [here](https://hexdocs.pm/faktory_worker_ex) instead of Github.
+
+## Quickstart
 
-The package can be installed by adding `faktory_worker_ex` to your list of dependencies in `mix.exs`:
 ```elixir
 def deps do
   [
-    {:faktory_worker_ex, "~> 0.0"}
+    {:faktory_worker_ex, "~> 1.0"}
   ]
 end
 ```
 
-## Quickstart
-
 ```elixir
-# For enqueuing jobs
-defmodule MyFaktoryClient do
-  use Faktory.Client, otp_app: :my_cool_app
-end
-
-# For processing jobs
-defmodule MyFaktoryWorker do
-  use Faktory.Worker, otp_app: :my_cool_app
-end
-
-# You must add them to your app's supervision tree
-defmodule MyCoolApp.Application do
-  use Application
+defmodule GreetJob do
+  use Faktory.Job
+  require Logger
 
-  def start(_type, _args) do
-    children = [MyFaktoryClient, MyFaktoryWorker]
-    Supervisor.start_link(children, strategy: :one_for_one)
+  def perform(name) do
+    Logger.info("Hello, #{name}!")
   end
-end
-
-defmodule MyGreeterJob do
-  use Faktory.Job
 
   def perform(greeting, name) do
-    IO.puts("#{greeting}, #{name}!!")
+    Logger.info("#{greeting}, #{name}!")
   end
 end
 
-# List argument must match the arity of MyGreeterJob.perform
-MyGreeterJob.perform_async(["Hello", "Genevieve"])
+# Notice the argument is a list that must have the same arity as one of the perform functions.
+GreetJob.perform_async(["Genevieve"])
+GreetJob.perform_async(["Sup", "my dude"])
 ```
 
-## Starting the worker
+```plain
+$ mix faktory
 
-`mix faktory`
+19:02:23.128 [info]  Hello, Genevieve!
 
-You should see logging output and the above job being processed.
+19:02:23.128 [info]  Sup, my dude!
+```
 
-`mix faktory -h`
+## Connection options
 
-To see command line options that can override in-app configuration.
+By default, both client and worker connections will connect to `localhost:7419`.
+You can change that via `Config`.
 
-`iex -S mix faktory`
+```elixir
+import Config
 
-If you want to debug your jobs using `IEx.pry`.
+config :faktory_worker_ex, Faktory.Connection,
+  host: "faktory.foo.com",
+  port: 8000
+```
 
 ## Configuration
 
-Compile-time config is done with `Mix.Config`.
+This library is massively configurable. It was meant to be used in large
+umbrella applications and with multiple Faktory servers.
+
+Most modules let you `use` them to make specific and individually configurable
+modules.
 
-Run-time config is done with environment variables and/or an `init/1` callback.
+There is a hierarchy to configuration. Arguments to `start_link` override all,
+`Config` overrides `use` arguments (for runtime configuration via `runtime.exs`),
+and specific modules override the base modules.
 
-See documentation on:
-* [Client](https://hexdocs.pm/faktory_worker_ex/Faktory.Client.html)
-* [Worker](https://hexdocs.pm/faktory_worker_ex/Faktory.Worker.html)
+```elixir
+import Config
+
+config :faktory_worker_ex, Faktory.Client, host: "foo",
+
+defmodule MyClient do
+  use Faktory.Client, host: "bar"
+end
+
+# Connect to "foo"
+{:ok, client} = Faktory.Client.start_link()
+
+# Connect to "bar"
+{:ok, client} = Faktory.Client.start_link(host: "bar")
+
+# Connect to "bar"
+MyClient.start_link()
+
+# Connect to "baz"
+MyClient.start_link(host: "baz")
+```
+
+All the configuration options are deep merged according to the hierarchy rules.
 
 ## Running a Faktory server
 
-To run this readme's example, you need to run a Faktory server.
+To run the quickstart example, you need to run a Faktory server.
 
-Easiest way is with Docker:
+Easiest way is with Docker.
 ```
 docker run --rm -p 7419:7419 -p 7420:7420 contribsys/faktory:latest -b :7419 -w :7420
 ```
 
 You should be able to go to [http://localhost:7420](http://localhost:7420) and see the web ui.
 
+## Using with multiple Faktory servers
+
+```elixir
+import Config
+
+config :my_app, FooClient,
+  host: "foo-faktory.myapp.com"
+
+config :my_app, BarClient,
+  host: "bar-faktory.myapp.com"
+
+config :my_app, FooWorker,
+  host: "foo-faktory.myapp.com"
+
+config :my_app, BarWorker,
+  host: "bar-faktory.myapp.com"
+
+defmodule FooClient do
+  use Faktory.Client
+end
+
+defmodule BarClient do
+  use Faktory.Client
+end
+
+defmodule FooWorker do
+  use Faktory.Worker
+end
+
+defmodule BarWorker do
+  use Faktory.Worker
+end
+
+defmodule FooJob do
+  use Faktory.Job, client: FooClient
+  def perform(), do: nil
+end
+
+defmodule BarJob do
+  use Faktory.Job, client: BarClient
+  def perform(), do: nil
+end
+
+FooJob.perform_async([]) # Enqueues job to Faktory server at foo-faktory.myapp.com
+BarJob.perform_async([]) # Enqueues job to Faktory server at bar-faktory.myapp.com
+```
+
+Be sure to add your workers to your application's supervision tree.
+```elixir
+defmodule MyApp.Application do
+  use Application
+
+  def start(_type, _args) do
+    children = [
+      FooWorker,
+      BarWorker,
+    ]
+
+    Supervisor.start_link(children, strategy: :one_for_one)
+  end
+end
+```
+
+And disable the default worker.
+```
+use Config
+
+config :faktory_worker_ex, Faktory.DefaultWorker, start: false
+```
+
+## Starting individual workers
+
+You can do this on the command line.
+```
+mix faktory --only FooWorker,BarWorker
+mix faktory --only FooWorker --only BarWorker
+
+mix faktory --except FooWorker,BarWorker
+mix faktory --except FooWorker --except BarWorker
+```
+
+Or you can tell a worker to start (or not start) via `Config`.
+```elixir
+import Config
+
+# Will start regardless of `mix faktory`
+config :my_app, FooWorker, start: true
+
+# Will not start regardless of `mix faktory`
+config :my_app, BarWorker, start: false
+```
+
 ## Features
 
 * Middleware
-* Connection pooling (for clients)
+* Connection pooling
 * Support for multiple Faktory servers
-* Faktory server authentication and TLS support
+* Supports 100% of Faktory features
 * Comprehensive documentation
-* Comprehensive supervision tree
 * Decent integration tests
 
-## Missing features
-
-* Responding to `quiet` and `terminate`
-* Running without `mix` (e.g. a Distillery release)
-
 ## Issues / Questions
 
 [https://github.com/cjbottaro/faktory_worker_ex/issues](https://github.com/cjbottaro/faktory_worker_ex/issues)