Exemple #1
0
 def test_main_naked_with_account_switch(self):
   self.capture_luci_ctx = True
   self.mock_popen_with_oserr()
   cmd = [
     '--no-log',
     '--cache', self.tempdir,
     '--named-cache-root', os.path.join(self.tempdir, 'c'),
     '--switch-to-account', 'task',
     '--',
     '/bin/echo',
     'hello',
     'world',
   ]
   root_ctx = {
     'accounts': [{'id': 'bot'}, {'id': 'task'}],
     'default_account_id' : 'bot',
     'secret': 'sekret',
     'rpc_port': 12345,
   }
   with luci_context.write(local_auth=root_ctx):
     run_isolated.main(cmd)
   # Switched default account to task.
   task_ctx = root_ctx.copy()
   task_ctx['default_account_id'] = 'task'
   self.assertEqual(task_ctx, self.popen_calls[0][1]['luci_ctx']['local_auth'])
Exemple #2
0
 def test_main_naked_with_account_pop(self):
     self.capture_luci_ctx = True
     self.mock_popen_with_oserr()
     cmd = [
         '--no-log',
         '--cache',
         os.path.join(self.tempdir, 'isolated_cache'),
         '--named-cache-root',
         os.path.join(self.tempdir, 'named_cache'),
         '--switch-to-account',
         'task',
         '--raw-cmd',
         '--',
         '/bin/echo',
         'hello',
         'world',
     ]
     root_ctx = {
         'accounts': [{
             'id': 'bot'
         }],  # only 'bot', there's no 'task'
         'default_account_id': 'bot',
         'secret': 'sekret',
         'rpc_port': 12345,
     }
     with luci_context.write(local_auth=root_ctx):
         run_isolated.main(cmd)
     # Unset default account, since 'task' account is not defined.
     task_ctx = root_ctx.copy()
     task_ctx.pop('default_account_id')
     self.assertEqual(task_ctx,
                      self.popen_calls[0][1]['luci_ctx']['local_auth'])
Exemple #3
0
 def test_main_relative_cwd_no_cmd(self):
     cmd = [
         '--relative-cwd',
         'a',
     ]
     with self.assertRaises(SystemExit):
         run_isolated.main(cmd)
Exemple #4
0
 def test_main_bad_relative_cwd(self):
   cmd = [
     '--raw-cmd',
     '--relative-cwd', 'a/../../b',
     '--',
     'bin/echo${EXECUTABLE_SUFFIX}',
     'hello',
     'world',
   ]
   with self.assertRaises(SystemExit):
     run_isolated.main(cmd)
Exemple #5
0
    def test_main_args(self):
        self.mock(run_isolated.tools, "disable_buffering", lambda: None)
        calls = []
        # Unused argument ''
        # pylint: disable=W0613
        def call(command, cwd, env):
            calls.append(command)
            return 0

        self.mock(run_isolated.subprocess, "call", call)
        isolated = json_dumps({"command": ["foo.exe", "cmd with space"]})
        isolated_hash = ALGO(isolated).hexdigest()

        def get_storage(_isolate_server, _namespace):
            return StorageFake({isolated_hash: isolated})

        self.mock(run_isolated.isolateserver, "get_storage", get_storage)

        cmd = [
            "--no-log",
            "--hash",
            isolated_hash,
            "--cache",
            self.tempdir,
            "--isolate-server",
            "https://localhost",
            "--",
            "--extraargs",
            "bar",
        ]
        ret = run_isolated.main(cmd)
        self.assertEqual(0, ret)
        self.assertEqual([[self.temp_join(u"foo.exe"), u"cmd with space", "--extraargs", "bar"]], calls)
