diff --git a/app/controllers/hosts_controller.rb b/app/controllers/hosts_controller.rb
index 3129107..0b6e1b6 100644
--- a/app/controllers/hosts_controller.rb
+++ b/app/controllers/hosts_controller.rb
@@ -1,122 +1,133 @@
 class HostsController < ApplicationController
   before_action :require_logged_in
   before_action :fetch_host, only: [:show, :edit, :update, :destroy, :submit_config,
-                                    :revoke, :restore, :run_restore]
+                                    :revoke, :restore, :run_restore, :disable]
   before_action :fetch_hosts_of_user, only: [:new, :edit, :create]
 
   # GET /hosts/new
   def new
     @host = Host.new
     @host.port = 9102
   end
 
   # POST /hosts
   def create
     @host = Host.new(fetch_params)
 
     @host.verified = current_user.needs_host_list?
 
     if user_can_add_this_host? && @host.save
       flash[:success] = 'Host created successfully'
       current_user.hosts << @host
       redirect_to host_path @host
     else
       flash[:error] = 'Host was not created'
       render :new
     end
   end
 
   # GET /hosts/1
   def show
     @schedules = @host.job_templates.map(&:schedule)
     @filesets = @host.job_templates.map(&:fileset)
   end
 
   # GET /hosts/1/edit
   def edit; end
 
   # PATCH /hosts/1
   def update
     updates = fetch_params.slice(:port, :password)
     if updates.present? && @host.update_attributes(updates)
       @host.recalculate
       flash[:success] = 'Host updated successfully. You must update your file deamon accordingly.'
       redirect_to host_path @host
     else
       render :edit
     end
   end
 
   # DELETE /hosts/1
   def destroy
     if @host.destroy
       flash[:success] = 'Host destroyed successfully'
     else
       flash[:error] = 'Host not destroyed'
     end
 
     redirect_to root_path
   end
 
+  # POST /hosts/1/disable
+  def disable
+    if @host.disable_jobs_and_update
+      flash[:success] = 'Client disabled'
+    else
+      flash[:error] = 'Something went wrong, try again later'
+    end
+
+    redirect_to host_path(@host)
+  end
+
   # POST /hosts/1/submit_config
   def submit_config
     if @host.dispatch_to_bacula
       flash[:success] = 'Host configuration sent to Bacula successfully'
     else
       flash[:error] = 'Something went wrong, try again later'
     end
 
     redirect_to host_path(@host)
   end
 
   # DELETE /hosts/1/revoke
   def revoke
     if @host.remove_from_bacula
       flash[:success] = 'Host configuration removed from Bacula successfully'
     else
       flash[:error] = 'Something went wrong, try again later'
     end
 
     redirect_to root_path
   end
 
   # GET /hosts/1/restore
   def restore
     if !@host.restorable?
       flash[:error] = "Can not issue a restore for this client"
       redirect_to @host.client.present? ? client_path(@host.client) : root_path
     end
   end
 
   # POST /hosts/1/run_estore
   def run_restore
     location = params[:restore_location]
     if location.present? && @host.restore(location)
       flash[:success] = "Restore job issued successfully, files will be soon available in #{location}"
     else
       flash[:error] = 'Something went wrong, try again later'
     end
 
     redirect_to client_path(@host.client)
   end
 
   private
 
   def fetch_hosts_of_user
     return if not current_user.needs_host_list?
 
     @hosts_of_user = session[:vms] - current_user.hosts.pluck(:fqdn)
   end
 
   def fetch_host
     @host = current_user.hosts.includes(job_templates: [:fileset, :schedule]).find(params[:id])
   end
 
   def fetch_params
     params.require(:host).permit(:fqdn, :port, :password)
   end
 
   def user_can_add_this_host?
     !current_user.needs_host_list? || @hosts_of_user.include?(@host.fqdn)
   end
 end
