Dependencies

cmake ( install cmake (sudo apt-get install cmake))
g++ ( install g++ (sudo apt-get install g++) )
Python 2.7 ( Python 3.0 not tested )
If you intend to use ecFlow Python API, You will need to install Python. (install python-dev (sudo apt-get install python-dev))
Please ensure that python is accessible on $PATH otherwise, you may need to customise $BOOST_ROOT/tools/build/v2/site-config.jam .
The python installation should include the development packages
If you do not need the python api, then you can build without it, see below.
Xlib, X11, XMotif for ecflowview .
Do not use Lesstif library to compile ecflowview as a replacement for Motif.
OpenMotif can be downloaded from http://www.ist.co.uk/downloads/motif_download.html
If you do not want use the GUI, then you can configure the build to ignore this dependency.

Setting up the build environment

ecfFlow consists of two tar files i.e. :
- boost_1_53_0.tar.gz
- ecFlow-4.0.9-Source.tar.gz
  Create a directory for the build:
  mkdir /tmp/ecflow_build
Copy the the two tar file into this directory, then change directory to /tmp/ecflow_build

Un-zip then un-tar the two file files:

tar -zxf boost_1_53_0.tar.gz
tar -zxf ecFlow-4.0.9-Source.tar.gz

You should have two directories created:
boost_1_53_0 ecFlow-4.0.9-Source

Create two environment variables. These are used by some of scripts:

export WK=/tmp/ecflow_build/ecFlow-4.0.9-Source
export BOOST_ROOT=/tmp/ecflow_build/boost_1_53_0

Build boost

Boost uses bjam for building the boost libs.
bjam source is available in boost, hence we first need to build bjam itself:
cd $BOOST_ROOT ./bootstrap.sh
Ecflow uses some of compiled libraries in boost. The following script will build the required lib’s, in both debug and release forms and will configure boost build according to your platform.

If you do not require the ecflow python api, you can avoid build boost python libs by setting.

export ECF_NO_PYTHON=1

before calling $WK/build_scripts/boost_build.sh

cd $BOOST_ROOT
$WK/build_scripts/boost_1_53_fix.sh    # fix for boost, only for some platforms
$WK/build_scripts/boost_build.sh       # compile boost libs used by ecFlow

Build

There are two build systems available for ecflow:

boost-build/bjam
cmake

It is recommended to use cmake, since boost-build/bjam will be deprecated.

cmake

As configure, CMake will run some tests on the customer's system to find out if required third-party software libraries are available and notes their locations (paths). Based on this information it will produces the Makefiles needed to compile and install ecflow

CMake is a cross-platform free software program for managing the build process of software using a compiler-independent method.

Generating the Makefiles with CMake

After changing into the build ecflow directory, the user has to run CMake with his/her own options. The command gives feedback on what requirements are fulfilled and what software is still required. Table below gives an overview of the different options of configure. The default (without any options) will compile a share library only and install it in /usr/local/.

cmake options	doc	default
CMAKE_INSTALL_PREFIX	where you want to install your ecflow	/usr/local
CMAKE_BUILD_TYPE	to select the type of compilation: Debug RelWithDebInfo Release (fully optimised compiler options) Production	Release
CMAKE_CXX_FLAGS	More flags for the C++ compiler
ENABLE_PYTHON	enable python interface	on
ENABLE_GUI	enable build of ecflowview	on
ENABLE_ALL_TESTS	enable performance, migration, regression tests.	off
BOOST_ROOT	where to find boost ( if non-standard installation ) If not specified cmake will look for an environment variable of the same name.

The C++ compilers are chosen by CMake. (This can be overwritten by setting the environment variables CXX on the command line before you call cmake, to the preferred compiler).

Further the variable CMAKE_CXX_FLAGS can be used to set compiler flags for optimisation or debugging.

cd $WK
mkdir build; cd build;

# Go with defaults, this should with DCMAKE_BUILD_TYPE=Release
cmake .. 

# build release with debug info  
# cmake .. -DCMAKE_BUILD_TYPE=RelWithDebInfo

# Override install prefix, build the most optimised executables 
# cmake .. -DCMAKE_INSTALL_PREFIX=/usr/local/apps/ecflow -DCMAKE_BUILD_TYPE=Release  

