1 # Copyright (C) The Arvados Authors. All rights reserved.
3 # SPDX-License-Identifier: Apache-2.0
5 from builtins import str
6 from builtins import object
9 import arvados_cwl.context
10 import arvados_cwl.util
11 from arvados_cwl.arvdocker import arv_docker_clear_cache
19 import cwltool.process
20 import cwltool.secrets
21 from schema_salad.ref_resolver import Loader
22 from schema_salad.sourceline import cmap
24 from .matcher import JsonDiffMatcher, StripYAMLComments
25 from .mock_discovery import get_rootDesc
27 if not os.getenv('ARVADOS_DEBUG'):
28 logging.getLogger('arvados.cwl-runner').setLevel(logging.WARN)
29 logging.getLogger('arvados.arv-run').setLevel(logging.WARN)
31 class CollectionMock(object):
32 def __init__(self, vwdmock, *args, **kwargs):
33 self.vwdmock = vwdmock
36 def open(self, *args, **kwargs):
38 return self.vwdmock.open(*args, **kwargs)
40 def copy(self, *args, **kwargs):
42 self.vwdmock.copy(*args, **kwargs)
44 def save_new(self, *args, **kwargs):
50 def portable_data_hash(self):
52 return arvados.config.EMPTY_BLOCK_LOCATOR
54 return "99999999999999999999999999999996+99"
57 class TestContainer(unittest.TestCase):
60 cwltool.process._names = set()
62 def helper(self, runner, enable_reuse=True):
63 document_loader, avsc_names, schema_metadata, metaschema_loader = cwltool.process.get_schema("v1.1")
65 make_fs_access=functools.partial(arvados_cwl.CollectionFsAccess,
66 collection_cache=arvados_cwl.CollectionCache(runner.api, None, 0))
67 loadingContext = arvados_cwl.context.ArvLoadingContext(
68 {"avsc_names": avsc_names,
70 "make_fs_access": make_fs_access,
72 "metadata": {"cwlVersion": "v1.1", "http://commonwl.org/cwltool#original_cwlVersion": "v1.0"}})
73 runtimeContext = arvados_cwl.context.ArvRuntimeContext(
74 {"work_api": "containers",
76 "name": "test_run_"+str(enable_reuse),
77 "make_fs_access": make_fs_access,
79 "enable_reuse": enable_reuse,
81 "project_uuid": "zzzzz-8i9sb-zzzzzzzzzzzzzzz"
84 return loadingContext, runtimeContext
86 # Helper function to set up the ArvCwlExecutor to use the containers api
87 # and test that the RuntimeStatusLoggingHandler is set up correctly
88 def setup_and_test_container_executor_and_logging(self, gcc_mock) :
89 api = mock.MagicMock()
90 api._rootDesc = copy.deepcopy(get_rootDesc())
92 # Make sure ArvCwlExecutor thinks it's running inside a container so it
93 # adds the logging handler that will call runtime_status_update() mock
94 self.assertFalse(gcc_mock.called)
95 runner = arvados_cwl.ArvCwlExecutor(api)
96 self.assertEqual(runner.work_api, 'containers')
97 root_logger = logging.getLogger('')
98 handlerClasses = [h.__class__ for h in root_logger.handlers]
99 self.assertTrue(arvados_cwl.RuntimeStatusLoggingHandler in handlerClasses)
102 # The test passes no builder.resources
103 # Hence the default resources will apply: {'cores': 1, 'ram': 1024, 'outdirSize': 1024, 'tmpdirSize': 1024}
104 @mock.patch("arvados.commands.keepdocker.list_images_in_arv")
105 def test_run(self, keepdocker):
106 for enable_reuse in (True, False):
107 arv_docker_clear_cache()
109 runner = mock.MagicMock()
110 runner.ignore_docker_for_reuse = False
111 runner.intermediate_output_ttl = 0
112 runner.secret_store = cwltool.secrets.SecretStore()
114 keepdocker.return_value = [("zzzzz-4zz18-zzzzzzzzzzzzzz3", "")]
115 runner.api.collections().get().execute.return_value = {
116 "portable_data_hash": "99999999999999999999999999999993+99"}
122 "arguments": [{"valueFrom": "$(runtime.outdir)"}],
124 "class": "CommandLineTool"
127 loadingContext, runtimeContext = self.helper(runner, enable_reuse)
129 arvtool = arvados_cwl.ArvadosCommandTool(runner, tool, loadingContext)
130 arvtool.formatgraph = None
132 for j in arvtool.job({}, mock.MagicMock(), runtimeContext):
133 j.run(runtimeContext)
134 runner.api.container_requests().create.assert_called_with(
135 body=JsonDiffMatcher({
137 'HOME': '/var/spool/cwl',
140 'name': 'test_run_'+str(enable_reuse),
141 'runtime_constraints': {
145 'use_existing': enable_reuse,
148 '/tmp': {'kind': 'tmp',
149 "capacity": 1073741824
151 '/var/spool/cwl': {'kind': 'tmp',
152 "capacity": 1073741824 }
154 'state': 'Committed',
155 'output_name': 'Output for step test_run_'+str(enable_reuse),
156 'owner_uuid': 'zzzzz-8i9sb-zzzzzzzzzzzzzzz',
157 'output_path': '/var/spool/cwl',
159 'container_image': '99999999999999999999999999999993+99',
160 'command': ['ls', '/var/spool/cwl'],
161 'cwd': '/var/spool/cwl',
162 'scheduling_parameters': {},
167 # The test passes some fields in builder.resources
168 # For the remaining fields, the defaults will apply: {'cores': 1, 'ram': 1024, 'outdirSize': 1024, 'tmpdirSize': 1024}
169 @mock.patch("arvados.commands.keepdocker.list_images_in_arv")
170 def test_resource_requirements(self, keepdocker):
171 arv_docker_clear_cache()
172 runner = mock.MagicMock()
173 runner.ignore_docker_for_reuse = False
174 runner.intermediate_output_ttl = 3600
175 runner.secret_store = cwltool.secrets.SecretStore()
177 keepdocker.return_value = [("zzzzz-4zz18-zzzzzzzzzzzzzz3", "")]
178 runner.api.collections().get().execute.return_value = {
179 "portable_data_hash": "99999999999999999999999999999993+99"}
185 "class": "ResourceRequirement",
191 "class": "http://arvados.org/cwl#RuntimeConstraints",
194 "class": "http://arvados.org/cwl#APIRequirement",
196 "class": "http://arvados.org/cwl#PartitionRequirement",
199 "class": "http://arvados.org/cwl#IntermediateOutput",
202 "class": "http://arvados.org/cwl#ReuseRequirement",
207 "class": "CommandLineTool"
210 loadingContext, runtimeContext = self.helper(runner)
211 runtimeContext.name = "test_resource_requirements"
213 arvtool = arvados_cwl.ArvadosCommandTool(runner, tool, loadingContext)
214 arvtool.formatgraph = None
215 for j in arvtool.job({}, mock.MagicMock(), runtimeContext):
216 j.run(runtimeContext)
218 call_args, call_kwargs = runner.api.container_requests().create.call_args
220 call_body_expected = {
222 'HOME': '/var/spool/cwl',
225 'name': 'test_resource_requirements',
226 'runtime_constraints': {
229 'keep_cache_ram': 536870912,
232 'use_existing': False,
235 '/tmp': {'kind': 'tmp',
236 "capacity": 4194304000 },
237 '/var/spool/cwl': {'kind': 'tmp',
238 "capacity": 5242880000 }
240 'state': 'Committed',
241 'output_name': 'Output for step test_resource_requirements',
242 'owner_uuid': 'zzzzz-8i9sb-zzzzzzzzzzzzzzz',
243 'output_path': '/var/spool/cwl',
245 'container_image': '99999999999999999999999999999993+99',
247 'cwd': '/var/spool/cwl',
248 'scheduling_parameters': {
249 'partitions': ['blurb']
255 call_body = call_kwargs.get('body', None)
256 self.assertNotEqual(None, call_body)
257 for key in call_body:
258 self.assertEqual(call_body_expected.get(key), call_body.get(key))
261 # The test passes some fields in builder.resources
262 # For the remaining fields, the defaults will apply: {'cores': 1, 'ram': 1024, 'outdirSize': 1024, 'tmpdirSize': 1024}
263 @mock.patch("arvados.commands.keepdocker.list_images_in_arv")
264 @mock.patch("arvados.collection.Collection")
265 def test_initial_work_dir(self, collection_mock, keepdocker):
266 arv_docker_clear_cache()
267 runner = mock.MagicMock()
268 runner.ignore_docker_for_reuse = False
269 runner.intermediate_output_ttl = 0
270 runner.secret_store = cwltool.secrets.SecretStore()
272 keepdocker.return_value = [("zzzzz-4zz18-zzzzzzzzzzzzzz3", "")]
273 runner.api.collections().get().execute.return_value = {
274 "portable_data_hash": "99999999999999999999999999999993+99"}
276 sourcemock = mock.MagicMock()
277 def get_collection_mock(p):
279 return (sourcemock, p.split("/", 1)[1])
281 return (sourcemock, "")
282 runner.fs_access.get_collection.side_effect = get_collection_mock
284 vwdmock = mock.MagicMock()
285 collection_mock.side_effect = lambda *args, **kwargs: CollectionMock(vwdmock, *args, **kwargs)
291 "class": "InitialWorkDirRequirement",
295 "location": "keep:99999999999999999999999999999995+99/bar"
298 "class": "Directory",
300 "location": "keep:99999999999999999999999999999995+99"
304 "basename": "filename",
305 "location": "keep:99999999999999999999999999999995+99/baz/filename"
308 "class": "Directory",
309 "basename": "subdir",
310 "location": "keep:99999999999999999999999999999995+99/subdir"
315 "class": "CommandLineTool"
318 loadingContext, runtimeContext = self.helper(runner)
319 runtimeContext.name = "test_initial_work_dir"
321 arvtool = arvados_cwl.ArvadosCommandTool(runner, tool, loadingContext)
322 arvtool.formatgraph = None
323 for j in arvtool.job({}, mock.MagicMock(), runtimeContext):
324 j.run(runtimeContext)
326 call_args, call_kwargs = runner.api.container_requests().create.call_args
328 vwdmock.copy.assert_has_calls([mock.call('bar', 'foo', source_collection=sourcemock)])
329 vwdmock.copy.assert_has_calls([mock.call('.', 'foo2', source_collection=sourcemock)])
330 vwdmock.copy.assert_has_calls([mock.call('baz/filename', 'filename', source_collection=sourcemock)])
331 vwdmock.copy.assert_has_calls([mock.call('subdir', 'subdir', source_collection=sourcemock)])
333 call_body_expected = {
335 'HOME': '/var/spool/cwl',
338 'name': 'test_initial_work_dir',
339 'runtime_constraints': {
343 'use_existing': True,
346 '/tmp': {'kind': 'tmp',
347 "capacity": 1073741824 },
348 '/var/spool/cwl': {'kind': 'tmp',
349 "capacity": 1073741824 },
350 '/var/spool/cwl/foo': {
351 'kind': 'collection',
353 'portable_data_hash': '99999999999999999999999999999996+99'
355 '/var/spool/cwl/foo2': {
356 'kind': 'collection',
358 'portable_data_hash': '99999999999999999999999999999996+99'
360 '/var/spool/cwl/filename': {
361 'kind': 'collection',
363 'portable_data_hash': '99999999999999999999999999999996+99'
365 '/var/spool/cwl/subdir': {
366 'kind': 'collection',
368 'portable_data_hash': '99999999999999999999999999999996+99'
371 'state': 'Committed',
372 'output_name': 'Output for step test_initial_work_dir',
373 'owner_uuid': 'zzzzz-8i9sb-zzzzzzzzzzzzzzz',
374 'output_path': '/var/spool/cwl',
376 'container_image': '99999999999999999999999999999993+99',
378 'cwd': '/var/spool/cwl',
379 'scheduling_parameters': {
385 call_body = call_kwargs.get('body', None)
386 self.assertNotEqual(None, call_body)
387 for key in call_body:
388 self.assertEqual(call_body_expected.get(key), call_body.get(key))
391 # Test redirecting stdin/stdout/stderr
392 @mock.patch("arvados.commands.keepdocker.list_images_in_arv")
393 def test_redirects(self, keepdocker):
394 arv_docker_clear_cache()
396 runner = mock.MagicMock()
397 runner.ignore_docker_for_reuse = False
398 runner.intermediate_output_ttl = 0
399 runner.secret_store = cwltool.secrets.SecretStore()
401 keepdocker.return_value = [("zzzzz-4zz18-zzzzzzzzzzzzzz3", "")]
402 runner.api.collections().get().execute.return_value = {
403 "portable_data_hash": "99999999999999999999999999999993+99"}
405 document_loader, avsc_names, schema_metadata, metaschema_loader = cwltool.process.get_schema("v1.1")
411 "stdout": "stdout.txt",
412 "stderr": "stderr.txt",
413 "stdin": "/keep/99999999999999999999999999999996+99/file.txt",
414 "arguments": [{"valueFrom": "$(runtime.outdir)"}],
416 "class": "CommandLineTool"
419 loadingContext, runtimeContext = self.helper(runner)
420 runtimeContext.name = "test_run_redirect"
422 arvtool = arvados_cwl.ArvadosCommandTool(runner, tool, loadingContext)
423 arvtool.formatgraph = None
424 for j in arvtool.job({}, mock.MagicMock(), runtimeContext):
425 j.run(runtimeContext)
426 runner.api.container_requests().create.assert_called_with(
427 body=JsonDiffMatcher({
429 'HOME': '/var/spool/cwl',
432 'name': 'test_run_redirect',
433 'runtime_constraints': {
437 'use_existing': True,
440 '/tmp': {'kind': 'tmp',
441 "capacity": 1073741824 },
442 '/var/spool/cwl': {'kind': 'tmp',
443 "capacity": 1073741824 },
446 "path": "/var/spool/cwl/stderr.txt"
449 "kind": "collection",
451 "portable_data_hash": "99999999999999999999999999999996+99"
455 "path": "/var/spool/cwl/stdout.txt"
458 'state': 'Committed',
459 "output_name": "Output for step test_run_redirect",
460 'owner_uuid': 'zzzzz-8i9sb-zzzzzzzzzzzzzzz',
461 'output_path': '/var/spool/cwl',
463 'container_image': '99999999999999999999999999999993+99',
464 'command': ['ls', '/var/spool/cwl'],
465 'cwd': '/var/spool/cwl',
466 'scheduling_parameters': {},
471 @mock.patch("arvados.collection.Collection")
472 def test_done(self, col):
473 api = mock.MagicMock()
475 runner = mock.MagicMock()
477 runner.num_retries = 0
478 runner.ignore_docker_for_reuse = False
479 runner.intermediate_output_ttl = 0
480 runner.secret_store = cwltool.secrets.SecretStore()
482 runner.api.containers().get().execute.return_value = {"state":"Complete",
486 col().open.return_value = []
488 loadingContext, runtimeContext = self.helper(runner)
490 arvjob = arvados_cwl.ArvadosContainer(runner,
498 arvjob.output_callback = mock.MagicMock()
499 arvjob.collect_outputs = mock.MagicMock()
500 arvjob.successCodes = [0]
501 arvjob.outdir = "/var/spool/cwl"
502 arvjob.output_ttl = 3600
504 arvjob.collect_outputs.return_value = {"out": "stuff"}
508 "log_uuid": "zzzzz-4zz18-zzzzzzzzzzzzzz1",
509 "output_uuid": "zzzzz-4zz18-zzzzzzzzzzzzzz2",
510 "uuid": "zzzzz-xvhdp-zzzzzzzzzzzzzzz",
511 "container_uuid": "zzzzz-8i9sb-zzzzzzzzzzzzzzz",
512 "modified_at": "2017-05-26T12:01:22Z"
515 self.assertFalse(api.collections().create.called)
516 self.assertFalse(runner.runtime_status_error.called)
518 arvjob.collect_outputs.assert_called_with("keep:abc+123", 0)
519 arvjob.output_callback.assert_called_with({"out": "stuff"}, "success")
520 runner.add_intermediate_output.assert_called_with("zzzzz-4zz18-zzzzzzzzzzzzzz2")
522 # Test to make sure we dont call runtime_status_update if we already did
523 # some where higher up in the call stack
524 @mock.patch("arvados_cwl.util.get_current_container")
525 def test_recursive_runtime_status_update(self, gcc_mock):
526 self.setup_and_test_container_executor_and_logging(gcc_mock)
527 root_logger = logging.getLogger('')
529 # get_current_container is invoked when we call runtime_status_update
530 # so try and log again!
531 gcc_mock.side_effect = lambda *args: root_logger.error("Second Error")
533 root_logger.error("First Error")
535 self.fail("RuntimeStatusLoggingHandler should not be called recursively")
537 @mock.patch("arvados_cwl.ArvCwlExecutor.runtime_status_update")
538 @mock.patch("arvados_cwl.util.get_current_container")
539 @mock.patch("arvados.collection.CollectionReader")
540 @mock.patch("arvados.collection.Collection")
541 def test_child_failure(self, col, reader, gcc_mock, rts_mock):
542 runner = self.setup_and_test_container_executor_and_logging(gcc_mock)
544 gcc_mock.return_value = {"uuid" : "zzzzz-dz642-zzzzzzzzzzzzzzz"}
545 self.assertTrue(gcc_mock.called)
547 runner.num_retries = 0
548 runner.ignore_docker_for_reuse = False
549 runner.intermediate_output_ttl = 0
550 runner.secret_store = cwltool.secrets.SecretStore()
551 runner.label = mock.MagicMock()
552 runner.label.return_value = '[container testjob]'
554 runner.api.containers().get().execute.return_value = {
561 col().open.return_value = []
563 loadingContext, runtimeContext = self.helper(runner)
565 arvjob = arvados_cwl.ArvadosContainer(runner,
573 arvjob.output_callback = mock.MagicMock()
574 arvjob.collect_outputs = mock.MagicMock()
575 arvjob.successCodes = [0]
576 arvjob.outdir = "/var/spool/cwl"
577 arvjob.output_ttl = 3600
578 arvjob.collect_outputs.return_value = {"out": "stuff"}
582 "log_uuid": "zzzzz-4zz18-zzzzzzzzzzzzzz1",
583 "output_uuid": "zzzzz-4zz18-zzzzzzzzzzzzzz2",
584 "uuid": "zzzzz-xvhdp-zzzzzzzzzzzzzzz",
585 "container_uuid": "zzzzz-8i9sb-zzzzzzzzzzzzzzz",
586 "modified_at": "2017-05-26T12:01:22Z"
589 rts_mock.assert_called_with(
591 'arvados.cwl-runner: [container testjob] (zzzzz-xvhdp-zzzzzzzzzzzzzzz) error log:',
592 ' ** log is empty **'
594 arvjob.output_callback.assert_called_with({"out": "stuff"}, "permanentFail")
596 # The test passes no builder.resources
597 # Hence the default resources will apply: {'cores': 1, 'ram': 1024, 'outdirSize': 1024, 'tmpdirSize': 1024}
598 @mock.patch("arvados.commands.keepdocker.list_images_in_arv")
599 def test_mounts(self, keepdocker):
600 arv_docker_clear_cache()
602 runner = mock.MagicMock()
603 runner.ignore_docker_for_reuse = False
604 runner.intermediate_output_ttl = 0
605 runner.secret_store = cwltool.secrets.SecretStore()
607 keepdocker.return_value = [("zzzzz-4zz18-zzzzzzzzzzzzzz3", "")]
608 runner.api.collections().get().execute.return_value = {
609 "portable_data_hash": "99999999999999999999999999999994+99",
610 "manifest_text": ". 99999999999999999999999999999994+99 0:0:file1 0:0:file2"}
612 document_loader, avsc_names, schema_metadata, metaschema_loader = cwltool.process.get_schema("v1.1")
621 "arguments": [{"valueFrom": "$(runtime.outdir)"}],
623 "class": "CommandLineTool"
626 loadingContext, runtimeContext = self.helper(runner)
627 runtimeContext.name = "test_run_mounts"
629 arvtool = arvados_cwl.ArvadosCommandTool(runner, tool, loadingContext)
630 arvtool.formatgraph = None
633 "class": "Directory",
634 "location": "keep:99999999999999999999999999999994+44",
635 "http://arvados.org/cwl#collectionUUID": "zzzzz-4zz18-zzzzzzzzzzzzzzz",
639 "location": "keep:99999999999999999999999999999994+44/file1",
643 "location": "keep:99999999999999999999999999999994+44/file2",
648 for j in arvtool.job(job_order, mock.MagicMock(), runtimeContext):
649 j.run(runtimeContext)
650 runner.api.container_requests().create.assert_called_with(
651 body=JsonDiffMatcher({
653 'HOME': '/var/spool/cwl',
656 'name': 'test_run_mounts',
657 'runtime_constraints': {
661 'use_existing': True,
664 "/keep/99999999999999999999999999999994+44": {
665 "kind": "collection",
666 "portable_data_hash": "99999999999999999999999999999994+44",
667 "uuid": "zzzzz-4zz18-zzzzzzzzzzzzzzz"
669 '/tmp': {'kind': 'tmp',
670 "capacity": 1073741824 },
671 '/var/spool/cwl': {'kind': 'tmp',
672 "capacity": 1073741824 }
674 'state': 'Committed',
675 'output_name': 'Output for step test_run_mounts',
676 'owner_uuid': 'zzzzz-8i9sb-zzzzzzzzzzzzzzz',
677 'output_path': '/var/spool/cwl',
679 'container_image': '99999999999999999999999999999994+99',
680 'command': ['ls', '/var/spool/cwl'],
681 'cwd': '/var/spool/cwl',
682 'scheduling_parameters': {},
687 # The test passes no builder.resources
688 # Hence the default resources will apply: {'cores': 1, 'ram': 1024, 'outdirSize': 1024, 'tmpdirSize': 1024}
689 @mock.patch("arvados.commands.keepdocker.list_images_in_arv")
690 def test_secrets(self, keepdocker):
691 arv_docker_clear_cache()
693 runner = mock.MagicMock()
694 runner.ignore_docker_for_reuse = False
695 runner.intermediate_output_ttl = 0
696 runner.secret_store = cwltool.secrets.SecretStore()
698 keepdocker.return_value = [("zzzzz-4zz18-zzzzzzzzzzzzzz3", "")]
699 runner.api.collections().get().execute.return_value = {
700 "portable_data_hash": "99999999999999999999999999999993+99"}
702 document_loader, avsc_names, schema_metadata, metaschema_loader = cwltool.process.get_schema("v1.1")
704 tool = cmap({"arguments": ["md5sum", "example.conf"],
705 "class": "CommandLineTool",
708 "class": "http://commonwl.org/cwltool#Secrets",
714 "id": "#secret_job.cwl",
717 "id": "#secret_job.cwl/pw",
725 "class": "InitialWorkDirRequirement",
728 "entry": "username: user\npassword: $(inputs.pw)\n",
729 "entryname": "example.conf"
735 loadingContext, runtimeContext = self.helper(runner)
736 runtimeContext.name = "test_secrets"
738 arvtool = arvados_cwl.ArvadosCommandTool(runner, tool, loadingContext)
739 arvtool.formatgraph = None
741 job_order = {"pw": "blorp"}
742 runner.secret_store.store(["pw"], job_order)
744 for j in arvtool.job(job_order, mock.MagicMock(), runtimeContext):
745 j.run(runtimeContext)
746 runner.api.container_requests().create.assert_called_with(
747 body=JsonDiffMatcher({
749 'HOME': '/var/spool/cwl',
752 'name': 'test_secrets',
753 'runtime_constraints': {
757 'use_existing': True,
760 '/tmp': {'kind': 'tmp',
761 "capacity": 1073741824
763 '/var/spool/cwl': {'kind': 'tmp',
764 "capacity": 1073741824 }
766 'state': 'Committed',
767 'output_name': 'Output for step test_secrets',
768 'owner_uuid': 'zzzzz-8i9sb-zzzzzzzzzzzzzzz',
769 'output_path': '/var/spool/cwl',
771 'container_image': '99999999999999999999999999999993+99',
772 'command': ['md5sum', 'example.conf'],
773 'cwd': '/var/spool/cwl',
774 'scheduling_parameters': {},
777 "/var/spool/cwl/example.conf": {
778 "content": "username: user\npassword: blorp\n",
784 # The test passes no builder.resources
785 # Hence the default resources will apply: {'cores': 1, 'ram': 1024, 'outdirSize': 1024, 'tmpdirSize': 1024}
786 @mock.patch("arvados.commands.keepdocker.list_images_in_arv")
787 def test_timelimit(self, keepdocker):
788 arv_docker_clear_cache()
790 runner = mock.MagicMock()
791 runner.ignore_docker_for_reuse = False
792 runner.intermediate_output_ttl = 0
793 runner.secret_store = cwltool.secrets.SecretStore()
795 keepdocker.return_value = [("zzzzz-4zz18-zzzzzzzzzzzzzz3", "")]
796 runner.api.collections().get().execute.return_value = {
797 "portable_data_hash": "99999999999999999999999999999993+99"}
803 "arguments": [{"valueFrom": "$(runtime.outdir)"}],
805 "class": "CommandLineTool",
808 "class": "ToolTimeLimit",
814 loadingContext, runtimeContext = self.helper(runner)
815 runtimeContext.name = "test_timelimit"
817 arvtool = arvados_cwl.ArvadosCommandTool(runner, tool, loadingContext)
818 arvtool.formatgraph = None
820 for j in arvtool.job({}, mock.MagicMock(), runtimeContext):
821 j.run(runtimeContext)
823 _, kwargs = runner.api.container_requests().create.call_args
824 self.assertEqual(42, kwargs['body']['scheduling_parameters'].get('max_run_time'))
827 class TestWorkflow(unittest.TestCase):
829 cwltool.process._names = set()
831 def helper(self, runner, enable_reuse=True):
832 document_loader, avsc_names, schema_metadata, metaschema_loader = cwltool.process.get_schema("v1.1")
834 make_fs_access=functools.partial(arvados_cwl.CollectionFsAccess,
835 collection_cache=arvados_cwl.CollectionCache(runner.api, None, 0))
837 document_loader.fetcher_constructor = functools.partial(arvados_cwl.CollectionFetcher, api_client=runner.api, fs_access=make_fs_access(""))
838 document_loader.fetcher = document_loader.fetcher_constructor(document_loader.cache, document_loader.session)
839 document_loader.fetch_text = document_loader.fetcher.fetch_text
840 document_loader.check_exists = document_loader.fetcher.check_exists
842 loadingContext = arvados_cwl.context.ArvLoadingContext(
843 {"avsc_names": avsc_names,
845 "make_fs_access": make_fs_access,
846 "loader": document_loader,
847 "metadata": {"cwlVersion": "v1.1", "http://commonwl.org/cwltool#original_cwlVersion": "v1.0"},
848 "construct_tool_object": runner.arv_make_tool})
849 runtimeContext = arvados_cwl.context.ArvRuntimeContext(
850 {"work_api": "containers",
852 "name": "test_run_wf_"+str(enable_reuse),
853 "make_fs_access": make_fs_access,
855 "enable_reuse": enable_reuse,
858 return loadingContext, runtimeContext
860 # The test passes no builder.resources
861 # Hence the default resources will apply: {'cores': 1, 'ram': 1024, 'outdirSize': 1024, 'tmpdirSize': 1024}
862 @mock.patch("arvados.collection.CollectionReader")
863 @mock.patch("arvados.collection.Collection")
864 @mock.patch('arvados.commands.keepdocker.list_images_in_arv')
865 def test_run(self, list_images_in_arv, mockcollection, mockcollectionreader):
866 arv_docker_clear_cache()
867 arvados_cwl.add_arv_hints()
869 api = mock.MagicMock()
870 api._rootDesc = get_rootDesc()
872 runner = arvados_cwl.executor.ArvCwlExecutor(api)
873 self.assertEqual(runner.work_api, 'containers')
875 list_images_in_arv.return_value = [["zzzzz-4zz18-zzzzzzzzzzzzzzz"]]
876 runner.api.collections().get().execute.return_value = {"portable_data_hash": "99999999999999999999999999999993+99"}
877 runner.api.collections().list().execute.return_value = {"items": [{"uuid": "zzzzz-4zz18-zzzzzzzzzzzzzzz",
878 "portable_data_hash": "99999999999999999999999999999993+99"}]}
880 runner.project_uuid = "zzzzz-8i9sb-zzzzzzzzzzzzzzz"
881 runner.ignore_docker_for_reuse = False
882 runner.num_retries = 0
883 runner.secret_store = cwltool.secrets.SecretStore()
885 loadingContext, runtimeContext = self.helper(runner)
886 runner.fs_access = runtimeContext.make_fs_access(runtimeContext.basedir)
888 tool, metadata = loadingContext.loader.resolve_ref("tests/wf/scatter2.cwl")
889 metadata["cwlVersion"] = tool["cwlVersion"]
891 mockc = mock.MagicMock()
892 mockcollection.side_effect = lambda *args, **kwargs: CollectionMock(mockc, *args, **kwargs)
893 mockcollectionreader().find.return_value = arvados.arvfile.ArvadosFile(mock.MagicMock(), "token.txt")
895 arvtool = arvados_cwl.ArvadosWorkflow(runner, tool, loadingContext)
896 arvtool.formatgraph = None
897 it = arvtool.job({}, mock.MagicMock(), runtimeContext)
899 next(it).run(runtimeContext)
900 next(it).run(runtimeContext)
902 with open("tests/wf/scatter2_subwf.cwl") as f:
903 subwf = StripYAMLComments(f.read()).rstrip()
905 runner.api.container_requests().create.assert_called_with(
906 body=JsonDiffMatcher({
911 "--preserve-entire-environment",
915 "container_image": "99999999999999999999999999999993+99",
916 "cwd": "/var/spool/cwl",
918 "HOME": "/var/spool/cwl",
922 "/keep/99999999999999999999999999999999+118": {
923 "kind": "collection",
924 "portable_data_hash": "99999999999999999999999999999999+118"
927 "capacity": 1073741824,
931 "capacity": 1073741824,
934 "/var/spool/cwl/cwl.input.yml": {
935 "kind": "collection",
936 "path": "cwl.input.yml",
937 "portable_data_hash": "99999999999999999999999999999996+99"
939 "/var/spool/cwl/workflow.cwl": {
940 "kind": "collection",
941 "path": "workflow.cwl",
942 "portable_data_hash": "99999999999999999999999999999996+99"
946 "path": "/var/spool/cwl/cwl.output.json"
949 "name": "scatterstep",
950 "output_name": "Output for step scatterstep",
951 "output_path": "/var/spool/cwl",
955 "runtime_constraints": {
959 "scheduling_parameters": {},
961 "state": "Committed",
964 mockc.open().__enter__().write.assert_has_calls([mock.call(subwf)])
965 mockc.open().__enter__().write.assert_has_calls([mock.call(
968 "basename": "token.txt",
970 "location": "/keep/99999999999999999999999999999999+118/token.txt",
976 # The test passes no builder.resources
977 # Hence the default resources will apply: {'cores': 1, 'ram': 1024, 'outdirSize': 1024, 'tmpdirSize': 1024}
978 @mock.patch("arvados.collection.CollectionReader")
979 @mock.patch("arvados.collection.Collection")
980 @mock.patch('arvados.commands.keepdocker.list_images_in_arv')
981 def test_overall_resource_singlecontainer(self, list_images_in_arv, mockcollection, mockcollectionreader):
982 arv_docker_clear_cache()
983 arvados_cwl.add_arv_hints()
985 api = mock.MagicMock()
986 api._rootDesc = get_rootDesc()
988 runner = arvados_cwl.executor.ArvCwlExecutor(api)
989 self.assertEqual(runner.work_api, 'containers')
991 list_images_in_arv.return_value = [["zzzzz-4zz18-zzzzzzzzzzzzzzz"]]
992 runner.api.collections().get().execute.return_value = {"uuid": "zzzzz-4zz18-zzzzzzzzzzzzzzz",
993 "portable_data_hash": "99999999999999999999999999999993+99"}
994 runner.api.collections().list().execute.return_value = {"items": [{"uuid": "zzzzz-4zz18-zzzzzzzzzzzzzzz",
995 "portable_data_hash": "99999999999999999999999999999993+99"}]}
997 runner.project_uuid = "zzzzz-8i9sb-zzzzzzzzzzzzzzz"
998 runner.ignore_docker_for_reuse = False
999 runner.num_retries = 0
1000 runner.secret_store = cwltool.secrets.SecretStore()
1002 loadingContext, runtimeContext = self.helper(runner)
1003 runner.fs_access = runtimeContext.make_fs_access(runtimeContext.basedir)
1004 loadingContext.do_update = True
1005 tool, metadata = loadingContext.loader.resolve_ref("tests/wf/echo-wf.cwl")
1007 mockcollection.side_effect = lambda *args, **kwargs: CollectionMock(mock.MagicMock(), *args, **kwargs)
1009 arvtool = arvados_cwl.ArvadosWorkflow(runner, tool, loadingContext)
1010 arvtool.formatgraph = None
1011 it = arvtool.job({}, mock.MagicMock(), runtimeContext)
1013 next(it).run(runtimeContext)
1014 next(it).run(runtimeContext)
1016 with open("tests/wf/echo-subwf.cwl") as f:
1017 subwf = StripYAMLComments(f.read())
1019 runner.api.container_requests().create.assert_called_with(
1020 body=JsonDiffMatcher({
1022 'environment': {'HOME': '/var/spool/cwl', 'TMPDIR': '/tmp'},
1023 'scheduling_parameters': {},
1024 'name': u'echo-subwf',
1025 'secret_mounts': {},
1026 'runtime_constraints': {'API': True, 'vcpus': 3, 'ram': 1073741824},
1030 '/var/spool/cwl/cwl.input.yml': {
1031 'portable_data_hash': '99999999999999999999999999999996+99',
1032 'kind': 'collection',
1033 'path': 'cwl.input.yml'
1035 '/var/spool/cwl/workflow.cwl': {
1036 'portable_data_hash': '99999999999999999999999999999996+99',
1037 'kind': 'collection',
1038 'path': 'workflow.cwl'
1041 'path': '/var/spool/cwl/cwl.output.json',
1046 'capacity': 1073741824
1047 }, '/var/spool/cwl': {
1049 'capacity': 3221225472
1052 'state': 'Committed',
1053 'output_path': '/var/spool/cwl',
1054 'container_image': '99999999999999999999999999999993+99',
1059 u'--preserve-entire-environment',
1060 u'workflow.cwl#main',
1063 'use_existing': True,
1064 'output_name': u'Output for step echo-subwf',
1065 'cwd': '/var/spool/cwl'
1068 def test_default_work_api(self):
1069 arvados_cwl.add_arv_hints()
1071 api = mock.MagicMock()
1072 api._rootDesc = copy.deepcopy(get_rootDesc())
1073 runner = arvados_cwl.executor.ArvCwlExecutor(api)
1074 self.assertEqual(runner.work_api, 'containers')