diff --git a/app/helpers/hosts_helper.rb b/app/helpers/hosts_helper.rb
index 80055c5..6465429 100644
--- a/app/helpers/hosts_helper.rb
+++ b/app/helpers/hosts_helper.rb
@@ -1,23 +1,25 @@
 module HostsHelper
   # Returns an html span with the host's status
   def host_status_label(host)
     case
     when host.pending?
       klass = "default"
     when host.configured?
       klass = "warning"
     when host.dispatched?
       klass = "info"
     when host.deployed?
       klass = "success"
     when host.updated?
       klass = "info"
     when host.redispatched?
       klass = "primary"
     when host.for_removal?
       klass = "danger"
+    when host.inactive?
+      klass = "warning"
     end
 
     content_tag(:span, class: "label label-#{klass}") { host.human_status_name.upcase }
   end
 end
diff --git a/app/models/host.rb b/app/models/host.rb
index ef789d4..f913c96 100644
--- a/app/models/host.rb
+++ b/app/models/host.rb
@@ -1,272 +1,291 @@
 # The bacula database must be independent from all of our application logic.
 # For this reason we have Host which is the application equivalent of a Bacula Client.
 #
 # A host is being created from our application. When it receives all the configuration
 # which is required it gets dispatched to bacula through some configuration files. After
 # that, a client with the exact same config is generated by bacula.
 class Host < ActiveRecord::Base
   STATUSES = {
     pending: 0,
     configured: 1,
     dispatched: 2,
     deployed: 3,
     updated: 4,
     redispatched: 5,
-    for_removal: 6
+    for_removal: 6,
+    inactive: 7
   }
 
   has_many :ownerships
   has_many :users, through: :ownerships, inverse_of: :hosts
 
   belongs_to :client, class_name: :Client, foreign_key: :name, primary_key: :name
   belongs_to :verifier, class_name: :User, foreign_key: :verifier_id, primary_key: :id
 
   has_many :filesets, dependent: :destroy
   has_many :job_templates, dependent: :destroy
   has_many :schedules, dependent: :destroy
 
   validates :file_retention, :job_retention,
     :port, :password, presence: true
   validates :port, numericality: true
 
   validates :fqdn, presence: true, uniqueness: true
 
   validate :fqdn_format
 
   scope :not_baculized, -> {
     joins("left join Client on Client.Name = hosts.name").where(Client: { Name: nil })
   }
   scope :unverified, -> { where(verified: false) }
 
   before_validation :set_retention, :unset_baculized, :sanitize_name
 
   state_machine :status, initial: :pending do
     STATUSES.each do |status_name, value|
       state status_name, value: value
     end
 
     after_transition [:dispatched, :redispatched, :configured, :updated] => :deployed do |host|
       host.job_templates.enabled.
         update_all(baculized: true, baculized_at: Time.now, updated_at: Time.now)
     end
 
     event :add_configuration do
-      transition [:pending, :dispatched] => :configured
+      transition [:pending, :dispatched, :inactive] => :configured
     end
 
     event :dispatch do
       transition :configured => :dispatched
     end
 
     event :redispatch do
       transition :updated => :redispatched
     end
 
     event :set_deployed do
       transition [:dispatched, :redispatched, :configured, :updated] => :deployed
     end
 
     event :change_deployed_config do
       transition [:deployed, :redispatched, :for_removal] => :updated
     end
 
     event :mark_for_removal do
       transition [:dispatched, :deployed, :updated, :redispatched] => :for_removal
     end
 