Exemple #6
0
  def test_main_naked_with_caches(self):
    # An empty named cache is not kept!
    # Interestingly, because we would need to put something in the named cache
    # for it to be kept, we need the tool to write to it. This is tested in the
    # smoke test.
    trimmed = []
    def trim_caches(caches, root, min_free_space, max_age_secs):
      trimmed.append(True)
      self.assertEqual(2, len(caches))
      self.assertTrue(root)
      # The name cache root is increased by the sum of the two hints.
      self.assertEqual(2*1024*1024*1024 + 1100, min_free_space)
      self.assertEqual(1814400, max_age_secs)
    self.mock(local_caching, 'trim_caches', trim_caches)
    nc = os.path.join(self.tempdir, 'named_cache')
    cmd = [
      '--no-log',
      '--leak-temp-dir',
      '--cache', os.path.join(self.tempdir, 'isolated_cache'), '100',
      '--named-cache-root', nc,
      '--named-cache', 'cache_foo', 'foo', '100',
      '--named-cache', 'cache_bar', 'bar', '1000',
      '--raw-cmd',
      '--',
      'bin/echo${EXECUTABLE_SUFFIX}',
      'hello',
      'world',
    ]
    ret = run_isolated.main(cmd)
    self.assertEqual(0, ret)

    for cache_name in ('cache_foo', 'cache_bar'):
      named_path = os.path.join(nc, 'named', cache_name)
      self.assertFalse(os.path.exists(named_path))
    self.assertTrue(trimmed)
    def test_main_naked_with_caches(self):
        cmd = [
            '--no-log',
            '--leak-temp-dir',
            '--cache',
            os.path.join(self.tempdir, 'cache'),
            '--named-cache-root',
            os.path.join(self.tempdir, 'c'),
            '--named-cache',
            'cache_foo',
            'foo',
            '--named-cache',
            'cache_bar',
            'bar',
            'bin/echo${EXECUTABLE_SUFFIX}',
            'hello',
            'world',
        ]
        ret = run_isolated.main(cmd)
        self.assertEqual(0, ret)

        for path, cache_name in [('foo', 'cache_foo'), ('bar', 'cache_bar')]:
            self.assertEqual(
                os.path.abspath(
                    os.readlink(os.path.join(self.tempdir, 'ir', path))),
                os.path.abspath(
                    os.readlink(
                        os.path.join(self.tempdir, 'c', 'named', cache_name))),
            )
Exemple #8
0
    def test_main(self):
        self.mock(run_isolated.tools, 'disable_buffering', lambda: None)
        calls = []

        # Unused argument ''
        # pylint: disable=W0613
        def call(command, cwd, env):
            calls.append(command)
            return 0

        self.mock(run_isolated.subprocess, 'call', call)
        isolated = json_dumps({
            'command': ['foo.exe', 'cmd with space'],
        })
        isolated_hash = ALGO(isolated).hexdigest()

        def get_storage(_isolate_server, _namespace):
            return StorageFake({isolated_hash: isolated})

        self.mock(run_isolated.isolateserver, 'get_storage', get_storage)

        cmd = [
            '--no-log',
            '--hash',
            isolated_hash,
            '--cache',
            self.tempdir,
            '--isolate-server',
            'https://localhost',
        ]
        ret = run_isolated.main(cmd)
        self.assertEqual(0, ret)
        self.assertEqual([[self.temp_join(u'foo.exe'), u'cmd with space']],
                         calls)
Exemple #9
0
    def test_main_naked_with_caches(self):
        cmd = [
            '--no-log',
            '--leak-temp-dir',
            '--cache',
            os.path.join(self.tempdir, 'cache'),
            '--named-cache-root',
            os.path.join(self.tempdir, 'c'),
            '--named-cache',
            'cache_foo',
            'foo',
            '--named-cache',
            'cache_bar',
            'bar',
            'bin/echo${EXECUTABLE_SUFFIX}',
            'hello',
            'world',
        ]
        ret = run_isolated.main(cmd)
        self.assertEqual(0, ret)

        for cache_name in ('cache_foo', 'cache_bar'):
            named_path = os.path.join(self.tempdir, 'c', 'named', cache_name)
            self.assertTrue(os.path.exists(named_path))
            self.assertEqual(
                os.path.join(self.tempdir, 'c'),
                os.path.dirname(os.readlink(named_path)),
            )
    def test_main_args(self):
        self.mock(tools, 'disable_buffering', lambda: None)
        isolated = json_dumps({'command': ['foo.exe', 'cmd w/ space']})
        isolated_hash = isolateserver_mock.hash_content(isolated)

        def get_storage(_isolate_server, _namespace):
            return StorageFake({isolated_hash: isolated})

        self.mock(isolateserver, 'get_storage', get_storage)

        cmd = [
            '--no-log',
            '--isolated',
            isolated_hash,
            '--cache',
            self.tempdir,
            '--isolate-server',
            'https://localhost',
            '--',
            '--extraargs',
            'bar',
        ]
        ret = run_isolated.main(cmd)
        self.assertEqual(0, ret)
        self.assertEqual([
            ([
                self.temp_join(u'foo.exe'), u'cmd w/ space', '--extraargs',
                'bar'
            ], {
                'detached': True
            }),
        ], self.popen_calls)
  def test_main_args(self):
    self.mock(tools, 'disable_buffering', lambda: None)
    isolated = json_dumps({'command': ['foo.exe', 'cmd w/ space']})
    isolated_hash = isolateserver_mock.hash_content(isolated)
    def get_storage(_isolate_server, _namespace):
      return StorageFake({isolated_hash:isolated})
    self.mock(isolateserver, 'get_storage', get_storage)

    cmd = [
        '--no-log',
        '--isolated', isolated_hash,
        '--cache', self.tempdir,
        '--isolate-server', 'https://localhost',
        '--',
        '--extraargs',
        'bar',
    ]
    ret = run_isolated.main(cmd)
    self.assertEqual(0, ret)
    self.assertEqual(
        [
          ([self.temp_join(u'foo.exe'), u'cmd w/ space', '--extraargs', 'bar'],
            {'detached': True}),
          ],
        self.popen_calls)