# do not build the gui.
# cmake .. -DCMAKE_INSTALL_PREFIX=/usr/local/apps/ecflow -DCMAKE_BUILD_TYPE=Release -DENABLE_GUI=OFF

# If you do not need the python api, use:
# cmake .. -DENABLE_PYTHON=OFF

# Use -j option to speed up compilation. Determine number of cpu's
CPUS=$(lscpu -p | grep -v '#' | wc -l)
make -j${CPUS}
make check
make install

To use the ecFlow Python Api , you need to add/change PYTHONPATH .

export PYTHONPATH=$PYTHONPATH:<prefix>/4.0.9/lib/python2.7/site-packages/ecflow
# If you used the default's then <prefix>=/usr/local
# otherwise you should use whatever you entered for -DCMAKE_INSTALL_PREFIX, hence in the examples above we would have:
export PYTHONPATH=$PYTHONPATH:/usr/local/apps/ecflow/4.0.9/lib/python2.7/site-packages/ecflow

boost-build/bjam

Now make sure bjam is accessible from $PATH or use $BOOST_ROOT/bjam in place bjam below.

For installation the following environment variables are required.

ECFLOW_INSTALL_DIR         # Directory Location for client ,server and gui program's
ECFLOW_PYTHON_INSTALL_DIR  # Directory Location for ecflow python package
        

The python installation can be customised, by changing Pyext/jamfile.jam and $BOOST_ROOT/tools/build/v2/site-config.jam

We now need to build ecFlow. Currently ecflowview/GUI is only built if environment variable of name ARCH is set to linux:

cd $WK
bjam variant=release

On some systems like fedora/redhat you may run into compiler errors which complain about the template depth being exceeded. In this case compile using:

cd $WK
bjam c++-template-depth=512 variant=release

# using boost 1.53 with gcc 4.8, will have excessive warnings. To prune these warnings use
bjam c++-template-depth=512 cxxflags=-Wno-unused-local-typedefs variant=release

If you have a multi-core machine, you can speed up the build using, the -j<n> option. Where ‘n’ is an integer, of the number of cores.

CPUS=$(lscpu -p | grep -v '#' | wc -l)
bjam variant=release -j${CPUS)

Once ecFlow is built it can be installed. NOTE, if you used c++-template-depth=512 || cxxflags=-Wno-unused-local-typedefs, use it again for the next step.
bjam variant=release install-all
This will create directories:
<ECFLOW_INSTALL_DIR>/bin <ECFLOW_INSTALL_DIR>/lib <ECFLOW_INSTALL_DIR>/doc <ECFLOW_INSTALL_DIR>/share <ECFLOW_PYTHON_INSTALL_DIR>
Depending on your umask setting you may need to call chmod 755 on the executables
To use the ecFlow Python Api , you need to add/change PYTHONPATH .
export PYTHONPATH=$PYTHONPATH:$ECFLOW_PYTHON_INSTALL_DIR
When compiling ecflowview in a system where motif is not installed in the usual location, or where both motif and lesstif are installed, it is possible to export the environment variables MOTIF_INCLUDE and MOTIF_LIBRARY to help bjam to find the right location for include files and libraries.
Openmotif may be retrieve from IST server and installed locally: wget http://www.ist-inc.com/motif/download/motif_files/openmotif-2.1.32-2_IST.x86_64.rpm rpm2cpio openmotif-2.1.32-2_IST.x86_64.rpm | cpio -idmv
user shall then compile setting MOTIF_INCLUDE and MOTIF_LIBRARY variable.
ecflowview

By default the ecflowview 'server' and ‘ecflowview.menu’ files are placed in <ECFLOW_INSTALL_DIR>/share/ecflow directory. However you can use ECFLOWVIEW_HOME shell variable to override this.

The <ECFLOW_INSTALL_DIR>/share/ecflow/server files defines the list of servers you want all your users to see in ecflowview. If has a very simple format. For each ecflow server add a line like:
<server_name> <machine_name> <port>
ECFLOWRC variable may be set to use alternative directory for user ecflowview option files (default is $HOME/.ecflowrc)