     result
   end
 
-  def handle_cast(:run, state(module: module, done_jobs: done_jobs, running?: false) = s) do
+  def handle_cast(:run, state(module: module, done_jobs: done_jobs, running?: false, overrides: overrides) = s) do
     update_status(:preparing, s)
     lc {_, _, _, job} inlist done_jobs, do: Hypnotoad.Job.done(job)
     # Start jobs
+    :ets.delete(overrides)
     Enum.each(Hypnotoad.Hosts.hosts, fn({host, _}) ->
       try do
         :gproc_ps.subscribe(:l, {Hypnotoad.Job, host, :success})

        end
        {:noreply, state(s, jobs: jobs, done_jobs: done_jobs, running?: jobs != [], failed: failed || (status == :failed))}
      nil ->
        L.error "Job ${module} ${options} on host ${host} reported status ${status} but was not in the list of pending jobs", module: module, options: options, status: status, host: host
        {:noreply, s}
    end 
  end

    :gen_server.cast(server, :run)
  end

  defrecordp :state, module: nil, jobs: [], done_jobs: [], running?: false, failed: false, overrides: nil

  def init(opts) do
    :gproc.add_local_property(__MODULE__, Keyword.put(opts, :status, :ready))
    {:ok, state(module: opts[:module], overrides: :ets.new(__MODULE__.Overrides, []))}
  end

  def handle_call(:module, _from, state(module: module) = s) do
    {:reply, module, s}
  end

  defp start_module(host, module, args, overrides) do
    Process.put(:host, host)
    result = if module.before_filter(args) do
      reqs = module.requirements(args) ++ Enum.map(:ets.lookup(overrides, {module, args}), fn({_, {m, a}}) ->
        {m, a, nil}
      end)
      Enum.each(reqs, fn({req_mod, req_args, parent}) ->
        if parent do
          :ets.insert(overrides, {{req_mod, req_args}, parent})
        end
      end)
      requirements = Enum.reduce(reqs, [], fn({req_mod, req_args, _parent}, acc) ->
        if start_module(host, req_mod, req_args, overrides) do
          [{req_mod, req_args}|acc]
        else
          acc
