#!/usr/bin/python2.4 #

Copyright 2009-2010 Google Inc.

#

Licensed under the Apache License, Version 2.0 (the "License");

you may not use this file except in compliance with the License.

You may obtain a copy of the License at

#

http://www.apache.org/licenses/LICENSE-2.0

#

Unless required by applicable law or agreed to in writing, software

distributed under the License is distributed on an "AS IS" BASIS,

WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

See the License for the specific language governing permissions and

limitations under the License.

========================================================================

This main.scons file is the root description of the build specified in this

directory and those under it. Individual components and the source files

used to build them are described in subsidiary files called 'build.scons'.

#

To build this project change the current directory to googleclient/Omaha.

Then run hammer.bat

#

A number of command line options can be specified. For a full list, use the

-h and -H command options.

#

Some useful options include:

-h : Prints a list of which modules and build variants are available

in this project.

-H : Print SCons specific help. SCons is a build tool which this

project uses in tandem with the Software Construction Toolkit

to build.

-c : Clean the project. I.e. delete all build output.

-j3 : Run up to 3 build steps at once.

#

Some useful build targets include:

all_programs : Build all programs generated by this project.

all_libraries : Build all libraries generated by this project.

all_tests : Build all tests generated by this project.

run_all_tests : Build and run all tests generated by this project.

#

Some examples:

Build all programs and libraries in debug mode:

hammer

Build and run all tests in debug mode on windows:

hammer MODE=dbg-win run_all_tests

Build arbitrary library in the default mode:

hammer

import os

To switch the build, simply change the value of the msc_ver variable below.

VC2003/VC71 is 1310 but not supported by the current build.

VC2005/VC80 is 1400.

VC2008/VC90 is 1500.

_msc_ver = 1400

TODO(Omaha) - Change this to match the official product name

_PUBLISHER_NAME = 'Google' _PRODUCT_NAME = 'Update' _ACTIVEX_NAME = 'npGoogleOneClick' _BHO_NAME = 'GoopdateBho'

The hash comes from the Thumbprint item in the Details tab of the file

properties for the public key .cer file.

TODO(omaha): Can we automate reading this and/or pass it on the command line?

_BUILD_SERVER_CERTIFICATE_HASH = 'fe5008fe0da7a2033816752d6eafe95214f5a7e1'

COM proxy setting.

The proxy clsid needs to be changed anytime the interfaces in

google_update_idl.idl change, or when a new interface is added. Use

guidgen.exe to generate new clsids in the format 'static const struct GUID'.

PROXY_CLSID_IS = {29A96789-9595-4947-BEDB-0FCC776F7DB8}

_PROXY_CLSID_IS = ('{0x29a96789, 0x9595, 0x4947, ' '{0xbe, 0xdb, 0xf, 0xcc, 0x77, 0x6f, 0x7d, 0xb8}}')

#

Set up version info

# execfile('VERSION')

Windows is the only environment we bulid for, so create a specialized base

environment for Windows.

win_env = Environment()

Make sure we use the Vista SDK.

NOTE: This must be set before the 'component_setup' tool is used.

win_env['PLATFORM_SDK_DIR'] = '$PLATFORM_SDK_VISTA_6_0_DIR'

win_env.Tool('component_setup') win_env.Tool('target_platform_windows')

Need to use 'masm' to override the 'as' tool currently used

by default in 'target_platform_windows'

win_env.Tool('masm')

win_env.Tool('atlmfc_vc80')

Visual Studio 2008 does not ship the sign tool. Use the sign tool from

the Platform SDK.

win_env.Tool('code_signing') _signtool_path = os.path.join(os.environ['OMAHA_VISTASDK_DIR'], 'bin\signtool.exe') win_env['SIGNTOOL'] = '"' + _signtool_path + '"'

Remove this value because it conflicts with a #define

in shlwapi.h in the Vista SDK

win_env.FilterOut(CPPDEFINES = ['OS_WINDOWS=OS_WINDOWS'])

win_env.Tool('component_targets_msvs')

We pre-generate our own manifests, so make sure hammer does not generate

default ones for us

