No OneTemporary
Actions

Subscribers

None

File Metadata

Created: Sun, Aug 10, 8:26 AM

View Options

	diff --git a/app/controllers/hosts_controller.rb b/app/controllers/hosts_controller.rb
	index 07951bf..b21329f 100644
	--- a/app/controllers/hosts_controller.rb
	+++ b/app/controllers/hosts_controller.rb
	@@ -1,198 +1,198 @@
	class HostsController < ApplicationController
	before_action :require_logged_in, except: :fd_config
	before_action :fetch_host, only: [:show, :edit, :update, :destroy, :submit_config,
	:revoke, :disable]
	before_action :fetch_hosts_of_user, only: [:new, :create]

	# GET /hosts/new
	def new
	@host = Host.new
	@host.port = 9102
	@host.email_recipients = [current_user.email]
	end

	# POST /hosts
	def create
	@host = Host.new(fetch_params)

	set_host_type

	@host.verified = !@host.institutional?

	if user_can_add_this_host? && @host.save
	flash[:success] = 'Host created successfully'
	current_user.hosts << @host
	UserMailer.notify_admin(current_user, @host.fqdn).deliver
	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
	if current_user.needs_host_list?
	@hosts_of_user = current_user.hosts.pluck(:fqdn)
	end
	end

	# PATCH /hosts/1
	def update
	updates = fetch_params.slice(:port, :password, :email_recipients)
	if updates.present? && @host.update_attributes(updates)
	@host.recalculate if @host.bacula_ready?
	- flash[:success] = 'Host updated successfully. You must update your file deamon accordingly.'
	+ flash[:success] = 'Host updated successfully. You must update your file daemon accordingly.'
	redirect_to host_path @host
	else
	render :edit
	end
	end

	# DELETE /hosts/1
	def destroy
	if (@host.client.nil? \|\| @host.remove_from_bacula(true)) && @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/fetch_vima_hosts
	def fetch_vima_hosts
	if params[:code].blank?
	return redirect_to client.auth_code.authorize_url(:redirect_uri => redirect_uri,
	scope: 'read')
	end

	access_token = client.auth_code.get_token(
	params['code'],
	{ :redirect_uri => redirect_uri },
	{ :mode => :query, :param_name => "access_token", :header_format => "" }
	)

	vms = access_token.get(
	'https://vima.grnet.gr/instances/list?tag=vima:service:archiving',
	{ mode: :query, param_name: 'access_token' }
	).parsed.deep_symbolize_keys[:response][:instances]

	session[:vms] = vms.first(50)

	current_user.temp_hosts = vms
	current_user.hosts_updated_at = Time.now
	current_user.save

	Host.where(fqdn: vms).each do \|host\|
	host.users << current_user unless host.users.include?(current_user)
	end

	redirect_to new_host_path
	end

	# GET /hosts/:id/fd_config?token=A_TOKEN
	def fd_config
	user = User.find_by(token: params[:token]) if params[:token]

	return redirect_to clients_path if user.nil?

	@host = user.hosts.find_by(id: params[:id])

	return redirect_to clients_path unless @host

	render text: [
	- @host.bacula_fd_filedeamon_config,
	+ @host.bacula_fd_filedaemon_config,
	@host.bacula_fd_director_config(false),
	@host.bacula_fd_messages_config
	].join("\n\n")
	end

	private

	def client
	OAuth2::Client.new(
	Rails.application.secrets.oauth2_vima_client_id,
	Rails.application.secrets.oauth2_vima_secret,
	site: 'https://vima.grnet.gr',
	token_url: "/o/token",
	authorize_url: "/o/authorize",
	:ssl => {:ca_path => "/etc/ssl/certs"}
	)
	end

	def redirect_uri
	uri = URI.parse(request.url)
	uri.scheme = 'https' unless Rails.env.development?
	uri.path = '/hosts/fetch_vima_hosts'
	uri.query = nil
	uri.to_s
	end

	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, email_recipients: [])
	end

	def user_can_add_this_host?
	!current_user.needs_host_list? \|\| @hosts_of_user.include?(@host.fqdn)
	end

	def set_host_type
	@host.origin = if current_user.vima?
	:vima
	elsif current_user.okeanos?
	:okeanos
	else
	:institutional
	end
	end
	end
	diff --git a/app/views/hosts/_fd_config.html.erb b/app/views/hosts/_fd_config.html.erb
	index add31c9..60cc110 100644
	--- a/app/views/hosts/_fd_config.html.erb
	+++ b/app/views/hosts/_fd_config.html.erb
	@@ -1,23 +1,23 @@
	<div class="col-xs-4">
	- <h3>Client FileDeamon Config</h3>
	+ <h3>Client FileDaemon Config</h3>
	<pre class="pre">
	-<%= @host.bacula_fd_filedeamon_config %>
	+<%= @host.bacula_fd_filedaemon_config %>
	</pre>
	</div>
	<div class="col-xs-4">
	<h3>Client Director Config</h3>
	<pre class="pre">
	<%= @host.bacula_fd_director_config %>
	</pre>
	</div>
	<div class="col-xs-4">
	<h3>Client Messages Config</h3>
	<pre class="pre">
	<%= @host.bacula_fd_messages_config %>
	</pre>
	</div>

	<div class='col-xs-10'>
	<%= link_to 'Download Config', fd_config_host_path(@host, token: current_user.token),
	class: "btn btn-success", role: "button", download: 'fd_config' %>
	</div>
	diff --git a/lib/configuration/host.rb b/lib/configuration/host.rb
	index 5050ee3..e6ecd3b 100644
	--- a/lib/configuration/host.rb
	+++ b/lib/configuration/host.rb
	@@ -1,142 +1,142 @@
	module Configuration
	# Helper module to add configuration getters for Host
	module Host

	# 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}",
	"}"
	] + message_config
	end

	# Constructs the messages bacula resource
	#
	# @return [Array]
	def message_config
	return [] if email_recipients.empty?
	[
	"Messages {",
	" Name = #{message_name}",
	" mailcommand = \"#{mail_command}\"",
	" operatorcommand = \"#{operator_command}\"",
	" mail = #{email_recipients.join(',')} = all, !skipped",
	" operator = #{settings[:operator_email]} = mount",
	" console = all, !skipped, !saved",
	" append = \"/var/log/bacula/bacula.log\" = all, !skipped",
	" catalog = all",
	"}"
	]
	end

	- # Fetches the Director resource for the file-deamon configuration
	+ # Fetches the Director resource for the file-daemon configuration
	# file
	def bacula_fd_director_config(hide_pass = true)
	[
	'Director {',
	" Name = \"#{Archiving.settings[:director_name]}\"",
	" Password = \"#{hide_pass ? '*********' : password }\"",
	'}'
	].join("\n")
	end

	- # Fetches the FileDeamon resource for the file-deamon configuration
	- def bacula_fd_filedeamon_config
	+ # Fetches the FileDaemon resource for the file-daemon configuration
	+ def bacula_fd_filedaemon_config
	[
	- 'FileDeamon {',
	+ 'FileDaemon {',
	" Name = #{name}",
	" FDport = #{port}",
	' WorkingDirectory = /var/lib/bacula',
	' Pid Directory = /var/run/bacula',
	' Maximum Concurrent Jobs = 10',
	' FDAddress = 0.0.0.0',
	'}'
	].join("\n")
	end

	- # Fetches the Message resource for the file-deamon configuration file
	+ # Fetches the Message resource for the file-daemon configuration file
	def bacula_fd_messages_config
	[
	'Messages {',
	" Name = #{message_name}",
	" director = #{Archiving.settings[:director_name]} = all, !skipped, !restored",
	'}'
	].join("\n")
	end

	# The name that the client will use for its messages
	def message_name
	"message_#{name}_#{Digest::MD5.hexdigest(created_at.to_s + name).first(10)}"
	end

	private

	def mail_command
	"#{mail_general}" <<
	' -t %r' <<
	' -u \"[Archiving]: %c %t %e\"'
	end

	def operator_command
	"#{mail_general}" <<
	' -t %r' <<
	' -u \"[Archiving]: Intervention needed for %j\" -m \"Intervention needed %r\"'
	end

	def mail_general
	command = "/usr/bin/sendEmail -f #{settings[:default_sender]}"
	command << " -s #{settings[:address]}:#{settings[:port]}"
	if settings[:user_name] && settings[:password]
	command << " -o tls=yes -xu #{settings[:user_name]} -xp #{settings[:password]}"
	end
	command
	end

	def settings
	Archiving.settings[:mail_settings]
	end
	end
	end
	diff --git a/spec/lib/configuration/host_spec.rb b/spec/lib/configuration/host_spec.rb
	index 18cf845..0795048 100644
	--- a/spec/lib/configuration/host_spec.rb
	+++ b/spec/lib/configuration/host_spec.rb
	@@ -1,121 +1,121 @@
	require 'spec_helper'

	describe Configuration::Host do
	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 '#bacula_fd_director_config' do
	let!(:host) { FactoryGirl.build(:host) }

	subject { host.bacula_fd_director_config }

	it 'opens and closes a Director part' do
	expect(subject).to match(/^Director {$/)
	expect(subject).to match(/^}$/)
	end

	it 'includes the client\'s Name' do
	expect(subject).to match(" Name = \"#{Archiving.settings[:director_name]}\"")
	end

	it 'includes the client\'s Password' do
	expect(subject).to match(" Password = \"[*]+\"")
	end
	end

	- describe '#bacula_fd_filedeamon_config' do
	+ describe '#bacula_fd_filedaemon_config' do
	let!(:host) { FactoryGirl.build(:host) }

	- subject { host.bacula_fd_filedeamon_config }
	+ subject { host.bacula_fd_filedaemon_config }

	- it 'opens and closes a FileDeamon part' do
	- expect(subject).to match(/^FileDeamon {$/)
	+ it 'opens and closes a FileDaemon part' do
	+ expect(subject).to match(/^FileDaemon {$/)
	expect(subject).to match(/^}$/)
	end

	it 'includes the client\'s Port' do
	expect(subject).to match("FDport = #{host.port}")
	end

	it 'includes the client\'s Name' do
	expect(subject).to match("Name = #{host.name}")
	end
	end
	end

No OneTemporaryActions

File Metadata

View Options

Event Timeline

No OneTemporary
Actions