Exemple #12
0
    def test_main_naked(self):
        self.mock_popen_with_oserr()
        self.mock(on_error, 'report', lambda _: None)
        # The most naked .isolated file that can exist.
        self.mock(tools, 'disable_buffering', lambda: None)
        isolated = json_dumps({'command': ['invalid', 'command']})
        isolated_hash = isolateserver_mock.hash_content(isolated)

        def get_storage(_isolate_server, _namespace):
            return StorageFake({isolated_hash: isolated})

        self.mock(isolateserver, 'get_storage', get_storage)

        cmd = [
            '--no-log',
            '--isolated',
            isolated_hash,
            '--cache',
            os.path.join(self.tempdir, 'isolated_cache'),
            '--isolate-server',
            'https://localhost',
            '--named-cache-root',
            os.path.join(self.tempdir, 'named_cache'),
            '--root-dir',
            self.tempdir,
        ]
        ret = run_isolated.main(cmd)
        self.assertEqual(1, ret)
        self.assertEqual(1, len(self.popen_calls))
        self.assertEqual([
            ([self.ir_dir(u'invalid'), u'command'], {
                'cwd': self.ir_dir(),
                'detached': True
            }),
        ], self.popen_calls)
  def test_main_naked(self):
    # The most naked .isolated file that can exist.
    self.mock(run_isolated.tools, 'disable_buffering', lambda: None)
    isolated = json_dumps({'command': ['invalid', 'command']})
    isolated_hash = ALGO(isolated).hexdigest()
    def get_storage(_isolate_server, _namespace):
      return StorageFake({isolated_hash:isolated})
    self.mock(run_isolated.isolateserver, 'get_storage', get_storage)

    # Keeps tuple of (args, kwargs).
    subprocess_call = []
    self.mock(
        run_isolated.subprocess, 'call',
        lambda *x, **y: subprocess_call.append((x, y)) or 8)

    cmd = [
        '--no-log',
        '--hash', isolated_hash,
        '--cache', self.tempdir,
        '--isolate-server', 'https://localhost',
    ]
    ret = run_isolated.main(cmd)
    self.assertEqual(8, ret)
    self.assertEqual(1, len(subprocess_call))
    self.assertTrue(subprocess_call[0][1].pop('cwd'))
    self.assertTrue(subprocess_call[0][1].pop('env'))
    self.assertEqual(
        [(([self.temp_join(u'invalid'), u'command'],), {})], subprocess_call)