+    event :set_inactive do
+      transition [:deployed, :dispatched, :updated, :redispatched] => :inactive
+    end
+
     event :disable do
       transition all => :pending
     end
   end
 
   # Constructs the final Bacula configuration for the host by appending configs for
   #
   # * Client
   # * Jobs
   # * Schedules
   # * Filesets
   #
   # by calling their `to_bacula_config_array` methods.
   #
   # @return [Array] containing each element's configuration line by line
   def baculize_config
     templates = job_templates.includes(:fileset, :schedule)
 
     result = [self] + templates.map {|x| [x, x.fileset, x.schedule] }.flatten.compact.uniq
     result.map(&:to_bacula_config_array)
   end
 
   # Constructs the final Bacula configuration for the host by appending configs for
   #
   # * Client
   # * Jobs
   # * Schedules
   # * Filesets
   #
   # by calling their `to_bacula_config_array` methods.
   #
   # It hides the password.
   #
   # @return [Array] containing each element's configuration line by line
   def baculize_config_no_pass
     baculize_config.join("\n").gsub(/Password = ".*"$/, 'Password = "*************"')
   end
 
   # Constructs an array where each element is a line for the Client's bacula config
   #
   # @return [Array]
   def to_bacula_config_array
     [
       "Client {",
       "  Name = #{name}",
       "  Address = #{fqdn}",
       "  FDPort = #{port}",
       "  Catalog = #{client_settings[:catalog]}",
       "  Password = \"#{password}\"",
       "  File Retention = #{file_retention} #{file_retention_period_type}",
       "  Job Retention = #{job_retention} #{job_retention_period_type}",
       "  AutoPrune = #{auto_prune_human}",
       "}"
     ]
   end
 
   # Shows the host's auto_prune setting
   def auto_prune_human
     client_settings[:autoprune]
   end
 
   # Uploads the host's config to bacula
   # Reloads bacula server
   #
   # It updates the host's status accordingly
   def dispatch_to_bacula
     return false if not needs_dispatch?
     bacula_handler.deploy_config
   end
 
   # Removes a Host from bacula configuration.
   # Reloads bacula server
   #
   # If all go well it changes the host's status and returns true
   def remove_from_bacula
     return false unless needs_revoke?
     bacula_handler.undeploy_config
   end
 
   # Restores a host's backup to a preselected location
   #
   # @param location[String] the desired restore location
   def restore(location)
     return false if not restorable?
     bacula_handler.restore(location)
   end
 
   # Runs the given backup job ASAP
   def backup_now(job_name)
     bacula_handler.backup_now(job_name)
   end
 
+  # Disables all jobs and sends the configuration to Bacula
+  def disable_jobs_and_update
+    job_templates.update_all(enabled: false)
+    bacula_handler.deploy_config
+  end
+
   # Determinex weather a host:
   #
   # * has all it takes to be deployed but
   # * the config is not yet sent to bacula
   #
   # @return [Boolean]
   def needs_dispatch?
     verified? && (can_dispatch? || can_redispatch?)
   end
 
   # Determines weather a host is marked for removal
   #
   # @return [Boolean]
   def needs_revoke?
     for_removal?
   end
 
   # Handles the host's job changes by updating the host's status
   def recalculate
     add_configuration || change_deployed_config
   end
 
   # Fetches an info message concerning the host's deploy status
   def display_message
     if !verified?
       { message: 'Your host needs to be verified by an admin', severity: :alert }
     elsif pending?
       { message: 'client not configured yet', severity: :alert }
     elsif configured? || dispatched?
       { message: 'client not deployed to Bacula', severity: :alert }
     elsif updated? || redispatched?
       { message: 'client configuration changed, deploy needed', severity: :alert }
     elsif for_removal?
       { message: 'pending client configuration withdraw', severity: :error }
     elsif inactive?
       { message: 'client disabled', severity: :alert }
     end
   end
 
   # Determines if a host can issue a restore job.
   #
   # @returns [Boolean] true if the host's client can issue a restore job
   def restorable?
     client.present? && client.is_backed_up?
   end
 
   # @return [User] the first of the host's users
   def first_user
     users.order('ownerships.created_at asc').first
   end
 
   # Marks the host as verified and sets the relevant metadata
   #
   # @param admin_verifier[Integer] the verifier's id
   def verify(admin_verifier)
     self.verified = true
     self.verifier_id = admin_verifier
     self.verified_at = Time.now
     save
   end
 
+  # Determines if a host can be disabled or not.
+  # Equivalent to is_deployed
+  #
+  # @return [Boolean]
+  def can_be_disabled?
+    dispatched? || deployed? || updated? || redispatched?
+  end
+
   private
 
   # automatic setters
 
   def sanitize_name
     self.name = fqdn
   end
 
   # Sets the file and job retention according to the global settings
   def set_retention
     self.file_retention = client_settings[:file_retention]
     self.file_retention_period_type = client_settings[:file_retention_period_type]
     self.job_retention = client_settings[:job_retention]
     self.job_retention_period_type = client_settings[:job_retention_period_type]
   end
 
   def unset_baculized
     self.baculized = false if new_record?
     true
   end
 
   # validation
 
   def fqdn_format
     regex = /(?=^.{4,253}$)(^((?!-)[a-zA-Z0-9-]{1,63}(?<!-)\.)+[a-zA-Z]{2,63}$)/
     unless fqdn =~ regex
       self.errors.add(:fqdn)
     end
   end
 
   # Proxy object for handling bacula directives
   def bacula_handler
     BaculaHandler.new(self)
   end
 
   # Fetches and memoizes the general configuration settings for Clients
   #
   # @see ConfigurationSetting.current_client_settings
   # @return [Hash] containing the settings
   def client_settings
     @client_settings ||= ConfigurationSetting.current_client_settings
   end
 end
