Exemplo n.º 1
0
  def BuildRelease(self, target):
    clnum_path = os.path.join('$JOB_TMP', self.CHECKOUT_DIR, 'CLNUM')

    toolchain_root = os.path.join('/google/data/rw/projects/toolchains', target,
                                  'unstable')
    toolchain_path = os.path.join(toolchain_root, '${CLNUM}')

    build_toolchain = cmd.Wrapper(
        cmd.Chain(
            cmd.MakeDir(toolchain_path),
            cmd.Shell('buildit',
                      '--keep-work-dir',
                      '--build-type=release',
                      '--work-dir=%s' % self.buildit_work_dir_path,
                      '--results-dir=%s' % toolchain_path,
                      '--force-release=%s' % '${CLNUM}',
                      target,
                      path='.')),
        cwd=self.buildit_path,
        umask='0022',
        env={'CLNUM': '$(< %s)' % clnum_path})

    # remove all but 10 most recent directories
    remove_old_toolchains_from_x20 = cmd.Wrapper(
        cmd.Pipe(
            cmd.Shell('ls', '-1', '-r'), cmd.Shell('sed', '-e', '1,10d'),
            cmd.Shell('xargs', 'rm', '-r', '-f')),
        cwd=toolchain_root)

    return cmd.Chain(build_toolchain, remove_old_toolchains_from_x20)
Exemplo n.º 2
0
  def RunTests(self, target, board, component='gcc'):
    dejagnu_flags = ['--outdir=%s' % self.dejagnu_output_path,
                     '--target_board=%s' % board]

    # Look for {pandaboard,qemu}.exp files in
    # //depot/google3/experimental/users/kbaclawski/dejagnu/boards

    site_exp_file = os.path.join('/google/src/head/depot/google3',
                                 'experimental/users/kbaclawski',
                                 'dejagnu/site.exp')

    build_dir_path = os.path.join(target, 'rpmbuild/BUILD/crosstool*-0.0',
                                  'build-%s' % component)

    run_dejagnu = cmd.Wrapper(
        cmd.Chain(
            cmd.MakeDir(self.dejagnu_output_path),
            cmd.Shell('make',
                      'check',
                      '-k',
                      '-j $(grep -c processor /proc/cpuinfo)',
                      'RUNTESTFLAGS="%s"' % ' '.join(dejagnu_flags),
                      'DEJAGNU="%s"' % site_exp_file,
                      ignore_error=True)),
        cwd=os.path.join(self.buildit_work_dir_path, build_dir_path),
        env={'REMOTE_TMPDIR': 'job-$JOB_ID'})

    save_results = cmd.Copy(self.dejagnu_output_path,
                            to_dir='$JOB_TMP/results',
                            recursive=True)

    return cmd.Chain(run_dejagnu, save_results)
 def CreateJobGroup(self):
     chain = cmd.Chain(
         self.CheckoutV14Dir(),
         cmd.Shell('python',
                   os.path.join(self.P4_VERSION_DIR, 'test_gcc_dejagnu.py'),
                   '--board=%s' % self._board, '--remote=%s' % self._remote,
                   '--cleanup=%s' % self._cleanup))
     label = 'dejagnu'
     job = jobs.CreateLinuxJob(label, chain, timeout=8 * 60 * 60)
     return job_group.JobGroup(label, [job],
                               cleanup_on_failure=True,
                               cleanup_on_completion=True)
Exemplo n.º 4
0
    def CreateJobGroup(self):
        chain = cmd.Chain(
            self.CheckoutV14Dir(),
            cmd.Shell(
                'python',
                os.path.join(self.P4_VERSION_DIR, 'test_toolchains.py'),
                '--force-mismatch',
                '--clean',
                '--public',  # crbug.com/145822
                '--board=%s' % self._board,
                '--remote=%s' % self._remote,
                '--githashes=%s' % self._gcc_githash))
        label = 'testlabel'
        job = jobs.CreateLinuxJob(label, chain, timeout=24 * 60 * 60)

        return job_group.JobGroup(label, [job], True, False)
  def RunBuildbot(self):
    config_dict = {'board': self.board,
                   'build_tests': True,
                   'chrome_tests': True,
                   'unittests': False,
                   'vm_tests': False,
                   'prebuilts': False,
                   'latest_toolchain': True,
                   'useflags': ['chrome_internal'],
                   'usepkg_chroot': True,
                   self.toolchain: True}
    config_name = '%s-toolchain-test' % self.board
    if 'arm' in self.board:
      config_list = ['arm']
    else:
      config_list = []
    config_list.extend(['internal', 'full', 'official', str(config_dict)])

    add_config_shell = self.AddBuildbotConfig(config_name, config_list)
    return cmd.Chain(add_config_shell, self.scripts.Buildbot(config_name))
    def AddJobGroup(self, group):
        with self._lock:
            group.id = self._id_producer.GetNextId()

        self._logger.debug('Creating runtime environment for %r.', group)

        CommandExecuter().RunCommand(
            cmd.Chain(cmd.RmTree(group.home_dir), cmd.MakeDir(group.home_dir)))

        with self._lock:
            self.all_job_groups.append(group)

            for job_ in group.jobs:
                self.job_manager.AddJob(job_)

            group.status = job_group.STATUS_EXECUTING

        self._logger.info('Added %r to queue.', group)

        return group.id
 def BuildAndBenchmark(self):
   return cmd.Chain(
       self.CheckoutV14Dir(),
       self.SetupChromeOSCheckout(self.chromeos_version, True),
       self.RunBuildbot(),
       self.scripts.RunBenchmarks(self.board, 'BootPerfServer,10:Page,3'))