Exemple #14
0
    def test_main_naked(self):
        # The most naked .isolated file that can exist.
        self.mock(run_isolated.tools, 'disable_buffering', lambda: None)
        isolated = json_dumps({'command': ['invalid', 'command']})
        isolated_hash = ALGO(isolated).hexdigest()

        def get_storage(_isolate_server, _namespace):
            return StorageFake({isolated_hash: isolated})

        self.mock(run_isolated.isolateserver, 'get_storage', get_storage)

        # Keeps tuple of (args, kwargs).
        subprocess_call = []
        self.mock(run_isolated.subprocess, 'call',
                  lambda *x, **y: subprocess_call.append((x, y)) or 8)

        cmd = [
            '--no-log',
            '--hash',
            isolated_hash,
            '--cache',
            self.tempdir,
            '--isolate-server',
            'https://localhost',
        ]
        ret = run_isolated.main(cmd)
        self.assertEqual(8, ret)
        self.assertEqual(1, len(subprocess_call))
        self.assertTrue(subprocess_call[0][1].pop('cwd'))
        self.assertTrue(subprocess_call[0][1].pop('env'))
        self.assertEqual([(([self.temp_join(u'invalid'), u'command'], ), {})],
                         subprocess_call)
  def test_main_args(self):
    self.mock(run_isolated.tools, 'disable_buffering', lambda: None)
    calls = []
    # Unused argument ''
    # pylint: disable=W0613
    def call(command, cwd, env):
      calls.append(command)
      return 0
    self.mock(run_isolated.subprocess, 'call', call)
    isolated = json_dumps(
        {
          'command': ['foo.exe', 'cmd with space'],
        })
    isolated_hash = ALGO(isolated).hexdigest()
    def get_storage(_isolate_server, _namespace):
      return StorageFake({isolated_hash:isolated})
    self.mock(run_isolated.isolateserver, 'get_storage', get_storage)

    cmd = [
        '--no-log',
        '--hash', isolated_hash,
        '--cache', self.tempdir,
        '--isolate-server', 'https://localhost',
        '--',
        '--extraargs',
        'bar',
    ]
    ret = run_isolated.main(cmd)
    self.assertEqual(0, ret)
    self.assertEqual(
        [[self.temp_join(u'foo.exe'), u'cmd with space', '--extraargs', 'bar']],
        calls)
  def test_main_naked(self):
    self.mock(on_error, 'report', lambda _: None)
    # The most naked .isolated file that can exist.
    self.mock(tools, 'disable_buffering', lambda: None)
    isolated = json_dumps({'command': ['invalid', 'command']})
    isolated_hash = isolateserver_mock.hash_content(isolated)
    def get_storage(_isolate_server, _namespace):
      return StorageFake({isolated_hash:isolated})
    self.mock(isolateserver, 'get_storage', get_storage)

    def r(self, args, **kwargs):
      old_init(self, args, **kwargs)
      raise OSError('Unknown')
    old_init = self.mock(subprocess42.Popen, '__init__', r)

    cmd = [
        '--no-log',
        '--isolated', isolated_hash,
        '--cache', self.tempdir,
        '--isolate-server', 'https://localhost',
    ]
    ret = run_isolated.main(cmd)
    self.assertEqual(1, ret)
    self.assertEqual(1, len(self.popen_calls))
    self.assertEqual(
        [([self.temp_join(u'invalid'), u'command'], {'detached': True})],
        self.popen_calls)
    def test_main_naked(self):
        self.mock(on_error, 'report', lambda _: None)
        # The most naked .isolated file that can exist.
        self.mock(tools, 'disable_buffering', lambda: None)
        isolated = json_dumps({'command': ['invalid', 'command']})
        isolated_hash = isolateserver_mock.hash_content(isolated)

        def get_storage(_isolate_server, _namespace):
            return StorageFake({isolated_hash: isolated})

        self.mock(isolateserver, 'get_storage', get_storage)

        def r(self, args, **kwargs):
            old_init(self, args, **kwargs)
            raise OSError('Unknown')

        old_init = self.mock(subprocess42.Popen, '__init__', r)

        cmd = [
            '--no-log',
            '--isolated',
            isolated_hash,
            '--cache',
            self.tempdir,
            '--isolate-server',
            'https://localhost',
        ]
        ret = run_isolated.main(cmd)
        self.assertEqual(1, ret)
        self.assertEqual(1, len(self.popen_calls))
        self.assertEqual([([self.temp_join(u'invalid'), u'command'], {
            'detached': True
        })], self.popen_calls)
Exemple #18
0
    def test_main_naked_with_caches(self):
        # An empty named cache is not kept!
        # Interestingly, because we would need to put something in the named cache
        # for it to be kept, we need the tool to write to it. This is tested in the
        # smoke test.
        nc = os.path.join(self.tempdir, 'named_cache')
        cmd = [
            '--no-log',
            '--leak-temp-dir',
            '--cache',
            os.path.join(self.tempdir, 'isolated_cache'),
            '--named-cache-root',
            nc,
            '--named-cache',
            'cache_foo',
            'foo',
            '--named-cache',
            'cache_bar',
            'bar',
            '--raw-cmd',
            '--',
            'bin/echo${EXECUTABLE_SUFFIX}',
            'hello',
            'world',
        ]
        ret = run_isolated.main(cmd)
        self.assertEqual(0, ret)

        for cache_name in ('cache_foo', 'cache_bar'):
            named_path = os.path.join(nc, 'named', cache_name)
            self.assertFalse(os.path.exists(named_path))
