X-Git-Url: https://git.arvados.org/arvados.git/blobdiff_plain/94f2b439783a8e63d6d7b9ba2760f54fc642a8fb..8a0e9c549595e114a0eadc9d6792a17fb59d0f3e:/services/api/test/unit/container_request_test.rb diff --git a/services/api/test/unit/container_request_test.rb b/services/api/test/unit/container_request_test.rb index b36ff06bbd..5d998a2442 100644 --- a/services/api/test/unit/container_request_test.rb +++ b/services/api/test/unit/container_request_test.rb @@ -5,6 +5,7 @@ require 'test_helper' require 'helpers/container_test_helper' require 'helpers/docker_migration_helper' +require 'arvados/collection' class ContainerRequestTest < ActiveSupport::TestCase include DockerMigrationHelper @@ -69,7 +70,7 @@ class ContainerRequestTest < ActiveSupport::TestCase cr.container_image = "img3" cr.cwd = "/tmp3" cr.environment = {"BUP" => "BOP"} - cr.mounts = {"BAR" => "BAZ"} + cr.mounts = {"BAR" => {"kind" => "BAZ"}} cr.output_path = "/tmp4" cr.priority = 2 cr.runtime_constraints = {"vcpus" => 4} @@ -81,29 +82,33 @@ class ContainerRequestTest < ActiveSupport::TestCase end [ - {"vcpus" => 1}, - {"vcpus" => 1, "ram" => nil}, - {"vcpus" => 0, "ram" => 123}, - {"vcpus" => "1", "ram" => "123"} - ].each do |invalid_constraints| - test "Create with #{invalid_constraints}" do + {"runtime_constraints" => {"vcpus" => 1}}, + {"runtime_constraints" => {"vcpus" => 1, "ram" => nil}}, + {"runtime_constraints" => {"vcpus" => 0, "ram" => 123}}, + {"runtime_constraints" => {"vcpus" => "1", "ram" => "123"}}, + {"mounts" => {"FOO" => "BAR"}}, + {"mounts" => {"FOO" => {}}}, + {"mounts" => {"FOO" => {"kind" => "tmp", "capacity" => 42.222}}}, + {"command" => ["echo", 55]}, + {"environment" => {"FOO" => 55}} + ].each do |value| + test "Create with invalid #{value}" do set_user_from_auth :active assert_raises(ActiveRecord::RecordInvalid) do - cr = create_minimal_req!(state: "Committed", - priority: 1, - runtime_constraints: invalid_constraints) + cr = create_minimal_req!({state: "Committed", + priority: 1}.merge(value)) cr.save! end end - test "Update with #{invalid_constraints}" do + test "Update with invalid #{value}" do set_user_from_auth :active cr = create_minimal_req!(state: "Uncommitted", priority: 1) cr.save! assert_raises(ActiveRecord::RecordInvalid) do cr = ContainerRequest.find_by_uuid cr.uuid - cr.update_attributes!(state: "Committed", - runtime_constraints: invalid_constraints) + cr.update_attributes!({state: "Committed", + priority: 1}.merge(value)) end end end @@ -241,18 +246,18 @@ class ContainerRequestTest < ActiveSupport::TestCase cr.reload assert_equal "Final", cr.state assert_equal users(:active).uuid, cr.modified_by_user_uuid - ['output', 'log'].each do |out_type| - pdh = Container.find_by_uuid(cr.container_uuid).send(out_type) - assert_equal(1, Collection.where(portable_data_hash: pdh, - owner_uuid: project.uuid).count, - "Container #{out_type} should be copied to #{project.uuid}") - end + assert_not_nil cr.output_uuid assert_not_nil cr.log_uuid output = Collection.find_by_uuid cr.output_uuid assert_equal output_pdh, output.portable_data_hash + assert_equal output.owner_uuid, project.uuid, "Container output should be copied to #{project.uuid}" + log = Collection.find_by_uuid cr.log_uuid - assert_equal log_pdh, log.portable_data_hash + assert_equal log.manifest_text, ". 37b51d194a7513e45b56f6524f2d51f2+3 0:3:bar +./log\\040for\\040container\\040#{cr.container_uuid} 37b51d194a7513e45b56f6524f2d51f2+3 0:3:bar\n" + + assert_equal log.owner_uuid, project.uuid, "Container log should be copied to #{project.uuid}" end test "Container makes container request, then is cancelled" do @@ -375,8 +380,8 @@ class ContainerRequestTest < ActiveSupport::TestCase end [ - ['running_container_auth', 'zzzzz-dz642-runningcontainr', 1], - ['active_no_prefs', nil, 0], + ['running_container_auth', 'zzzzz-dz642-runningcontainr', 501], + ['active_no_prefs', nil, 0] ].each do |token, expected, expected_priority| test "create as #{token} and expect requesting_container_uuid to be #{expected}" do set_user_from_auth token @@ -387,6 +392,15 @@ class ContainerRequestTest < ActiveSupport::TestCase end end + test "create as container_runtime_token and expect requesting_container_uuid to be zzzzz-dz642-20isqbkl8xwnsao" do + set_user_from_auth :container_runtime_token + Thread.current[:token] = "#{Thread.current[:token]}/zzzzz-dz642-20isqbkl8xwnsao" + cr = ContainerRequest.create(container_image: "img", output_path: "/tmp", command: ["echo", "foo"]) + assert_not_nil cr.uuid, 'uuid should be set for newly created container_request' + assert_equal 'zzzzz-dz642-20isqbkl8xwnsao', cr.requesting_container_uuid + assert_equal 1, cr.priority + end + [[{"vcpus" => [2, nil]}, lambda { |resolved| resolved["vcpus"] == 2 }], [{"vcpus" => [3, 7]}, @@ -428,6 +442,27 @@ class ContainerRequestTest < ActiveSupport::TestCase "path" => "/foo", } end], + [{"/out" => { + "kind" => "collection", + "portable_data_hash" => "1f4b0bc7583c2a7f9102c395f4ffc5e3+45", + "path" => "/foo"}}, + lambda do |resolved| + resolved["/out"] == { + "portable_data_hash" => "1f4b0bc7583c2a7f9102c395f4ffc5e3+45", + "kind" => "collection", + "path" => "/foo", + } + end], + # Empty collection + [{"/out" => { + "kind" => "collection", + "path" => "/foo"}}, + lambda do |resolved| + resolved["/out"] == { + "kind" => "collection", + "path" => "/foo", + } + end], ].each do |mounts, okfunc| test "resolve mounts #{mounts.inspect} to values" do set_user_from_auth :active @@ -461,9 +496,8 @@ class ContainerRequestTest < ActiveSupport::TestCase "path" => "/foo", }, } - assert_raises(ArgumentError) do - Container.resolve_mounts(m) - end + resolved_mounts = Container.resolve_mounts(m) + assert_equal m['portable_data_hash'], resolved_mounts['portable_data_hash'] end ['arvados/apitestfixture:latest', @@ -480,7 +514,7 @@ class ContainerRequestTest < ActiveSupport::TestCase 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.docker_image_formats = [ver] + Rails.configuration.Containers["SupportedDockerImageFormats"] = [ver] pdh = collections(coll).portable_data_hash resolved = Container.resolve_container_image(pdh) assert_equal resolved, pdh @@ -499,8 +533,14 @@ class ContainerRequestTest < ActiveSupport::TestCase end end + test "allow unrecognized container when there are remote_hosts" do + set_user_from_auth :active + Rails.configuration.RemoteClusters = {"foooo" => {"Host" => "bar.com"} } + Container.resolve_container_image('acbd18db4cc2f85cedef654fccc4a4d8+3') + end + test "migrated docker image" do - Rails.configuration.docker_image_formats = ['v2'] + Rails.configuration.Containers["SupportedDockerImageFormats"] = ['v2'] add_docker19_migration_link # Test that it returns only v2 images even though request is for v1 image. @@ -518,7 +558,7 @@ class ContainerRequestTest < ActiveSupport::TestCase end test "use unmigrated docker image" do - Rails.configuration.docker_image_formats = ['v1'] + Rails.configuration.Containers["SupportedDockerImageFormats"] = ['v1'] add_docker19_migration_link # Test that it returns only supported v1 images even though there is a @@ -537,7 +577,7 @@ class ContainerRequestTest < ActiveSupport::TestCase end test "incompatible docker image v1" do - Rails.configuration.docker_image_formats = ['v1'] + Rails.configuration.Containers["SupportedDockerImageFormats"] = ['v1'] add_docker19_migration_link # Don't return unsupported v2 image even if we ask for it directly. @@ -550,7 +590,7 @@ class ContainerRequestTest < ActiveSupport::TestCase end test "incompatible docker image v2" do - Rails.configuration.docker_image_formats = ['v2'] + Rails.configuration.Containers["SupportedDockerImageFormats"] = ['v2'] # No migration link, don't return unsupported v1 image, set_user_from_auth :active @@ -664,6 +704,89 @@ class ContainerRequestTest < ActiveSupport::TestCase assert_not_equal cr2.container_uuid, cr.container_uuid end + test "Retry on container cancelled with runtime_token" do + set_user_from_auth :spectator + spec = api_client_authorizations(:active) + cr = create_minimal_req!(priority: 1, state: "Committed", + runtime_token: spec.token, + container_count_max: 2) + prev_container_uuid = cr.container_uuid + + c = act_as_system_user do + c = Container.find_by_uuid(cr.container_uuid) + assert_equal spec.token, c.runtime_token + c.update_attributes!(state: Container::Locked) + c.update_attributes!(state: Container::Running) + c + end + + cr.reload + assert_equal "Committed", cr.state + assert_equal prev_container_uuid, cr.container_uuid + prev_container_uuid = cr.container_uuid + + act_as_system_user do + c.update_attributes!(state: Container::Cancelled) + end + + cr.reload + assert_equal "Committed", cr.state + assert_not_equal prev_container_uuid, cr.container_uuid + prev_container_uuid = cr.container_uuid + + c = act_as_system_user do + c = Container.find_by_uuid(cr.container_uuid) + assert_equal spec.token, c.runtime_token + c.update_attributes!(state: Container::Cancelled) + c + end + + cr.reload + assert_equal "Final", cr.state + assert_equal prev_container_uuid, cr.container_uuid + end + + + test "Retry saves logs from previous attempts" do + set_user_from_auth :active + cr = create_minimal_req!(priority: 1, state: "Committed", container_count_max: 3) + + c = act_as_system_user do + c = Container.find_by_uuid(cr.container_uuid) + c.update_attributes!(state: Container::Locked) + c.update_attributes!(state: Container::Running) + c + end + + container_uuids = [] + + [0, 1, 2].each do + cr.reload + assert_equal "Committed", cr.state + container_uuids << cr.container_uuid + + c = act_as_system_user do + logc = Collection.new(manifest_text: ". 37b51d194a7513e45b56f6524f2d51f2+3 0:3:bar\n") + logc.save! + c = Container.find_by_uuid(cr.container_uuid) + c.update_attributes!(state: Container::Cancelled, log: logc.portable_data_hash) + c + end + end + + container_uuids.sort! + + cr.reload + assert_equal "Final", cr.state + assert_equal 3, cr.container_count + assert_equal ". 37b51d194a7513e45b56f6524f2d51f2+3 0:3:bar +./log\\040for\\040container\\040#{container_uuids[0]} 37b51d194a7513e45b56f6524f2d51f2+3 0:3:bar +./log\\040for\\040container\\040#{container_uuids[1]} 37b51d194a7513e45b56f6524f2d51f2+3 0:3:bar +./log\\040for\\040container\\040#{container_uuids[2]} 37b51d194a7513e45b56f6524f2d51f2+3 0:3:bar +" , Collection.find_by_uuid(cr.log_uuid).manifest_text + + end + test "Output collection name setting using output_name with name collision resolution" do set_user_from_auth :active output_name = 'unimaginative name' @@ -713,7 +836,7 @@ class ContainerRequestTest < ActiveSupport::TestCase assert_not_nil(trash) assert_not_nil(delete) assert_in_delta(trash, now + 1.second, 10) - assert_in_delta(delete, now + Rails.configuration.blob_signature_ttl.second, 10) + assert_in_delta(delete, now + Rails.configuration.Collections["BlobSigningTTL"].second, 10) end def check_output_ttl_1y(now, trash, delete) @@ -760,16 +883,16 @@ class ContainerRequestTest < ActiveSupport::TestCase [ [false, ActiveRecord::RecordInvalid], [true, nil], - ].each do |preemptable_conf, expected| - test "having Rails.configuration.preemptable_instances=#{preemptable_conf}, create preemptable container request and verify #{expected}" do - sp = {"preemptable" => true} + ].each do |preemptible_conf, expected| + 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, command: ["echo", "hello"], output_path: "test", scheduling_parameters: sp, mounts: {"test" => {"kind" => "json"}}} - Rails.configuration.preemptable_instances = preemptable_conf + Rails.configuration.Containers["UsePreemptibleInstances"] = preemptible_conf set_user_from_auth :active cr = create_minimal_req!(common_attrs) @@ -790,15 +913,15 @@ class ContainerRequestTest < ActiveSupport::TestCase 'zzzzz-dz642-runningcontainr', nil, ].each do |requesting_c| - test "having preemptable instances active on the API server, a committed #{requesting_c.nil? ? 'non-':''}child CR should not ask for preemptable instance if parameter already set to false" do + test "having preemptible instances active on the API server, a committed #{requesting_c.nil? ? 'non-':''}child CR should not ask for preemptible instance if parameter already set to false" do common_attrs = {cwd: "test", priority: 1, command: ["echo", "hello"], output_path: "test", - scheduling_parameters: {"preemptable" => false}, + scheduling_parameters: {"preemptible" => false}, mounts: {"test" => {"kind" => "json"}}} - Rails.configuration.preemptable_instances = true + Rails.configuration.Containers["UsePreemptibleInstances"] = true set_user_from_auth :active if requesting_c @@ -813,7 +936,7 @@ class ContainerRequestTest < ActiveSupport::TestCase cr.state = ContainerRequest::Committed cr.save! - assert_equal false, cr.scheduling_parameters['preemptable'] + assert_equal false, cr.scheduling_parameters['preemptible'] end end @@ -822,15 +945,15 @@ class ContainerRequestTest < ActiveSupport::TestCase [true, nil, nil], [false, 'zzzzz-dz642-runningcontainr', nil], [false, nil, nil], - ].each do |preemptable_conf, requesting_c, schedule_preemptable| - test "having Rails.configuration.preemptable_instances=#{preemptable_conf}, #{requesting_c.nil? ? 'non-':''}child CR should #{schedule_preemptable ? '':'not'} ask for preemptable instance by default" do + ].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 common_attrs = {cwd: "test", priority: 1, command: ["echo", "hello"], output_path: "test", mounts: {"test" => {"kind" => "json"}}} - Rails.configuration.preemptable_instances = preemptable_conf + Rails.configuration.Containers["UsePreemptibleInstances"] = preemptible_conf set_user_from_auth :active if requesting_c @@ -845,7 +968,7 @@ class ContainerRequestTest < ActiveSupport::TestCase cr.state = ContainerRequest::Committed cr.save! - assert_equal schedule_preemptable, cr.scheduling_parameters['preemptable'] + assert_equal schedule_preemptible, cr.scheduling_parameters['preemptible'] end end @@ -855,6 +978,11 @@ class ContainerRequestTest < ActiveSupport::TestCase [{"partitions" => "fastcpu"}, ContainerRequest::Committed, ActiveRecord::RecordInvalid], [{"partitions" => "fastcpu"}, ContainerRequest::Uncommitted], [{"partitions" => ["fastcpu","vfastcpu"]}, ContainerRequest::Committed], + [{"max_run_time" => "one day"}, ContainerRequest::Committed, ActiveRecord::RecordInvalid], + [{"max_run_time" => "one day"}, ContainerRequest::Uncommitted], + [{"max_run_time" => -1}, ContainerRequest::Committed, ActiveRecord::RecordInvalid], + [{"max_run_time" => -1}, ContainerRequest::Uncommitted], + [{"max_run_time" => 86400}, ContainerRequest::Committed], ].each do |sp, state, expected| test "create container request with scheduling_parameters #{sp} in state #{state} and verify #{expected}" do common_attrs = {cwd: "test", @@ -881,6 +1009,26 @@ class ContainerRequestTest < ActiveSupport::TestCase end end + test "Having preemptible_instances=true create a committed child container request and verify the scheduling parameter of its container" do + common_attrs = {cwd: "test", + priority: 1, + command: ["echo", "hello"], + output_path: "test", + state: ContainerRequest::Committed, + mounts: {"test" => {"kind" => "json"}}} + set_user_from_auth :active + Rails.configuration.Containers["UsePreemptibleInstances"] = true + + cr = with_container_auth(Container.find_by_uuid 'zzzzz-dz642-runningcontainr') do + create_minimal_req!(common_attrs) + end + assert_equal 'zzzzz-dz642-runningcontainr', cr.requesting_container_uuid + assert_equal true, cr.scheduling_parameters["preemptible"] + + c = Container.find_by_uuid(cr.container_uuid) + assert_equal true, c.scheduling_parameters["preemptible"] + end + [['Committed', true, {name: "foobar", priority: 123}], ['Committed', false, {container_count: 2}], ['Committed', false, {container_count: 0}], @@ -1045,4 +1193,38 @@ class ContainerRequestTest < ActiveSupport::TestCase secret_mounts: sm) assert_equal [:secret_mounts], cr.errors.messages.keys end + + test "using runtime_token" do + set_user_from_auth :spectator + spec = api_client_authorizations(:active) + cr = create_minimal_req!(state: "Committed", runtime_token: spec.token, priority: 1) + cr.save! + c = Container.find_by_uuid cr.container_uuid + lock_and_run c + assert_nil c.auth_uuid + assert_equal c.runtime_token, spec.token + + assert_not_nil ApiClientAuthorization.find_by_uuid(spec.uuid) + + act_as_system_user do + c.update_attributes!(state: Container::Complete, + exit_code: 0, + output: '1f4b0bc7583c2a7f9102c395f4ffc5e3+45', + log: 'fa7aeb5140e2848d39b416daeef4ffc5+45') + end + + cr.reload + c.reload + assert_nil cr.runtime_token + assert_nil c.runtime_token + end + + test "invalid runtime_token" do + set_user_from_auth :active + spec = api_client_authorizations(:spectator) + assert_raises(ArgumentError) do + cr = create_minimal_req!(state: "Committed", runtime_token: "#{spec.token}xx") + cr.save! + end + end end