Using scons for a Project made of a few programs - build

Question

I'm trying to create a build system for my project which will be based on scons.
The project consist of several directories, each holding part of the whole project.
Each directory hold the sources of either a shared library, a program or a process (daemon).
One directory (bin) holds all shared libraries and all executables.
Most of the directories already contain a sconscript file (named Sconstruct) which builds the directory's module (lib / executable) and put it in the bin directory.
Now I want to create one more sconscript - to rule them all..
In the parent directory I want a sconscript that builds all libraries and executables of the project, so that after I change a few sources here and there I can run scons from the parent directory and all affected modules will be re-built.
I tried a few ways, and they all failed.
I'm quite a noob in the scons business, and I susspect this is the root cause of my failures, but I'm sure this problem was solved many times by other, more experienced, developers - as the situation I described is quite common.
So, any suggestions are welcomed!
EDIT:
My current Sconstruct in the parent directory looks like this:
import os
env = os.environ
Export('env', 'os')
SConscript([
'Server1_Dir/Sconstruct',
'Server2_Dir/Sconstruct',
'Server3_Dir/Sconstruct'
])
The Sconstructs in the sub-directories (I know they should be called Sconscript) start with:
import os
Import('env')
home=env.get('HOME')
So it seems to me that I'm using the same environment for all scripts, though I'm getting a lot of:
scons: warning: Two different environments were specified for target....
warnings, which are unclear for me.
It's also worth noting that not all server-combinations in the main script yield these warnings - some may leave together peacefully, but not all.
It does seem to me that this is the right way to go, but I can't find a way to get rid of those warnings (and their root cause).
Thanks.

Answer 1

What you want to do is called a hierarchical build as described here. In SCons, there can only be one SConstruct per project.
The way to create a hierarchical build in SCons is to make the root SCons script be the SConstruct, and the subdirectory SCons scripts be called SConscript. The root SConstruct script "loads" the subdirectory SConscripts using the SConscript() function described in the above link.
Here's an example assuming you have a root SConstruct and a lib and bin subdir:
SConstruct
env = Environment()
SConscript('lib/SConscript', exports='env')
SConscript('bin/SConscript', exports='env')
lib/SConscript
Import('env')
env.Library('yourlib', ['yourLibSource.cc'])
bin/SConscript
Import('env')
env.Program('yourbin', ['yourBinSource.cc'])

Answer 2

My scripts, before I tried to unify them, looked like the following (and worked properly):
Librarry building-script Stracture:
Environment and Definitions:
~~~~~~~~~~~~~~~~~~~~~~
import os
env = os.environ
home = env.get('HOME')
projects = []
third_parties_projects = []
my_rpath = []
Preparing lists of paths and files:
~~~~~~~~~~~~~~~~~~~~~~~~~
all_user_implemented_libs = os.path.join(home,"Project/lib/")
my_rpath.append("/path/to/lib/dir/")
projects.append(os.path.join(home,"Project/library_1/"))
projects.append(os.path.join(home,"Project/library_2/"))
...
third_parties_projects.append("/opt/some_product/include/")
...
so_files = Split("""
source_1.cpp
source_2.cpp
...
""")
Controlling the build:
~~~~~~~~~~~~~~~~
myprog = Environment(CXXFLAGS = flags, ENV = env, CPPPATH = projects + third_parties_projects + ['.'], RPATH = my_rpath)
myprog.Decider('MD5')
mylib = myprog.SharedLibrary(all_user_implemented_libs + 'lib_name', so_files)
myprog.Default(mylib)
Process building-script Stracture:
Environment and Definitions:
~~~~~~~~~~~~~~~~~~~~~~
import os
env = os.environ
home = env.get('HOME')
projects = []
third_parties_projects = []
user_libpaths = []
my_rpath = []
Preparing lists of paths and files:
~~~~~~~~~~~~~~~~~~~~~~~~~
projects.append(os.path.join(home,"Project/library_1/"))
projects.append(os.path.join(home,"Project/library_2/"))
....
my_rpath.append("/path/to/lib/dir/")
third_parties_projects.append("/opt/some_product/include/")
...
all_user_implemented_bins = os.path.join(home,"Project/bin/")
all_user_implemented_libs = os.path.join(home,"Project/lib/")
flags = ''
libs = Split("""
lib_1
lib_2
...
""")
third_party_libpaths.append("/opt/some_product/")
...
source_ext_files = Split("""
ext_source_1.cpp
...
""")
source_files_for_executable = Split("""
source_1.cpp
sosurce_2.cpp
...
""")
user_libpaths.append(all_user_implemented_libs)
Building the underlaying libs:
~~~~~~~~~~~~~~~~~~~~~~
for project in projects:
SConscript(project+'/Sconstruct')
Controlling the build:
~~~~~~~~~~~~~~~~
myprog = Environment(CXXFLAGS = flags, ENV = env, CPPPATH = projects + third_parties_projects + ['.'], RPATH = my_rpath)
myprog.Decider('MD5')
my_prog = myprog.Program(all_user_implemented_bins + 'process_name', source_files_for_executable + source_ext_files, LIBS = libs, LIBPATH = third_party_libpaths + user_libpaths)
myprog.Default(my_prog)
These scripts are scattered each in its corresponding lib/exec directory, and work fine when executed separately.
Now I want to add one more script (like the one in the original question) in the parent directory which will build the whole product - all executables and all underlaying libraries - as necessary.
Thanks.