diff --git a/app/views/hosts/show.html.erb b/app/views/hosts/show.html.erb
index daaa70d..f8aef61 100644
--- a/app/views/hosts/show.html.erb
+++ b/app/views/hosts/show.html.erb
@@ -1,34 +1,41 @@
 <%= notifier(@host.display_message) unless @host.deployed? %>
 
 <div class="row right">
-  <%= link_to 'Remove host', host_path(@host), method: :delete, data: { confirm: 'Are you sure?' },
+  <% if @host.can_be_disabled? %>
+    <%= link_to 'Disable client', disable_host_path(@host), method: :post,
+      data: { confirm: 'This will disable the client. Are you sure?' },
+      class: "btn btn-warning", role: "button" %>
+  <% end %>
+
+  <%= link_to 'Remove client', host_path(@host), method: :delete,
+    data: { confirm: 'This will remove the client from Bacula. Are you sure?' },
     class: "btn btn-danger", role: "button" %>
 </div>
 
 <h2>Configuration for <%= @host.name %>
   <small><%= host_status_label(@host) %></small>
 </h2>
 
 <br/>
 
 <div class="row">
   <div class="col-xs-4">
     <h3>Host Details</h3>
   </div>
   <div class="col-xs-6">
     <h3>Jobs</h3>
   </div>
 </div>
 <div class="row">
   <%= render partial: "host_details" %>
   <%= render partial: "jobs/job_templates" %>
 
   <div class="col-xs-6">
     <h3>Config File</h3>
     <pre class="pre-scrollable">
 <%= @host.baculize_config_no_pass %>
     </pre>
   </div>
 </div>
 
 <%= render partial: 'jobs/modals' %>
diff --git a/config/routes.rb b/config/routes.rb
index 4d1cd47..c8c0de6 100644
--- a/config/routes.rb
+++ b/config/routes.rb
@@ -1,71 +1,72 @@
 Rails.application.routes.draw do
   root 'application#index'
   post 'login' => 'application#login'
   match 'vima', to: 'application#vima', :via => [:get, :post]
   get 'logout' => 'application#logout'
 
   resources :clients, only: [:index, :show] do
     member do
       get :jobs
       get :logs
       get :stats
       post :stats
       get :users
     end
 
     collection do
       post :index
     end
   end
 
   resources :hosts, only: [:new, :create, :show, :edit, :update, :destroy] do
     member do
       post :submit_config
       get :restore
       post :run_restore
+      post :disable
       delete :revoke
     end
 
     resources :jobs, only: [:new, :create, :show, :edit, :update, :destroy] do
       member do
         patch :toggle_enable
         post :backup_now
       end
     end
 
     resources :filesets, only: [:show, :new, :create, :destroy]
     resources :schedules, only: [:show, :new, :edit, :create, :update, :destroy]
   end
 
   namespace :admin do
     match '/', to: 'base#index', via: [:get, :post]
 
     resources :settings, only: [:index, :new, :create, :edit, :update] do
       member do
         delete :reset
       end
     end
 
     resources :clients, only: [:index, :show] do
       member do
         get :jobs
         get :logs
         get :stats
         post :stats
         get :configuration
       end
     end
 
     resources :hosts, only: [:show] do
       collection do
         get :unverified
       end
 
       member do
         post :verify
       end
     end
 
     resources :users, only: [:index]
   end
 end