Exemple #19
0
    def test_main(self):
        self.mock(tools, 'disable_buffering', lambda: None)
        isolated = json_dumps({
            'command': ['foo.exe', 'cmd with space'],
        })
        isolated_hash = isolateserver_mock.hash_content(isolated)

        def get_storage(_isolate_server, _namespace):
            return StorageFake({isolated_hash: isolated})

        self.mock(isolateserver, 'get_storage', get_storage)

        cmd = [
            '--no-log',
            '--isolated',
            isolated_hash,
            '--cache',
            os.path.join(self.tempdir, 'isolated_cache'),
            '--named-cache-root',
            os.path.join(self.tempdir, 'named_cache'),
            '--isolate-server',
            'https://localhost',
            '--root-dir',
            self.tempdir,
        ]
        ret = run_isolated.main(cmd)
        self.assertEqual(0, ret)
        self.assertEqual([
            ([self.ir_dir(u'foo.exe'), u'cmd with space'], {
                'cwd': self.ir_dir(),
                'detached': True
            }),
        ], self.popen_calls)
Exemple #20
0
    def test_main_naked_with_cipd_client_no_packages(self):
        cipd_cache = os.path.join(self.tempdir, 'cipd_cache')
        cmd = [
            '--no-log',
            '--cache',
            os.path.join(self.tempdir, 'isolated_cache'),
            '--cipd-enabled',
            '--cipd-client-version',
            'git:wowza',
            '--cipd-server',
            self.cipd_server.url,
            '--cipd-cache',
            cipd_cache,
            '--named-cache-root',
            os.path.join(self.tempdir, 'named_cache'),
            '--raw-cmd',
            '--relative-cwd',
            'a',
            '--',
            'bin/echo${EXECUTABLE_SUFFIX}',
            'hello',
            'world',
        ]

        self.capture_popen_env = True
        ret = run_isolated.main(cmd)
        self.assertEqual(0, ret)

        # The CIPD client was bootstrapped and hardlinked (or copied on Win).
        client_binary_file = unicode(
            os.path.join(cipd_cache, 'clients',
                         'aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa'))
        self.assertTrue(fs.isfile(client_binary_file))
        client_binary_link = unicode(
            os.path.join(cipd_cache, 'bin', 'cipd' + cipd.EXECUTABLE_SUFFIX))
        self.assertTrue(fs.isfile(client_binary_link))

        # 'cipd ensure' was NOT called (only 'echo hello world' was).
        env = self.popen_calls[0][1].pop('env')
        self.assertEqual([
            ([self.ir_dir(u'a', 'bin', 'echo'), u'hello', u'world'], {
                'cwd': self.ir_dir('a'),
                'detached': True
            }),
        ], self.popen_calls)

        # Directory with cipd client is in front of PATH.
        path = env['PATH'].split(os.pathsep)
        self.assertEqual(os.path.join(cipd_cache, 'bin'), path[0])

        # CIPD_CACHE_DIR is set.
        self.assertEqual(os.path.join(cipd_cache, 'cache'),
                         env['CIPD_CACHE_DIR'])
Exemple #21
0
    def test_main_json(self):
        # Instruct the Popen mock to write a file in ISOLATED_OUTDIR so it will be
        # archived back on termination.
        self.mock(tools, 'disable_buffering', lambda: None)
        sub_cmd = [
            self.ir_dir(u'foo.exe'),
            u'cmd with space',
            '${ISOLATED_OUTDIR}/out.txt',
        ]
        isolated_in_json = json_dumps({'command': sub_cmd})
        isolated_in_hash = isolateserver_mock.hash_content(isolated_in_json)

        def get_storage(_isolate_server, _namespace):
            return StorageFake({isolated_in_hash: isolated_in_json})

        self.mock(isolateserver, 'get_storage', get_storage)

        out = os.path.join(self.tempdir, 'res.json')
        cmd = [
            '--no-log',
            '--isolated',
            isolated_in_hash,
            '--cache',
            os.path.join(self.tempdir, 'isolated_cache'),
            '--isolate-server',
            'https://localhost:1',
            '--named-cache-root',
            os.path.join(self.tempdir, 'named_cache'),
            '--json',
            out,
            '--root-dir',
            self.tempdir,
        ]
        ret = run_isolated.main(cmd)
        self.assertEqual(0, ret)
        # Replace ${ISOLATED_OUTDIR} with the temporary directory.
        sub_cmd[2] = self.popen_calls[0][0][2]
        self.assertNotIn('ISOLATED_OUTDIR', sub_cmd[2])
        self.assertEqual([(sub_cmd, {
            'cwd': self.ir_dir(),
            'detached': True
        })], self.popen_calls)
        isolated_out = {
            'algo': 'sha-1',
            'files': {
                'out.txt': {
                    'h': isolateserver_mock.hash_content('generated data\n'),
                    's': 15,
                    'm': 0640,
                },
            },
            'version': isolated_format.ISOLATED_FILE_VERSION,
        }
