No OneTemporary
Actions

Subscribers

None

File Metadata

Created: Fri, Aug 8, 10:37 PM

View Options

	diff --git a/config/application.rb b/config/application.rb
	index 212a8dd..c2959bc 100644
	--- a/config/application.rb
	+++ b/config/application.rb
	@@ -1,55 +1,55 @@
	require File.expand_path('../boot', __FILE__)

	require 'rails/all'

	# Production doesn't use bundler
	# you've limited to :test, :development, or :production.
	if ENV['RAILS_ENV'] != 'production'
	Bundler.require(*Rails.groups)
	else
	# Dependencies to load before starting rails in production
	require 'kaminari'
	require 'jquery-rails'
	require 'state_machine'
	require 'beaneater'
	require 'oauth2'
	require 'warden'
	require 'net/scp'
	end

	-module Baas
	+module Archiving
	def self.settings opts = nil
	@settings \|\|= {}

	return @settings if opts.nil?
	@settings.merge! opts
	@settings
	end

	class Application < Rails::Application
	# Settings in config/environments/* take precedence over those specified here.
	# Application configuration should go into files in config/initializers
	# -- all .rb files in that directory are automatically loaded.

	# Store/Read localtime from the database
	config.time_zone = 'Athens'
	config.active_record.default_timezone = :local

	# The default locale is :en and all translations from config/locales/*.rb,yml are auto loaded.
	# config.i18n.load_path += Dir[Rails.root.join('my', 'locales', '*.{rb,yml}').to_s]
	# config.i18n.default_locale = :de
	config.autoload_paths << Rails.root.join('lib')

	# config.x = {}
	end

	# def self.settings
	# Application.config.x
	# end

	def self.bean
	@bean \|\|= Bean::Client.new(
	YAML.load_file(Rails.root.join('config', 'beanstalk.yml'))[Rails.env].symbolize_keys[:host]
	)
	end
	end
	diff --git a/config/initializers/00_settings.rb b/config/initializers/00_settings.rb
	index 86537d3..04e38d4 100644
	--- a/config/initializers/00_settings.rb
	+++ b/config/initializers/00_settings.rb
	@@ -1,6 +1,6 @@
	-Baas.settings director_name: YAML.load_file(Rails.root.join('config', 'bacula.yml'))[Rails.env].
	+Archiving.settings director_name: YAML.load_file(Rails.root.join('config', 'bacula.yml'))[Rails.env].
	symbolize_keys[:director]

	Archiving.settings vima_oauth_enabled: true
	Archiving.settings institutional_authentication_enabled: true
	Archiving.settings okeanos_authentication_enabled: false
	diff --git a/lib/configuration/host.rb b/lib/configuration/host.rb
	index a558254..0ac8b0b 100644
	--- a/lib/configuration/host.rb
	+++ b/lib/configuration/host.rb
	@@ -1,81 +1,81 @@
	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}",
	"}"
	]
	end

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

	# Fetches the FileDeamon resource for the file-deamon configuration
	def bacula_fd_filedeamon_config
	[
	'FileDeamon {',
	" 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
	end
	end
	diff --git a/lib/peter/strategies/vima.rb b/lib/peter/strategies/vima.rb
	index d1efa4d..68494eb 100644
	--- a/lib/peter/strategies/vima.rb
	+++ b/lib/peter/strategies/vima.rb
	@@ -1,109 +1,109 @@
	## -- encoding : utf-8 --
	require 'oauth2'

	Warden::Strategies.add(:vima) do
	Key = Rails.application.secrets.oauth2_vima_client_id
	Secret = Rails.application.secrets.oauth2_vima_secret

	def valid?
	params['vima'] \|\| params['error'] \|\| params['code']
	end

	def client
	OAuth2::Client.new(
	Key,
	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 = '/vima'
	uri.query = nil
	uri.to_s
	end

	def redirect_to_vima
	redirect! client.auth_code.authorize_url(:redirect_uri => redirect_uri, scope: 'read')
	end

	def authenticate!
	- if !Baas::settings[:vima_oauth_enabled]
	+ if !Archiving::settings[:vima_oauth_enabled]
	return fail!("ViMa is temporarily disabled")
	end

	if params['error']
	Rails.logger.warn("WARDEN: ERROR #{params['error']}")
	return fail!("ViMa log in failed: #{params['error']}")
	end

	return redirect_to_vima if params['vima']

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

	user_data = access_token.get(
	'https://vima.grnet.gr/user/details',
	{ mode: :query, param_name: 'access_token' }
	).parsed.deep_symbolize_keys

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

	if [user_data[:username], user_data[:email], user_data[:id]].any?(&:blank?)
	return fail!("ViMa login failed: no user data")
	end

	###### TBR
	# temporary, for user migration
	user = User.find_or_initialize_by(username: user_data[:username],
	email: user_data[:email])
	user.identifier = "vima:#{user_data[:id]}"
	######

	# actual implementation
	#user = User.find_or_initialize_by(identifier: user_data[:identifier])

	user.login_at = Time.now

	if user.new_record?
	user.enabled = true
	# TBR
	user.identifier = "vima:#{user_data[:id]}"
	user.vima!
	else
	user.save!
	end

	if vms[:response][:errors] != false
	Rails.logger.warn("ViMa: errors on instances/list response for user #{vms[:user][:username]}")
	end

	if !user.enabled?
	return fail!('Service not available')
	end

	assign_vms(user, vms[:response][:instances])

	success!(user)
	end

	def assign_vms(user, vms)
	Rails.logger.warn("ViMa: user: #{user.username}")
	Rails.logger.warn("ViMa: vms: #{vms}")
	Rails.logger.warn("ViMa: session vms: #{session[:vms]}")
	session[:vms] = vms.first(50)
	Host.where(fqdn: vms).each do \|host\|
	host.users << user unless host.users.include?(user)
	end
	end
	end
	diff --git a/spec/lib/configuration/host_spec.rb b/spec/lib/configuration/host_spec.rb
	index f4cdb29..04d440f 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 = \"#{Baas.settings[:director_name]}\"")
	+ expect(subject).to match(" Name = \"#{Archiving.settings[:director_name]}\"")
	end

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

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

	subject { host.bacula_fd_filedeamon_config }

	it 'opens and closes a FileDeamon part' do
	expect(subject).to match(/^FileDeamon {$/)
	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