def permit_unsigned_manifests isok=true
# Set security model for the life of a test.
- Rails.configuration.Collections["BlobSigning"] = !isok
+ Rails.configuration.Collections.BlobSigning = !isok
end
def assert_signed_manifest manifest_text, label='', token: false
exp = tok[/\+A[[:xdigit:]]+@([[:xdigit:]]+)/, 1].to_i(16)
sig = Blob.sign_locator(
bare,
- key: Rails.configuration.Collections["BlobSigningKey"],
+ key: Rails.configuration.Collections.BlobSigningKey,
expire: exp,
api_token: token)[/\+A[^\+]*/, 0]
assert_includes tok, sig
token = api_client_authorizations(:active).send(token_method)
signed = Blob.sign_locator(
'acbd18db4cc2f85cedef654fccc4a4d8+3',
- key: Rails.configuration.Collections["BlobSigningKey"],
+ key: Rails.configuration.Collections.BlobSigningKey,
api_token: token)
authorize_with_token token
put :update, params: {
def request_capped_index(params={})
authorize_with :user1_with_load
coll1 = collections(:collection_1_of_201)
- Rails.configuration.API["MaxIndexDatabaseRead"] =
+ Rails.configuration.API.MaxIndexDatabaseRead =
yield(coll1.manifest_text.size)
get :index, params: {
select: %w(uuid manifest_text),
# Build a manifest with both signed and unsigned locators.
signing_opts = {
- key: Rails.configuration.Collections["BlobSigningKey"],
+ key: Rails.configuration.Collections.BlobSigningKey,
api_token: api_token(:active),
}
signed_locators = locators.collect do |x|
# TODO(twp): in phase 4, all locators will need to be signed, so
# this test should break and will need to be rewritten. Issue #2755.
signing_opts = {
- key: Rails.configuration.Collections["BlobSigningKey"],
+ key: Rails.configuration.Collections.BlobSigningKey,
api_token: api_token(:active),
ttl: 3600 # 1 hour
}
test "create fails with invalid signature" do
authorize_with :active
signing_opts = {
- key: Rails.configuration.Collections["BlobSigningKey"],
+ key: Rails.configuration.Collections.BlobSigningKey,
api_token: api_token(:active),
}
test "create fails with uuid of signed manifest" do
authorize_with :active
signing_opts = {
- key: Rails.configuration.Collections["BlobSigningKey"],
+ key: Rails.configuration.Collections.BlobSigningKey,
api_token: api_token(:active),
}
ea10d51bcf88862dbcc36eb292017dfd+45)
signing_opts = {
- key: Rails.configuration.Collections["BlobSigningKey"],
+ key: Rails.configuration.Collections.BlobSigningKey,
api_token: api_token(:active),
}
[1, 5, nil].each do |ask|
test "Set replication_desired=#{ask.inspect}" do
- Rails.configuration.Collections["DefaultReplication"] = 2
+ Rails.configuration.Collections.DefaultReplication = 2
authorize_with :active
put :update, params: {
id: collections(:replication_undesired_unconfirmed).uuid,
assert_response 200
c = Collection.find_by_uuid(uuid)
assert_operator c.trash_at, :<, db_current_time
- assert_equal c.delete_at, c.trash_at + Rails.configuration.Collections["BlobSigningTTL"]
+ assert_equal c.delete_at, c.trash_at + Rails.configuration.Collections.BlobSigningTTL
end
test 'delete long-trashed collection immediately using http DELETE verb' do
assert_response 200
c = Collection.find_by_uuid(uuid)
assert_operator c.trash_at, :<, db_current_time
- assert_operator c.delete_at, :>=, time_before_trashing + Rails.configuration.Collections["DefaultTrashLifetime"]
+ assert_operator c.delete_at, :>=, time_before_trashing + Rails.configuration.Collections.DefaultTrashLifetime
end
end
end
test "update collection with versioning enabled" do
- Rails.configuration.Collections["CollectionVersioning"] = true
- Rails.configuration.Collections["PreserveVersionIfIdle"] = 1 # 1 second
+ Rails.configuration.Collections.CollectionVersioning = true
+ Rails.configuration.Collections.PreserveVersionIfIdle = 1 # 1 second
col = collections(:collection_owned_by_active)
assert_equal 2, col.version
token = api_client_authorizations(:active).v2token
signed = Blob.sign_locator(
'acbd18db4cc2f85cedef654fccc4a4d8+3',
- key: Rails.configuration.Collections["BlobSigningKey"],
+ key: Rails.configuration.Collections.BlobSigningKey,
api_token: token)
authorize_with_token token
put :update, params: {
end
test 'get contents with jobs and pipeline instances disabled' do
- Rails.configuration.API["DisabledAPIs"] = ['jobs.index', 'pipeline_instances.index']
+ Rails.configuration.API.DisabledAPIs = ['jobs.index', 'pipeline_instances.index']
authorize_with :active
get :contents, params: {
test 'get contents with low max_index_database_read' do
# Some result will certainly have at least 12 bytes in a
# restricted column
- Rails.configuration.API["MaxIndexDatabaseRead"] = 12
+ Rails.configuration.API.MaxIndexDatabaseRead = 12
authorize_with :active
get :contents, params: {
id: groups(:aproject).uuid,
# We need to verify that "cancel" creates a trigger file, so first
# let's make sure there is no stale trigger file.
begin
- File.unlink(Rails.configuration.Containers["JobsAPI"]["CrunchRefreshTrigger"])
+ File.unlink(Rails.configuration.Containers.JobsAPI.CrunchRefreshTrigger)
rescue Errno::ENOENT
end
'server should correct bogus cancelled_at ' +
job['cancelled_at'])
assert_equal(true,
- File.exist?(Rails.configuration.Containers["JobsAPI"]["CrunchRefreshTrigger"]),
+ File.exist?(Rails.configuration.Containers.JobsAPI.CrunchRefreshTrigger),
'trigger file should be created when job is cancelled')
end
# We need to verify that "cancel" creates a trigger file, so first
# let's make sure there is no stale trigger file.
begin
- File.unlink(Rails.configuration.Containers["JobsAPI"]["CrunchRefreshTrigger"])
+ File.unlink(Rails.configuration.Containers.JobsAPI.CrunchRefreshTrigger)
rescue Errno::ENOENT
end
# We need to verify that "cancel" creates a trigger file, so first
# let's make sure there is no stale trigger file.
begin
- File.unlink(Rails.configuration.Containers["JobsAPI"]["CrunchRefreshTrigger"])
+ File.unlink(Rails.configuration.Containers.JobsAPI.CrunchRefreshTrigger)
rescue Errno::ENOENT
end
end
test 'jobs.create disabled in config' do
- Rails.configuration.API["DisabledAPIs"] = ["jobs.create",
+ Rails.configuration.API.DisabledAPIs = ["jobs.create",
"pipeline_instances.create"]
authorize_with :active
post :create, params: {
end
test "node should fail ping with invalid hostname config format" do
- Rails.configuration.Containers["SLURM"]["Managed"]["AssignNodeHostname"] = 'compute%<slot_number>04' # should end with "04d"
+ Rails.configuration.Containers.SLURM.Managed.AssignNodeHostname = 'compute%<slot_number>04' # should end with "04d"
post :ping, params: {
id: nodes(:new_with_no_hostname).uuid,
ping_secret: nodes(:new_with_no_hostname).info['ping_secret'],
assert_response :success
discovery_doc = JSON.parse(@response.body)
assert_includes discovery_doc, 'defaultTrashLifetime'
- assert_equal discovery_doc['defaultTrashLifetime'], Rails.configuration.Collections["DefaultTrashLifetime"]
+ assert_equal discovery_doc['defaultTrashLifetime'], Rails.configuration.Collections.DefaultTrashLifetime
assert_match(/^[0-9a-f]+(-modified)?$/, discovery_doc['source_version'])
assert_match(/^[0-9a-f]+(-modified)?$/, discovery_doc['sourceVersion'])
assert_match(/^unknown$/, discovery_doc['packageVersion'])
- assert_equal discovery_doc['websocketUrl'], Rails.configuration.Services["Websocket"]["ExternalURL"].to_s
- assert_equal discovery_doc['workbenchUrl'], Rails.configuration.Services["Workbench1"]["ExternalURL"].to_s
+ assert_equal discovery_doc['websocketUrl'], Rails.configuration.Services.Websocket.ExternalURL.to_s
+ assert_equal discovery_doc['workbenchUrl'], Rails.configuration.Services.Workbench1.ExternalURL.to_s
assert_equal('zzzzz', discovery_doc['uuidPrefix'])
end
end
test "non-empty disable_api_methods" do
- Rails.configuration.API["DisabledAPIs"] =
+ Rails.configuration.API.DisabledAPIs =
['jobs.create', 'pipeline_instances.create', 'pipeline_templates.create']
get :index
assert_response :success
setup_email = ActionMailer::Base.deliveries.last
assert_not_nil setup_email, 'Expected email after setup'
- assert_equal Rails.configuration.Users["UserNotifierEmailFrom"], setup_email.from[0]
+ assert_equal Rails.configuration.Users.UserNotifierEmailFrom, setup_email.from[0]
assert_equal 'foo@example.com', setup_email.to[0]
assert_equal 'Welcome to Arvados - shell account enabled', setup_email.subject
assert (setup_email.body.to_s.include? 'Your Arvados shell account has been set up'),
'Expected Your Arvados shell account has been set up in email body'
- assert (setup_email.body.to_s.include? "#{Rails.configuration.Services["Workbench1"]["ExternalURL"]}users/#{created['uuid']}/virtual_machines"), 'Expected virtual machines url in email body'
+ assert (setup_email.body.to_s.include? "#{Rails.configuration.Services.Workbench1.ExternalURL}users/#{created['uuid']}/virtual_machines"), 'Expected virtual machines url in email body'
end
test "setup inactive user by changing is_active to true" do
def self.included base
base.setup do
# Extract the test repository data into the default test
- # environment's Rails.configuration.Git["Repositories"]. (We
+ # environment's Rails.configuration.Git.Repositories. (We
# don't use that config setting here, though: it doesn't seem
# worth the risk of stepping on a real git repo root.)
@tmpdir = Rails.root.join 'tmp', 'git'
FileUtils.mkdir_p @tmpdir
system("tar", "-xC", @tmpdir.to_s, "-f", "test/test.git.tar")
- Rails.configuration.Git["Repositories"] = "#{@tmpdir}/test"
- Rails.configuration.Containers["JobsAPI"]["GitInternalDir"] = "#{@tmpdir}/internal.git"
+ Rails.configuration.Git.Repositories = "#{@tmpdir}/test"
+ Rails.configuration.Containers.JobsAPI.GitInternalDir = "#{@tmpdir}/internal.git"
end
base.teardown do
end
def internal_tag tag
- IO.read "|git --git-dir #{Rails.configuration.Containers["JobsAPI"]["GitInternalDir"].shellescape} log --format=format:%H -n1 #{tag.shellescape}"
+ IO.read "|git --git-dir #{Rails.configuration.Containers.JobsAPI.GitInternalDir.shellescape} log --format=format:%H -n1 #{tag.shellescape}"
end
# Intercept fetch_remote_repository and fetch from a specified url
test "store collection as json" do
signing_opts = {
- key: Rails.configuration.Collections["BlobSigningKey"],
+ key: Rails.configuration.Collections.BlobSigningKey,
api_token: api_token(:active),
}
signed_locator = Blob.sign_locator('bad42fa702ae3ea7d888fef11b46f450+44',
test "store collection with manifest_text only" do
signing_opts = {
- key: Rails.configuration.Collections["BlobSigningKey"],
+ key: Rails.configuration.Collections.BlobSigningKey,
api_token: api_token(:active),
}
signed_locator = Blob.sign_locator('bad42fa702ae3ea7d888fef11b46f450+44',
test "store collection then update name" do
signing_opts = {
- key: Rails.configuration.Collections["BlobSigningKey"],
+ key: Rails.configuration.Collections.BlobSigningKey,
api_token: api_token(:active),
}
signed_locator = Blob.sign_locator('bad42fa702ae3ea7d888fef11b46f450+44',
end
test "create request with async=true defers permissions update" do
- Rails.configuration.API["AsyncPermissionsUpdateInterval"] = 1 # second
+ Rails.configuration.API.AsyncPermissionsUpdateInterval = 1 # second
name = "Random group #{rand(1000)}"
assert_equal nil, Group.find_by_name(name)
end
test 'auto-activate user from trusted cluster' do
- Rails.configuration.RemoteClusters['zbbbb']["ActivateUsers"] = true
+ Rails.configuration.RemoteClusters['zbbbb'].ActivateUsers = true
get '/arvados/v1/users/current',
params: {format: 'json'},
headers: auth(remote: 'zbbbb')
].each do |testcase|
test "user auto-activate #{testcase.inspect}" do
# Configure auto_setup behavior according to testcase[:cfg]
- Rails.configuration.Users["AutoSetupNewUsers"] = testcase[:cfg][:auto]
- Rails.configuration.Users["AutoSetupNewUsersWithVmUUID"] =
+ Rails.configuration.Users.AutoSetupNewUsers = testcase[:cfg][:auto]
+ Rails.configuration.Users.AutoSetupNewUsersWithVmUUID =
(testcase[:cfg][:vm] ? virtual_machines(:testvm).uuid : "")
- Rails.configuration.Users["AutoSetupNewUsersWithRepository"] =
+ Rails.configuration.Users.AutoSetupNewUsersWithRepository =
testcase[:cfg][:repo]
mock_auth_with(email: testcase[:email])
end
def run_with_expiry(clean_after)
- Rails.configuration.Containers["Logging"]["MaxAge"] = clean_after
+ Rails.configuration.Containers.Logging.MaxAge = clean_after
Rake::Task[TASK_NAME].reenable
Rake.application.invoke_task TASK_NAME
end
end
def run_with_expiry(clean_after)
- Rails.configuration.Containers["Logging"]["MaxAge"] = clean_after
+ Rails.configuration.Containers.Logging.MaxAge = clean_after
Rake::Task[TASK_NAME].reenable
Rake.application.invoke_task TASK_NAME
end
expire: 0x7fffffff,
}
- original_ttl = Rails.configuration.Collections["BlobSigningTTL"]
- Rails.configuration.Collections["BlobSigningTTL"] = original_ttl*2
+ original_ttl = Rails.configuration.Collections.BlobSigningTTL
+ Rails.configuration.Collections.BlobSigningTTL = original_ttl*2
signed2 = Blob.sign_locator @@known_locator, {
api_token: @@known_token,
key: @@known_key,
expire: 0x7fffffff,
}
- Rails.configuration.Collections["BlobSigningTTL"] = original_ttl
+ Rails.configuration.Collections.BlobSigningTTL = original_ttl
assert_not_equal signed, signed2
end
end
test "auto-create version after idle setting" do
- Rails.configuration.Collections["CollectionVersioning"] = true
- Rails.configuration.Collections["PreserveVersionIfIdle"] = 600 # 10 minutes
+ Rails.configuration.Collections.CollectionVersioning = true
+ Rails.configuration.Collections.PreserveVersionIfIdle = 600 # 10 minutes
act_as_user users(:active) do
# Set up initial collection
c = create_collection 'foo', Encoding::US_ASCII
end
test "preserve_version=false assignment is ignored while being true and not producing a new version" do
- Rails.configuration.Collections["CollectionVersioning"] = true
- Rails.configuration.Collections["PreserveVersionIfIdle"] = 3600
+ Rails.configuration.Collections.CollectionVersioning = true
+ Rails.configuration.Collections.PreserveVersionIfIdle = 3600
act_as_user users(:active) do
# Set up initial collection
c = create_collection 'foo', Encoding::US_ASCII
end
test "uuid updates on current version make older versions update their pointers" do
- Rails.configuration.Collections["CollectionVersioning"] = true
- Rails.configuration.Collections["PreserveVersionIfIdle"] = 0
+ Rails.configuration.Collections.CollectionVersioning = true
+ Rails.configuration.Collections.PreserveVersionIfIdle = 0
act_as_system_user do
# Set up initial collection
c = create_collection 'foo', Encoding::US_ASCII
end
test "older versions' modified_at indicate when they're created" do
- Rails.configuration.Collections["CollectionVersioning"] = true
- Rails.configuration.Collections["PreserveVersionIfIdle"] = 0
+ Rails.configuration.Collections.CollectionVersioning = true
+ Rails.configuration.Collections.PreserveVersionIfIdle = 0
act_as_user users(:active) do
# Set up initial collection
c = create_collection 'foo', Encoding::US_ASCII
end
test "past versions should not be directly updatable" do
- Rails.configuration.Collections["CollectionVersioning"] = true
- Rails.configuration.Collections["PreserveVersionIfIdle"] = 0
+ Rails.configuration.Collections.CollectionVersioning = true
+ Rails.configuration.Collections.PreserveVersionIfIdle = 0
act_as_system_user do
# Set up initial collection
c = create_collection 'foo', Encoding::US_ASCII
assert c_old.invalid?
c_old.reload
# Now disable collection versioning, it should behave the same way
- Rails.configuration.Collections["CollectionVersioning"] = false
+ Rails.configuration.Collections.CollectionVersioning = false
c_old.name = 'this was foo'
assert c_old.invalid?
end
['is_trashed', true, false],
].each do |attr, first_val, second_val|
test "sync #{attr} with older versions" do
- Rails.configuration.Collections["CollectionVersioning"] = true
- Rails.configuration.Collections["PreserveVersionIfIdle"] = 0
+ Rails.configuration.Collections.CollectionVersioning = true
+ Rails.configuration.Collections.PreserveVersionIfIdle = 0
act_as_system_user do
# Set up initial collection
c = create_collection 'foo', Encoding::US_ASCII
[false, 'replication_desired', 5, false],
].each do |versioning, attr, val, new_version_expected|
test "update #{attr} with versioning #{versioning ? '' : 'not '}enabled should #{new_version_expected ? '' : 'not '}create a new version" do
- Rails.configuration.Collections["CollectionVersioning"] = versioning
- Rails.configuration.Collections["PreserveVersionIfIdle"] = 0
+ Rails.configuration.Collections.CollectionVersioning = versioning
+ Rails.configuration.Collections.PreserveVersionIfIdle = 0
act_as_user users(:active) do
# Create initial collection
c = create_collection 'foo', Encoding::US_ASCII
end
test 'current_version_uuid is ignored during update' do
- Rails.configuration.Collections["CollectionVersioning"] = true
- Rails.configuration.Collections["PreserveVersionIfIdle"] = 0
+ Rails.configuration.Collections.CollectionVersioning = true
+ Rails.configuration.Collections.PreserveVersionIfIdle = 0
act_as_user users(:active) do
# Create 1st collection
col1 = create_collection 'foo', Encoding::US_ASCII
end
test 'with versioning enabled, simultaneous updates increment version correctly' do
- Rails.configuration.Collections["CollectionVersioning"] = true
- Rails.configuration.Collections["PreserveVersionIfIdle"] = 0
+ Rails.configuration.Collections.CollectionVersioning = true
+ Rails.configuration.Collections.PreserveVersionIfIdle = 0
act_as_user users(:active) do
# Create initial collection
col = create_collection 'foo', Encoding::US_ASCII
[0, 2, 4, nil].each do |ask|
test "set replication_desired to #{ask.inspect}" do
- Rails.configuration.Collections["DefaultReplication"] = 2
+ Rails.configuration.Collections.DefaultReplication = 2
act_as_user users(:active) do
c = collections(:replication_undesired_unconfirmed)
c.update_attributes replication_desired: ask
name: 'foo',
trash_at: db_current_time + 1.years)
sig_exp = /\+A[0-9a-f]{40}\@([0-9]+)/.match(c.signed_manifest_text)[1].to_i
- expect_max_sig_exp = db_current_time.to_i + Rails.configuration.Collections["BlobSigningTTL"]
+ expect_max_sig_exp = db_current_time.to_i + Rails.configuration.Collections.BlobSigningTTL
assert_operator c.trash_at.to_i, :>, expect_max_sig_exp
assert_operator sig_exp.to_i, :<=, expect_max_sig_exp
end
test test_name do
act_as_user users(:active) do
min_exp = (db_current_time +
- Rails.configuration.Collections["BlobSigningTTL"].seconds)
+ Rails.configuration.Collections.BlobSigningTTL.seconds)
if fixture_name == :expired_collection
# Fixture-finder shorthand doesn't find trashed collections
# because they're not in the default scope.
end
test 'default trash interval > blob signature ttl' do
- Rails.configuration.Collections["DefaultTrashLifetime"] = 86400 * 21 # 3 weeks
+ Rails.configuration.Collections.DefaultTrashLifetime = 86400 * 21 # 3 weeks
start = db_current_time
act_as_user users(:active) do
c = Collection.create!(manifest_text: '', name: 'foo')
test 'tag_in_internal_repository creates and updates tags in internal.git' do
authorize_with :active
- gitint = "git --git-dir #{Rails.configuration.Containers["JobsAPI"]["GitInternalDir"]}"
+ gitint = "git --git-dir #{Rails.configuration.Containers.JobsAPI.GitInternalDir}"
IO.read("|#{gitint} tag -d testtag 2>/dev/null") # "no such tag", fine
assert_match(/^fatal: /, IO.read("|#{gitint} show testtag 2>&1"))
refute $?.success?
end
def with_foo_repository
- Dir.chdir("#{Rails.configuration.Git["Repositories"]}/#{repositories(:foo).uuid}") do
+ Dir.chdir("#{Rails.configuration.Git.Repositories}/#{repositories(:foo).uuid}") do
must_pipe("git checkout master 2>&1")
yield
end
must_pipe("git -c user.email=x@x -c user.name=X commit -m -")
end
Commit.tag_in_internal_repository 'active/foo', sha1, tag
- gitint = "git --git-dir #{Rails.configuration.Containers["JobsAPI"]["GitInternalDir"].shellescape}"
+ gitint = "git --git-dir #{Rails.configuration.Containers.JobsAPI.GitInternalDir.shellescape}"
assert_match(/^commit /, IO.read("|#{gitint} show #{tag.shellescape}"))
assert $?.success?
end
must_pipe("git reset --hard HEAD^")
end
Commit.tag_in_internal_repository 'active/foo', sha1, tag
- gitint = "git --git-dir #{Rails.configuration.Containers["JobsAPI"]["GitInternalDir"].shellescape}"
+ gitint = "git --git-dir #{Rails.configuration.Containers.JobsAPI.GitInternalDir.shellescape}"
assert_match(/^commit /, IO.read("|#{gitint} show #{tag.shellescape}"))
assert $?.success?
end
test "Container.resolve_container_image(pdh)" do
set_user_from_auth :active
[[:docker_image, 'v1'], [:docker_image_1_12, 'v2']].each do |coll, ver|
- Rails.configuration.Containers["SupportedDockerImageFormats"] = [ver]
+ Rails.configuration.Containers.SupportedDockerImageFormats = [ver]
pdh = collections(coll).portable_data_hash
resolved = Container.resolve_container_image(pdh)
assert_equal resolved, pdh
end
test "migrated docker image" do
- Rails.configuration.Containers["SupportedDockerImageFormats"] = ['v2']
+ Rails.configuration.Containers.SupportedDockerImageFormats = ['v2']
add_docker19_migration_link
# Test that it returns only v2 images even though request is for v1 image.
end
test "use unmigrated docker image" do
- Rails.configuration.Containers["SupportedDockerImageFormats"] = ['v1']
+ Rails.configuration.Containers.SupportedDockerImageFormats = ['v1']
add_docker19_migration_link
# Test that it returns only supported v1 images even though there is a
end
test "incompatible docker image v1" do
- Rails.configuration.Containers["SupportedDockerImageFormats"] = ['v1']
+ Rails.configuration.Containers.SupportedDockerImageFormats = ['v1']
add_docker19_migration_link
# Don't return unsupported v2 image even if we ask for it directly.
end
test "incompatible docker image v2" do
- Rails.configuration.Containers["SupportedDockerImageFormats"] = ['v2']
+ Rails.configuration.Containers.SupportedDockerImageFormats = ['v2']
# No migration link, don't return unsupported v1 image,
set_user_from_auth :active
assert_not_nil(trash)
assert_not_nil(delete)
assert_in_delta(trash, now + 1.second, 10)
- assert_in_delta(delete, now + Rails.configuration.Collections["BlobSigningTTL"].second, 10)
+ assert_in_delta(delete, now + Rails.configuration.Collections.BlobSigningTTL.second, 10)
end
def check_output_ttl_1y(now, trash, delete)
[false, ActiveRecord::RecordInvalid],
[true, nil],
].each do |preemptible_conf, expected|
- test "having Rails.configuration.Containers['UsePreemptibleInstances']=#{preemptible_conf}, create preemptible container request and verify #{expected}" do
+ test "having Rails.configuration.Containers.UsePreemptibleInstances=#{preemptible_conf}, create preemptible container request and verify #{expected}" do
sp = {"preemptible" => true}
common_attrs = {cwd: "test",
priority: 1,
output_path: "test",
scheduling_parameters: sp,
mounts: {"test" => {"kind" => "json"}}}
- Rails.configuration.Containers["UsePreemptibleInstances"] = preemptible_conf
+ Rails.configuration.Containers.UsePreemptibleInstances = preemptible_conf
set_user_from_auth :active
cr = create_minimal_req!(common_attrs)
scheduling_parameters: {"preemptible" => false},
mounts: {"test" => {"kind" => "json"}}}
- Rails.configuration.Containers["UsePreemptibleInstances"] = true
+ Rails.configuration.Containers.UsePreemptibleInstances = true
set_user_from_auth :active
if requesting_c
[false, 'zzzzz-dz642-runningcontainr', nil],
[false, nil, nil],
].each do |preemptible_conf, requesting_c, schedule_preemptible|
- test "having Rails.configuration.Containers['UsePreemptibleInstances']=#{preemptible_conf}, #{requesting_c.nil? ? 'non-':''}child CR should #{schedule_preemptible ? '':'not'} ask for preemptible instance by default" do
+ test "having Rails.configuration.Containers.UsePreemptibleInstances=#{preemptible_conf}, #{requesting_c.nil? ? 'non-':''}child CR should #{schedule_preemptible ? '':'not'} ask for preemptible instance by default" do
common_attrs = {cwd: "test",
priority: 1,
command: ["echo", "hello"],
output_path: "test",
mounts: {"test" => {"kind" => "json"}}}
- Rails.configuration.Containers["UsePreemptibleInstances"] = preemptible_conf
+ Rails.configuration.Containers.UsePreemptibleInstances = preemptible_conf
set_user_from_auth :active
if requesting_c
state: ContainerRequest::Committed,
mounts: {"test" => {"kind" => "json"}}}
set_user_from_auth :active
- Rails.configuration.Containers["UsePreemptibleInstances"] = true
+ Rails.configuration.Containers.UsePreemptibleInstances = true
cr = with_container_auth(Container.find_by_uuid 'zzzzz-dz642-runningcontainr') do
create_minimal_req!(common_attrs)
end
test "find_reusable method should select higher priority queued container" do
- Rails.configuration.Containers["LogReuseDecisions"] = true
+ Rails.configuration.Containers.LogReuseDecisions = true
set_user_from_auth :active
common_attrs = REUSABLE_COMMON_ATTRS.merge({environment:{"var" => "queued"}})
c_low_priority, _ = minimal_new(common_attrs.merge({use_existing:false, priority:1}))
test "find_reusable with logging enabled" do
set_user_from_auth :active
- Rails.configuration.Containers["LogReuseDecisions"] = true
+ Rails.configuration.Containers.LogReuseDecisions = true
Rails.logger.expects(:info).at_least(3)
Container.find_reusable(REUSABLE_COMMON_ATTRS)
end
end
test "Exceed maximum lock-unlock cycles" do
- Rails.configuration.Containers["MaxDispatchAttempts"] = 3
+ Rails.configuration.Containers.MaxDispatchAttempts = 3
set_user_from_auth :active
c, cr = minimal_new
test 'override --cgroup-root with CRUNCH_CGROUP_ROOT' do
ENV['CRUNCH_CGROUP_ROOT'] = '/path/to/cgroup'
- Rails.configuration.Containers["JobsAPI"]["CrunchJobWrapper"] = "none"
+ Rails.configuration.Containers.JobsAPI.CrunchJobWrapper = "none"
act_as_system_user do
j = Job.create(repository: 'active/foo',
script: 'hash',
test 'rate limit of partial line segments' do
act_as_system_user do
- Rails.configuration.Containers["Logging"]["LogPartialLineThrottlePeriod"] = 1
+ Rails.configuration.Containers.Logging.LogPartialLineThrottlePeriod = 1
job = {}
job[:bytes_logged] = 0
end
test 'scancel orphaned job nodes' do
- Rails.configuration.Containers["JobsAPI"]["CrunchJobWrapper"] = "slurm_immediate"
+ Rails.configuration.Containers.JobsAPI.CrunchJobWrapper = "slurm_immediate"
act_as_system_user do
dispatch = CrunchDispatch.new
end
test 'cancel slurm jobs' do
- Rails.configuration.Containers["JobsAPI"]["CrunchJobWrapper"] = "slurm_immediate"
- Rails.configuration.Containers["JobsAPI"]["CrunchJobUser"] = 'foobar'
+ Rails.configuration.Containers.JobsAPI.CrunchJobWrapper = "slurm_immediate"
+ Rails.configuration.Containers.JobsAPI.CrunchJobUser = 'foobar'
fake_squeue = IO.popen("echo #{@job[:before_reboot].uuid}")
fake_scancel = IO.popen("true")
IO.expects(:popen).
end
test 'use reboot time' do
- Rails.configuration.Containers["JobsAPI"]["CrunchJobWrapper"] = nil
+ Rails.configuration.Containers.JobsAPI.CrunchJobWrapper = nil
@dispatch.expects(:open).once.with('/proc/stat').
returns open(Rails.root.join('test/fixtures/files/proc_stat'))
@dispatch.fail_jobs(before: 'reboot')
].each do |use_config|
test "Job with no Docker image uses default docker image when configuration is set #{use_config}" do
default_docker_image = collections(:docker_image)[:portable_data_hash]
- Rails.configuration.Containers["JobsAPI"]["DefaultDockerImage"] = default_docker_image if use_config
+ Rails.configuration.Containers.JobsAPI.DefaultDockerImage = default_docker_image if use_config
job = Job.new job_attrs
assert job.valid?, job.errors.full_messages.to_s
end
test "use migrated docker image if requesting old-format image by tag" do
- Rails.configuration.Containers["SupportedDockerImageFormats"] = ['v2']
+ Rails.configuration.Containers.SupportedDockerImageFormats = ['v2']
add_docker19_migration_link
job = Job.create!(
job_attrs(
end
test "use migrated docker image if requesting old-format image by pdh" do
- Rails.configuration.Containers["SupportedDockerImageFormats"] = ['v2']
+ Rails.configuration.Containers.SupportedDockerImageFormats = ['v2']
add_docker19_migration_link
job = Job.create!(
job_attrs(
[:docker_image_1_12, :docker_image_1_12, :docker_image_1_12],
].each do |existing_image, request_image, expect_image|
test "if a #{existing_image} job exists, #{request_image} yields #{expect_image} after migration" do
- Rails.configuration.Containers["SupportedDockerImageFormats"] = ['v1']
+ Rails.configuration.Containers.SupportedDockerImageFormats = ['v1']
if existing_image == :docker_image
oldjob = Job.create!(
end
end
- Rails.configuration.Containers["SupportedDockerImageFormats"] = ['v2']
+ Rails.configuration.Containers.SupportedDockerImageFormats = ['v2']
add_docker19_migration_link
# Check that both v1 and v2 images get resolved to v2.
end
test 'find_reusable with logging' do
- Rails.configuration.Containers["LogReuseDecisions"] = true
+ Rails.configuration.Containers.LogReuseDecisions = true
Rails.logger.expects(:info).at_least(3)
try_find_reusable
end
assert_nil Job.find_reusable(example_attrs, {}, [], [users(:active)])
# ...unless config says to reuse the earlier job in such cases.
- Rails.configuration.Containers["JobsAPI"]["ReuseJobIfOutputsDiffer"] = true
+ Rails.configuration.Containers.JobsAPI.ReuseJobIfOutputsDiffer = true
j = Job.find_reusable(example_attrs, {}, [], [users(:active)])
assert_equal foobar.uuid, j.uuid
end
end
test 'enable legacy api configuration option = true' do
- Rails.configuration.Containers["JobsAPI"]["Enable"] = "true"
+ Rails.configuration.Containers.JobsAPI.Enable = "true"
check_enable_legacy_jobs_api
- assert_equal [], Rails.configuration.API["DisabledAPIs"]
+ assert_equal [], Rails.configuration.API.DisabledAPIs
end
test 'enable legacy api configuration option = false' do
- Rails.configuration.Containers["JobsAPI"]["Enable"] = "false"
+ Rails.configuration.Containers.JobsAPI.Enable = "false"
check_enable_legacy_jobs_api
- assert_equal Disable_jobs_api_method_list, Rails.configuration.API["DisabledAPIs"]
+ assert_equal Disable_jobs_api_method_list, Rails.configuration.API.DisabledAPIs
end
test 'enable legacy api configuration option = auto, has jobs' do
- Rails.configuration.Containers["JobsAPI"]["Enable"] = "auto"
+ Rails.configuration.Containers.JobsAPI.Enable = "auto"
assert Job.count > 0
check_enable_legacy_jobs_api
- assert_equal [], Rails.configuration.API["DisabledAPIs"]
+ assert_equal [], Rails.configuration.API.DisabledAPIs
end
test 'enable legacy api configuration option = auto, no jobs' do
- Rails.configuration.Containers["JobsAPI"]["Enable"] = "auto"
+ Rails.configuration.Containers.JobsAPI.Enable = "auto"
act_as_system_user do
Job.destroy_all
end
assert_equal 0, Job.count
- assert_equal [], Rails.configuration.API["DisabledAPIs"]
+ assert_equal [], Rails.configuration.API.DisabledAPIs
check_enable_legacy_jobs_api
- assert_equal Disable_jobs_api_method_list, Rails.configuration.API["DisabledAPIs"]
+ assert_equal Disable_jobs_api_method_list, Rails.configuration.API.DisabledAPIs
end
end
end
test "non-empty configuration.unlogged_attributes" do
- Rails.configuration.AuditLogs["UnloggedAttributes"] = ["manifest_text"]
+ Rails.configuration.AuditLogs.UnloggedAttributes = ["manifest_text"]
txt = ". acbd18db4cc2f85cedef654fccc4a4d8+3 0:3:foo\n"
act_as_system_user do
end
test "empty configuration.unlogged_attributes" do
- Rails.configuration.AuditLogs["UnloggedAttributes"] = []
+ Rails.configuration.AuditLogs.UnloggedAttributes = []
txt = ". acbd18db4cc2f85cedef654fccc4a4d8+3 0:3:foo\n"
act_as_system_user do
test 'retain old audit logs with default settings' do
assert_no_logs_deleted do
AuditLogs.delete_old(
- max_age: Rails.configuration.AuditLogs["MaxAge"],
- max_batch: Rails.configuration.AuditLogs["MaxDeleteBatch"])
+ max_age: Rails.configuration.AuditLogs.MaxAge,
+ max_batch: Rails.configuration.AuditLogs.MaxDeleteBatch)
end
end
test 'delete old audit logs in thread' do
begin
- Rails.configuration.AuditLogs["MaxAge"] = 20
- Rails.configuration.AuditLogs["MaxDeleteBatch"] = 100000
+ Rails.configuration.AuditLogs.MaxAge = 20
+ Rails.configuration.AuditLogs.MaxDeleteBatch = 100000
Rails.cache.delete 'AuditLogs'
initial_log_count = Log.unscoped.all.count + 1
act_as_system_user do
end
test "dns_server_conf_template" do
- Rails.configuration.Containers["SLURM"]["Managed"]["DNSServerConfDir"] = Rails.root.join 'tmp'
- Rails.configuration.Containers["SLURM"]["Managed"]["DNSServerConfTemplate"] = Rails.root.join 'config', 'unbound.template'
+ Rails.configuration.Containers.SLURM.Managed.DNSServerConfDir = Rails.root.join 'tmp'
+ Rails.configuration.Containers.SLURM.Managed.DNSServerConfTemplate = Rails.root.join 'config', 'unbound.template'
conffile = Rails.root.join 'tmp', 'compute65535.conf'
File.unlink conffile rescue nil
assert Node.dns_server_update 'compute65535', '127.0.0.1'
end
test "dns_server_restart_command" do
- Rails.configuration.Containers["SLURM"]["Managed"]["DNSServerConfDir"] = Rails.root.join 'tmp'
- Rails.configuration.Containers["SLURM"]["Managed"]["DNSServerReloadCommand"] = 'foobar'
+ Rails.configuration.Containers.SLURM.Managed.DNSServerConfDir = Rails.root.join 'tmp'
+ Rails.configuration.Containers.SLURM.Managed.DNSServerReloadCommand = 'foobar'
restartfile = Rails.root.join 'tmp', 'restart.txt'
File.unlink restartfile rescue nil
assert Node.dns_server_update 'compute65535', '127.0.0.127'
end
test "dns_server_restart_command fail" do
- Rails.configuration.Containers["SLURM"]["Managed"]["DNSServerConfDir"] = Rails.root.join 'tmp', 'bogusdir'
- Rails.configuration.Containers["SLURM"]["Managed"]["DNSServerReloadCommand"] = 'foobar'
+ Rails.configuration.Containers.SLURM.Managed.DNSServerConfDir = Rails.root.join 'tmp', 'bogusdir'
+ Rails.configuration.Containers.SLURM.Managed.DNSServerReloadCommand = 'foobar'
refute Node.dns_server_update 'compute65535', '127.0.0.127'
end
test "dns_server_update_command with valid command" do
testfile = Rails.root.join('tmp', 'node_test_dns_server_update_command.txt')
- Rails.configuration.Containers["SLURM"]["Managed"]["DNSServerUpdateCommand"] =
+ Rails.configuration.Containers.SLURM.Managed.DNSServerUpdateCommand =
('echo -n "%{hostname} == %{ip_address}" >' +
testfile.to_s.shellescape)
assert Node.dns_server_update 'compute65535', '127.0.0.1'
end
test "dns_server_update_command with failing command" do
- Rails.configuration.Containers["SLURM"]["Managed"]["DNSServerUpdateCommand"] = 'false %{hostname}'
+ Rails.configuration.Containers.SLURM.Managed.DNSServerUpdateCommand = 'false %{hostname}'
refute Node.dns_server_update 'compute65535', '127.0.0.1'
end
test "dns update with no commands/dirs configured" do
- Rails.configuration.Containers["SLURM"]["Managed"]["DNSServerUpdateCommand"] = ""
- Rails.configuration.Containers["SLURM"]["Managed"]["DNSServerConfDir"] = ""
- Rails.configuration.Containers["SLURM"]["Managed"]["DNSServerConfTemplate"] = 'ignored!'
- Rails.configuration.Containers["SLURM"]["Managed"]["DNSServerReloadCommand"] = 'ignored!'
+ Rails.configuration.Containers.SLURM.Managed.DNSServerUpdateCommand = ""
+ Rails.configuration.Containers.SLURM.Managed.DNSServerConfDir = ""
+ Rails.configuration.Containers.SLURM.Managed.DNSServerConfTemplate = 'ignored!'
+ Rails.configuration.Containers.SLURM.Managed.DNSServerReloadCommand = 'ignored!'
assert Node.dns_server_update 'compute65535', '127.0.0.127'
end
test "don't leave temp files behind if there's an error writing them" do
- Rails.configuration.Containers["SLURM"]["Managed"]["DNSServerConfTemplate"] = Rails.root.join 'config', 'unbound.template'
+ Rails.configuration.Containers.SLURM.Managed.DNSServerConfTemplate = Rails.root.join 'config', 'unbound.template'
Tempfile.any_instance.stubs(:puts).raises(IOError)
Dir.mktmpdir do |tmpdir|
- Rails.configuration.Containers["SLURM"]["Managed"]["DNSServerConfDir"] = tmpdir
+ Rails.configuration.Containers.SLURM.Managed.DNSServerConfDir = tmpdir
refute Node.dns_server_update 'compute65535', '127.0.0.127'
assert_empty Dir.entries(tmpdir).select{|f| File.file? f}
end
end
test "ping new node with no hostname and no config" do
- Rails.configuration.Containers["SLURM"]["Managed"]["AssignNodeHostname"] = false
+ Rails.configuration.Containers.SLURM.Managed.AssignNodeHostname = false
node = ping_node(:new_with_no_hostname, {})
refute_nil node.slot_number
assert_nil node.hostname
end
test "ping new node with zero padding config" do
- Rails.configuration.Containers["SLURM"]["Managed"]["AssignNodeHostname"] = 'compute%<slot_number>04d'
+ Rails.configuration.Containers.SLURM.Managed.AssignNodeHostname = 'compute%<slot_number>04d'
node = ping_node(:new_with_no_hostname, {})
slot_number = node.slot_number
refute_nil slot_number
end
test "ping node with hostname and no config and expect hostname unchanged" do
- Rails.configuration.Containers["SLURM"]["Managed"]["AssignNodeHostname"] = false
+ Rails.configuration.Containers.SLURM.Managed.AssignNodeHostname = false
node = ping_node(:new_with_custom_hostname, {})
assert_equal(23, node.slot_number)
assert_equal("custom1", node.hostname)
end
test 'run out of slots' do
- Rails.configuration.Containers["MaxComputeVMs"] = 3
+ Rails.configuration.Containers.MaxComputeVMs = 3
act_as_system_user do
Node.destroy_all
(1..4).each do |i|
n = Node.create!
args = { ip: "10.0.0.#{i}", ping_secret: n.info['ping_secret'] }
- if i <= Rails.configuration.Containers["MaxComputeVMs"]
+ if i <= Rails.configuration.Containers.MaxComputeVMs
n.ping(args)
else
assert_raises do
end
def assert_server_path(path_tail, repo_sym)
- assert_equal(File.join(Rails.configuration.Git["Repositories"], path_tail),
+ assert_equal(File.join(Rails.configuration.Git.Repositories, path_tail),
repositories(repo_sym).server_path)
end
assert_not_nil email
# Test the body of the sent email contains what we expect it to
- assert_equal Rails.configuration.Users["UserNotifierEmailFrom"], email.from.first
+ assert_equal Rails.configuration.Users.UserNotifierEmailFrom, email.from.first
assert_equal user.email, email.to.first
assert_equal 'Welcome to Arvados - shell account enabled', email.subject
assert (email.body.to_s.include? 'Your Arvados shell account has been set up'),
'Expected Your Arvados shell account has been set up in email body'
- assert (email.body.to_s.include? Rails.configuration.Services["Workbench1"]["ExternalURL"].to_s),
+ assert (email.body.to_s.include? Rails.configuration.Services.Workbench1.ExternalURL.to_s),
'Expected workbench url in email body'
end
end
test "new username set avoiding blacklist" do
- Rails.configuration.Users["AutoSetupUsernameBlacklist"] = ["root"]
+ Rails.configuration.Users.AutoSetupUsernameBlacklist = ["root"]
check_new_username_setting("root", "root2")
end
assert_equal 0, @all_users.count, "No admin users should exist (except for the system user)"
end
- Rails.configuration.Users["AutoAdminFirstUser"] = auto_admin_first_user_config
- Rails.configuration.Users["AutoAdminUserWithEmail"] = auto_admin_user_config
+ Rails.configuration.Users.AutoAdminFirstUser = auto_admin_first_user_config
+ Rails.configuration.Users.AutoAdminUserWithEmail = auto_admin_user_config
# See if the foo user has is_admin
foo = User.new
test "create new user with auto setup #{active} #{email} #{auto_setup_vm} #{auto_setup_repo}" do
set_user_from_auth :admin
- Rails.configuration.Users["AutoSetupNewUsers"] = true
+ Rails.configuration.Users.AutoSetupNewUsers = true
if auto_setup_vm
- Rails.configuration.Users["AutoSetupNewUsersWithVmUUID"] = virtual_machines(:testvm)['uuid']
+ Rails.configuration.Users.AutoSetupNewUsersWithVmUUID = virtual_machines(:testvm)['uuid']
else
- Rails.configuration.Users["AutoSetupNewUsersWithVmUUID"] = ""
+ Rails.configuration.Users.AutoSetupNewUsersWithVmUUID = ""
end
- Rails.configuration.Users["AutoSetupNewUsersWithRepository"] = auto_setup_repo
+ Rails.configuration.Users.AutoSetupNewUsersWithRepository = auto_setup_repo
create_user_and_verify_setup_and_notifications active, new_user_recipients, inactive_recipients, email, expect_username
end
end
def create_user_and_verify_setup_and_notifications (active, new_user_recipients, inactive_recipients, email, expect_username)
- Rails.configuration.Users["NewUserNotificationRecipients"] = new_user_recipients
- Rails.configuration.Users["NewInactiveUserNotificationRecipients"] = inactive_recipients
+ Rails.configuration.Users.NewUserNotificationRecipients = new_user_recipients
+ Rails.configuration.Users.NewInactiveUserNotificationRecipients = inactive_recipients
ActionMailer::Base.deliveries = []
- can_setup = (Rails.configuration.Users["AutoSetupNewUsers"] and
+ can_setup = (Rails.configuration.Users.AutoSetupNewUsers and
(not expect_username.nil?))
expect_repo_name = "#{expect_username}/#{expect_username}"
prior_repo = Repository.where(name: expect_repo_name).first
assert_equal(expect_username, user.username)
# check user setup
- verify_link_exists(Rails.configuration.Users["AutoSetupNewUsers"] || active,
+ verify_link_exists(Rails.configuration.Users.AutoSetupNewUsers || active,
groups(:all_users).uuid, user.uuid,
"permission", "can_read")
# Check for OID login link.
- verify_link_exists(Rails.configuration.Users["AutoSetupNewUsers"] || active,
+ verify_link_exists(Rails.configuration.Users.AutoSetupNewUsers || active,
user.uuid, user.email, "permission", "can_login")
# Check for repository.
if named_repo = (prior_repo or
Repository.where(name: expect_repo_name).first)
verify_link_exists((can_setup and prior_repo.nil? and
- Rails.configuration.Users["AutoSetupNewUsersWithRepository"]),
+ Rails.configuration.Users.AutoSetupNewUsersWithRepository),
named_repo.uuid, user.uuid, "permission", "can_manage")
end
# Check for VM login.
- if (auto_vm_uuid = Rails.configuration.Users["AutoSetupNewUsersWithVmUUID"]) != ""
+ if (auto_vm_uuid = Rails.configuration.Users.AutoSetupNewUsersWithVmUUID) != ""
verify_link_exists(can_setup, auto_vm_uuid, user.uuid,
"permission", "can_login", "username", expect_username)
end
new_user_email = nil
new_inactive_user_email = nil
- new_user_email_subject = "#{Rails.configuration.Users["EmailSubjectPrefix"]}New user created notification"
- if Rails.configuration.Users["AutoSetupNewUsers"]
+ new_user_email_subject = "#{Rails.configuration.Users.EmailSubjectPrefix}New user created notification"
+ if Rails.configuration.Users.AutoSetupNewUsers
new_user_email_subject = (expect_username or active) ?
- "#{Rails.configuration.Users["EmailSubjectPrefix"]}New user created and setup notification" :
- "#{Rails.configuration.Users["EmailSubjectPrefix"]}New user created, but not setup notification"
+ "#{Rails.configuration.Users.EmailSubjectPrefix}New user created and setup notification" :
+ "#{Rails.configuration.Users.EmailSubjectPrefix}New user created, but not setup notification"
end
ActionMailer::Base.deliveries.each do |d|
if d.subject == new_user_email_subject then
new_user_email = d
- elsif d.subject == "#{Rails.configuration.Users["EmailSubjectPrefix"]}New inactive user notification" then
+ elsif d.subject == "#{Rails.configuration.Users.EmailSubjectPrefix}New inactive user notification" then
new_inactive_user_email = d
end
end
# if the new user email recipients config parameter is set
if not new_user_recipients.empty? then
assert_not_nil new_user_email, 'Expected new user email after setup'
- assert_equal Rails.configuration.Users["UserNotifierEmailFrom"], new_user_email.from[0]
+ assert_equal Rails.configuration.Users.UserNotifierEmailFrom, new_user_email.from[0]
assert_equal new_user_recipients, new_user_email.to[0]
assert_equal new_user_email_subject, new_user_email.subject
else
if not active
if not inactive_recipients.empty? then
assert_not_nil new_inactive_user_email, 'Expected new inactive user email after setup'
- assert_equal Rails.configuration.Users["UserNotifierEmailFrom"], new_inactive_user_email.from[0]
+ assert_equal Rails.configuration.Users.UserNotifierEmailFrom, new_inactive_user_email.from[0]
assert_equal inactive_recipients, new_inactive_user_email.to[0]
- assert_equal "#{Rails.configuration.Users["EmailSubjectPrefix"]}New inactive user notification", new_inactive_user_email.subject
+ assert_equal "#{Rails.configuration.Users.EmailSubjectPrefix}New inactive user notification", new_inactive_user_email.subject
else
assert_nil new_inactive_user_email, 'Did not expect new inactive user email after setup'
end
projects / arvados.git / commitdiff