Exemple #22
0
 def test_main_naked_without_isolated(self):
   self.mock_popen_with_oserr()
   cmd = [
     '--no-log',
     '--cache', self.tempdir,
     '--named-cache-root', os.path.join(self.tempdir, 'c'),
     '/bin/echo',
     'hello',
     'world',
   ]
   ret = run_isolated.main(cmd)
   self.assertEqual(1, ret)
   self.assertEqual(1, len(self.popen_calls))
   self.assertEqual(
       [([u'/bin/echo', u'hello', u'world'], {'detached': True})],
       self.popen_calls)
Exemple #23
0
 def test_main_naked_leaking(self):
   workdir = tempfile.mkdtemp()
   try:
     cmd = [
       '--no-log',
       '--cache', self.tempdir,
       '--root-dir', workdir,
       '--leak-temp-dir',
       '--named-cache-root', os.path.join(self.tempdir, 'c'),
       '/bin/echo',
       'hello',
       'world',
     ]
     ret = run_isolated.main(cmd)
     self.assertEqual(0, ret)
   finally:
     fs.rmtree(unicode(workdir))
Exemple #24
0
    def test_main_naked(self):
        # The most naked .isolated file that can exist.
        self.mock(run_isolated.tools, "disable_buffering", lambda: None)
        isolated = json_dumps({"command": ["invalid", "command"]})
        isolated_hash = ALGO(isolated).hexdigest()

        def get_storage(_isolate_server, _namespace):
            return StorageFake({isolated_hash: isolated})

        self.mock(run_isolated.isolateserver, "get_storage", get_storage)

        # Keeps tuple of (args, kwargs).
        subprocess_call = []
        self.mock(run_isolated.subprocess, "call", lambda *x, **y: subprocess_call.append((x, y)) or 8)

        cmd = ["--no-log", "--hash", isolated_hash, "--cache", self.tempdir, "--isolate-server", "https://localhost"]
        ret = run_isolated.main(cmd)
        self.assertEqual(8, ret)
        self.assertEqual(1, len(subprocess_call))
        self.assertTrue(subprocess_call[0][1].pop("cwd"))
        self.assertTrue(subprocess_call[0][1].pop("env"))
        self.assertEqual([(([self.temp_join(u"invalid"), u"command"],), {})], subprocess_call)
  def test_main_json(self):
    # Instruct the Popen mock to write a file in ISOLATED_OUTDIR so it will be
    # archived back on termination.
    self.mock(tools, 'disable_buffering', lambda: None)
    sub_cmd = [
      self.temp_join(u'foo.exe'), u'cmd with space',
      '${ISOLATED_OUTDIR}/out.txt',
    ]
    isolated = json_dumps({'command': sub_cmd})
    isolated_hash = isolateserver_mock.hash_content(isolated)
    def get_storage(_isolate_server, _namespace):
      return StorageFake({isolated_hash:isolated})
    self.mock(isolateserver, 'get_storage', get_storage)

    out = os.path.join(self.tempdir, 'res.json')
    cmd = [
        '--no-log',
        '--isolated', isolated_hash,
        '--cache', self.tempdir,
        '--isolate-server', 'https://localhost:1',
        '--json', out,
    ]
    ret = run_isolated.main(cmd)
    self.assertEqual(0, ret)
    # Replace ${ISOLATED_OUTDIR} with the temporary directory.
    sub_cmd[2] = self.popen_calls[0][0][2]
    self.assertNotIn('ISOLATED_OUTDIR', sub_cmd[2])
    self.assertEqual([(sub_cmd, {'detached': True})], self.popen_calls)
    expected = {
      u'exit_code': 0,
      u'internal_failure': None,
      u'outputs_ref': {
        u'isolated': u'e0a0fffa0910dd09e7ef4c89496116f60317e6c4',
        u'isolatedserver': u'http://localhost:1',
        u'namespace': u'default-gzip',
      },
      u'version': 1,
    }
    self.assertEqual(expected, tools.read_json(out))
  def test_main_json(self):
    # Instruct the Popen mock to write a file in ISOLATED_OUTDIR so it will be
    # archived back on termination.
    self.mock(tools, 'disable_buffering', lambda: None)
    sub_cmd = [
      self.temp_join(u'foo.exe'), u'cmd with space',
      '${ISOLATED_OUTDIR}/out.txt',
    ]
    isolated_in_json = json_dumps({'command': sub_cmd})
    isolated_in_hash = isolateserver_mock.hash_content(isolated_in_json)
    def get_storage(_isolate_server, _namespace):
      return StorageFake({isolated_in_hash:isolated_in_json})
    self.mock(isolateserver, 'get_storage', get_storage)

    out = os.path.join(self.tempdir, 'res.json')
    cmd = [
        '--no-log',
        '--isolated', isolated_in_hash,
        '--cache', self.tempdir,
        '--isolate-server', 'https://localhost:1',
        '--json', out,
    ]
    ret = run_isolated.main(cmd)
    self.assertEqual(0, ret)
    # Replace ${ISOLATED_OUTDIR} with the temporary directory.
    sub_cmd[2] = self.popen_calls[0][0][2]
    self.assertNotIn('ISOLATED_OUTDIR', sub_cmd[2])
    self.assertEqual([(sub_cmd, {'detached': True})], self.popen_calls)
    isolated_out = {
      'algo': 'sha-1',
      'files': {
        'out.txt': {
          'h': isolateserver_mock.hash_content('generated data\n'),
          's': 15,
          'm': 0640,
        },
      },
      'version': isolated_format.ISOLATED_FILE_VERSION,
    }
