No OneTemporary
Actions

Subscribers

None

File Metadata

Created: Sun, May 18, 7:48 AM

View Options

	diff --git a/app/helpers/settings_helper.rb b/app/helpers/settings_helper.rb
	index e1020bb..5bed428 100644
	--- a/app/helpers/settings_helper.rb
	+++ b/app/helpers/settings_helper.rb
	@@ -1,29 +1,29 @@
	module SettingsHelper
	# Creates an html table for the given attributes
	#
	# @example table_for( a: 1, b: 2 )
	# <div>
	# <table>
	# <tr>
	# <td><b>A</b></td>
	# <td>1</td>
	# </tr>
	# <tr>
	# <td><b>B</b></td>
	# <td>2</td>
	# </tr>
	# </table>
	# </div>
	#
	# @param attributes[Hash]
	- # @returns [String] Html table
	+ # @return [String] Html table
	def table_for(attributes)
	content_tag(:div, class: 'table-responsive') do
	content_tag(:table, class: 'table table-striped table-bordered table-condensed') do
	attributes.map { \|key, value\|
	"<tr><td><b>#{key.to_s.titleize}</b></td><td>#{value}</td></tr>"
	}.inject { \|result, element\| result.concat(element) }.html_safe
	end
	end
	end
	end
	diff --git a/app/models/client.rb b/app/models/client.rb
	index 7897946..bc574b4 100644
	--- a/app/models/client.rb
	+++ b/app/models/client.rb
	@@ -1,141 +1,141 @@
	# Bacula Client class.
	# All hosts that are getting backed up with Bacula have a Client entry, with
	# attributes concerning the Client.
	class Client < ActiveRecord::Base
	self.table_name = :Client
	self.primary_key = :ClientId

	alias_attribute :name, :Name
	alias_attribute :uname, :Uname
	alias_attribute :auto_prune, :AutoPrune
	alias_attribute :file_retention, :FileRetention
	alias_attribute :job_retention, :JobRetention

	has_many :jobs, foreign_key: :ClientId
	has_one :host, foreign_key: :name, primary_key: :Name

	scope :for_user, ->(user_id) { joins(host: :users).where(users: { id: user_id }) }

	DAY_SECS = 60 * 60 * 24

	delegate :manually_inserted?, to: :host

	# Fetches the client's job_templates that are already persisted to
	# Bacula's configuration
	#
	# @return [ActiveRecord::Relation] of `JobTemplate`
	def persisted_jobs
	host.job_templates.where(baculized: true).includes(:fileset, :schedule)
	end

	# Fetches the client's performed jobs in reverse chronological order
	#
	# @return [ActiveRecord::Relation] of `Job`
	def recent_jobs
	jobs.order(EndTime: :desc).includes(:file_set)
	end

	# Helper method. It shows the client's job retention,
	# (which is expressed in seconds) in days.
	#
	# @return [Integer]
	def job_retention_days
	job_retention / DAY_SECS
	end

	# Helper method. It shows the client's file retention,
	# (which is expressed in seconds) in days.
	#
	# @return [Integer]
	def file_retention_days
	file_retention / DAY_SECS
	end

	# Helper method for auto_prune
	#
	# @return [String] 'yes' or 'no'
	def auto_prune_human
	auto_prune == 1 ? 'yes' : 'no'
	end

	# Helper method for displayin the last job's datetime in a nice format.
	def last_job_date_formatted
	if job_time = last_job_datetime
	I18n.l(job_time, format: :long)
	end
	end

	# Helper method for fetching the last job's datetime
	def last_job_datetime
	jobs.backup_type.last.try(:end_time)
	end

	# Fetches the first and last job's end times.
	#
	- # @returns [Array] of datetimes in proper format
	+ # @return [Array] of datetimes in proper format
	def backup_enabled_datetime_range
	jobs.backup_type.pluck(:end_time).minmax.map { \|x\| x.strftime('%Y-%m-%d') }
	end

	# Shows if a client has any backup jobs to Bacule config
	#
	# @return [Boolean]
	def is_backed_up?
	jobs.backup_type.any?
	end

	# Shows the total file size of the jobs that run for a specific client
	#
	# @return [Integer] Size in Bytes
	def backup_jobs_size
	jobs.backup_type.map(&:job_bytes).sum
	end

	# Shows the total files' count for the jobs that run for a specific client
	#
	# @return [Integer] File count
	def files_count
	jobs.map(&:job_files).sum
	end

	# Fetches the client's jobs that are running at the moment
	#
	# @return [Integer]
	def running_jobs
	jobs.running.count
	end

	# Displays the bacula config that is generated from the client's
	# host
	#
	# @return [String]
	def bacula_config
	return unless host
	host.baculize_config.join("\n")
	end

	# Fetches the job ids that will construct the desired restore
	#
	- # @param fileset_id[Integer] the fileset
	+ # @param file_set_id[Integer] the fileset
	# @param restore_point[Datetime] the restore point
	#
	# @return [Array] of ids
	def get_job_ids(file_set_id, restore_point)
	job_ids = {}
	backup_jobs = jobs.backup_type.terminated.where(file_set_id: file_set_id)
	backup_jobs = backup_jobs.where('EndTime < ?', restore_point) if restore_point

	job_ids['F'] = backup_jobs.where(level: 'F').pluck(:JobId).last
	return [] if job_ids['F'].nil?
	job_ids['D'] = backup_jobs.where(level: 'D').where("JobId > ?", job_ids['F']).pluck(:JobId).last
	job_ids['I'] = backup_jobs.where(level: 'I').
	where("JobId > ?", job_ids['D'] \|\| job_ids['F'] ).pluck(:JobId)

	job_ids.values.flatten.compact
	end

	# Fetches the bacula filesets that are associated with the client
	def file_sets
	FileSet.joins(:jobs).where(Job: { JobId: job_ids }).uniq
	end
	end
	diff --git a/app/models/host.rb b/app/models/host.rb
	index a5b7c05..af5a670 100644
	--- a/app/models/host.rb
	+++ b/app/models/host.rb
	@@ -1,311 +1,311 @@
	# 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
	include Configuration::Host

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

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

	validates :fqdn, presence: true, uniqueness: true

	validate :fqdn_format

	validate :valid_recipients

	scope :not_baculized, -> {
	joins("left join Client on Client.Name = hosts.name").where(Client: { 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

	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

	# 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.
	#
	- # @returns [Boolean] true if the host's client 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

	# 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

	# 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

No OneTemporaryActions

File Metadata

View Options

Event Timeline

No OneTemporary
Actions