diff --git a/lib/bacula_handler.rb b/lib/bacula_handler.rb
index 34778d3..29e8bd9 100644
--- a/lib/bacula_handler.rb
+++ b/lib/bacula_handler.rb
@@ -1,184 +1,188 @@
 class BaculaHandler
   require 'net/scp'
 
   attr_accessor :host, :templates, :client, :jobs, :schedules, :filesets
 
   # Initializes a BaculaHandler instance.
   #
   # Sets `host` and `templates` attributes.
   # Sets the temporal files that contain the client's configuration
   #
   # @param host[Host] A the host instance the the bacula handler will act upon
   def initialize(host)
     @host = host
     @templates = host.job_templates.includes(:fileset, :schedule)
 
     @client = get_client_file
     @jobs = get_jobs_file
     @schedules = get_schedules_file
     @filesets = get_filesets_file
   end
 
   # Deploys the host's config to the bacula director by
   #
   # * uploading the configuration
   # * reloadind the bacula director
   #
   # Updates the host's status accordingly
   #
   # @return [Boolean] false if something went wrong
   def deploy_config
     return false unless send_config
     if reload_bacula
-      host.set_deployed
+      if host.job_templates.enabled.any?
+        host.set_deployed
+      else
+        host.set_inactive
+      end
     else
       host.dispatch || host.redispatch
     end
   end
 
   # Removes the host's configuration from the bacula director by
   #
   # * removing the host's configuration files
   # * reloading the bacula director
   #
   # Updates the host's status accordingly
   #
   # @return [Boolean] false if something went wrong
   def undeploy_config
     return false unless remove_config
     host.disable if reload_bacula
   end
 
   # Schedules an immediate backup to the bacula director for the given host and job
   #
   # @param job_name[String] the job's name
   def backup_now(job_name)
     job = host.job_templates.enabled.find_by(name: job_name)
     return false unless job
     command = "echo \"run job=\\\"#{job.name_for_config}\\\" yes\" | #{bconsole}"
     log(command)
     exec_with_timeout(command, 2)
   end
 
   # Schedules an immediate restore to the bacula director for the given host.
   #
   # @param location[String] the desired restore location
   def restore(location="/tmp/bacula-restore")
     command = "echo \"restore client=\\\"#{host.name}\\\" where=\\\"#{location}\\\" select current all done yes\" | #{bconsole}"
     log(command)
     exec_with_timeout(command, 2)
   end
 
   private
 
   def get_client_file
     file = a_tmpfile
     file.write host.to_bacula_config_array.join("\n")
     file.close
     file
   end
 
   def get_jobs_file
     file = a_tmpfile
     file.write templates.map(&:to_bacula_config_array).join("\n")
     file.close
     file
   end
 
   def get_schedules_file
     file = a_tmpfile
     file.write templates.map(&:schedule).uniq.map(&:to_bacula_config_array).join("\n")
     file.close
     file
   end
 
   def get_filesets_file
     file = a_tmpfile
     file.write templates.map(&:fileset).uniq.map(&:to_bacula_config_array).join("\n")
     file.close
     file
   end
 
   def send_config
     begin
       Net::SCP.upload!(
         ssh_settings[:host],
         ssh_settings[:username],
         client.path,
         ssh_settings[:path] + 'clients/' + host.name + '.conf',
         ssh: { keys: [ssh_settings[:key_file]] }
       )
       Net::SCP.upload!(
         ssh_settings[:host],
         ssh_settings[:username],
         jobs.path,
         ssh_settings[:path] + 'jobs/' + host.name + '.conf',
         ssh: { keys: [ssh_settings[:key_file]] }
       )
       Net::SCP.upload!(
         ssh_settings[:host],
         ssh_settings[:username],
         schedules.path,
         ssh_settings[:path] + 'schedules/' + host.name + '.conf',
         ssh: { keys: [ssh_settings[:key_file]] }
       )
       Net::SCP.upload!(
         ssh_settings[:host],
         ssh_settings[:username],
         filesets.path,
         ssh_settings[:path] + 'filesets/' + host.name + '.conf',
         ssh: { keys: [ssh_settings[:key_file]] }
       )
     rescue
       return false
     end
     true
   end
 
   def remove_config
     begin
       Net::SSH.start(ssh_settings[:host], ssh_settings[:username],
                      keys: ssh_settings[:key_file]) do |ssh|
         ssh.exec!("rm #{ssh_settings[:path]}*/#{host.name}.conf")
       end
     rescue
       return false
     end
     true
   end
 
   def reload_bacula
     command = "echo \"reload quit\" | #{bconsole}"
     exec_with_timeout(command, 2)
   end
 
   def exec_with_timeout(command, sec)
     begin
       Timeout::timeout(sec) do
         `#{command}`
       end
     rescue
       return false
     end
     true
   end
 
   def bconsole
     "bconsole -c #{Rails.root}/config/bconsole.conf"
   end
 
   def ssh_settings
     @ssh_settings ||= YAML::load(File.open("#{Rails.root}/config/ssh.yml"))[Rails.env].
       symbolize_keys
   end
 
   def a_tmpfile
     file = Tempfile.new(host.name)
     file.chmod(0666)
     file
   end
 
   def log(msg)
     Rails.logger.warn("[BaculaHandler]: #{msg}")
   end
 end