Exemple #27
0
def CMDrun_isolated(args):
  """Internal command to run an isolated command."""
  sys.path.insert(0, os.path.join(THIS_FILE, 'client'))
  # run_isolated setups logging by itself.
  import run_isolated
  return run_isolated.main(args)
  def test_main_naked_with_packages(self):
    pin_idx_ref = [0]
    pins = [
      [
        ('infra/data/x', 'badc0fee'*5),
        ('infra/data/y', 'cafebabe'*5),
      ],
      [
        ('infra/tools/echo/linux-amd64', 'deadbeef'*5),
      ],
    ]

    def fake_ensure(args, **_kwargs):
      if (args[0].endswith('/cipd') and
          args[1] == 'ensure'
          and '-json-output' in args):
        idx = args.index('-json-output')
        with open(args[idx+1], 'w') as json_out:
          json.dump({
            'result': [
              {'package': pkg, 'instance_id': ver}
              for pkg, ver in pins[pin_idx_ref[0]]
            ],
          }, json_out)
        pin_idx_ref[0] += 1
        return 0

    self.popen_mocks.append(fake_ensure)
    cipd_cache = os.path.join(self.tempdir, 'cipd_cache')
    cmd = [
      '--no-log',
      '--cache', os.path.join(self.tempdir, 'cache'),
      '--cipd-client-version', 'git:wowza',
      '--cipd-package', 'bin:infra/tools/echo/${platform}:latest',
      '--cipd-package', '.:infra/data/x:latest',
      '--cipd-package', '.:infra/data/y:canary',
      '--cipd-server', self.cipd_server.url,
      '--cipd-cache', cipd_cache,
      '--named-cache-root', os.path.join(self.tempdir, 'c'),
      'bin/echo${EXECUTABLE_SUFFIX}',
      'hello',
      'world',
    ]
    ret = run_isolated.main(cmd)
    self.assertEqual(0, ret)

    self.assertEqual(3, len(self.popen_calls))

    # Test cipd-ensure command for installing packages.
    for cipd_ensure_cmd, _ in self.popen_calls[0:2]:
      self.assertEqual(cipd_ensure_cmd[:2], [
        os.path.join(cipd_cache, 'cipd' + cipd.EXECUTABLE_SUFFIX),
        'ensure',
      ])
      cache_dir_index = cipd_ensure_cmd.index('-cache-dir')
      self.assertEqual(
          cipd_ensure_cmd[cache_dir_index+1],
          os.path.join(cipd_cache, 'cipd_internal'))

    # Test cipd client cache. `git:wowza` was a tag and so is cacheable.
    self.assertEqual(len(os.listdir(os.path.join(cipd_cache, 'versions'))), 2)
    version_file = unicode(os.path.join(
        cipd_cache, 'versions', '633d2aa4119cc66803f1600f9c4d85ce0e0581b5'))
    self.assertTrue(fs.isfile(version_file))
    with open(version_file) as f:
      self.assertEqual(f.read(), 'aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa')

    client_binary_file = unicode(os.path.join(
        cipd_cache, 'clients', 'aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa'))
    self.assertTrue(fs.isfile(client_binary_file))

    # Test echo call.
    echo_cmd, _ = self.popen_calls[2]
    self.assertTrue(echo_cmd[0].endswith(
        os.path.sep + 'bin' + os.path.sep + 'echo' + cipd.EXECUTABLE_SUFFIX),
        echo_cmd[0])
    self.assertEqual(echo_cmd[1:], ['hello', 'world'])
