No OneTemporary
Actions

Subscribers

None

File Metadata

Created: Sun, May 18, 12:27 AM

View Options

	diff --git a/app/models/host.rb b/app/models/host.rb
	index 1a9ccc5..5b77583 100644
	--- a/app/models/host.rb
	+++ b/app/models/host.rb
	@@ -1,209 +1,219 @@
	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 })
	}

	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}",
	" Password = \"#{password}\"",
	" File Retention = #{file_retention} days",
	" Job Retention = #{job_retention} days",
	" AutoPrune = yes",
	"}"
	]
	end

	def auto_prune_human
	AUTOPRUNE == 1 ? 'yes' : 'no'
	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

	+ # 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

	def set_retention
	self.file_retention = FILE_RETENTION_DAYS
	self.job_retention = JOB_RETENTION_DAYS
	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
	end
	diff --git a/spec/factories/user.rb b/spec/factories/user.rb
	index ec67985..bf8b7d5 100644
	--- a/spec/factories/user.rb
	+++ b/spec/factories/user.rb
	@@ -1,6 +1,12 @@
	FactoryGirl.define do
	factory :user do
	sequence(:username) { \|n\| "user-#{n}" }
	user_type 0
	end
	+
	+ trait :admin do
	+ after(:create) do \|user\|
	+ user.admin!
	+ end
	+ end
	end
	diff --git a/spec/models/host_spec.rb b/spec/models/host_spec.rb
	index 5339880..6f2cbf2 100644
	--- a/spec/models/host_spec.rb
	+++ b/spec/models/host_spec.rb
	@@ -1,297 +1,313 @@
	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}")
	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

No OneTemporaryActions

File Metadata

View Options

Event Timeline

No OneTemporary
Actions