diff --git a/spec/models/host_spec.rb b/spec/models/host_spec.rb
index 154928d..38b3592 100644
--- a/spec/models/host_spec.rb
+++ b/spec/models/host_spec.rb
@@ -1,288 +1,290 @@
 require 'spec_helper'
 
 describe Host do
   context 'validates' do
     it "presence of Password" do
         expect(Host.new).to have(1).errors_on(:password)
     end
 
     it 'numericality of :port' do
       expect(Host.new(port: :lala)).to have(2).errors_on(:port)
     end
 
     [:file_retention, :job_retention, :name].each do |field|
       it "#{field} is set automatically" do
         host = Host.new(fqdn: 'test')
         host.valid?
         expect(host.send(field)).to be_present
       end
     end
   end
 
   context 'when fqdn is invalid' do
     let(:host) { FactoryGirl.build(:host, fqdn: :lala) }
 
     it 'has errors' do
       expect(host).to have(1).errors_on(:fqdn)
     end
   end
 
   context 'name field' do
     let(:host) { FactoryGirl.create(:host, name: nil) }
     it 'is generated by the system' do
       expect(host.name).to be
     end
   end
 
   describe '#to_bacula_config_array' do
     let(:host) { FactoryGirl.create(:host) }
 
     it "is a valid client directive" do
       expect(host.to_bacula_config_array).to include('Client {')
       expect(host.to_bacula_config_array).to include('}')
     end
 
     it "contains Address directive" do
       expect(host.to_bacula_config_array).to include("  Address = #{host.fqdn}")
     end
 
     it "contains FDPort directive" do
       expect(host.to_bacula_config_array).to include("  FDPort = #{host.port}")
     end
 
     it "contains Catalog directive" do
       expect(host.to_bacula_config_array).
         to include("  Catalog = #{ConfigurationSetting.current_client_settings[:catalog]}")
     end
 
     it "contains Password directive" do
       expect(host.to_bacula_config_array).to include("  Password = \"#{host.password}\"")
     end
 
     it "contains File Retention directive" do
       expect(host.to_bacula_config_array).
         to include("  File Retention = #{host.file_retention} days")
     end
 
     it "contains Job Retention directive" do
       expect(host.to_bacula_config_array).
         to include("  Job Retention = #{host.job_retention} days")
     end
 
     it "contains AutoPrune directive" do
       expect(host.to_bacula_config_array).to include("  AutoPrune = yes")
     end
   end
 
   describe '#baculize_config' do
     let!(:host) { FactoryGirl.create(:host) }
 
     let!(:fileset) { FactoryGirl.create(:fileset, host: host) }
     let!(:other_fileset) { FactoryGirl.create(:fileset, host: host) }
 
     let!(:schedule) { FactoryGirl.create(:schedule) }
     let!(:other_schedule) { FactoryGirl.create(:schedule) }
 
     let!(:enabled_job) do
       FactoryGirl.create(:job_template, host: host, schedule: schedule,
                          fileset: fileset, enabled: true)
     end
     let!(:disabled_job) do
       FactoryGirl.create(:job_template, host: host, schedule: other_schedule,
                          fileset: other_fileset, enabled: false)
     end
 
     subject { host.baculize_config }
 
     it 'includes the client\'s config' do
       expect(subject).to include(host.to_bacula_config_array)
     end
 
     it 'includes the all the job template\'s configs' do
       expect(subject).to include(enabled_job.to_bacula_config_array)
       expect(subject).to include(disabled_job.to_bacula_config_array)
     end
 
     it 'includes all the used schedules\'s configs' do
       expect(subject).to include(schedule.to_bacula_config_array)
       expect(subject).to include(other_schedule.to_bacula_config_array)
     end
 
     it 'includes all the used filesets\'s configs' do
       expect(subject).to include(fileset.to_bacula_config_array)
       expect(subject).to include(other_fileset.to_bacula_config_array)
     end
   end
 
   describe '#dispatch_to_bacula' do
     let(:configured_host) { FactoryGirl.create(:host, :configured) }
     let(:updated_host) { FactoryGirl.create(:host, :updated) }
 
     context 'for non verified hosts' do
       let(:unverified_host) { FactoryGirl.create(:host, :configured) }
 
       it 'returns false' do
         expect(unverified_host.dispatch_to_bacula).to eq(false)
       end
     end
 
     it 'calls BaculaHandler#deploy_config' do
       BaculaHandler.any_instance.should_receive(:deploy_config)
       configured_host.dispatch_to_bacula
     end
 
     context 'when the config does not reach bacula' do
       before do
         BaculaHandler.any_instance.should_receive(:send_config) { false }
       end
 
       it 'returns false' do
         expect(configured_host.dispatch_to_bacula).to eq(false)
       end
 
       it 'does not change the status of a configured host' do
         expect { configured_host.dispatch_to_bacula }.
           to_not change { configured_host.reload.status }
       end
 
       it 'does not change the status of an updated host' do
         expect { updated_host.dispatch_to_bacula }.
           to_not change { updated_host.reload.status }
       end
     end
 
     context 'when the config is sent to bacula' do
       before do
         BaculaHandler.any_instance.should_receive(:send_config) { true }
       end
 
       context 'and bacula gets reloaded' do
         before do
           BaculaHandler.any_instance.should_receive(:reload_bacula) { true }
         end
 
         it 'makes the configured host deployed' do
           configured_host.dispatch_to_bacula
           expect(configured_host.reload).to be_deployed
         end
 
         it 'makes the updated host deployed' do
           updated_host.dispatch_to_bacula
           expect(updated_host.reload).to be_deployed
         end
       end
 
       context 'but bacula fails to reload' do
         before do
           BaculaHandler.any_instance.should_receive(:reload_bacula) { false }
         end
 
         it 'makes the configured host dispatcheda' do
           configured_host.dispatch_to_bacula
           expect(configured_host.reload).to be_dispatched
         end
 
         it 'makes the updated host redispatched' do
           updated_host.dispatch_to_bacula
           expect(updated_host.reload).to be_redispatched
         end
       end
     end
   end
 
   describe '#remove_from_bacula' do
     let(:host) { FactoryGirl.create(:host, status: Host::STATUSES[:for_removal]) }
 
     context 'when the config is NOT removed from bacula' do
       before { BaculaHandler.any_instance.should_receive(:remove_config) { false } }
 
       it 'returns false' do
         expect(host.remove_from_bacula).to eq(false)
       end
 
       it 'does not alter the host\'s status' do
         expect { host.remove_from_bacula }.
           to_not change { host.reload.status }
       end
     end
 
     context 'when the config is removed from bacula' do
       before { BaculaHandler.any_instance.should_receive(:remove_config) { true } }
 
       context 'and bacula gets reloaded' do
         before { BaculaHandler.any_instance.should_receive(:reload_bacula) { true } }
 
         it 'returns true' do
           expect(host.remove_from_bacula).to eq(true)
         end
 
         it 'changes the host\'s status to pending' do
           expect { host.remove_from_bacula }.
             to change { host.reload.human_status_name }.from('for removal').to('pending')
         end
       end
     end
   end
 
   describe '#recalculate' do
     let(:host) { FactoryGirl.create(:host, :with_enabled_jobs) }
 
     [:configured, :updated].each do |status|
       context "a #{status} host" do
         before { host.update_column(:status, Host::STATUSES[status]) }
 
         it "stays #{status}" do
           expect { host.recalculate }.to_not change { host.reload.status }
         end
       end
     end
 
