0
0
mirror of https://github.com/mongodb/mongo.git synced 2024-12-01 09:32:32 +01:00
mongodb/SConstruct

1661 lines
52 KiB
Python
Raw Normal View History

2009-07-27 23:30:41 +02:00
# -*- mode: python; -*-
2010-04-29 23:03:40 +02:00
# build file for MongoDB
# this requires scons
2009-01-06 00:19:56 +01:00
# you can get from http://www.scons.org
# then just type scons
2009-02-02 01:13:12 +01:00
# some common tasks
# build 64-bit mac and pushing to s3
2009-02-06 22:51:14 +01:00
# scons --64 s3dist
2009-02-11 03:37:18 +01:00
# scons --distname=0.8 s3dist
2009-02-12 15:10:11 +01:00
# all s3 pushes require settings.py and simples3
2009-02-02 01:13:12 +01:00
2009-01-06 00:19:56 +01:00
import os
2009-01-27 19:08:44 +01:00
import sys
2009-11-19 18:40:23 +01:00
import imp
import types
2009-02-01 23:39:07 +01:00
import re
import shutil
2009-04-22 23:06:31 +02:00
import urllib
import urllib2
import buildscripts
2010-01-02 14:59:54 +01:00
import buildscripts.bb
from buildscripts import utils
2010-01-02 14:59:54 +01:00
buildscripts.bb.checkOk()
2009-01-06 00:19:56 +01:00
2009-01-14 16:58:32 +01:00
# --- options ----
AddOption('--prefix',
dest='prefix',
type='string',
nargs=1,
action='store',
metavar='DIR',
help='installation prefix')
2009-02-11 03:37:18 +01:00
AddOption('--distname',
dest='distname',
type='string',
nargs=1,
action='store',
metavar='DIR',
help='dist name (0.8.0)')
2010-01-29 16:43:02 +01:00
AddOption('--distmod',
dest='distmod',
type='string',
nargs=1,
action='store',
metavar='DIR',
help='additional piece for full dist name')
2009-01-20 16:22:09 +01:00
AddOption( "--64",
dest="force64",
type="string",
nargs=0,
action="store",
help="whether to force 64 bit" )
2009-01-14 16:58:32 +01:00
2009-01-22 15:12:58 +01:00
AddOption( "--32",
dest="force32",
type="string",
nargs=0,
action="store",
help="whether to force 32 bit" )
AddOption( "--mm",
dest="mm",
type="string",
nargs=0,
action="store",
help="use main memory instead of memory mapped files" )
2009-01-27 04:19:15 +01:00
AddOption( "--release",
dest="release",
type="string",
nargs=0,
action="store",
help="relase build")
2009-01-22 15:12:58 +01:00
2009-07-07 17:12:39 +02:00
AddOption( "--static",
dest="static",
type="string",
nargs=0,
action="store",
help="fully static build")
2009-04-23 23:40:43 +02:00
AddOption('--usesm',
dest='usesm',
type="string",
nargs=0,
action="store",
help="use spider monkey for javascript" )
2009-10-10 07:30:00 +02:00
AddOption('--usev8',
dest='usev8',
type="string",
nargs=0,
action="store",
help="use v8 for javascript" )
2009-12-14 18:38:53 +01:00
AddOption('--asio',
dest='asio',
type="string",
nargs=0,
action="store",
help="Use Asynchronous IO (NOT READY YET)" )
2009-02-18 05:29:28 +01:00
AddOption( "--d",
dest="debugBuild",
2009-01-30 16:29:07 +01:00
type="string",
nargs=0,
action="store",
2009-02-18 05:29:28 +01:00
help="debug build no optimization, etc..." )
2009-01-30 16:29:07 +01:00
AddOption( "--dd",
dest="debugBuildAndLogging",
type="string",
nargs=0,
action="store",
help="debug build no optimization, additional debug logging, etc..." )
2009-02-04 21:08:55 +01:00
AddOption( "--recstore",
dest="recstore",
type="string",
nargs=0,
action="store",
help="use new recstore" )
2009-02-09 20:30:45 +01:00
AddOption( "--noshell",
dest="noshell",
type="string",
nargs=0,
action="store",
help="don't build shell" )
2009-02-04 21:08:55 +01:00
AddOption( "--safeshell",
dest="safeshell",
type="string",
nargs=0,
action="store",
help="don't let shell scripts run programs (still, don't run untrusted scripts)" )
2009-06-30 22:08:42 +02:00
AddOption( "--extrapath",
dest="extrapath",
type="string",
nargs=1,
action="store",
2010-05-08 17:46:40 +02:00
help="comma separated list of add'l paths (--extrapath /opt/foo/,/foo) static linking" )
2009-12-09 21:16:28 +01:00
AddOption( "--extrapathdyn",
dest="extrapathdyn",
type="string",
nargs=1,
action="store",
2010-05-08 17:46:40 +02:00
help="comma separated list of add'l paths (--extrapath /opt/foo/,/foo) dynamic linking" )
2009-12-09 21:16:28 +01:00
2009-06-30 22:08:42 +02:00
2009-10-16 08:20:08 +02:00
AddOption( "--extralib",
dest="extralib",
type="string",
nargs=1,
action="store",
2010-05-08 17:46:40 +02:00
help="comma separated list of libraries (--extralib js_static,readline" )
2009-10-16 08:20:08 +02:00
AddOption( "--staticlib",
dest="staticlib",
type="string",
nargs=1,
action="store",
2010-05-08 17:46:40 +02:00
help="comma separated list of libs to link statically (--staticlib js_static,boost_program_options-mt,..." )
AddOption( "--staticlibpath",
dest="staticlibpath",
type="string",
nargs=1,
action="store",
2010-05-08 17:46:40 +02:00
help="comma separated list of dirs to search for staticlib arguments" )
2009-08-28 17:14:26 +02:00
AddOption( "--cxx",
dest="cxx",
type="string",
nargs=1,
action="store",
help="compiler to use" )
AddOption( "--boost-compiler",
dest="boostCompiler",
type="string",
nargs=1,
action="store",
help="compiler used for boost (gcc41)" )
2009-08-31 20:56:49 +02:00
AddOption( "--boost-version",
dest="boostVersion",
type="string",
nargs=1,
action="store",
help="boost version for linking(1_38)" )
AddOption( "--cpppath",
dest="cpppath",
type="string",
nargs=1,
action="store",
help="Include path if you have headers in a nonstandard directory" )
AddOption( "--libpath",
dest="libpath",
type="string",
nargs=1,
action="store",
help="Library path if you have libraries in a nonstandard directory" )
2009-12-08 23:00:17 +01:00
#
# to use CPUPROFILE=/tmp/profile
2009-12-21 20:45:18 +01:00
# to view pprof -gv mongod /tmp/profile
2009-12-08 23:00:17 +01:00
#
2009-07-29 20:19:55 +02:00
AddOption( "--pg",
dest="profile",
type="string",
nargs=0,
action="store" )
AddOption( "--gdbserver",
dest="gdbserver",
type="string",
nargs=0,
action="store" )
AddOption("--nostrip",
dest="nostrip",
action="store_true",
help="do not strip installed binaries")
AddOption("--sharedclient",
dest="sharedclient",
action="store",
help="build a libmongoclient.so/.dll")
AddOption("--smokedbprefix",
dest="smokedbprefix",
action="store",
help="prefix to dbpath et al. for smoke tests")
2009-01-14 16:58:32 +01:00
# --- environment setup ---
def removeIfInList( lst , thing ):
if thing in lst:
lst.remove( thing )
def printLocalInfo():
import sys, SCons
print( "scons version: " + SCons.__version__ )
print( "python version: " + " ".join( [ `i` for i in sys.version_info ] ) )
printLocalInfo()
2009-01-06 00:19:56 +01:00
boostLibs = [ "thread" , "filesystem" , "program_options" ]
onlyServer = len( COMMAND_LINE_TARGETS ) == 0 or ( len( COMMAND_LINE_TARGETS ) == 1 and str( COMMAND_LINE_TARGETS[0] ) in [ "mongod" , "mongos" , "test" ] )
nix = False
linux = False
linux64 = False
darwin = False
windows = False
freebsd = False
openbsd = False
2009-06-01 22:09:16 +02:00
solaris = False
2009-07-22 19:42:21 +02:00
force64 = not GetOption( "force64" ) is None
if not force64 and os.getcwd().endswith( "mongo-64" ):
force64 = True
print( "*** assuming you want a 64-bit build b/c of directory *** " )
2009-07-24 20:27:35 +02:00
msarch = None
if force64:
msarch = "amd64"
force32 = not GetOption( "force32" ) is None
release = not GetOption( "release" ) is None
2009-07-07 17:12:39 +02:00
static = not GetOption( "static" ) is None
debugBuild = ( not GetOption( "debugBuild" ) is None ) or ( not GetOption( "debugBuildAndLogging" ) is None )
debugLogging = not GetOption( "debugBuildAndLogging" ) is None
noshell = not GetOption( "noshell" ) is None
2009-04-23 23:40:43 +02:00
usesm = not GetOption( "usesm" ) is None
2009-10-10 07:30:00 +02:00
usev8 = not GetOption( "usev8" ) is None
2009-12-14 18:38:53 +01:00
asio = not GetOption( "asio" ) is None
justClientLib = (COMMAND_LINE_TARGETS == ['mongoclient'])
2009-09-09 15:46:12 +02:00
env = Environment( MSVS_ARCH=msarch , tools = ["default", "gch"], toolpath = '.' )
2009-08-28 17:14:26 +02:00
if GetOption( "cxx" ) is not None:
2009-08-28 17:58:38 +02:00
env["CC"] = GetOption( "cxx" )
2009-08-28 17:14:26 +02:00
env["CXX"] = GetOption( "cxx" )
2009-07-24 20:27:35 +02:00
env["LIBPATH"] = []
if GetOption( "libpath" ) is not None:
env["LIBPATH"] = [GetOption( "libpath" )]
if GetOption( "cpppath" ) is not None:
env["CPPPATH"] = [GetOption( "cpppath" )]
2009-07-24 20:27:35 +02:00
if GetOption( "recstore" ) != None:
env.Append( CPPDEFINES=[ "_RECSTORE" ] )
env.Append( CPPDEFINES=[ "_SCONS" , "MONGO_EXPOSE_MACROS" ] )
2009-07-24 20:27:35 +02:00
env.Append( CPPPATH=[ "." ] )
if GetOption( "safeshell" ) != None:
env.Append( CPPDEFINES=[ "MONGO_SAFE_SHELL" ] )
2009-07-24 20:27:35 +02:00
boostCompiler = GetOption( "boostCompiler" )
if boostCompiler is None:
boostCompiler = ""
else:
boostCompiler = "-" + boostCompiler
2009-08-31 20:56:49 +02:00
boostVersion = GetOption( "boostVersion" )
if boostVersion is None:
boostVersion = ""
else:
boostVersion = "-" + boostVersion
2010-05-23 18:33:34 +02:00
if ( not ( usesm or usev8 or justClientLib) ):
usesm = True
2010-05-24 05:30:52 +02:00
distBuild = len( COMMAND_LINE_TARGETS ) == 1 and ( str( COMMAND_LINE_TARGETS[0] ) == "s3dist" or str( COMMAND_LINE_TARGETS[0] ) == "dist" )
2009-12-09 20:58:37 +01:00
extraLibPlaces = []
2009-12-09 21:16:28 +01:00
def addExtraLibs( s ):
2009-12-09 23:41:14 +01:00
for x in s.split(","):
2009-06-30 22:08:42 +02:00
env.Append( CPPPATH=[ x + "/include" ] )
env.Append( LIBPATH=[ x + "/lib" ] )
2010-01-14 22:45:03 +01:00
env.Append( LIBPATH=[ x + "/lib64" ] )
2009-12-09 23:34:18 +01:00
extraLibPlaces.append( x + "/lib" )
2009-12-09 21:16:28 +01:00
if GetOption( "extrapath" ) is not None:
addExtraLibs( GetOption( "extrapath" ) )
2009-06-30 22:08:42 +02:00
release = True
2009-07-22 19:42:21 +02:00
2009-12-09 21:16:28 +01:00
if GetOption( "extrapathdyn" ) is not None:
addExtraLibs( GetOption( "extrapathdyn" ) )
2009-10-16 08:20:08 +02:00
if GetOption( "extralib" ) is not None:
for x in GetOption( "extralib" ).split( "," ):
env.Append( LIBS=[ x ] )
2010-05-24 05:30:52 +02:00
class InstallSetup:
binaries = False
clientSrc = False
headers = False
bannerDir = None
headerRoot = "include"
2010-05-23 18:33:34 +02:00
2010-05-24 05:30:52 +02:00
def __init__(self):
self.default()
def default(self):
self.binaries = True
self.clientSrc = False
self.headers = False
self.bannerDir = None
self.headerRoot = "include"
def justClient(self):
self.binaries = False
self.clientSrc = True
self.headers = True
self.bannerDir = "distsrc/client/"
self.headerRoot = ""
2010-05-23 18:33:34 +02:00
2010-05-24 05:30:52 +02:00
installSetup = InstallSetup()
if distBuild:
installSetup.bannerDir = "distsrc"
2010-05-23 18:33:34 +02:00
# ------ SOURCE FILE SETUP -----------
2010-04-27 21:27:52 +02:00
commonFiles = Split( "pch.cpp buildinfo.cpp db/common.cpp db/jsobj.cpp db/json.cpp db/lasterror.cpp db/nonce.cpp db/queryutil.cpp shell/mongo.cpp" )
2010-04-08 01:29:56 +02:00
commonFiles += [ "util/background.cpp" , "util/mmap.cpp" , "util/ramstore.cpp", "util/sock.cpp" , "util/util.cpp" , "util/message.cpp" ,
2010-05-17 23:11:48 +02:00
"util/assert_util.cpp" , "util/httpclient.cpp" , "util/md5main.cpp" , "util/base64.cpp", "util/concurrency/vars.cpp", "util/concurrency/task.cpp", "util/debug_util.cpp",
"util/concurrency/thread_pool.cpp", "util/password.cpp", "util/version.cpp",
"util/histogram.cpp", "util/concurrency/spin_lock.cpp", "util/text.cpp" , "util/stringutils.cpp" ]
2009-05-04 17:49:18 +02:00
commonFiles += Glob( "util/*.c" )
commonFiles += Split( "client/connpool.cpp client/dbclient.cpp client/dbclientcursor.cpp client/model.cpp client/syncclusterconnection.cpp s/shardconnection.cpp" )
2009-01-06 00:19:56 +01:00
2009-01-30 04:21:33 +01:00
#mmap stuff
if GetOption( "mm" ) != None:
commonFiles += [ "util/mmap_mm.cpp" ]
elif os.sys.platform == "win32":
2009-01-30 04:21:33 +01:00
commonFiles += [ "util/mmap_win.cpp" ]
else:
commonFiles += [ "util/mmap_posix.cpp" ]
if os.path.exists( "util/processinfo_" + os.sys.platform + ".cpp" ):
commonFiles += [ "util/processinfo_" + os.sys.platform + ".cpp" ]
else:
commonFiles += [ "util/processinfo_none.cpp" ]
2010-04-14 16:35:29 +02:00
coreDbFiles = [ "db/commands.cpp" ]
2010-06-08 17:06:34 +02:00
coreServerFiles = [ "util/message_server_port.cpp" ,
2010-04-14 16:35:29 +02:00
"client/parallel.cpp" ,
"db/matcher.cpp" , "db/indexkey.cpp" , "db/dbcommands_generic.cpp" ]
2010-06-08 17:06:34 +02:00
if GetOption( "asio" ) != None:
coreServerFiles += [ "util/message_server_asio.cpp" ]
2010-05-29 21:45:47 +02:00
serverOnlyFiles = Split( "db/query.cpp db/update.cpp db/introspect.cpp db/btree.cpp db/clientcursor.cpp db/tests.cpp db/repl.cpp db/repl/rs.cpp db/repl/consensus.cpp db/repl/rs_initiate.cpp db/repl/replset_commands.cpp db/repl/manager.cpp db/repl/health.cpp db/repl/heartbeat.cpp db/repl/rs_config.cpp db/oplog.cpp db/repl_block.cpp db/btreecursor.cpp db/cloner.cpp db/namespace.cpp db/matcher_covered.cpp db/dbeval.cpp db/dbwebserver.cpp db/dbhelpers.cpp db/instance.cpp db/client.cpp db/database.cpp db/pdfile.cpp db/cursor.cpp db/security_commands.cpp db/security.cpp util/miniwebserver.cpp db/storage.cpp db/queryoptimizer.cpp db/extsort.cpp db/mr.cpp s/d_util.cpp db/cmdline.cpp" )
serverOnlyFiles += [ "db/index.cpp" ] + Glob( "db/geo/*.cpp" )
2010-04-28 19:28:11 +02:00
serverOnlyFiles += [ "db/dbcommands.cpp" , "db/dbcommands_admin.cpp" ]
coreServerFiles += Glob( "db/stats/*.cpp" )
2010-02-27 22:42:00 +01:00
serverOnlyFiles += [ "db/driverHelpers.cpp" ]
2010-05-24 18:52:28 +02:00
scriptingFiles = [ "scripting/engine.cpp" , "scripting/utils.cpp" ]
2009-04-23 23:40:43 +02:00
if usesm:
2010-05-24 18:52:28 +02:00
scriptingFiles += [ "scripting/engine_spidermonkey.cpp" ]
2009-10-10 07:30:00 +02:00
elif usev8:
2010-05-24 18:52:28 +02:00
scriptingFiles += [ Glob( "scripting/*v8*.cpp" ) ]
else:
2010-05-24 18:52:28 +02:00
scriptingFiles += [ "scripting/engine_none.cpp" ]
coreServerFiles += scriptingFiles
coreShardFiles = [ "s/config.cpp" , "s/chunk.cpp" , "s/shard.cpp" , "s/shardkey.cpp" ]
shardServerFiles = coreShardFiles + Glob( "s/strategy*.cpp" ) + [ "s/commands_admin.cpp" , "s/commands_public.cpp" , "s/request.cpp" , "s/cursors.cpp" , "s/server.cpp" , "s/config_migrate.cpp" , "s/s_only.cpp" , "s/stats.cpp" , "s/balance.cpp" , "s/balancer_policy.cpp" , "db/cmdline.cpp" ]
2010-07-12 23:48:09 +02:00
serverOnlyFiles += coreShardFiles + [ "s/d_logic.cpp" , "s/d_writeback.cpp" , "s/d_migrate.cpp" , "s/d_state.cpp" , "s/d_split.cpp" , "client/distlock.cpp" ]
2009-03-11 22:28:49 +01:00
2009-11-18 18:53:56 +01:00
serverOnlyFiles += [ "db/module.cpp" ] + Glob( "db/modules/*.cpp" )
2009-11-19 18:40:23 +01:00
modules = []
2010-05-26 17:11:15 +02:00
moduleNames = []
2009-11-19 18:40:23 +01:00
2009-11-18 23:19:26 +01:00
for x in os.listdir( "db/modules/" ):
if x.find( "." ) >= 0:
continue
2009-11-19 18:40:23 +01:00
print( "adding module: " + x )
2010-05-26 17:11:15 +02:00
moduleNames.append( x )
2009-11-19 18:40:23 +01:00
modRoot = "db/modules/" + x + "/"
serverOnlyFiles += Glob( modRoot + "src/*.cpp" )
modBuildFile = modRoot + "build.py"
if os.path.exists( modBuildFile ):
modules += [ imp.load_module( "module_" + x , open( modBuildFile , "r" ) , modBuildFile , ( ".py" , "r" , imp.PY_SOURCE ) ) ]
2009-11-18 18:53:56 +01:00
2009-11-03 18:17:51 +01:00
allClientFiles = commonFiles + coreDbFiles + [ "client/clientOnly.cpp" , "client/gridfs.cpp" , "s/d_util.cpp" ];
2009-01-06 00:19:56 +01:00
# ---- other build setup -----
2009-01-20 16:22:09 +01:00
2009-02-06 16:48:39 +01:00
platform = os.sys.platform
if "uname" in dir(os):
processor = os.uname()[4]
else:
processor = "i386"
2009-02-06 16:48:39 +01:00
if force32:
processor = "i386"
if force64:
processor = "x86_64"
DEFAULT_INSTALl_DIR = "/usr/local"
installDir = DEFAULT_INSTALl_DIR
2009-01-22 15:12:58 +01:00
nixLibPrefix = "lib"
2009-01-07 19:27:01 +01:00
2009-02-11 03:37:18 +01:00
distName = GetOption( "distname" )
dontReplacePackage = False
2009-02-11 03:37:18 +01:00
if distBuild:
release = True
if GetOption( "prefix" ):
installDir = GetOption( "prefix" )
2010-05-24 05:30:52 +02:00
if installDir.find( "mongo-cxx-driver" ) >= 0:
installSetup.justClient()
def findVersion( root , choices ):
2010-05-03 23:29:49 +02:00
if not isinstance(root, list):
root = [root]
for r in root:
for c in choices:
if ( os.path.exists( r + c ) ):
return r + c
raise RuntimeError("can't find a version of [" + repr(root) + "] choices: " + repr(choices))
2009-04-12 03:19:29 +02:00
def choosePathExist( choices , default=None):
for c in choices:
2009-04-28 14:47:56 +02:00
if c != None and os.path.exists( c ):
2009-04-12 03:19:29 +02:00
return c
return default
2010-01-28 22:36:47 +01:00
def filterExists(paths):
return filter(os.path.exists, paths)
2009-01-06 00:19:56 +01:00
if "darwin" == os.sys.platform:
2009-01-28 23:27:12 +01:00
darwin = True
2009-02-06 16:48:39 +01:00
platform = "osx" # prettier than darwin
2009-01-28 23:27:12 +01:00
2009-10-16 08:20:08 +02:00
if env["CXX"] is None:
if os.path.exists( "/usr/bin/g++-4.2" ):
env["CXX"] = "g++-4.2"
2009-01-06 00:53:46 +01:00
2009-01-07 19:27:01 +01:00
nix = True
2009-01-25 16:01:43 +01:00
if force64:
env.Append( CPPPATH=["/usr/64/include"] )
env.Append( LIBPATH=["/usr/64/lib"] )
2009-02-06 16:48:39 +01:00
if installDir == DEFAULT_INSTALl_DIR and not distBuild:
installDir = "/usr/64/"
2009-01-25 16:01:43 +01:00
else:
2010-01-28 22:36:47 +01:00
env.Append( CPPPATH=filterExists(["/sw/include" , "/opt/local/include"]) )
env.Append( LIBPATH=filterExists(["/sw/lib/", "/opt/local/lib"]) )
2009-01-25 16:01:43 +01:00
2009-01-06 00:53:46 +01:00
elif "linux2" == os.sys.platform:
2009-03-25 18:22:09 +01:00
linux = True
2009-02-06 22:53:08 +01:00
platform = "linux"
2009-02-01 15:06:49 +01:00
2009-01-22 16:14:03 +01:00
if os.uname()[4] == "x86_64" and not force32:
linux64 = True
2009-01-22 15:12:58 +01:00
nixLibPrefix = "lib64"
2009-04-01 04:08:55 +02:00
env.Append( LIBPATH=["/usr/lib64" , "/lib64" ] )
2009-02-05 18:42:35 +01:00
env.Append( LIBS=["pthread"] )
2009-07-22 19:42:21 +02:00
force64 = False
2009-01-27 04:19:15 +01:00
if force32:
2009-01-27 14:57:15 +01:00
env.Append( LIBPATH=["/usr/lib32"] )
2009-01-27 04:19:15 +01:00
2009-01-07 19:27:01 +01:00
nix = True
2009-07-07 17:12:39 +02:00
if static:
env.Append( LINKFLAGS=" -static " )
2009-02-01 15:06:49 +01:00
elif "sunos5" == os.sys.platform:
nix = True
2009-06-01 22:09:16 +02:00
solaris = True
2010-04-27 21:48:38 +02:00
env.Append( CPPDEFINES=[ "__sunos__" ] )
2009-07-17 17:21:42 +02:00
env.Append( LIBS=["socket","resolv"] )
2009-02-01 15:06:49 +01:00
2009-11-02 02:19:00 +01:00
elif os.sys.platform.startswith( "freebsd" ):
nix = True
freebsd = True
env.Append( CPPPATH=[ "/usr/local/include" ] )
env.Append( LIBPATH=[ "/usr/local/lib" ] )
env.Append( CPPDEFINES=[ "__freebsd__" ] )
elif os.sys.platform.startswith( "openbsd" ):
nix = True
openbsd = True
env.Append( CPPPATH=[ "/usr/local/include" ] )
env.Append( LIBPATH=[ "/usr/local/lib" ] )
env.Append( CPPDEFINES=[ "__openbsd__" ] )
2009-01-07 21:51:42 +01:00
elif "win32" == os.sys.platform:
windows = True
2010-06-01 23:25:25 +02:00
#if force64:
# release = True
for pathdir in env['ENV']['PATH'].split(os.pathsep):
if os.path.exists(os.path.join(pathdir, 'cl.exe')):
2010-05-03 01:17:35 +02:00
print( "found visual studio at " + pathdir )
break
else:
#use current environment
env['ENV'] = dict(os.environ)
2009-12-29 18:12:47 +01:00
def find_boost():
for x in ('', ' (x86)'):
2010-04-28 00:28:10 +02:00
boostDir = "C:/Program Files" + x + "/boost/latest"
if os.path.exists( boostDir ):
return boostDir
for bv in reversed( range(33,50) ):
for extra in ('', '_0', '_1'):
boostDir = "C:/Program Files" + x + "/Boost/boost_1_" + str(bv) + extra
if os.path.exists( boostDir ):
return boostDir
2010-04-29 17:32:22 +02:00
if os.path.exists( "C:/boost" ):
return "C:/boost"
if os.path.exists( "/boost" ):
return "/boost"
return None
2009-12-29 18:12:47 +01:00
boostDir = find_boost()
if boostDir is None:
print( "can't find boost" )
Exit(1)
else:
print( "boost found at '" + boostDir + "'" )
2009-12-29 18:12:47 +01:00
serverOnlyFiles += [ "util/ntservice.cpp" ]
boostLibs = []
2010-06-03 20:29:11 +02:00
env.Append(CPPPATH=[ "js/src/" ])
2010-05-23 18:33:34 +02:00
env.Append(CPPPATH=["../js/src/"])
env.Append(LIBPATH=["../js/src"])
2010-06-03 20:29:11 +02:00
env.Append(LIBPATH=["../js/"])
2010-05-23 18:33:34 +02:00
env.Append( CPPDEFINES=[ "OLDJS" ] )
env.Append( CPPDEFINES=[ "_UNICODE" ] )
env.Append( CPPDEFINES=[ "UNICODE" ] )
2010-05-03 23:29:49 +02:00
winSDKHome = findVersion( [ "C:/Program Files/Microsoft SDKs/Windows/", "C:/Program Files (x86)/Microsoft SDKs/Windows/" ] ,
[ "v7.0A", "v7.0", "v6.1", "v6.0a", "v6.0" ] )
print( "Windows SDK Root '" + winSDKHome + "'" )
2009-01-07 21:51:42 +01:00
env.Append( CPPPATH=[ boostDir , "pcre-7.4" , winSDKHome + "/Include" ] )
2009-01-07 21:51:42 +01:00
2010-06-01 23:25:25 +02:00
# consider adding /MP build with multiple processes option.
# /EHsc exception handling style for visual studio
# /W3 warning level
2009-02-10 21:12:15 +01:00
env.Append( CPPFLAGS=" /EHsc /W3 " )
2010-06-01 23:25:25 +02:00
# some warnings we don't like:
env.Append( CPPFLAGS=" /wd4355 /wd4800 /wd4267 /wd4244 " )
2010-06-02 00:40:31 +02:00
2010-06-14 06:24:30 +02:00
env.Append( CPPDEFINES=["WIN32","_CONSOLE","_CRT_SECURE_NO_WARNINGS","HAVE_CONFIG_H","PCRE_STATIC","SUPPORT_UCP","SUPPORT_UTF8,PSAPI_VERSION=1" ] )
2009-01-08 00:05:22 +01:00
2010-04-27 21:27:52 +02:00
#env.Append( CPPFLAGS=' /Yu"pch.h" ' ) # this would be for pre-compiled headers, could play with it later
2010-06-01 23:25:25 +02:00
# docs say don't use /FD from command line
# /Gy funtion level linking
# /Gm is minimal rebuild, but may not work in parallel mode.
2009-02-10 21:12:15 +01:00
if release:
env.Append( CPPDEFINES=[ "NDEBUG" ] )
2010-06-01 23:25:25 +02:00
env.Append( CPPFLAGS= " /O2 /MT /Gy /Zi /TP /errorReport:none " )
# TODO: this has caused some linking problems :
2010-06-01 23:25:25 +02:00
# /GL whole program optimization
2010-06-03 20:29:11 +02:00
# /LTCG link time code generation
env.Append( CPPFLAGS= " /GL " )
env.Append( LINKFLAGS=" /LTCG " )
2009-02-10 21:12:15 +01:00
else:
env.Append( CPPDEFINES=[ "_DEBUG" ] )
# /Od disable optimization
# /ZI debug info w/edit & continue
2010-06-01 23:25:25 +02:00
# /TP it's a c++ file
# RTC1 /GZ (Enable Stack Frame Run-Time Error Checking)
env.Append( CPPFLAGS=" /Od /RTC1 /MDd /Z7 /TP /errorReport:none " )
env.Append( CPPFLAGS=' /Fd"mongod.pdb" ' )
2010-06-03 20:29:11 +02:00
env.Append( LINKFLAGS=" /debug " )
2009-01-07 21:51:42 +01:00
2010-06-15 16:31:01 +02:00
if os.path.exists("../readline/lib") :
env.Append( LIBPATH=["../readline/lib"] )
env.Append( CPPPATH=["../readline/include"] )
2010-05-03 01:17:35 +02:00
if force64 and os.path.exists( boostDir + "/lib/vs2010_64" ):
env.Append( LIBPATH=[ boostDir + "/lib/vs2010_64" ] )
elif not force64 and os.path.exists( boostDir + "/lib/vs2010_32" ):
env.Append( LIBPATH=[ boostDir + "/lib/vs2010_32" ] )
else:
env.Append( LIBPATH=[ boostDir + "/Lib" ] )
if force64:
2009-07-24 20:27:35 +02:00
env.Append( LIBPATH=[ winSDKHome + "/Lib/x64" ] )
else:
env.Append( LIBPATH=[ winSDKHome + "/Lib" ] )
2010-06-18 12:44:11 +02:00
if release:
2010-07-03 05:21:50 +02:00
#env.Append( LINKFLAGS=" /NODEFAULTLIB:MSVCPRT /NODEFAULTLIB:MSVCRTD " )
env.Append( LINKFLAGS=" /NODEFAULTLIB:MSVCPRT " )
2010-06-18 12:44:11 +02:00
else:
env.Append( LINKFLAGS=" /NODEFAULTLIB:MSVCPRT /NODEFAULTLIB:MSVCRT " )
2010-06-18 12:36:33 +02:00
2009-01-08 15:53:46 +01:00
def pcreFilter(x):
name = x.name
if x.name.endswith( "dftables.c" ):
return False
if x.name.endswith( "pcredemo.c" ):
return False
if x.name.endswith( "pcretest.c" ):
return False
if x.name.endswith( "unittest.cc" ):
return False
if x.name.endswith( "pcregrep.c" ):
return False
return True
pcreFiles = []
pcreFiles += filter( pcreFilter , Glob( "pcre-7.4/*.c" ) )
pcreFiles += filter( pcreFilter , Glob( "pcre-7.4/*.cc" ) )
commonFiles += pcreFiles
allClientFiles += pcreFiles
winLibString = "ws2_32.lib kernel32.lib advapi32.lib Psapi.lib"
if force64:
2010-06-03 20:29:11 +02:00
winLibString += ""
#winLibString += " LIBCMT LIBCPMT "
else:
winLibString += " user32.lib gdi32.lib winspool.lib comdlg32.lib shell32.lib ole32.lib oleaut32.lib "
winLibString += " odbc32.lib odbccp32.lib uuid.lib "
2009-07-24 20:27:35 +02:00
env.Append( LIBS=Split(winLibString) )
2010-06-02 00:40:31 +02:00
# dm these should automatically be defined by the compiler. commenting out to see if works. jun2010
#if force64:
# env.Append( CPPDEFINES=["_AMD64_=1"] )
#else:
# env.Append( CPPDEFINES=["_X86_=1"] )
env.Append( CPPPATH=["../winpcap/Include"] )
env.Append( LIBPATH=["../winpcap/Lib"] )
2009-01-06 00:53:46 +01:00
else:
print( "No special config for [" + os.sys.platform + "] which probably means it won't work" )
2009-01-06 00:19:56 +01:00
2009-01-07 19:27:01 +01:00
if nix:
2009-09-09 15:46:12 +02:00
env.Append( CPPFLAGS="-fPIC -fno-strict-aliasing -ggdb -pthread -Wall -Wsign-compare -Wno-unknown-pragmas -Winvalid-pch" )
2009-04-06 22:10:31 +02:00
env.Append( CXXFLAGS=" -Wnon-virtual-dtor " )
env.Append( LINKFLAGS=" -fPIC -pthread -rdynamic" )
2009-02-17 18:24:47 +01:00
env.Append( LIBS=[] )
2009-01-08 00:05:22 +01:00
2009-02-18 05:29:28 +01:00
if debugBuild:
env.Append( CPPFLAGS=" -O0 -fstack-protector " );
env['ENV']['GLIBCXX_FORCE_NEW'] = 1; # play nice with valgrind
2009-01-30 16:29:07 +01:00
else:
env.Append( CPPFLAGS=" -O3" )
if debugLogging:
env.Append( CPPFLAGS=" -D_DEBUG" );
2009-01-30 16:29:07 +01:00
2009-01-20 16:22:09 +01:00
if force64:
2009-01-30 16:29:07 +01:00
env.Append( CFLAGS="-m64" )
2009-01-20 16:22:09 +01:00
env.Append( CXXFLAGS="-m64" )
2009-01-22 16:14:03 +01:00
env.Append( LINKFLAGS="-m64" )
2009-01-20 16:22:09 +01:00
2009-01-22 15:12:58 +01:00
if force32:
2009-01-30 16:29:07 +01:00
env.Append( CFLAGS="-m32" )
2009-01-22 15:12:58 +01:00
env.Append( CXXFLAGS="-m32" )
2009-01-22 16:14:03 +01:00
env.Append( LINKFLAGS="-m32" )
2009-01-20 16:22:09 +01:00
2009-07-29 20:19:55 +02:00
if GetOption( "profile" ) is not None:
2009-11-24 19:08:36 +01:00
env.Append( LIBS=[ "profiler" ] )
2009-01-20 16:22:09 +01:00
if GetOption( "gdbserver" ) is not None:
env.Append( CPPDEFINES=["USE_GDBSERVER"] )
2009-09-09 15:46:12 +02:00
# pre-compiled headers
2009-09-09 16:58:59 +02:00
if False and 'Gch' in dir( env ):
2009-09-09 15:46:12 +02:00
print( "using precompiled headers" )
2010-04-27 21:27:52 +02:00
env['Gch'] = env.Gch( [ "pch.h" ] )[0]
#Depends( "pch.o" , "pch.h.gch" )
#SideEffect( "dummyGCHSideEffect" , "pch.h.gch" )
2009-10-10 07:30:00 +02:00
if usev8:
env.Append( CPPPATH=["../v8/include/"] )
env.Append( LIBPATH=["../v8/"] )
2009-09-09 15:46:12 +02:00
2009-08-28 22:44:03 +02:00
if "uname" in dir(os):
hacks = buildscripts.findHacks( os.uname() )
if hacks is not None:
hacks.insert( env , { "linux64" : linux64 } )
2009-08-05 21:38:58 +02:00
try:
umask = os.umask(022)
except OSError:
pass
# --- check system ---
2009-12-05 17:54:36 +01:00
def getGitBranch():
if not os.path.exists( ".git" ):
return None
version = open( ".git/HEAD" ,'r' ).read().strip()
if not version.startswith( "ref: " ):
return version
version = version.split( "/" )
version = version[len(version)-1]
return version
def getGitBranchString( prefix="" , postfix="" ):
2009-12-07 01:18:30 +01:00
t = re.compile( '[/\\\]' ).split( os.getcwd() )
if len(t) > 2 and t[len(t)-1] == "mongo":
2010-01-29 22:59:22 +01:00
par = t[len(t)-2]
m = re.compile( ".*_([vV]\d+\.\d+)$" ).match( par )
if m is not None:
return prefix + m.group(1).lower() + postfix
2010-02-04 16:40:07 +01:00
if par.find("Nightly") > 0:
2010-01-29 22:59:22 +01:00
return ""
2009-12-07 01:18:30 +01:00
2009-12-05 17:54:36 +01:00
b = getGitBranch()
if b == None or b == "master":
return ""
return prefix + b + postfix
2009-03-17 15:22:26 +01:00
def getGitVersion():
if not os.path.exists( ".git" ):
return "nogitversion"
version = open( ".git/HEAD" ,'r' ).read().strip()
if not version.startswith( "ref: " ):
return version
version = version[5:]
f = ".git/" + version
if not os.path.exists( f ):
return version
return open( f , 'r' ).read().strip()
2009-03-18 19:15:52 +01:00
def getSysInfo():
if windows:
2009-03-19 13:51:04 +01:00
return "windows " + str( sys.getwindowsversion() )
2009-03-18 19:15:52 +01:00
else:
return " ".join( os.uname() )
2009-10-01 18:06:04 +02:00
def add_exe(target):
if windows:
return target + ".exe"
return target
2009-03-18 19:29:14 +01:00
def setupBuildInfoFile( outFile ):
2009-03-17 15:22:26 +01:00
version = getGitVersion()
2010-05-26 17:11:15 +02:00
if len(moduleNames) > 0:
version = version + " modules: " + ','.join( moduleNames )
2009-03-18 19:15:52 +01:00
sysInfo = getSysInfo()
2009-11-24 17:13:13 +01:00
contents = '\n'.join([
2010-04-27 21:27:52 +02:00
'#include "pch.h"',
2009-11-24 17:13:13 +01:00
'#include <iostream>',
'#include <boost/version.hpp>',
'namespace mongo { const char * gitVersion(){ return "' + version + '"; } }',
2010-05-03 01:17:35 +02:00
'namespace mongo { string sysInfo(){ return "' + sysInfo + ' BOOST_LIB_VERSION=" BOOST_LIB_VERSION ; } }',
2009-11-24 17:13:13 +01:00
])
2009-11-30 16:42:50 +01:00
contents += '\n';
2009-03-17 15:22:26 +01:00
if os.path.exists( outFile ) and open( outFile ).read().strip() == contents.strip():
return
2009-11-30 16:42:50 +01:00
contents += '\n';
2009-03-17 15:22:26 +01:00
out = open( outFile , 'w' )
out.write( contents )
2009-03-18 19:15:52 +01:00
out.close()
2009-03-17 15:22:26 +01:00
2009-03-18 19:29:14 +01:00
setupBuildInfoFile( "buildinfo.cpp" )
2009-03-17 15:22:26 +01:00
2009-04-28 14:47:56 +02:00
def bigLibString( myenv ):
s = str( myenv["LIBS"] )
if 'SLIBS' in myenv._dict:
s += str( myenv["SLIBS"] )
return s
2009-04-28 14:47:56 +02:00
2010-05-23 18:33:34 +02:00
def doConfigure( myenv , needPcre=True , shell=False ):
2009-02-01 23:39:07 +01:00
conf = Configure(myenv)
2009-02-04 15:41:52 +01:00
myenv["LINKFLAGS_CLEAN"] = list( myenv["LINKFLAGS"] )
myenv["LIBS_CLEAN"] = list( myenv["LIBS"] )
2009-05-28 19:19:02 +02:00
if 'CheckCXX' in dir( conf ):
if not conf.CheckCXX():
2009-05-28 19:19:19 +02:00
print( "c++ compiler not installed!" )
2009-05-28 19:19:02 +02:00
Exit(1)
2009-05-28 19:16:03 +02:00
2009-02-17 18:24:47 +01:00
if nix and not shell:
if not conf.CheckLib( "stdc++" ):
print( "can't find stdc++ library which is needed" );
Exit(1)
2010-05-23 18:33:34 +02:00
def myCheckLib( poss , failIfNotFound=False , staticOnly=False):
2009-01-28 23:27:12 +01:00
2009-02-01 23:39:07 +01:00
if type( poss ) != types.ListType :
poss = [poss]
2009-01-28 23:27:12 +01:00
allPlaces = [];
2009-12-09 20:58:37 +01:00
allPlaces += extraLibPlaces
if nix and release:
2009-02-01 23:39:07 +01:00
allPlaces += myenv["LIBPATH"]
if not force64:
allPlaces += [ "/usr/lib" , "/usr/local/lib" ]
2009-02-01 23:39:07 +01:00
for p in poss:
for loc in allPlaces:
fullPath = loc + "/lib" + p + ".a"
if os.path.exists( fullPath ):
myenv['_LIBFLAGS']='${_stripixes(LIBLINKPREFIX, LIBS, LIBLINKSUFFIX, LIBPREFIXES, LIBSUFFIXES, __env__)} $SLIBS'
myenv.Append( SLIBS=" " + fullPath + " " )
2009-02-01 23:39:07 +01:00
return True
2009-02-04 15:21:39 +01:00
2010-05-23 18:33:34 +02:00
if release and not windows and failIfNotFound:
print( "ERROR: can't find static version of: " + str( poss ) + " in: " + str( allPlaces ) )
Exit(1)
res = not staticOnly and conf.CheckLib( poss )
2009-02-04 15:21:39 +01:00
if res:
return True
if failIfNotFound:
2010-05-11 22:21:24 +02:00
print( "can't find or link against library " + str( poss ) + " in " + str( myenv["LIBPATH"] ) )
print( "see config.log for more information" )
2009-02-04 15:21:39 +01:00
Exit(1)
2009-02-04 15:21:39 +01:00
return False
2009-02-01 23:39:07 +01:00
if needPcre and not conf.CheckCXXHeader( 'pcrecpp.h' ):
2009-02-01 23:39:07 +01:00
print( "can't find pcre" )
Exit(1)
2009-01-25 16:01:43 +01:00
2009-02-01 23:39:07 +01:00
if not conf.CheckCXXHeader( "boost/filesystem/operations.hpp" ):
print( "can't find boost headers" )
2009-02-03 23:19:00 +01:00
if shell:
print( "\tshell might not compile" )
else:
Exit(1)
2009-01-27 17:38:41 +01:00
2009-12-30 20:58:42 +01:00
if asio:
if conf.CheckCXXHeader( "boost/asio.hpp" ):
myenv.Append( CPPDEFINES=[ "USE_ASIO" ] )
else:
print( "WARNING: old version of boost - you should consider upgrading" )
# this will add it if it exists and works
2009-12-17 16:23:23 +01:00
myCheckLib( [ "boost_system" + boostCompiler + "-mt" + boostVersion ,
"boost_system" + boostCompiler + boostVersion ] )
2009-02-01 23:39:07 +01:00
for b in boostLibs:
l = "boost_" + b
myCheckLib( [ l + boostCompiler + "-mt" + boostVersion ,
l + boostCompiler + boostVersion ] ,
2009-08-31 20:56:49 +02:00
release or not shell)
2009-08-12 20:54:53 +02:00
if not conf.CheckCXXHeader( "execinfo.h" ):
myenv.Append( CPPDEFINES=[ "NOEXECINFO" ] )
if nix and needPcre:
2009-02-01 23:39:07 +01:00
myCheckLib( "pcrecpp" , True )
myCheckLib( "pcre" , True )
myenv["_HAVEPCAP"] = myCheckLib( ["pcap", "wpcap"] )
removeIfInList( myenv["LIBS"] , "pcap" )
removeIfInList( myenv["LIBS"] , "wpcap" )
2009-11-19 18:40:23 +01:00
for m in modules:
m.configure( conf , myenv )
2009-11-03 23:15:14 +01:00
# this is outside of usesm block so don't have to rebuild for java
if windows:
myenv.Append( CPPDEFINES=[ "XP_WIN" ] )
else:
myenv.Append( CPPDEFINES=[ "XP_UNIX" ] )
2009-08-28 17:50:20 +02:00
if solaris:
conf.CheckLib( "nsl" )
2009-04-23 23:40:43 +02:00
if usesm:
2010-06-03 20:29:11 +02:00
# see http://www.mongodb.org/pages/viewpageattachments.action?pageId=12157032
J = [ "mozjs" , "js", "js_static" ]
if windows:
if msarch == "amd64":
if release:
J = [ "js64r", "js", "mozjs" , "js_static" ]
else:
J = "js64d"
print( "looking for js64d.lib for spidermonkey. (available at mongodb.org prebuilt)" );
2010-06-03 20:29:11 +02:00
else:
if release:
J = [ "js32r", "js", "mozjs" , "js_static" ]
else:
J = [ "js32d", "js", "mozjs" , "js_static" ]
2010-06-03 20:29:11 +02:00
myCheckLib( J , True )
mozHeader = "js"
2009-04-28 14:47:56 +02:00
if bigLibString(myenv).find( "mozjs" ) >= 0:
mozHeader = "mozjs"
if not conf.CheckHeader( mozHeader + "/jsapi.h" ):
if conf.CheckHeader( "jsapi.h" ):
myenv.Append( CPPDEFINES=[ "OLDJS" ] )
else:
print( "no spider monkey headers!" )
Exit(1)
2009-04-23 23:40:43 +02:00
2009-10-10 07:30:00 +02:00
if usev8:
if debugBuild:
myCheckLib( [ "v8_g" , "v8" ] , True )
else:
myCheckLib( "v8" , True )
2009-10-10 07:30:00 +02:00
2009-02-12 03:05:28 +01:00
if shell:
2009-02-12 05:16:29 +01:00
haveReadLine = False
if darwin:
myenv.Append( CPPDEFINES=[ "USE_READLINE" ] )
2009-03-04 14:18:50 +01:00
if force64:
myCheckLib( "readline" , True )
myCheckLib( "ncurses" , True )
else:
myenv.Append( LINKFLAGS=" /usr/lib/libreadline.dylib " )
elif openbsd:
myenv.Append( CPPDEFINES=[ "USE_READLINE" ] )
myCheckLib( "termcap" , True )
myCheckLib( "readline" , True )
2009-05-29 18:08:51 +02:00
elif myCheckLib( "readline" , release and nix , staticOnly=release ):
2009-02-12 03:05:28 +01:00
myenv.Append( CPPDEFINES=[ "USE_READLINE" ] )
2009-06-29 19:09:30 +02:00
myCheckLib( "ncurses" , staticOnly=release )
2009-04-17 22:23:01 +02:00
myCheckLib( "tinfo" , staticOnly=release )
2009-02-12 03:16:08 +01:00
else:
print( "\n*** notice: no readline library, mongo shell will not have nice interactive line editing ***\n" )
2009-03-25 18:22:09 +01:00
if linux:
myCheckLib( "rt" , True )
# requires ports devel/libexecinfo to be installed
if freebsd or openbsd:
myCheckLib( "execinfo", True )
env.Append( LIBS=[ "execinfo" ] )
# Handle staticlib,staticlibpath options.
staticlibfiles = []
if GetOption( "staticlib" ) is not None:
# FIXME: probably this loop ought to do something clever
# depending on whether we want to use 32bit or 64bit
# libraries. For now, we sort of rely on the user supplying a
# sensible staticlibpath option. (myCheckLib implements an
# analogous search, but it also does other things I don't
# understand, so I'm not using it.)
if GetOption ( "staticlibpath" ) is not None:
dirs = GetOption ( "staticlibpath" ).split( "," )
else:
dirs = [ "/usr/lib64", "/usr/lib" ]
for l in GetOption( "staticlib" ).split( "," ):
removeIfInList(myenv["LIBS"], l)
found = False
for d in dirs:
f= "%s/lib%s.a" % ( d, l )
if os.path.exists( f ):
staticlibfiles.append(f)
found = True
break
if not found:
raise "can't find a static %s" % l
myenv.Append(LINKCOM=" $STATICFILES")
myenv.Append(STATICFILES=staticlibfiles)
2009-02-01 23:39:07 +01:00
return conf.Finish()
env = doConfigure( env )
2009-01-27 04:19:15 +01:00
# --- js concat ---
def concatjs(target, source, env):
2009-01-27 04:19:15 +01:00
outFile = str( target[0] )
2009-01-27 04:19:15 +01:00
fullSource = ""
2009-12-10 03:30:09 +01:00
first = True
2009-01-27 04:19:15 +01:00
for s in source:
f = open( str(s) , 'r' )
for l in f:
l = l.split("//")[0].strip()
if len ( l ) == 0:
continue
2009-12-10 03:30:09 +01:00
if l == "}":
fullSource += "}"
continue
if first:
first = False
else:
fullSource += "\n"
fullSource += l
fullSource += "\n"
2009-12-10 03:30:09 +01:00
fullSource = re.compile( r'/\*\*.*?\*/' , re.M | re.S ).sub( "" , fullSource )
2009-01-27 04:19:15 +01:00
out = open( outFile , 'w' )
out.write( fullSource )
return None
jsBuilder = Builder(action = concatjs,
suffix = '.jsall',
src_suffix = '.js')
env.Append( BUILDERS={'JSConcat' : jsBuilder})
# --- jsh ---
def jsToH(target, source, env):
2009-01-27 04:19:15 +01:00
outFile = str( target[0] )
if len( source ) != 1:
raise Exception( "wrong" )
h = "const char * jsconcatcode" + outFile.split( "mongo" )[-1].replace( "-" , "_").split( ".cpp")[0] + " = \n"
2009-01-27 04:19:15 +01:00
for l in open( str(source[0]) , 'r' ):
l = l.strip()
2009-11-20 19:24:26 +01:00
l = l.split( "//" )[0]
2009-01-27 04:19:15 +01:00
l = l.replace( '\\' , "\\\\" )
l = l.replace( '"' , "\\\"" )
2009-01-27 04:19:15 +01:00
h += '"' + l + "\\n\"\n "
2009-01-27 04:19:15 +01:00
h += ";\n\n"
out = open( outFile , 'w' )
out.write( h )
return None
jshBuilder = Builder(action = jsToH,
suffix = '.cpp',
2009-01-27 04:19:15 +01:00
src_suffix = '.jsall')
env.Append( BUILDERS={'JSHeader' : jshBuilder})
# --- targets ----
2009-01-08 00:05:22 +01:00
2009-01-13 15:56:18 +01:00
clientEnv = env.Clone();
clientEnv.Append( CPPPATH=["../"] )
2009-05-28 17:16:19 +02:00
clientEnv.Prepend( LIBS=[ "mongoclient"] )
2009-07-13 19:44:11 +02:00
clientEnv.Prepend( LIBPATH=["."] )
2010-07-02 16:59:27 +02:00
#clientEnv["CPPDEFINES"].remove( "MONGO_EXPOSE_MACROS" )
2009-05-11 20:57:26 +02:00
l = clientEnv[ "LIBS" ]
removeIfInList( l , "pcre" )
removeIfInList( l , "pcrecpp" )
2009-01-13 15:56:18 +01:00
testEnv = env.Clone()
testEnv.Append( CPPPATH=["../"] )
2009-09-18 20:33:21 +02:00
testEnv.Prepend( LIBS=[ "mongotestfiles" ] )
2009-07-13 19:44:11 +02:00
testEnv.Prepend( LIBPATH=["."] )
2009-01-12 21:27:55 +01:00
# ----- TARGETS ------
def checkErrorCodes():
import buildscripts.errorcodes as x
if x.checkErrorCodes() == False:
print( "next id to use:" + str( x.getNextCode() ) )
Exit(-1)
checkErrorCodes()
2009-01-06 00:19:56 +01:00
2009-01-12 16:34:12 +01:00
# main db target
mongod = env.Program( "mongod" , commonFiles + coreDbFiles + coreServerFiles + serverOnlyFiles + [ "db/db.cpp" ] )
Default( mongod )
2009-01-12 16:34:12 +01:00
# tools
allToolFiles = commonFiles + coreDbFiles + coreServerFiles + serverOnlyFiles + [ "client/gridfs.cpp", "tools/tool.cpp" ]
2010-02-23 21:37:30 +01:00
normalTools = [ "dump" , "restore" , "export" , "import" , "files" , "stat" ]
2010-04-25 05:03:14 +02:00
env.Alias( "tools" , [ add_exe( "mongo" + x ) for x in normalTools ] )
2010-02-23 18:21:16 +01:00
for x in normalTools:
env.Program( "mongo" + x , allToolFiles + [ "tools/" + x + ".cpp" ] )
2009-02-08 16:37:39 +01:00
2010-06-09 17:31:30 +02:00
#some special tools
env.Program( "bsondump" , allToolFiles + [ "tools/bsondump.cpp" ] )
2009-04-02 21:10:52 +02:00
env.Program( "mongobridge" , allToolFiles + [ "tools/bridge.cpp" ] )
2009-02-13 15:22:04 +01:00
# mongos
2009-03-11 22:28:49 +01:00
mongos = env.Program( "mongos" , commonFiles + coreDbFiles + coreServerFiles + shardServerFiles )
2009-03-02 15:13:20 +01:00
2009-01-12 16:34:12 +01:00
# c++ library
clientLibName = str( env.Library( "mongoclient" , allClientFiles )[0] )
if GetOption( "sharedclient" ):
sharedClientLibName = str( env.SharedLibrary( "mongoclient" , allClientFiles )[0] )
env.Library( "mongotestfiles" , commonFiles + coreDbFiles + coreServerFiles + serverOnlyFiles + ["client/gridfs.cpp"])
2010-05-24 05:30:52 +02:00
env.Library( "mongoshellfiles" , allClientFiles + coreServerFiles )
2009-01-12 21:27:55 +01:00
2009-01-29 15:19:51 +01:00
clientTests = []
2009-01-13 15:15:47 +01:00
# examples
2009-01-29 15:19:51 +01:00
clientTests += [ clientEnv.Program( "firstExample" , [ "client/examples/first.cpp" ] ) ]
clientTests += [ clientEnv.Program( "secondExample" , [ "client/examples/second.cpp" ] ) ]
2009-01-29 16:30:25 +01:00
clientTests += [ clientEnv.Program( "whereExample" , [ "client/examples/whereExample.cpp" ] ) ]
2009-01-29 15:19:51 +01:00
clientTests += [ clientEnv.Program( "authTest" , [ "client/examples/authTest.cpp" ] ) ]
2010-02-12 17:33:07 +01:00
clientTests += [ clientEnv.Program( "httpClientTest" , [ "client/examples/httpClientTest.cpp" ] ) ]
2010-07-02 16:59:27 +02:00
# clientTests += [ clientEnv.Program( "bsondemo" , [ "bson/bsondemo/bsondemo.cpp" ] ) ] #TODO
2009-01-12 21:27:55 +01:00
2009-01-13 15:15:47 +01:00
# testing
test = testEnv.Program( "test" , Glob( "dbtests/*.cpp" ) )
2010-04-25 05:03:14 +02:00
if windows:
testEnv.Alias( "test" , "test.exe" )
2009-09-18 20:33:21 +02:00
perftest = testEnv.Program( "perftest", [ "dbtests/framework.cpp" , "dbtests/perf/perftest.cpp" ] )
2009-01-29 15:19:51 +01:00
clientTests += [ clientEnv.Program( "clientTest" , [ "client/examples/clientTest.cpp" ] ) ]
2009-01-12 21:27:55 +01:00
2009-02-13 22:18:57 +01:00
# --- sniffer ---
mongosniff_built = False
if darwin or clientEnv["_HAVEPCAP"]:
mongosniff_built = True
2009-02-13 22:18:57 +01:00
sniffEnv = clientEnv.Clone()
if not windows:
sniffEnv.Append( LIBS=[ "pcap" ] )
else:
sniffEnv.Append( LIBS=[ "wpcap" ] )
2009-02-13 22:18:57 +01:00
sniffEnv.Program( "mongosniff" , "tools/sniffer.cpp" )
# --- shell ---
env.JSConcat( "shell/mongo.jsall" , ["shell/utils.js","shell/db.js","shell/mongo.js","shell/mr.js","shell/query.js","shell/collection.js"] )
2009-05-02 03:25:26 +02:00
env.JSHeader( "shell/mongo.jsall" )
env.JSConcat( "shell/mongo-server.jsall" , [ "shell/servers.js"] )
env.JSHeader( "shell/mongo-server.jsall" )
shellEnv = env.Clone();
2009-02-01 23:39:07 +01:00
2009-02-05 18:42:35 +01:00
if release and ( ( darwin and force64 ) or linux64 ):
2009-02-01 23:39:07 +01:00
shellEnv["LINKFLAGS"] = env["LINKFLAGS_CLEAN"]
shellEnv["LIBS"] = env["LIBS_CLEAN"]
2009-02-05 18:42:35 +01:00
shellEnv["SLIBS"] = ""
2009-02-01 23:39:07 +01:00
2009-02-09 20:30:45 +01:00
if noshell:
print( "not building shell" )
2009-02-12 03:05:28 +01:00
elif not onlyServer:
2009-08-28 17:50:20 +02:00
weird = force64 and not windows and not solaris
2009-02-12 03:05:28 +01:00
if weird:
shellEnv["CFLAGS"].remove("-m64")
shellEnv["CXXFLAGS"].remove("-m64")
shellEnv["LINKFLAGS"].remove("-m64")
shellEnv["CPPPATH"].remove( "/usr/64/include" )
shellEnv["LIBPATH"].remove( "/usr/64/lib" )
2010-01-28 22:36:47 +01:00
shellEnv.Append( CPPPATH=filterExists(["/sw/include" , "/opt/local/include"]) )
shellEnv.Append( LIBPATH=filterExists(["/sw/lib/", "/opt/local/lib" , "/usr/lib"]) )
l = shellEnv["LIBS"]
2009-02-02 00:41:25 +01:00
2009-02-01 23:39:07 +01:00
removeIfInList( l , "pcre" )
removeIfInList( l , "pcrecpp" )
2009-02-12 03:05:28 +01:00
if windows:
shellEnv.Append( LIBS=["winmm.lib"] )
2010-06-06 02:55:11 +02:00
coreShellFiles = [ "shell/dbshell.cpp" , "shell/shell_utils.cpp" , "shell/mongo-server.cpp" ]
2009-05-08 15:15:56 +02:00
2009-02-12 03:05:28 +01:00
if weird:
2009-05-08 15:15:56 +02:00
shell32BitFiles = coreShellFiles
2009-02-12 03:05:28 +01:00
for f in allClientFiles:
shell32BitFiles.append( "32bit/" + str( f ) )
2010-05-24 18:52:28 +02:00
for f in scriptingFiles:
2010-05-24 05:38:51 +02:00
shell32BitFiles.append( "32bit/" + str( f ) )
2009-02-12 03:05:28 +01:00
shellEnv.VariantDir( "32bit" , "." )
2010-04-21 21:24:25 +02:00
shellEnv.Append( CPPPATH=["32bit/"] )
2009-02-12 03:05:28 +01:00
else:
shellEnv.Prepend( LIBPATH=[ "." ] )
2009-02-02 00:26:18 +01:00
2010-05-23 18:33:34 +02:00
shellEnv = doConfigure( shellEnv , needPcre=False , shell=True )
2009-02-02 00:26:18 +01:00
2009-02-12 03:05:28 +01:00
if weird:
mongo = shellEnv.Program( "mongo" , shell32BitFiles )
2009-02-12 03:05:28 +01:00
else:
2010-05-24 05:30:52 +02:00
shellEnv.Prepend( LIBS=[ "mongoshellfiles"] )
2009-05-08 15:15:56 +02:00
mongo = shellEnv.Program( "mongo" , coreShellFiles )
2009-02-12 03:05:28 +01:00
2009-08-14 04:44:55 +02:00
if weird:
Depends( "32bit/shell/mongo.cpp" , "shell/mongo.cpp" )
Depends( "32bit/shell/mongo-server.cpp" , "shell/mongo-server.cpp" )
2009-08-14 04:44:55 +02:00
# ---- RUNNING TESTS ----
smokeEnv = testEnv.Clone()
smokeEnv['ENV']['PATH']=os.environ['PATH']
smokeEnv.Alias( "dummySmokeSideEffect", [], [] )
smokeFlags = []
# Ugh. Frobbing the smokeFlags must precede using them to construct
# actions, I think.
if GetOption( 'smokedbprefix') is not None:
smokeFlags += ['--smoke-db-prefix', GetOption( 'smokedbprefix')]
if 'startMongodSmallOplog' in COMMAND_LINE_TARGETS:
smokeFlags += ["--small-oplog"]
def addTest(name, deps, actions):
smokeEnv.Alias( name, deps, actions )
smokeEnv.AlwaysBuild( name )
# Prevent smoke tests from running in parallel
smokeEnv.SideEffect( "dummySmokeSideEffect", name )
def addSmoketest( name, deps ):
addTest(name, deps, [ "python buildscripts/smoke.py " + " ".join(smokeFlags) + ' ' + name ])
addSmoketest( "smoke", [ add_exe( "test" ) ] )
addSmoketest( "smokePerf", [ "perftest" ] )
addSmoketest( "smokeClient" , clientTests )
addSmoketest( "mongosTest" , [ mongos[0].abspath ] )
# These tests require the mongo shell
2009-03-26 19:55:00 +01:00
if not onlyServer and not noshell:
addSmoketest( "smokeJs", [add_exe("mongo")] )
addSmoketest( "smokeClone", [ "mongo", "mongod" ] )
addSmoketest( "smokeRepl", [ "mongo", "mongod", "mongobridge" ] )
addSmoketest( "smokeDisk", [ add_exe( "mongo" ), add_exe( "mongod" ) ] )
addSmoketest( "smokeAuth", [ add_exe( "mongo" ), add_exe( "mongod" ) ] )
addSmoketest( "smokeParallel", [ add_exe( "mongo" ), add_exe( "mongod" ) ] )
addSmoketest( "smokeSharding", [ "mongo", "mongod", "mongos" ] )
addSmoketest( "smokeJsPerf", [ "mongo" ] )
addSmoketest("smokeJsSlow", [add_exe("mongo")])
addSmoketest( "smokeQuota", [ "mongo" ] )
addSmoketest( "smokeTool", [ add_exe( "mongo" ) ] )
# Note: although the test running logic has been moved to
# buildscripts/smoke.py, the interface to running the tests has been
# something like 'scons startMongod <suite>'; startMongod is now a
# no-op, and should go away eventually.
smokeEnv.Alias( "startMongod", [add_exe("mongod")]);
smokeEnv.AlwaysBuild( "startMongod" );
smokeEnv.SideEffect( "dummySmokeSideEffect", "startMongod" )
smokeEnv.Alias( "startMongodSmallOplog", [add_exe("mongod")], [] );
smokeEnv.AlwaysBuild( "startMongodSmallOplog" );
smokeEnv.SideEffect( "dummySmokeSideEffect", "startMongodSmallOplog" )
def addMongodReqTargets( env, target, source ):
2010-05-26 18:11:21 +02:00
mongodReqTargets = [ "smokeClient", "smokeJs" ]
for target in mongodReqTargets:
smokeEnv.Depends( target, "startMongod" )
smokeEnv.Depends( "smokeAll", target )
smokeEnv.Alias( "addMongodReqTargets", [], [addMongodReqTargets] )
smokeEnv.AlwaysBuild( "addMongodReqTargets" )
smokeEnv.Alias( "smokeAll", [ "smoke", "mongosTest", "smokeClone", "smokeRepl", "addMongodReqTargets", "smokeDisk", "smokeAuth", "smokeSharding", "smokeTool" ] )
smokeEnv.AlwaysBuild( "smokeAll" )
2009-04-02 22:56:39 +02:00
def addMongodReqNoJsTargets( env, target, source ):
mongodReqTargets = [ "smokeClient" ]
for target in mongodReqTargets:
smokeEnv.Depends( target, "startMongod" )
smokeEnv.Depends( "smokeAllNoJs", target )
2009-04-02 22:56:39 +02:00
smokeEnv.Alias( "addMongodReqNoJsTargets", [], [addMongodReqNoJsTargets] )
smokeEnv.AlwaysBuild( "addMongodReqNoJsTargets" )
2009-04-02 22:56:39 +02:00
smokeEnv.Alias( "smokeAllNoJs", [ "smoke", "mongosTest", "addMongodReqNoJsTargets" ] )
smokeEnv.AlwaysBuild( "smokeAllNoJs" )
2009-04-02 22:56:39 +02:00
def recordPerformance( env, target, source ):
from buildscripts import benchmark_tools
global perftest
import subprocess, re
p = subprocess.Popen( [ perftest[0].abspath ], stdout=subprocess.PIPE )
b = p.communicate()[ 0 ]
print( "perftest results:" );
print( b );
if p.returncode != 0:
return True
entries = re.findall( "{.*?}", b )
import sys
for e in entries:
matches = re.match( "{'(.*?)': (.*?)}", e )
name = matches.group( 1 )
val = float( matches.group( 2 ) )
sub = { "benchmark": { "project": "http://github.com/mongodb/mongo", "description": "" }, "trial": {} }
sub[ "benchmark" ][ "name" ] = name
sub[ "benchmark" ][ "tags" ] = [ "c++", re.match( "(.*)__", name ).group( 1 ) ]
sub[ "trial" ][ "server_hash" ] = getGitVersion()
sub[ "trial" ][ "client_hash" ] = ""
sub[ "trial" ][ "result" ] = val
try:
print(benchmark_tools.post_data(sub))
except:
print( "exception posting perf results" )
print( sys.exc_info() )
return False
addTest( "recordPerf", [ "perftest" ] , [ recordPerformance ] )
def run_shell_tests(env, target, source):
from buildscripts import test_shell
test_shell.mongo_path = windows and "mongo.exe" or "mongo"
test_shell.run_tests()
env.Alias("test_shell", [], [run_shell_tests])
env.AlwaysBuild("test_shell")
2009-01-12 21:27:55 +01:00
# ---- INSTALL -------
def getSystemInstallName():
n = platform + "-" + processor
if static:
n += "-static"
2009-08-14 20:29:59 +02:00
if nix and os.uname()[2].startswith( "8." ):
n += "-tiger"
2010-05-26 22:58:54 +02:00
if len(moduleNames) > 0:
n += "-" + "-".join( moduleNames )
2009-11-20 19:47:22 +01:00
try:
import settings
if "distmod" in dir( settings ):
n = n + "-" + str( settings.distmod )
except:
pass
2010-01-29 16:43:02 +01:00
dn = GetOption( "distmod" )
if dn and len(dn) > 0:
n = n + "-" + dn
2009-11-20 19:47:22 +01:00
return n
def getCodeVersion():
fullSource = open( "util/version.cpp" , "r" ).read()
allMatches = re.findall( r"versionString.. = \"(.*?)\"" , fullSource );
if len(allMatches) != 1:
print( "can't find version # in code" )
return None
return allMatches[0]
2010-05-28 17:49:07 +02:00
if getCodeVersion() == None:
Exit(-1)
def getDistName( sofar ):
global distName
global dontReplacePackage
if distName is not None:
return distName
if str( COMMAND_LINE_TARGETS[0] ) == "s3dist":
version = getCodeVersion()
if not version.endswith( "+" ) and not version.endswith("-"):
print( "got real code version, doing release build for: " + version )
dontReplacePackage = True
distName = version
return version
2009-12-05 17:54:36 +01:00
return getGitBranchString( "" , "-" ) + today.strftime( "%Y-%m-%d" )
2009-02-06 16:48:39 +01:00
if distBuild:
2009-02-08 20:58:52 +01:00
from datetime import date
today = date.today()
installDir = "mongodb-" + getSystemInstallName() + "-"
installDir += getDistName( installDir )
2009-02-08 20:58:52 +01:00
print "going to make dist: " + installDir
2009-01-12 21:27:55 +01:00
2009-02-08 16:37:39 +01:00
# binaries
def checkGlibc(target,source,env):
import subprocess
stringProcess = subprocess.Popen( [ "strings" , str( target[0] ) ] , stdout=subprocess.PIPE )
stringResult = stringProcess.communicate()[0]
if stringResult.count( "GLIBC_2.4" ) > 0:
2009-12-30 21:22:13 +01:00
print( "************* " + str( target[0] ) + " has GLIBC_2.4 dependencies!" )
Exit(-3)
2009-05-16 13:17:12 +02:00
allBinaries = []
def installBinary( e , name ):
2010-05-24 05:30:52 +02:00
if not installSetup.binaries:
return
2009-05-16 13:17:12 +02:00
global allBinaries
2009-05-29 19:23:25 +02:00
if windows:
e.Alias( name , name + ".exe" )
name += ".exe"
2009-05-29 19:23:25 +02:00
inst = e.Install( installDir + "/bin" , name )
2009-07-22 19:42:21 +02:00
fullInstallName = installDir + "/bin/" + name
2009-05-29 19:23:25 +02:00
2009-05-16 13:17:12 +02:00
allBinaries += [ name ]
if (solaris or linux) and (not GetOption("nostrip")):
e.AddPostAction( inst, e.Action( 'strip ' + fullInstallName ) )
2009-07-22 19:42:21 +02:00
2009-07-10 05:18:55 +02:00
if linux and len( COMMAND_LINE_TARGETS ) == 1 and str( COMMAND_LINE_TARGETS[0] ) == "s3dist":
e.AddPostAction( inst , checkGlibc )
2009-02-08 16:37:39 +01:00
2009-08-05 21:38:58 +02:00
if nix:
e.AddPostAction( inst , e.Action( 'chmod 755 ' + fullInstallName ) )
2010-02-23 18:21:16 +01:00
for x in normalTools:
installBinary( env , "mongo" + x )
if mongosniff_built:
installBinary(env, "mongosniff")
2009-07-22 19:42:57 +02:00
installBinary( env , "mongod" )
2009-04-22 18:58:39 +02:00
installBinary( env , "mongos" )
2009-02-08 16:37:39 +01:00
2009-02-09 20:30:45 +01:00
if not noshell:
installBinary( env , "mongo" )
2009-01-12 21:27:55 +01:00
2009-05-16 13:17:12 +02:00
env.Alias( "all" , allBinaries )
2010-04-26 06:05:02 +02:00
env.Alias( "core" , [ add_exe( "mongo" ) , add_exe( "mongod" ) , add_exe( "mongos" ) ] )
2009-05-16 13:17:12 +02:00
# NOTE: In some cases scons gets confused between installation targets and build
# dependencies. Here, we use InstallAs instead of Install to prevent such confusion
# on a case-by-case basis.
2009-01-12 21:27:55 +01:00
#headers
2010-05-24 05:30:52 +02:00
if installSetup.headers:
for id in [ "", "util/", "util/mongoutils/", "util/concurrency/", "db/" , "db/stats/" , "db/repl/" , "client/" , "bson/", "bson/util/" , "s/" , "scripting/" ]:
env.Install( installDir + "/" + installSetup.headerRoot + "/mongo/" + id , Glob( id + "*.h" ) )
env.Install( installDir + "/" + installSetup.headerRoot + "/mongo/" + id , Glob( id + "*.hpp" ) )
if installSetup.clientSrc:
for x in allClientFiles:
x = str(x)
env.Install( installDir + "/mongo/" + x.rpartition( "/" )[0] , x )
2009-01-12 21:27:55 +01:00
#lib
2010-05-24 05:30:52 +02:00
if installSetup.binaries:
env.Install( installDir + "/" + nixLibPrefix, clientLibName )
if GetOption( "sharedclient" ):
env.Install( installDir + "/" + nixLibPrefix, sharedClientLibName )
2009-01-12 21:27:55 +01:00
2009-02-11 12:39:00 +01:00
#textfiles
2010-05-24 05:30:52 +02:00
if installSetup.bannerDir:
for x in os.listdir( installSetup.bannerDir ):
full = installSetup.bannerDir + "/" + x
if os.path.isdir( full ):
continue
if x.find( "~" ) >= 0:
continue
env.Install( installDir , full )
2009-02-11 12:39:00 +01:00
2009-01-12 21:27:55 +01:00
#final alias
env.Alias( "install" , installDir )
# aliases
if windows:
env.Alias( "mongoclient" , "mongoclient.lib" )
else:
env.Alias( "mongoclient" , "libmongoclient.a" )
# ---- CONVENIENCE ----
def tabs( env, target, source ):
from subprocess import Popen, PIPE
from re import search, match
diff = Popen( [ "git", "diff", "-U0", "origin", "master" ], stdout=PIPE ).communicate()[ 0 ]
sourceFile = False
for line in diff.split( "\n" ):
if match( "diff --git", line ):
2009-01-18 16:23:57 +01:00
sourceFile = not not search( "\.(h|hpp|c|cpp)\s*$", line )
2009-01-17 16:33:43 +01:00
if sourceFile and match( "\+ *\t", line ):
return True
return False
env.Alias( "checkSource", [], [ tabs ] )
env.AlwaysBuild( "checkSource" )
def gitPush( env, target, source ):
import subprocess
return subprocess.call( [ "git", "push" ] )
env.Alias( "push", [ ".", "smoke", "checkSource" ], gitPush )
env.AlwaysBuild( "push" )
2009-01-27 19:08:44 +01:00
# ---- deploying ---
2009-02-11 03:37:18 +01:00
def s3push( localName , remoteName=None , remotePrefix=None , fixName=True , platformDir=True ):
if remotePrefix is None:
if distName is None:
2009-12-05 17:54:36 +01:00
remotePrefix = getGitBranchString( "-" ) + "-latest"
2009-02-11 03:37:18 +01:00
else:
remotePrefix = "-" + distName
2009-01-27 19:08:44 +01:00
sys.path.append( "." )
2009-08-27 17:52:22 +02:00
sys.path.append( ".." )
sys.path.append( "../../" )
2009-01-27 19:08:44 +01:00
import simples3
import settings
2009-02-02 15:54:11 +01:00
s = simples3.S3Bucket( settings.bucket , settings.id , settings.key )
2009-01-27 19:08:44 +01:00
if remoteName is None:
remoteName = localName
2009-02-02 04:11:26 +01:00
if fixName:
2009-02-06 16:48:39 +01:00
(root,dot,suffix) = localName.rpartition( "." )
name = remoteName + "-" + getSystemInstallName()
2009-07-07 17:12:39 +02:00
name += remotePrefix
2009-02-06 16:48:39 +01:00
if dot == "." :
name += "." + suffix
2009-02-02 04:11:26 +01:00
name = name.lower()
else:
name = remoteName
2009-01-27 19:08:44 +01:00
2009-02-06 16:48:39 +01:00
if platformDir:
name = platform + "/" + name
2009-02-11 03:37:18 +01:00
print( "uploading " + localName + " to http://s3.amazonaws.com/" + s.name + "/" + name )
if dontReplacePackage:
for ( key , modify , etag , size ) in s.listdir( prefix=name ):
print( "error: already a file with that name, not uploading" )
Exit(2)
2009-02-10 16:54:43 +01:00
s.put( name , open( localName , "rb" ).read() , acl="public-read" );
2009-02-11 03:37:18 +01:00
print( " done uploading!" )
2009-01-27 19:08:44 +01:00
def s3shellpush( env , target , source ):
s3push( "mongo" , "mongo-shell" )
env.Alias( "s3shell" , [ "mongo" ] , [ s3shellpush ] )
env.AlwaysBuild( "s3shell" )
2009-02-02 00:27:04 +01:00
def s3dist( env , target , source ):
2009-02-11 16:53:51 +01:00
s3push( distFile , "mongodb" )
env.Append( TARFLAGS=" -z " )
2009-02-02 00:27:04 +01:00
2010-05-05 16:56:44 +02:00
if installDir[-1] != "/":
if windows:
distFile = installDir + ".zip"
env.Zip( distFile , installDir )
else:
distFile = installDir + ".tgz"
env.Tar( distFile , installDir )
env.Alias( "dist" , distFile )
env.Alias( "s3dist" , [ "install" , distFile ] , [ s3dist ] )
env.AlwaysBuild( "s3dist" )
2009-02-02 00:27:04 +01:00
def clean_old_dist_builds(env, target, source):
prefix = "mongodb-%s-%s" % (platform, processor)
filenames = sorted(os.listdir("."))
filenames = [x for x in filenames if x.startswith(prefix)]
to_keep = [x for x in filenames if x.endswith(".tgz") or x.endswith(".zip")][-2:]
for filename in [x for x in filenames if x not in to_keep]:
2009-04-22 17:15:22 +02:00
print "removing %s" % filename
try:
shutil.rmtree(filename)
except:
os.remove(filename)
env.Alias("dist_clean", [], [clean_old_dist_builds])
env.AlwaysBuild("dist_clean")
# --- an uninstall target ---
if len(COMMAND_LINE_TARGETS) > 0 and 'uninstall' in COMMAND_LINE_TARGETS:
SetOption("clean", 1)
# By inspection, changing COMMAND_LINE_TARGETS here doesn't do
# what we want, but changing BUILD_TARGETS does.
BUILD_TARGETS.remove("uninstall")
BUILD_TARGETS.append("install")