chrome/build_nacl_irt.py - chromium/src.git - Git at Google

 #!/usr/bin/python
 # Copyright (c) 2011 The Chromium Authors. All rights reserved.
 # Use of this source code is governed by a BSD-style license that can be
 # found in the LICENSE file.

 import optparse
 import os
 import re
 import shutil
 import subprocess
 import sys


 # Where things are in relation to this script.
 SCRIPT_DIR = os.path.dirname(os.path.abspath(__file__))
 SRC_DIR = os.path.dirname(SCRIPT_DIR)
 NACL_DIR = os.path.join(SRC_DIR, 'native_client')

 # Pathing to the two command_buffer directories (relative to native_client).
 NACL_CMD_BUFFER_DIR = os.path.join('src', 'shared',
                                    'ppapi_proxy', 'command_buffer')
 GPU_CMD_BUFFER_DIR = os.path.join('..', 'gpu', 'command_buffer')

 # Pathing to mirror of nacl tree in ppapi.
 PPAPI_NACL_DIR = os.path.join(SRC_DIR, 'ppapi', 'native_client')


 def RelativePath(path, base):
   """Find the relative path.

   Arguments:
     path: path we want a relative path to.
     base: path we want a relative path from.
   Returns:
     The relative path from base to path.
   """
   path = os.path.abspath(path)
   base = os.path.abspath(base)
   path_parts = path.split(os.sep)
   base_parts = base.split(os.sep)
   while path_parts and base_parts and path_parts[0] == base_parts[0]:
     path_parts = path_parts[1:]
     base_parts = base_parts[1:]
   rel_parts = ['..'] * len(base_parts) + path_parts
   return os.sep.join(rel_parts)


 def PrintInputs(platforms):
   """Print all the transitive inputs required to build the IRT.

   Arguments:
     platforms: list of platform names to build for.
   """
   inputs = set()
   for platform in platforms:
     # Invoke scons to get dependency tree.
     cmd = [
         sys.executable, 'scons.py', '-n', '--tree=all',
         '--mode=nacl', 'platform=' + platform,
         'scons-out/nacl_irt-' + platform + '/staging/irt.nexe',
     ]
     p = subprocess.Popen(cmd, cwd=NACL_DIR,
                          stdout=subprocess.PIPE,
                          stderr=subprocess.PIPE)
     (p_stdout, p_stderr) = p.communicate()
     # If things fail on windows, try running --help, if that fails,
     # emit this script as an input (to satiate gyp), and assume we're being
     # run on a test only bot.
     # TODO(bradnelson): add plumbing to the buildbots to allow this script
     #     to know its on a test only bot + make scons return a _particular_
     #     return code so we can detect this kind of fail in one step.
     if p.returncode != 0 and sys.platform == 'win32':
       cmd = [sys.executable, 'scons.py', '--help']
       p = subprocess.Popen(cmd, cwd=NACL_DIR,
                            stdout=subprocess.PIPE,
                            stderr=subprocess.PIPE)
       (p_stdout, p_stderr) = p.communicate()
       if p.returncode !=0:
         # If scons can't even run, emit just this script as an input.
         # See comment above this one.
         print RelativePath(__file__, SCRIPT_DIR).replace(os.sep, '/')
         return
     if p.returncode != 0:
       sys.exit(2)
     # Extract unique inputs.
     for line in p_stdout.splitlines():
       m = re.match('^[ -+|]*\+\-(.+)', line)
       if not m:
         continue
       filename = m.group(1)
       if '[' in filename:
         continue
       if filename.startswith('scons-out'):
         continue
       if filename.endswith('.nexe'):
         continue
       # Apply the underlay of gpu/command_buffer (to match scons).
       if filename.startswith(NACL_CMD_BUFFER_DIR + os.sep):
         filename = GPU_CMD_BUFFER_DIR + filename[len(NACL_CMD_BUFFER_DIR):]
       # Apply the underlay of ppapi (to match scons).
       if (not os.path.exists(os.path.join(NACL_DIR, filename)) and
           os.path.exists(os.path.join(PPAPI_NACL_DIR, filename))):
         filename = '../ppapi/native_client/' + filename
       inputs.add(filename)
   # Check that everything exists and make it script relative.
   # Exclude things above SRC_DIR.
   rel_inputs = set()
   for f in inputs:
     nf = os.path.join(NACL_DIR, f)
     if not os.path.exists(nf):
       raise Exception('missing input file "%s"' % nf)
     # If the relative path from SRC_DIR to the file starts with ../ ignore it.
     # (i.e. the file is outside the client).
     if RelativePath(nf, SRC_DIR).startswith('..' + os.sep):
       continue
     rel_inputs.add(RelativePath(nf, SCRIPT_DIR).replace(os.sep, '/'))
   # Print it sorted.
   rel_inputs = sorted(list(rel_inputs))
   for f in rel_inputs:
     print f


 def BuildIRT(platforms, out_dir):
   """Build the IRT for several platforms.

   Arguments:
     platforms: list of platform names to build for.
     out_dir: directory to output the IRT to.
   """
   # Make out_dir absolute.
   out_dir = os.path.abspath(out_dir)
   # Clean.
   scons_out = os.path.join(NACL_DIR, 'scons-out')
   if os.path.exists(scons_out):
     shutil.rmtree(scons_out)
   # Build for each platform.
   for platform in platforms:
     cmd = [
         sys.executable, 'scons.py', '--verbose', '-j8',
         '--mode=nacl', 'platform=' + platform,
         'scons-out/nacl_irt-' + platform + '/staging/irt.nexe',
     ]
     print 'Running: ' + ' '.join(cmd)
     # Work around the fact that python's readline module (used by scons),
     # attempts to alter file handle state on stdin in a way that blocks if
     # a process is not a member of a foreground job on a tty on OSX.
     # e.g. On a Mac:
     #
     # hydric:test mseaborn$ python -c 'import readline' &
     # [1] 67058
     # hydric:test mseaborn$
     # [1]+  Stopped                 python -c 'import readline'
     #
     # i.e. the process receives a stop signal when it's a background job.
     if sys.platform == 'darwin':
       devnull = open(os.devnull, 'r')
     else:
       devnull = None
     p = subprocess.Popen(cmd, cwd=NACL_DIR, stdin=devnull)
     p.wait()
     if p.returncode != 0:
       sys.exit(3)
   # Copy out each platform after stripping.
   for platform in platforms:
     uplatform = platform.replace('-', '_')
     platform2 = {'x86-32': 'i686', 'x86-64': 'x86_64'}.get(platform, platform)
     cplatform = {
         'win32': 'win',
         'cygwin': 'win',
         'darwin': 'mac',
     }.get(sys.platform, 'linux')
     nexe = os.path.join(out_dir, 'nacl_irt_' + uplatform + '.nexe')
     cmd = [
       '../native_client/toolchain/' + cplatform + '_x86_newlib/bin/' +
           platform2 + '-nacl-strip',
       '--strip-debug',
       '../native_client/scons-out/nacl_irt-' + platform + '/staging/irt.nexe',
       '-o', nexe
     ]
     print 'Running: ' + ' '.join(cmd)
     p = subprocess.Popen(cmd, cwd=SCRIPT_DIR)
     p.wait()
     if p.returncode != 0:
       sys.exit(4)


 def Main(argv):
   parser = optparse.OptionParser()
   parser.add_option('--inputs', dest='inputs', default=False,
                     action='store_true',
                     help='only emit the transitive inputs to the irt build')
   parser.add_option('--platform', dest='platforms', action='append',
                     default=[],
                     help='add a platform to build for (x86-32|x86-64)')
   parser.add_option('--outdir', dest='outdir',
                     help='directory to out irt to')
   (options, args) = parser.parse_args(argv[1:])
   if args or not options.platforms or (
       not options.inputs and not options.outdir):
     parser.print_help()
     sys.exit(1)

   if options.inputs:
     PrintInputs(options.platforms)
   else:
     BuildIRT(options.platforms, options.outdir)


 if __name__ == '__main__':
   Main(sys.argv)
	#!/usr/bin/python
	# Copyright (c) 2011 The Chromium Authors. All rights reserved.
	# Use of this source code is governed by a BSD-style license that can be
	# found in the LICENSE file.

	import optparse
	import os
	import re
	import shutil
	import subprocess
	import sys


	# Where things are in relation to this script.
	SCRIPT_DIR = os.path.dirname(os.path.abspath(__file__))
	SRC_DIR = os.path.dirname(SCRIPT_DIR)
	NACL_DIR = os.path.join(SRC_DIR, 'native_client')

	# Pathing to the two command_buffer directories (relative to native_client).
	NACL_CMD_BUFFER_DIR = os.path.join('src', 'shared',
	'ppapi_proxy', 'command_buffer')
	GPU_CMD_BUFFER_DIR = os.path.join('..', 'gpu', 'command_buffer')

	# Pathing to mirror of nacl tree in ppapi.
	PPAPI_NACL_DIR = os.path.join(SRC_DIR, 'ppapi', 'native_client')


	def RelativePath(path, base):
	"""Find the relative path.

	Arguments:
	path: path we want a relative path to.
	base: path we want a relative path from.
	Returns:
	The relative path from base to path.
	"""
	path = os.path.abspath(path)
	base = os.path.abspath(base)
	path_parts = path.split(os.sep)
	base_parts = base.split(os.sep)
	while path_parts and base_parts and path_parts[0] == base_parts[0]:
	path_parts = path_parts[1:]
	base_parts = base_parts[1:]
	rel_parts = ['..'] * len(base_parts) + path_parts
	return os.sep.join(rel_parts)


	def PrintInputs(platforms):
	"""Print all the transitive inputs required to build the IRT.

	Arguments:
	platforms: list of platform names to build for.
	"""
	inputs = set()
	for platform in platforms:
	# Invoke scons to get dependency tree.
	cmd = [
	sys.executable, 'scons.py', '-n', '--tree=all',
	'--mode=nacl', 'platform=' + platform,
	'scons-out/nacl_irt-' + platform + '/staging/irt.nexe',
	]
	p = subprocess.Popen(cmd, cwd=NACL_DIR,
	stdout=subprocess.PIPE,
	stderr=subprocess.PIPE)
	(p_stdout, p_stderr) = p.communicate()
	# If things fail on windows, try running --help, if that fails,
	# emit this script as an input (to satiate gyp), and assume we're being
	# run on a test only bot.
	# TODO(bradnelson): add plumbing to the buildbots to allow this script
	# to know its on a test only bot + make scons return a _particular_
	# return code so we can detect this kind of fail in one step.
	if p.returncode != 0 and sys.platform == 'win32':
	cmd = [sys.executable, 'scons.py', '--help']
	p = subprocess.Popen(cmd, cwd=NACL_DIR,
	stdout=subprocess.PIPE,
	stderr=subprocess.PIPE)
	(p_stdout, p_stderr) = p.communicate()
	if p.returncode !=0:
	# If scons can't even run, emit just this script as an input.
	# See comment above this one.
	print RelativePath(__file__, SCRIPT_DIR).replace(os.sep, '/')
	return
	if p.returncode != 0:
	sys.exit(2)
	# Extract unique inputs.
	for line in p_stdout.splitlines():
	m = re.match('^[ -+\|]*\+\-(.+)', line)
	if not m:
	continue
	filename = m.group(1)
	if '[' in filename:
	continue
	if filename.startswith('scons-out'):
	continue
	if filename.endswith('.nexe'):
	continue
	# Apply the underlay of gpu/command_buffer (to match scons).
	if filename.startswith(NACL_CMD_BUFFER_DIR + os.sep):
	filename = GPU_CMD_BUFFER_DIR + filename[len(NACL_CMD_BUFFER_DIR):]
	# Apply the underlay of ppapi (to match scons).
	if (not os.path.exists(os.path.join(NACL_DIR, filename)) and
	os.path.exists(os.path.join(PPAPI_NACL_DIR, filename))):
	filename = '../ppapi/native_client/' + filename
	inputs.add(filename)
	# Check that everything exists and make it script relative.
	# Exclude things above SRC_DIR.
	rel_inputs = set()
	for f in inputs:
	nf = os.path.join(NACL_DIR, f)
	if not os.path.exists(nf):
	raise Exception('missing input file "%s"' % nf)
	# If the relative path from SRC_DIR to the file starts with ../ ignore it.
	# (i.e. the file is outside the client).
	if RelativePath(nf, SRC_DIR).startswith('..' + os.sep):
	continue
	rel_inputs.add(RelativePath(nf, SCRIPT_DIR).replace(os.sep, '/'))
	# Print it sorted.
	rel_inputs = sorted(list(rel_inputs))
	for f in rel_inputs:
	print f


	def BuildIRT(platforms, out_dir):
	"""Build the IRT for several platforms.

	Arguments:
	platforms: list of platform names to build for.
	out_dir: directory to output the IRT to.
	"""
	# Make out_dir absolute.
	out_dir = os.path.abspath(out_dir)
	# Clean.
	scons_out = os.path.join(NACL_DIR, 'scons-out')
	if os.path.exists(scons_out):
	shutil.rmtree(scons_out)
	# Build for each platform.
	for platform in platforms:
	cmd = [
	sys.executable, 'scons.py', '--verbose', '-j8',
	'--mode=nacl', 'platform=' + platform,
	'scons-out/nacl_irt-' + platform + '/staging/irt.nexe',
	]
	print 'Running: ' + ' '.join(cmd)
	# Work around the fact that python's readline module (used by scons),
	# attempts to alter file handle state on stdin in a way that blocks if
	# a process is not a member of a foreground job on a tty on OSX.
	# e.g. On a Mac:
	#
	# hydric:test mseaborn$ python -c 'import readline' &
	# [1] 67058
	# hydric:test mseaborn$
	# [1]+ Stopped python -c 'import readline'
	#
	# i.e. the process receives a stop signal when it's a background job.
	if sys.platform == 'darwin':
	devnull = open(os.devnull, 'r')
	else:
	devnull = None
	p = subprocess.Popen(cmd, cwd=NACL_DIR, stdin=devnull)
	p.wait()
	if p.returncode != 0:
	sys.exit(3)
	# Copy out each platform after stripping.
	for platform in platforms:
	uplatform = platform.replace('-', '_')
	platform2 = {'x86-32': 'i686', 'x86-64': 'x86_64'}.get(platform, platform)
	cplatform = {
	'win32': 'win',
	'cygwin': 'win',
	'darwin': 'mac',
	}.get(sys.platform, 'linux')
	nexe = os.path.join(out_dir, 'nacl_irt_' + uplatform + '.nexe')
	cmd = [
	'../native_client/toolchain/' + cplatform + '_x86_newlib/bin/' +
	platform2 + '-nacl-strip',
	'--strip-debug',
	'../native_client/scons-out/nacl_irt-' + platform + '/staging/irt.nexe',
	'-o', nexe
	]
	print 'Running: ' + ' '.join(cmd)
	p = subprocess.Popen(cmd, cwd=SCRIPT_DIR)
	p.wait()
	if p.returncode != 0:
	sys.exit(4)


	def Main(argv):
	parser = optparse.OptionParser()
	parser.add_option('--inputs', dest='inputs', default=False,
	action='store_true',
	help='only emit the transitive inputs to the irt build')
	parser.add_option('--platform', dest='platforms', action='append',
	default=[],
	help='add a platform to build for (x86-32\|x86-64)')
	parser.add_option('--outdir', dest='outdir',
	help='directory to out irt to')
	(options, args) = parser.parse_args(argv[1:])
	if args or not options.platforms or (
	not options.inputs and not options.outdir):
	parser.print_help()
	sys.exit(1)

	if options.inputs:
	PrintInputs(options.platforms)
	else:
	BuildIRT(options.platforms, options.outdir)


	if __name__ == '__main__':
	Main(sys.argv)