-    context 'a pending host' do
-      before { host.update_column(:status, Host::STATUSES[:pending]) }
+    [:pending, :dispatched, :inactive].each do |status|
+      context "a #{status} host" do
+        before { host.update_column(:status, Host::STATUSES[status]) }
 
-      it 'becomes configured' do
-        expect { host.recalculate }.
-          to change { host.reload.human_status_name }.
-          from('pending').to('configured')
+        it 'becomes configured' do
+          expect { host.recalculate }.
+            to change { host.reload.human_status_name }.
+            from(host.human_status_name).to('configured')
+        end
       end
     end
 
     context 'a dispatched host' do
       before { host.update_column(:status, Host::STATUSES[:dispatched]) }
 
       it 'becomes configured' do
         expect { host.recalculate }.
           to change { host.reload.human_status_name }.
           from('dispatched').to('configured')
       end
     end
 
     [:deployed, :redispatched, :for_removal].each do |status|
       context "a #{status} host" do
         before { host.update_column(:status, Host::STATUSES[status]) }
 
         it 'becomes updated' do
           expect { host.recalculate }.
             to change { host.reload.human_status_name }.
             from(host.human_status_name).to('updated')
         end
       end
     end
   end
 
   describe '#verify' do
     let!(:host) { FactoryGirl.create(:host, verified: false) }
     let(:admin) { FactoryGirl.create(:user, :admin) }
 
     it 'verifies host' do
       host.verify(admin.id)
       expect(host).to be_verified
     end
 
     it 'sets the verification credentials' do
       host.verify(admin.id)
       expect(host.verifier_id).to eq(admin.id)
       expect(host.verified_at).not_to be nil
     end
   end
 end
