Home | History | Annotate | Download | only in helper
      1 # Copyright 2011 Google Inc. All Rights Reserved.
      2 
      3 __author__ = 'asharif (at] google.com (Ahmad Sharif)'
      4 
      5 import os.path
      6 import re
      7 
      8 from automation.clients.helper import jobs
      9 from automation.clients.helper import perforce
     10 from automation.common import command as cmd
     11 from automation.common import machine
     12 
     13 
     14 class ScriptsFactory(object):
     15 
     16   def __init__(self, chromeos_root, scripts_path):
     17     self._chromeos_root = chromeos_root
     18     self._scripts_path = scripts_path
     19 
     20   def SummarizeResults(self, logs_path):
     21     return cmd.Shell('summarize_results.py', logs_path, path=self._scripts_path)
     22 
     23   def Buildbot(self, config_name):
     24     buildbot = os.path.join(self._chromeos_root,
     25                             'chromite/cbuildbot/cbuildbot.py')
     26 
     27     return cmd.Shell(buildbot, '--buildroot=%s' % self._chromeos_root,
     28                      '--resume', '--noarchive', '--noprebuilts', '--nosync',
     29                      '--nouprev', '--notests', '--noclean', config_name)
     30 
     31   def RunBenchmarks(self, board, tests):
     32     image_path = os.path.join(self._chromeos_root, 'src/build/images', board,
     33                               'latest/chromiumos_image.bin')
     34 
     35     return cmd.Shell('cros_run_benchmarks.py',
     36                      '--remote=$SECONDARY_MACHINES[0]',
     37                      '--board=%s' % board,
     38                      '--tests=%s' % tests,
     39                      '--full_table',
     40                      image_path,
     41                      path='/home/mobiletc-prebuild')
     42 
     43   def SetupChromeOS(self, version='latest', use_minilayout=False):
     44     setup_chromeos = cmd.Shell('setup_chromeos.py',
     45                                '--public',
     46                                '--dir=%s' % self._chromeos_root,
     47                                '--version=%s' % version,
     48                                path=self._scripts_path)
     49 
     50     if use_minilayout:
     51       setup_chromeos.AddOption('--minilayout')
     52     return setup_chromeos
     53 
     54 
     55 class CommandsFactory(object):
     56   DEPOT2_DIR = '//depot2/'
     57   P4_CHECKOUT_DIR = 'perforce2/'
     58   P4_VERSION_DIR = os.path.join(P4_CHECKOUT_DIR, 'gcctools/chromeos/v14')
     59 
     60   CHROMEOS_ROOT = 'chromeos'
     61   CHROMEOS_SCRIPTS_DIR = os.path.join(CHROMEOS_ROOT, 'src/scripts')
     62   CHROMEOS_BUILDS_DIR = '/home/mobiletc-prebuild/www/chromeos_builds'
     63 
     64   def __init__(self, chromeos_version, board, toolchain, p4_snapshot):
     65     self.chromeos_version = chromeos_version
     66     self.board = board
     67     self.toolchain = toolchain
     68     self.p4_snapshot = p4_snapshot
     69 
     70     self.scripts = ScriptsFactory(self.CHROMEOS_ROOT, self.P4_VERSION_DIR)
     71 
     72   def AddBuildbotConfig(self, config_name, config_list):
     73     config_header = 'add_config(%r, [%s])' % (config_name,
     74                                               ', '.join(config_list))
     75     config_file = os.path.join(self.CHROMEOS_ROOT,
     76                                'chromite/cbuildbot/cbuildbot_config.py')
     77     quoted_config_header = '%r' % config_header
     78     quoted_config_header = re.sub("'", "\\\"", quoted_config_header)
     79 
     80     return cmd.Pipe(
     81         cmd.Shell('echo', quoted_config_header),
     82         cmd.Shell('tee', '--append', config_file))
     83 
     84   def RunBuildbot(self):
     85     config_dict = {'board': self.board,
     86                    'build_tests': True,
     87                    'chrome_tests': True,
     88                    'unittests': False,
     89                    'vm_tests': False,
     90                    'prebuilts': False,
     91                    'latest_toolchain': True,
     92                    'useflags': ['chrome_internal'],
     93                    'usepkg_chroot': True,
     94                    self.toolchain: True}
     95     config_name = '%s-toolchain-test' % self.board
     96     if 'arm' in self.board:
     97       config_list = ['arm']
     98     else:
     99       config_list = []
    100     config_list.extend(['internal', 'full', 'official', str(config_dict)])
    101 
    102     add_config_shell = self.AddBuildbotConfig(config_name, config_list)
    103     return cmd.Chain(add_config_shell, self.scripts.Buildbot(config_name))
    104 
    105   def BuildAndBenchmark(self):
    106     return cmd.Chain(
    107         self.CheckoutV14Dir(),
    108         self.SetupChromeOSCheckout(self.chromeos_version, True),
    109         self.RunBuildbot(),
    110         self.scripts.RunBenchmarks(self.board, 'BootPerfServer,10:Page,3'))
    111 
    112   def GetP4Snapshot(self, p4view):
    113     p4client = perforce.CommandsFactory(self.P4_CHECKOUT_DIR, p4view)
    114 
    115     if self.p4_snapshot:
    116       return p4client.CheckoutFromSnapshot(self.p4_snapshot)
    117     else:
    118       return p4client.SetupAndDo(p4client.Sync(), p4client.Remove())
    119 
    120   def CheckoutV14Dir(self):
    121     p4view = perforce.View(self.DEPOT2_DIR, [
    122         perforce.PathMapping('gcctools/chromeos/v14/...')
    123     ])
    124     return self.GetP4Snapshot(p4view)
    125 
    126   def SetupChromeOSCheckout(self, version, use_minilayout=False):
    127     version_re = '^\d+\.\d+\.\d+\.[a-zA-Z0-9]+$'
    128 
    129     location = os.path.join(self.CHROMEOS_BUILDS_DIR, version)
    130 
    131     if version in ['weekly', 'quarterly']:
    132       assert os.path.islink(location), 'Symlink %s does not exist.' % location
    133 
    134       location_expanded = os.path.abspath(os.path.realpath(location))
    135       version = os.path.basename(location_expanded)
    136 
    137     if version in ['top', 'latest'] or re.match(version_re, version):
    138       return self.scripts.SetupChromeOS(version, use_minilayout)
    139 
    140     elif version.endswith('bz2') or version.endswith('gz'):
    141       return cmd.UnTar(location_expanded, self.CHROMEOS_ROOT)
    142 
    143     else:
    144       signature_file_location = os.path.join(location,
    145                                              'src/scripts/enter_chroot.sh')
    146       assert os.path.exists(signature_file_location), (
    147           'Signature file %s does not exist.' % signature_file_location)
    148 
    149       return cmd.Copy(location, to_dir=self.CHROMEOS_ROOT, recursive=True)
    150 
    151 
    152 class JobsFactory(object):
    153 
    154   def __init__(self,
    155                chromeos_version='top',
    156                board='x86-mario',
    157                toolchain='trunk',
    158                p4_snapshot=''):
    159     self.chromeos_version = chromeos_version
    160     self.board = board
    161     self.toolchain = toolchain
    162 
    163     self.commands = CommandsFactory(chromeos_version, board, toolchain,
    164                                     p4_snapshot)
    165 
    166   def BuildAndBenchmark(self):
    167     command = self.commands.BuildAndBenchmark()
    168 
    169     label = 'BuildAndBenchmark(%s,%s,%s)' % (self.toolchain, self.board,
    170                                              self.chromeos_version)
    171 
    172     machine_label = 'chromeos-%s' % self.board
    173 
    174     job = jobs.CreateLinuxJob(label, command)
    175     job.DependsOnMachine(
    176         machine.MachineSpecification(label=machine_label,
    177                                      lock_required=True),
    178         False)
    179 
    180     return job
    181