del win_env['MANIFEST_FILE']

Hack to work around bug in Hammer (http://b/1585388).

TODO(Omaha): Remove when bug is fixed.

if win_env['ENV'].has_key('SYSTEMROOT'): if win_env['ENV'].has_key('SystemRoot'): del win_env['ENV']['SYSTEMROOT'] del os.environ['SYSTEMROOT']

Work around http://code.google.com/p/swtoolkit/issues/detail?id=10.

win_env['COMPONENT_TEST_SUBSYSTEM_WINDOWS'] = 1

Declare command line options relating to code signing

authenticode_file and authenticode_password are used by the normal signing

tool and to sign manifests for ClickOnce.

patching_certificate is used to create patchable MSI installers and MSPs.

authenticode_file and authenticode_password are only used if ! build_server.

patching_certificate is used in all cases.

AddOption( '--authenticode_file', action='store', nargs=1, type='string', default='$MAIN_DIR/data/OmahaTestCert.pfx' )

default_cert_password = 'test' AddOption( '--authenticode_password', action='store', nargs=1, type='string', default=default_cert_password )

AddOption( '--patching_certificate', action='store', nargs=1, type='string', default='$MAIN_DIR/data/OmahaTestCert.cer' )

Declare option for specifying path to new official build files

AddOption( '--official_build_path', action='store', nargs=1, type='string', default=None )

Declare various boolean states.

DeclareBit('use_precompiled_headers', 'Use precompiled headers in build') DeclareBit('official_installers', 'Building using checked-in binaries') DeclareBit('build_server', 'Running on the build server') DeclareBit('test_certificate', 'Files will be signed with the test certificate') DeclareBit('bin', 'Building from pre-built binaries') DeclareBit('min', 'Building minimal set of projects') DeclareBit('all', 'Building all Projects') DeclareBit('msvs', 'Building Visual Studio solution files')

Build official installers if --official_installers is on the command line.

win_env.SetBitFromOption('official_installers', False)

Build as a build server if --build_server is on the command line.

win_env.SetBitFromOption('build_server', False)

Store new versions of pre-built binaries if --bin is on the command line.

win_env.SetBitFromOption('bin', False)

Build minimal set of libs if --min is on the command line.

win_env.SetBitFromOption('min', False)

Build all libs if --all is on the command line.

win_env.SetBitFromOption('all', False)

Build Visual Studio solution files if --msvs is on the command line.

win_env.SetBitFromOption('msvs', False)

Also build all directories if this is the build server.

if win_env.Bit('build_server'): win_env.SetBits('all')

Make sure 'all' overrides 'min'.

if win_env.Bit('all'): win_env.ClearBits('min')

Allow use of command-line-specified certificates to sign with, but

only if we're not on the build server.

if not win_env.Bit('build_server'): win_env.Replace( CERTIFICATE_PATH=GetOption('authenticode_file'), CERTIFICATE_PASSWORD=GetOption('authenticode_password'), )

# Store whether we're using the default test cert separately, because # we won't always know what the default password was. if GetOption('authenticode_password') is default_cert_password: win_env.SetBits('test_certificate')

The precompiled headers are to be used as an optional build speed up

build facility. Individual compilation units in the project must build with

or without precompiled headers. Building without precompiled headers is sort

of meaningless, since all the time we should build with it. However,

eliminating the dependency is desirable from a few reasons:

1. making sure the files in the project include all the definitions they need

2. creating different precompile headers if needed.

3. making sure the precompile headers do not add to the size bloat.

There are two current limitations with the current setup.

First, due to pushing the warning level to W4 and WAll, we rely on the

common precompile.h to properly turn off the warnings inside system and

library code.

Second, to override the ATLASSERT, a file must be included before any of

the atl headers. To do this on a case by case basis is impractical and

error prone.

Therefore, when building with precompile headers off, the code is

building on W3 and it is not taking over the ATL asserts.

win_env.SetBitFromOption('use_precompiled_headers', True)

if win_env.Bit('use_precompiled_headers'): print 'Using precompiled headers.'

def _EnablePrecompile(self_env, target_name): if self_env.Bit('use_precompiled_headers'):

# We enable all warnings on all levels. The goal is to fix the code that # we have written and to programmatically disable the warnings for the # code we do not control. This list of warnings should shrink as the code # gets fixed. self_env.FilterOut(CCFLAGS=['/W3']) self_env.Append( CCFLAGS = [ '/W4', '/Wall', ], INCLUDES = [ '$MAIN_DIR/precompile/precompile.h' ], )

self_env['PCHSTOP'] = '$MAIN_DIR/precompile/precompile.h'

pch_env = self_env.Clone() # Must manually force-include the header, as the precompilation step does # not evaluate $INCLUDES pch_env.Append(CCFLAGS = ['/FI$MAIN_DIR/precompile/precompile.h']) # Append 'pch' to the target base name to prevent target name collisions. # One case where this might have occurred is when a .cc file has the same # base name as the target program/library. pch_output = pch_env.PCH( target=target_name.replace('.', '') + '_pch' + '.pch', source='$MAIN_DIR/precompile/precompile.cc', )

self_env['PCH'] = pch_output[0]

# Return the pch .obj file that is created, so it can be # included with the inputs of a module return [pch_output[1]]

win_env.AddMethod(_EnablePrecompile, 'EnablePrecompile')

def _SignDotNetManifest(self_env, target, unsigned_manifest): sign_manifest_cmd =('@mage -Sign $SOURCE -ToFile $TARGET -TimestampUri ' 'http://timestamp.verisign.com/scripts/timstamp.dll ')

if self_env.Bit('build_server'): # If signing fails with the following error, the hash may not match any # certificates: "Internal error, please try again. Object reference not set # to an instance of an object." sign_manifest_cmd += ('-CertHash ' + self_env['build_server_certificate_hash']) else: sign_manifest_cmd += '-CertFile %s -Password %s' % ( GetOption('authenticode_file'), GetOption('authenticode_password'))

signed_manifest = self_env.Command( target=target, source=unsigned_manifest, action=sign_manifest_cmd )

return signed_manifest

win_env.AddMethod(_SignDotNetManifest, 'SignDotNetManifest')

def _SetProductVersion(self_env, version_major, version_minor, version_build, version_patch): build_two_versions = False

if (self_env.Bit('build_server') or 'OMAHA_BUILD_TWO_VERSIONS' in os.environ.keys()): build_two_versions = True

if build_two_versions: self_env['product_version_series'] = [0, 1] else: self_env['product_version_series'] = [0]

if version_patch > 0: original_value = version_patch value_name = 'patch' else: original_value = version_build value_name = 'build' if 2 * (original_value / 2) == original_value: raise Exception('ERROR: By convention, the %s number in VERSION ' '(currently %d) should be odd.' % (value_name, original_value))

ver_descriptions = [] versions = [] for delta in self_env['product_version_series']: # If we're doing a patch, increment that; else, increment build vp = version_patch vb = version_build if vp > 0: vp = vp + delta else: vb = vb + delta v = (version_major, version_minor, vb, vp) versions.append(v) ver_descriptions.append('%d.%d.%d.%d' % (version_major, version_minor, vb, vp))

self_env['product_version'] = versions

# print the version string so we know what build are we building on the # build server print 'Working on versions: %s' % ', '.join(ver_descriptions)

win_env.AddMethod(_SetProductVersion, 'SetProductVersion') win_env.SetProductVersion(version_major, version_minor, version_build, version_patch)

win_env['msc_ver'] = _msc_ver;

win_env['build_server_certificate_hash'] = _BUILD_SERVER_CERTIFICATE_HASH

Plug-in versioning. Firefox Plug-in needs a different filename for each

version of the plug-in. If the filename is the same, even though the path

is different, Firefox decides not to load the new DLL if it has the old DLL

loaded in memory.

def _SetActiveXFilenames(self_env, activex_version): activex_name = _ACTIVEX_NAME + activex_version self_env['ACTIVEX_FILENAME'] = activex_name + '.dll' self_env['ACTIVEX_UNSIGNED_FILENAME'] = activex_name + '_unsigned.dll'

win_env.AddMethod(_SetActiveXFilenames, 'SetActiveXFilenames') win_env.SetActiveXFilenames(oneclick_plugin_version)

BHO settings.

win_env['BHO_FILENAME'] = '%s.dll' % (_BHO_NAME) win_env['BHO_UNSIGNED_FILENAME'] = '%s_unsigned.dll' % (_BHO_NAME)

win_env.Append( # Add windows specific compiler flags. CCFLAGS = [ '/nologo', '/c', '/Zc:forScope', '/D_HAS_EXCEPTIONS=0', '/DCOMPILER_MSVC', '/J', '/DSTL_MSVC', '/GR-', '/D_CRT_SECURE_CPP_OVERLOAD_SECURE_NAMES=1', '/D_CRT_SECURE_CPP_OVERLOAD_STANDARD_NAMES=1', '/D_CRT_SECURE_CPP_OVERLOAD_STANDARD_NAMES_COUNT=1', '/WX', # warnings as errors

# # Disable the following level 4 warnings below. # '/wd4127', # conditional expression is constant '/wd4189', # local variable is initialized but not referenced '/wd4505', # unreferenced local function has been removed

# # Disable the pedantic warnings below. # '/wd4191', # unsafe conversion from 'type of expression' to # 'type required' '/wd4217', # member template functions cannot be used for # copy-assignment... '/wd4365', # conversion from 'type_1' to 'type_2', # signed/unsigned mismatch '/wd4512', # assignment operator could not be generated '/wd4514', # unreferenced inline function has been removed '/wd4555', # expression has no effect '/wd4619', # #pragma warning : there is no warning number 'number' '/wd4623', # default constructor could not be generated... '/wd4625', # copy constructor could not be generated... '/wd4626', # assignment operator could not be generated... '/wd4668', # not defined as a preprocessor macro, replacing with '0'. '/wd4710', # function not inlined '/wd4711', # function 'function' selected for inline expansion '/wd4738', # storing 32-bit float result in memory... '/wd4820', # bytes padding added after construct 'member_name' ],

# Where to look for include files. CPPPATH = [ '$MAIN_DIR', '$MAIN_DIR/..', '$MAIN_DIR/third_party/chrome', ],

# Defines for windows environment. CPPDEFINES = [ 'WIN32', '_WINDOWS', 'UNICODE', '_UNICODE', 'WIN32_LEAN_AND_MEAN', 'STRICT', 'SECURITY_WIN32', '_ATL_ALL_WARNINGS', '_ATL_CSTRING_EXPLICIT_CONSTRUCTORS', '_ATL_CSTRING_NO_CRT', '_ATL_NO_ACLAPI', '_ATL_NO_DEFAULT_LIBS', '_ATL_NO_EXCEPTIONS', '_ATL_NO_GLOBAL_SOCKET_STARTUP', '_ATL_NO_PERF_SUPPORT', '_ATL_NO_TRACK_HEAP', '_ATL_NO_UUIDOF', '_CRT_RAND_S', # rand_s support available in Windows XP only. '_WTL_NO_CSTRING', # WTL uses ATL CString instead.

# '_ATL_NO_CONNECTION_POINTS', # '_ATL_NO_DOCHOSTUIHANDLER', # '_ATL_NO_HOSTING',

# Set these C_DEFINES when APPVER=5.0 # (see win32.mak in Platform SDK) # Target Windows XP and IE 6.0 and above. 'WINVER=0x0501', '_WIN32_WINNT=0x0501', '_WIN32_IE=0x0600', '_RICHEDIT_VER=0x0010',

# don't define min and max in windef.h 'NOMINMAX',

# Logging is enabled in all modes for # diagnostics purposes. 'LOGGING', 'PUBLISHER_NAME_ANSI=\"%s\"' % _PUBLISHER_NAME, 'PRODUCT_NAME_ANSI=\"%s\"' % _PRODUCT_NAME, 'ACTIVEX_NAME=_T(\"%s\")' % _ACTIVEX_NAME, 'PROXY_CLSID_IS=%s' % _PROXY_CLSID_IS, 'OFFICIAL_BUILD=%d' % win_env.Bit('build_server'), 'TEST_CERTIFICATE=%d' % win_env.Bit('test_certificate'), 'ACTIVEX_FILENAME=_T(\"%s\")' % win_env['ACTIVEX_FILENAME'], 'ACTIVEX_VERSION_ANSI=\"%s\"' % oneclick_plugin_version, 'BHO_NAME=_T(\"%s\")' % _BHO_NAME, 'BHO_FILENAME=_T(\"%s\")' % win_env['BHO_FILENAME'], ],

# Link in some windows libraries. LIBS = [ 'advapi32', 'comdlg32', 'gdi32', 'kernel32', 'odbc32', 'odbccp32', 'ole32', 'oleaut32', 'shell32', 'user32', 'uuid', 'winspool', ],

# Common linker flags. LINKFLAGS = [ '/nologo', '/SUBSYSTEM:WINDOWS', '/MACHINE:X86', '/RELEASE', '/MAP', '/NODEFAULTLIB', ],

# Shared library specific linker flags. SHLINKFLAGS = [ '/nologo', '/SUBSYSTEM:WINDOWS', '/MACHINE:x86', ],

# Resource compiler flags. RCFLAGS = [ '/l 1033', # /l == default language ID '/DOFFICIAL_BUILD=%d' % win_env.Bit('build_server'), '/DPUBLISHER_NAME_ANSI=\"%s\"' % _PUBLISHER_NAME, '/DPRODUCT_NAME_ANSI=\"%s\"' % _PRODUCT_NAME, '/DACTIVEX_NAME=_T(\"%s\")' % _ACTIVEX_NAME, '/DACTIVEX_FILENAME=_T(\"%s\")' % win_env['ACTIVEX_FILENAME'], '/DACTIVEX_VERSION_ANSI=\"%s\"' % oneclick_plugin_version, '/DBHO_NAME=_T(\"%s\")' % _BHO_NAME, '/DBHO_FILENAME=_T(\"%s\")' % win_env['BHO_FILENAME'], ], )

Allow verification of these settings in the build log.

if win_env.Bit('build_server'): print 'OFFICIAL_BUILD=1' print 'TEST_CERTIFICATE=%d' % win_env.Bit('test_certificate')

List of languages that are fully supported.

win_env['languages'] = [ 'ar', 'bg', 'bn', 'ca', 'cs', 'da', 'de', 'el', 'en', 'en-GB', 'es', 'es-419', 'et', 'fa', 'fi', 'fil', 'fr', 'gu', 'hi', 'hr', 'hu', 'id', 'is', 'it', 'iw', 'ja', 'kn', 'ko', 'lt', 'lv', 'ml', 'mr', 'ms', 'nl', 'no', 'or', 'pl', 'pt-BR', 'pt-PT', 'ro', 'ru', 'sk', 'sl', 'sr', 'sv', 'ta', 'te', 'th', 'tr', 'uk', 'ur', 'vi', 'zh-CN', 'zh-TW', ]

The shell and goopdate.dll contain additional languages.

'userdefault' addresses apps that don't look up the resource for the OS

language. See http://b/1328652.

win_env['additional_shell_languages'] = [ 'am', 'sw', 'userdefault', 'zh-HK', ]

Make sure python.exe can be located.

win_env.AppendENVPath('PATH', os.environ['OMAHA_PYTHON_DIR'])

Make sure Vista SDK in all the important paths earlier in path than VC80.

_sdk_path = os.environ['OMAHA_VISTASDK_DIR'] for mid_dir in ['', 'vc']: for env_var, sub_dir in [('PATH', 'bin'), ('INCLUDE', 'include'), ('LIB', 'lib')]: var_path = os.path.join(_sdk_path, mid_dir, sub_dir) if os.path.exists(var_path): win_env.PrependENVPath(env_var, var_path)

if not win_env.Bit('official_installers'): win_env.Append(CPPPATH = os.environ['OMAHA_WTL_DIR'])

# Make sure csc.exe can be located. win_env.AppendENVPath('PATH', os.environ['OMAHA_NET_DIR'])

WiX path has to be added before the WiX tool can be called.

win_env.AppendENVPath('PATH', os.environ['OMAHA_WIX_DIR'])

win_env.Tool('wix')

_base_dirs = [ '.', # ./build.scons is used to copy some files to staging. 'common', 'core', 'goopdate', 'google_update', 'mi_exe_stub', 'net', 'recovery', 'service', 'setup', 'statsreport', 'testing', 'third_party', 'tools', 'worker', ]

_normal_dirs = [ 'bho', 'clickonce', 'installers', 'plugins', ]

_official_installers_dirs = [ 'enterprise', 'installers', ]

_extra_dirs = [ 'enterprise', 'standalone', 'test', ]

#

Need to decide which subdirs need to be built.

# _dirs_to_build = set()

if win_env.Bit('official_installers'): # Only want to build very specific subdirs. _dirs_to_build.update(_official_installers_dirs) elif not win_env.Bit('bin'): # All other configs get the base dirs. _dirs_to_build.update(_base_dirs)

if win_env.Bit('min'): print '*** Building Minimal Set of Projects ***' else: _dirs_to_build.update(_normal_dirs)

if win_env.Bit('all'): _dirs_to_build.update(_extra_dirs)

Build Google application-specific metainstallers.

if os.path.exists(win_env.Dir('$MAIN_DIR/internal').abspath): _dirs_to_build.update(['internal'])

Instruct Hammer which dirs to build.

win_env['BUILD_SCONSCRIPTS'] = list(_dirs_to_build)

Create the leaf debug Windows environment.

windows_debug_env = win_env.Clone( # Give this build a name and a description. BUILD_TYPE = 'dbg-win', BUILD_TYPE_DESCRIPTION = 'Windows debug build', )

Use common debug settings.

windows_debug_env.Tool('target_debug')

windows_debug_env.Append( CCFLAGS = [ '/RTC1', '/Od', '/MTd', ], CPPDEFINES = [ '_DEBUG', 'DEBUG', ], )

Create the leaf optimized Windows environment.

windows_optimized_env = win_env.Clone( # Give this build a name and a description. BUILD_TYPE = 'opt-win', BUILD_TYPE_DESCRIPTION = 'Windows optimized build', )

Use common optimized settings.

windows_optimized_env.Tool('target_optimized')

windows_optimized_env.Append( CCFLAGS = [ '/O1', # Optimize for small size. '/GS', '/FD', '/GL', # Global optimization goes with link flag '/LTCG' '/MT', ], CPPDEFINES = [ 'NDEBUG', 'SHIPPING' # code in 'common' needs this ], ARFLAGS = [ '/LTCG', # Set LTCG for creation of .lib files too. ], LINKFLAGS = [ '/incremental:no', '/opt:ref', '/opt:icf=32', '/opt:nowin98', '/LTCG', # Link-time code generation goes with cl flag '/GL' ], )

Create an environment for coverage test builds, based on the dbg build.

windows_coverage_env = windows_debug_env.Clone( BUILD_TYPE = 'coverage-win', BUILD_TYPE_DESCRIPTION = 'Windows coverage build', )

The Coverage build require additional tools that not everyone has. Therefore,

it should build as part of the all group.

windows_coverage_env.FilterOut(BUILD_GROUPS=['all'])

windows_coverage_env.Tool('code_coverage')

Coverage will run omaha_unittest.exe, which requires some extra environment.

for env_var in os.environ: if not env_var in windows_coverage_env['ENV']: windows_coverage_env['ENV'][env_var] = os.environ[env_var]

Create a target that covers everything in the staging dir, as many of those

files will be required for the unittests to run successfully.

windows_coverage_env.Alias( 'run_omaha_unittest', '$STAGING_DIR', '$STAGING_DIR/omaha_unittest.exe' ) windows_coverage_env.Append( # TODO(omaha): We cannot run our unit tests on the new build system. Ensure # coverage works with the new test execution system. # COVERAGE_TARGETS=['run_omaha_unittest'], COVERAGE_INSTRUMENTATION_PATHS=['$STAGING_DIR'], # This value should only be used in code if absolutely necessary. CPPDEFINES=['COVERAGE_ENABLED'], )

TODO(omaha): Prevent the analyzer, which will fail, from running until we can

run unit tests on the build system. See the TODO above.

windows_coverage_env['COVERAGE_START_CMD'] = '@echo Not starting coverage' windows_coverage_env['COVERAGE_STOP_CMD'] = '@echo Not ending coverage'

Skip signing in coverage build until the last step.

windows_coverage_env['SIGNTOOL_ORIG'] = windows_coverage_env['SIGNTOOL'] windows_coverage_env['SIGNTOOL'] = '@echo Signing deferred: '

def SigningCommand(env, filename): # Only do signing if there is a certificate file or certificate name. if env.subst('$CERTIFICATE_PATH') or env.subst('$CERTIFICATE_NAME'): # The command used to do signing (target added on below). signing_cmd = '$SIGNTOOL_ORIG sign ' # Add in certificate file if any. if env.subst('$CERTIFICATE_PATH'): signing_cmd += ' /f "$CERTIFICATE_PATH"' # Add certificate password if any. if env.subst('$CERTIFICATE_PASSWORD'): signing_cmd += ' /p "$CERTIFICATE_PASSWORD"' # Add certificate store if any. if env.subst('$CERTIFICATE_NAME'): # The command used to do signing (target added on below). signing_cmd += ' /s "$CERTIFICATE_STORE" /n "$CERTIFICATE_NAME"' # Add timestamp server if any. if env.subst('$TIMESTAMP_SERVER'): signing_cmd += ' /t "$TIMESTAMP_SERVER"' # Add in target name signing_cmd += ' "%s"' % filename return signing_cmd else: return 'echo no signing needed'

def _IsInstrumentableFileType(file): if (file.endswith('.exe') or file.endswith('.dll')): return True return False

def _IsSignableFileType(file): if (file.endswith('.exe') or file.endswith('.dll') or file.endswith('.msi') or file.endswith('.msp')): return True return False

Sign files during the install stage, since instrumentation invalidates the

signature. Signing within the individual build files was disabled above.

Do not sign intermediate "_unsigned" or "_unittest" files.

Instrumented files must be signed after installing becuase install is what

does the instrumentation. This also seems to be required to avoid

unnecessarily rebuilding non-instrumentable files.

def _PostCoverageSigningInstall(dest, source, env): if _IsInstrumentableFileType(dest) or not _IsSignableFileType(dest): # Install the file to staging. Includes instrumentation if appropriate. env'PRECOVERAGE_SIGN_INSTALL' else: # For signable but not instrumentable files, copy the files rather than # using PRECOVERAGE_SIGN_INSTALL as this works around unnecessary rebuilds # caused by http://code.google.com/p/swtoolkit/issues/detail?id=13. env.Execute('copy "%s" "%s"' % (source, dest))

if (_IsSignableFileType(dest) and (-1 == dest.find('_unsigned')) and (-1 == dest.find('_unittest')) and os.path.split(os.path.split(dest)[0])[1] == 'staging'): env.Execute(SigningCommand(env, dest))

windows_coverage_env['PRECOVERAGE_SIGN_INSTALL'] = ( windows_coverage_env['INSTALL']) windows_coverage_env['INSTALL'] = _PostCoverageSigningInstall

Make debug the default build after any copies of it have been made.

windows_debug_env.Append(BUILD_GROUPS = ['default'])

----------------------------------------------------------

Build the variants listed above.

This step will call each of the SConscripts (build.scons) listed,

once for each variant currently being built.

BuildEnvironments( [ windows_debug_env, windows_optimized_env, windows_coverage_env, ] )

if win_env.Bit('msvs'): source_project = win_env.ComponentVSDirProject('all_source', ['$MAIN_DIR'])

# 'all_*' values do not appear to be populated until after BuildEnvironments # is called. Thus, the solution will be specific to either debug or optimized. # ComponentVSSourceProject() might be more desirable, but it does not appear # to work. windows_debug_env.ComponentVSSolution('omaha_dbg', ['all_programs', 'all_libraries'], projects=[source_project])