diff --git a/spec/routing/host_routing_spec.rb b/spec/routing/host_routing_spec.rb
index 60de023..8507964 100644
--- a/spec/routing/host_routing_spec.rb
+++ b/spec/routing/host_routing_spec.rb
@@ -1,47 +1,52 @@
 require 'spec_helper'
 
 describe HostsController do
   it 'routes GET /hosts/new' do
     expect(get('/hosts/new')).to route_to(controller: 'hosts', action: 'new')
   end
 
   it 'routes POST /hosts' do
     expect(post('/hosts')).to route_to(controller: 'hosts', action: 'create')
   end
 
   it 'routes GET /hosts/1' do
     expect(get('/hosts/1')).to route_to(controller: 'hosts', action: 'show', id: '1')
   end
 
   it 'routes GET /hosts/1/edit' do
     expect(get('/hosts/1/edit')).to route_to(controller: 'hosts', action: 'edit', id: '1')
   end
 
   it 'routes PUT /hosts/1' do
     expect(put('/hosts/1')).to route_to(controller: 'hosts', action: 'update', id: '1')
   end
 
   it 'routes DELETE /hosts/1' do
     expect(delete('/hosts/1')).to route_to(controller: 'hosts', action: 'destroy', id: '1')
   end
 
   it 'routes POST /hosts/1/submit_config' do
     expect(post('/hosts/1/submit_config')).
       to route_to(controller: 'hosts', action: 'submit_config', id: '1')
   end
 
+  it 'routes POST /hosts/1/disable' do
+    expect(post('/hosts/1/disable')).
+      to route_to(controller: 'hosts', action: 'disable', id: '1')
+  end
+
   it 'routes DELETE /hosts/1/revoke' do
     expect(delete('/hosts/1/revoke')).
       to route_to(controller: 'hosts', action: 'revoke', id: '1')
   end
 
   it 'routes POST /hosts/1/restore' do
     expect(post('/hosts/1/run_restore')).
       to route_to(controller: 'hosts', action: 'run_restore', id: '1')
   end
 
   it 'routes GET /hosts/1/restore' do
     expect(get('/hosts/1/restore')).
       to route_to(controller: 'hosts', action: 'restore', id: '1')
   end
 end