diff --git a/app/models/configuration_setting.rb b/app/models/configuration_setting.rb
index a3e0ddf..4011253 100644
--- a/app/models/configuration_setting.rb
+++ b/app/models/configuration_setting.rb
@@ -1,57 +1,60 @@
 # ConfigurationSetting class describes a model that keeps the current Bacula
 # configuration.
 #
 # It has some hard coded settings as defaults.
 # Archiving's admins can enter new settings concerning:
 #
 # * jobs
 # * clients
 #
 # and override the default ones.
 #
 # ConfigurationSetting is supposed to have only one record in persisted in the database
 # which will hold the altered configuration as a patch to the defaults.
 # Admins can reset this change at any time.
 class ConfigurationSetting < ActiveRecord::Base
   serialize :job, JSON
   serialize :client, JSON
 
   JOB = {
     storage: :File,
     pool: :Default,
     messages: :Standard,
     priority: 10,
     :'Write Bootstrap' => '"/var/lib/bacula/%c.bsr"'
   }
 
   CLIENT = {
+    catalog: 'MyCatalog',
     file_retention: 60,
-    file_retention_period: :days,
+    file_retention_period_type: 'days',
     job_retention: 180,
-    job_retention_period: :days
+    job_retention_period_type: 'days',
+    autoprune: 'yes'
   }
 
   RETENTION_PERIODS = %w{seconds minutes hours days weeks months quarters years}
+  AUTOPRUNE_OPTIONS = ['yes', 'no']
 
   # Fetches the current configuration for jobs.
   #
   # The current configuration is the last submitted record, patched to the default
   # settings.
   # If there is no record, the default settings are returned
   #
   # @return [Hash] with settings
   def self.current_job_settings
     (last || new).job.symbolize_keys.reverse_merge(JOB.dup)
   end
 
   # Fetches the current configuration for clients.
   #
   # The current configuration is the last submitted record, patched to the default
   # settings.
   # If there is no record, the default settings are returned
   #
   # @return [Hash] with settings
   def self.current_client_settings
     (last || new).client.symbolize_keys.reverse_merge(CLIENT.dup)
   end
 end
diff --git a/app/models/host.rb b/app/models/host.rb
index d815108..d46876a 100644
--- a/app/models/host.rb
+++ b/app/models/host.rb
@@ -1,225 +1,231 @@
 class Host < ActiveRecord::Base
   establish_connection Baas::settings[:local_db]
 
-  FILE_RETENTION_DAYS = 60
-  JOB_RETENTION_DAYS = 180
-  CATALOG = 'MyCatalog'
-  AUTOPRUNE = 1
-
   STATUSES = {
     pending: 0,
     configured: 1,
     dispatched: 2,
     deployed: 3,
     updated: 4,
     redispatched: 5,
     for_removal: 6
   }
 
   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
     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 :disable do
       transition all => :pending
     end
   end
 
   def baculize_config
     templates = job_templates.enabled.includes(:fileset, :schedule)
 
     result = [self] + templates.map {|x| [x, x.fileset, x.schedule] }.flatten.compact.uniq
     result.map(&:to_bacula_config_array)
   end
 
   def to_bacula_config_array
     [
       "Client {",
       "  Name = #{name}",
       "  Address = #{fqdn}",
       "  FDPort = #{port}",
-      "  Catalog = #{CATALOG}",
+      "  Catalog = #{client_settings[:catalog]}",
       "  Password = \"#{password}\"",
-      "  File Retention = #{file_retention} days",
-      "  Job Retention = #{job_retention} days",
-      "  AutoPrune = yes",
+      "  File Retention = #{file_retention} #{file_retention_period_type}",
+      "  Job Retention = #{job_retention} #{job_retention_period_type}",
+      "  AutoPrune = #{auto_prune_human}",
       "}"
     ]
   end
 
   def auto_prune_human
-    AUTOPRUNE == 1 ? 'yes' : 'no'
+    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
 
   def needs_dispatch?
     verified? && (can_dispatch? || can_redispatch?)
   end
 
   def needs_revoke?
     for_removal?
   end
 
   # Handles the host's job changes by updating the host's status
   def recalculate
     if job_templates(true).enabled.any?
       add_configuration || change_deployed_config
     else
       mark_for_removal || disable
     end
   end
 
   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
 
   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 = FILE_RETENTION_DAYS
-    self.job_retention = JOB_RETENTION_DAYS
+    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
 
   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/spec/models/host_spec.rb b/spec/models/host_spec.rb
index 6f2cbf2..96ca938 100644
--- a/spec/models/host_spec.rb
+++ b/spec/models/host_spec.rb
@@ -1,313 +1,314 @@
 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 = #{Host::CATALOG}")
+      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 enabled job template\'s configs' do
       expect(subject).to include(enabled_job.to_bacula_config_array)
       expect(subject).to_not include(disabled_job.to_bacula_config_array)
     end
 
     it 'includes the used schedules\'s configs' do
       expect(subject).to include(schedule.to_bacula_config_array)
       expect(subject).to_not include(other_schedule.to_bacula_config_array)
     end
 
     it 'includes the used filesets\'s configs' do
       expect(subject).to include(fileset.to_bacula_config_array)
       expect(subject).to_not 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
     context 'when the host does NOT have enabled jobs' do
       let(:host) { FactoryGirl.create(:host, :with_disabled_jobs) }
 
       context 'and is configured' do
         before { host.update_column(:status, Host::STATUSES[:configured]) }
 
         it 'becomes pending' do
           expect { host.recalculate }.
             to change { host.reload.human_status_name }.from('configured').to('pending')
         end
       end
 
       [:dispatched, :deployed, :updated, :redispatched].each do |status|
         context "and is #{status}" do
           before { host.update_column(:status, Host::STATUSES[status]) }
 
           it 'becomes for_removal' do
             expect { host.recalculate }.
               to change { host.reload.human_status_name }.from(status.to_s).to('for removal')
           end
         end
       end
     end
 
     context 'when host has enabled jobs' 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]) }
 
         it 'becomes configured' do
           expect { host.recalculate }.
             to change { host.reload.human_status_name }.
             from('pending').to('configured')
         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
   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