No OneTemporary
Actions

Subscribers

None

File Metadata

Created: Sun, May 18, 3:12 AM

View Options

	diff --git a/app/models/host.rb b/app/models/host.rb
	index c1e7df2..6add30f 100644
	--- a/app/models/host.rb
	+++ b/app/models/host.rb
	@@ -1,345 +1,363 @@
	# 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
	establish_connection ARCHIVING_CONF

	include Configuration::Host

	STATUSES = {
	pending: 0,
	configured: 1,
	dispatched: 2,
	deployed: 3,
	updated: 4,
	redispatched: 5,
	for_removal: 6,
	inactive: 7,
	blocked: 8
	}

	+ # The default file daemon port
	+ DEFAULT_PORT = 9102
	+
	enum origin: { institutional: 0, vima: 1, okeanos: 2 }
	serialize :email_recipients, JSON

	has_many :ownerships
	has_many :users, through: :ownerships, inverse_of: :hosts
	has_many :invitations

	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, :quota, numericality: { greater_than: 0 }

	validates :fqdn, presence: true, uniqueness: true

	validate :fqdn_format

	validate :valid_recipients

	scope :not_baculized, -> {
	joins("left join #{Client.table_name} on #{Client.table_name}.Name = hosts.name").
	where(Client.table_name => { Name: nil })
	}

	scope :in_bacula, -> {
	where(
	status: STATUSES.select { \|k,_\|
	[:deployed, :updated, :redispatched, :for_removal].include? k
	}.values
	)
	}

	scope :unverified, -> { where(verified: false) }

	- before_validation :set_retention, :unset_baculized, :sanitize_name, :sanitize_email_recipients
	+ before_validation :set_retention, :unset_baculized, :sanitize_name,
	+ :sanitize_email_recipients, :set_password, :set_port

	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, :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

	event :block do
	transition all - [:blocked] => :blocked
	end

	event :unblock do
	transition :blocked => :pending
	end
	end

	# API serializer
	# Override `as_json` method to personalize for API use.
	def as_json(opts={})
	if for_api = opts.delete(:for_api)
	api_json
	else
	super(opts)
	end
	end

	# Determines if a host has enabled jobs in order to be dispatched to Bacula
	#
	# @return [Boolean]
	def bacula_ready?
	job_templates.enabled.any?
	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
	#
	# @param force[Boolean] forces removal
	def remove_from_bacula(force=false)
	return false if not (force \|\| needs_revoke?)
	bacula_handler.undeploy_config
	end

	# Restores a host's backup to a preselected location
	#
	# @param fileset_id[Integer] the desired fileset
	# @param location[String] the desired restore location
	# @param restore_point[Datetime] the desired restore_point datetime
	def restore(file_set_id, location, restore_point=nil)
	return false if not restorable?
	job_ids = client.get_job_ids(file_set_id, restore_point)
	file_set_name = FileSet.find(file_set_id).file_set
	bacula_handler.restore(job_ids, file_set_name, restore_point, 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

	# Disables all jobs if needed and then locks the host
	def disable_jobs_and_lock
	return false if can_set_inactive? && !disable_jobs_and_update
	block
	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 }
	elsif blocked?
	{ message: 'client disabled by admin.', severity: :error }
	end
	end

	# Determines if a host can issue a restore job.
	#
	# @return [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
	recipients = users.pluck(:email)
	if save
	UserMailer.notify_for_verification(recipients, name).deliver if recipients.any?
	return true
	end
	false
	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

	# Determines if a host is inserted manually from the user or
	# provided as an option from a list by the system via a third party
	# like ViMa or Okeanos
	#
	# @return [Boolean]
	def manually_inserted?
	institutional?
	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

	def sanitize_email_recipients
	self.email_recipients.reject!(&:blank?)
	end

	+ def set_password
	+ return true if persisted?
	+
	+ self.password = Digest::SHA256.hexdigest(
	+ Time.now.to_s + Rails.application.secrets.salt + fqdn.to_s
	+ )
	+ end
	+
	+ def set_port
	+ return true if persisted?
	+
	+ self.port = DEFAULT_PORT
	+ 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 valid_recipients
	if !email_recipients.all? { \|email\| email =~ /\A([^@\s]+)@((?:[-a-z0-9]+\.)+[a-z]{2,})\z/i }
	self.errors.add(:email_recipients)
	end
	end

	# Handles the returned attribues for api
	#
	# @return [Hash] of the desired attributes for api use
	def api_json
	{
	id: id,
	name: name,
	uname: client.uname,
	port: port,
	file_retention: "#{file_retention} #{file_retention_period_type}",
	job_retention: "#{job_retention} #{job_retention_period_type}",
	quota: quota,
	last_backup: client.last_job_datetime,
	files: client.files_count,
	space_used: client.backup_jobs_size,
	collaborators: email_recipients,
	backup_jobs: job_templates.enabled.backup.map(&:api_json),
	restorable_filesets: client.file_sets.map(&:api_json)
	}
	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/spec/controllers/hosts_controller_spec.rb b/spec/controllers/hosts_controller_spec.rb
	index 81b4775..2c81461 100644
	--- a/spec/controllers/hosts_controller_spec.rb
	+++ b/spec/controllers/hosts_controller_spec.rb
	@@ -1,142 +1,142 @@
	require 'spec_helper'

	describe HostsController do
	let(:user) { FactoryGirl.create(:user) }
	before { controller.stub(:current_user) { user } }

	describe 'GET #new' do
	before { get :new }

	it 'initializes a host' do
	expect(assigns(:host)).to be
	end

	it 'renders' do
	expect(response).to render_template(:new)
	end
	end

	describe 'PATCH #update' do
	let!(:host) { FactoryGirl.create(:host) }

	before { host.users << user }

	context 'with valid params' do
	let(:params) do
	{
	id: host.id,
	host: { port: 9999, password: 'wrong_pass' }
	}
	end

	it 'updates the host' do
	expect { patch :update, params }.
	to change { [host.reload.port, host.reload.password] }.
	to([9999, 'wrong_pass'])
	end

	it 'redirects to host_show' do
	patch :update, params
	expect(response).to redirect_to(host_path(host))
	end
	end

	context 'with fqdn in params' do
	let(:params) do
	{
	id: host.id,
	host: { fqdn: 'another.host.gr' }
	}
	end

	it 'does not update the host' do
	expect { patch :update, params }.
	to_not change { host.reload.fqdn }
	end

	it 'renders the edit page' do
	patch :update, params
	expect(response).to render_template(:edit)
	end
	end
	end

	describe 'POST #create' do
	context 'with valid params' do
	let(:params) do
	{
	host: FactoryGirl.build(:host).attributes.symbolize_keys.
	slice(:password, :fqdn, :port)
	}
	end

	it 'creates the host' do
	expect { post :create, params }.
	to change { Host.count }.by(1)
	end

	it 'redirects to root' do
	post :create, params
	expect(response).to redirect_to(host_path(Host.last))
	end

	it 'assigns the host to the user' do
	expect { post :create, params }.
	to change { user.hosts(true).count }.from(0).to(1)
	end
	end

	context 'with invalid params' do
	let(:params) do
	{
	host: FactoryGirl.build(:host).attributes.symbolize_keys.
	- slice(:fqdn, :port)
	+ slice(:port)
	}
	end

	before { post :create, params }

	it 'initializes a host with errors' do
	expect(assigns(:host)).to be
	end

	it 'renders :new' do
	expect(response).to render_template(:new)
	end
	end
	end

	describe 'POST #submit_config' do
	let(:host) { FactoryGirl.create(:host, :configured) }
	let(:params) { { id: host.id } }

	before { host.users << user }

	it 'redirects to root' do
	post :submit_config, params
	expect(response).to redirect_to(host_path(host))
	end

	it 'calls submit_config_to_bacula on host' do
	Host.any_instance.should_receive(:dispatch_to_bacula)
	post :submit_config, params
	end
	end

	describe 'DELETE #revoke' do
	let(:host) { FactoryGirl.create(:host, status: Host::STATUSES[:for_removal]) }
	let(:params) { { id: host.id } }

	before { host.users << user }

	it 'redirects to root' do
	delete :revoke, params
	expect(response).to redirect_to(root_path)
	end

	it 'calls remove_from_bacula on host' do
	Host.any_instance.should_receive(:remove_from_bacula)
	delete :revoke, params
	end
	end
	end
	diff --git a/spec/models/host_spec.rb b/spec/models/host_spec.rb
	index 705e48a..16b5902 100644
	--- a/spec/models/host_spec.rb
	+++ b/spec/models/host_spec.rb
	@@ -1,210 +1,202 @@
	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\|
	+ [:file_retention, :job_retention, :name, :password, :port].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 '#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, :blocked].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

	[: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(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

No OneTemporaryActions

File Metadata

View Options

Event Timeline

No OneTemporary
Actions