Exemple #29
0
def CMDrun_isolated(args):
    """Internal command to run an isolated command."""
    sys.path.insert(0, os.path.join(THIS_FILE, 'client'))
    # run_isolated setups logging by itself.
    import run_isolated
    return run_isolated.main(args)
Exemple #30
0
    def test_main_naked_with_packages(self):
        self.mock(cipd, 'get_platform', lambda: 'linux-amd64')

        pins = {
            '': [
                ('infra/data/x', 'badc0fee' * 5),
                ('infra/data/y', 'cafebabe' * 5),
            ],
            'bin': [
                ('infra/tools/echo/linux-amd64', 'deadbeef' * 5),
            ],
        }

        def fake_ensure(args, **_kwargs):
            if (args[0].endswith('/cipd') and args[1] == 'ensure'
                    and '-json-output' in args):
                idx = args.index('-json-output')
                with open(args[idx + 1], 'w') as json_out:
                    json.dump(
                        {
                            'result': {
                                subdir: [{
                                    'package': pkg,
                                    'instance_id': ver
                                } for pkg, ver in packages]
                                for subdir, packages in pins.iteritems()
                            }
                        }, json_out)
                return 0

        self.popen_mocks.append(fake_ensure)
        cipd_cache = os.path.join(self.tempdir, 'cipd_cache')
        cmd = [
            '--no-log',
            '--cache',
            os.path.join(self.tempdir, 'isolated_cache'),
            '--cipd-client-version',
            'git:wowza',
            '--cipd-package',
            'bin:infra/tools/echo/${platform}:latest',
            '--cipd-package',
            '.:infra/data/x:latest',
            '--cipd-package',
            '.:infra/data/y:canary',
            '--cipd-server',
            self.cipd_server.url,
            '--cipd-cache',
            cipd_cache,
            '--named-cache-root',
            os.path.join(self.tempdir, 'named_cache'),
            '--raw-cmd',
            '--',
            'bin/echo${EXECUTABLE_SUFFIX}',
            'hello',
            'world',
        ]
        ret = run_isolated.main(cmd)
        self.assertEqual(0, ret)

        self.assertEqual(2, len(self.popen_calls))

        # Test cipd-ensure command for installing packages.
        cipd_ensure_cmd, _ = self.popen_calls[0]
        self.assertEqual(cipd_ensure_cmd[:2], [
            os.path.join(cipd_cache, 'bin', 'cipd' + cipd.EXECUTABLE_SUFFIX),
            'ensure',
        ])
        cache_dir_index = cipd_ensure_cmd.index('-cache-dir')
        self.assertEqual(cipd_ensure_cmd[cache_dir_index + 1],
                         os.path.join(cipd_cache, 'cache'))

        # Test cipd client cache. `git:wowza` was a tag and so is cacheable.
        self.assertEqual(len(os.listdir(os.path.join(cipd_cache, 'versions'))),
                         2)
        version_file = unicode(
            os.path.join(cipd_cache, 'versions',
                         '765a0de4c618f91faf923cb68a47bb564aed412d'))
        self.assertTrue(fs.isfile(version_file))
        with open(version_file) as f:
            self.assertEqual(f.read(),
                             'aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa')

        client_binary_file = unicode(
            os.path.join(cipd_cache, 'clients',
                         'aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa'))
        self.assertTrue(fs.isfile(client_binary_file))

        # Test echo call.
        echo_cmd, _ = self.popen_calls[1]
        self.assertTrue(
            echo_cmd[0].endswith(os.path.sep + 'bin' + os.path.sep + 'echo' +
                                 cipd.EXECUTABLE_SUFFIX), echo_cmd[0])
        self.assertEqual(echo_cmd[1:], [u'hello', u'world'])
Exemple #31
0
def CMDrun_isolated(args):
  """Internal command to run an isolated command."""
  logging_utils.prepare_logging('run_isolated_bot.log')
  sys.path.insert(0, os.path.join(THIS_FILE, 'client'))
  import run_isolated
  return run_isolated.main(args)