1# Copyright 2011 Google Inc. All Rights Reserved.
2
3__author__ = 'asharif@google.com (Ahmad Sharif)'
4
5import os.path
6import re
7
8from automation.clients.helper import jobs
9from automation.clients.helper import perforce
10from automation.common import command as cmd
11from automation.common import machine
12
13
14class 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
55class 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
152class 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