Skip to main content

Notice: This Wiki is now read only and edits are no longer possible. Please see: for the plan.

Jump to: navigation, search

Non Java projects Proposal

< To: Buckminster Project
< To: Helping_Out_(Buckminster)
< To: Buckminster component meta-data language 1.0 (Reference)


While trying to use Buckminster for both my Java and C++ projects, I realized that Java projects within Eclipse were pretty straightforward but C/C++ projects were much more difficult to manage.

Why is it so hard to use Buckminster with non Java projects ?

Component materialization is much harder in non Java environments because :

  • there are no standard way to describe C/C++ projects so you have to write the CSpec file anyway ( contrary to Eclipse Java projects which provides a way to auto generate the CSpec )
  • compiling, testing, your code requires to execute programs from outside ( shell scripts, compiler, unit tests and so forth ).
  • some of the resources you need to materialize are libraries that are only available as zipped url resources.
    • which implies you have to download and unzip them : Buckminster cannot do that for the moment despites its exactly what you expect it to do. So to overcome this issue you have to write ant tasks.

Work flow currently used

The toolchain I created to manage C/C++ projects dependencies is as follows :

  • Create Spec components to describe dependencies
  • Specify actions like build / clean / rebuild
    • those actions have prerequisites pointing to other components (eg: the path to the libTiff include folder)
  • Write ant scripts called from buckminster to
    • retrieve libraries from urls or retrieve files from archives pointed by url
    • execute commands with specific environment variables (eg. calling the compiler with paths to libraries)
  • Create the script to compile the code ( Makefile or Boost Jamfile or SCons file )


This page is a proposal to extends Buckminster in order to bring users from the non Java world a better experience.

Executor Actor (now available)

This actor would add the possibility to execute programs directly from the CSpec without writing Ant Scripts.


  • Executes programs or shell scripts
  • Sets arguments
    • arguments can refer to prerequisites
  • Sets environment variables for the execution
    • environments variables values can refer to prerequisites
  • Sets execution directory


<cs:public name="build" actor="executor">
            <cs:property key="newenvironment" value="true"/>
            <cs:property key="env" value="TIFF_LIB=${tiff.lib};TIFF_INCLUDE=${tiff.include};
            <cs:property key="shell" value="${compiler} -j2 debug"/>
            <cs:property key="VERSION" value="1.0.0"/>
            <cs:attribute component="mingw-5.1.4" name="compiler" alias="compiler" />
            <cs:attribute component="libtiff-3.6.1" name="include" alias="tiff.include" />
            <cs:attribute component="libtiff-3.6.1" name="lib" alias="tiff.lib" />

Valid properties

This syntax integrates into Buckminster's CSpec Actions.

  • env : a list of semi-colon separated environment variable
  • newenvironment : if set to true, the execution will start from a blank environment variables.
    • Note in early design development the opposite paradigm was chosen and one has to use inheritEnvVar to start from the system environment variables, now it's the default behavior.
  • failonerror : if unset or set to true, the action will fail if execution returns non 0 return value. Default is true.
  • exec : the program to execute
  • execDir : the program execution directory (if not set : the component directory)
  • shell : a batch file to execute

Note that you have to choose between exec or shell keyword.

All those properties can contain variables.

Those variables are set by surrounding properties or named path with ${}. See examples above.

Fetcher Actor (now available)

This actor is used to materialize resources into the component. I'm still not sure this behavior should be provided by an actor or through the materialization process. It seems the actor can be used at will so it's more flexible than the materialization but this point can be discussed.


  • fetch single (for the moment)
  • log to https sites
  • unzip, untar, untargz, untarbz2 files (add 7zip support ?)
    • possibility to specify destination directory
    • possibility to filter the archive content
    • keep hierarchy or flatten folders


<cs:public name="download" actor="fetcher">
      <cs:property key="dir" value="data"/>
      <cs:property key="options" value="uncompress;flatten;include=*.html;include=*.c"/>
      <cs:property key="url" value=""/>

Valid Properties

  • url : the resource to fetch
  • dir : the directory where the file(s) should be placed
    • if not set dir points to component's location

If the resource you are accessing is protected with basic authentication, you can also specify :

  • login : the login to use with basic authentication
  • pass : the password to use with basic authentication

Note that both properties have to be set to enable authentication.

  • options : a set of options to customize the fetch operation, valid options are :
    • uncompress : specify that the resource pointed by the url is an archive and that it should be uncompressed
    • flatten : valid only with uncompress. If specified the folder hierarchy is flatten
    • include : a regular expression to include specific files only. Note that you can specify multiple include directives in the options line. Regular expressions beginning with the '-' (minus sign) will be considered as an exclusion. See examples below :
Options samples

full options sample, uncompress the archive and flattens the folder hierarchy, including only files in the binaries directory that are not html files


flatten and include keywords will NOT work until the uncompress keyword is set, the following options line will simply copy the url resource locally.


Script Actor ( dismissed actually )

Builds a platform dependent shell script baking a set of environment variables. It is used to executes actions independently from Buckminster. Sure, you will loose the dynamic aspect of Buckminster's actions but you'll get faster executions.


  • sets the environment variable according to the platform
  • action's prerequisites are automatically set in the script
  • allow appending lines to the script
  • allow filtering of specific lines
  • allow unsetting of specific variables


<cs:public name="my.script" actor="script">
      <cs:property key="append.0" value="echo Will be displayed anyway"/>
      <cs:property key="append.1" value="echo Will be displayed on windows"/>
      <cs:property key="append.2" value="echo Will be displayed on linux"/>
      <cs:property key="append.3" value="echo BJAM=${BJAM}"/>
      <cs:property key="filter.1" value="(target.os=win32)"/>
      <cs:property key="filter.2" value="(target.os=linux)"/>
      <cs:property key="script.dir" value="data"/>
      <cs:property key="" value="/bin/bash"/>
      <cs:property key="" value="script"/>
      <cs:property key="unset" value="BJAM"/>
      <cs:attribute name="bjam" alias="BJAM" component="boost-1.36.0"/>
      <cs:attribute name="include" alias="BOOST_INCLUDE" component="boost-1.36.0"/>
      <cs:attribute name="libs" alias="BOOST_LIBS" component="boost-1.36.0"/>
  • On windows, would produce the file data/script.bat
echo Will be displayed anyway
echo Will be displayed on windows
  • On linux, would produce the file data/
echo Will be displayed anyway
echo Will be displayed on linux

Valid Properties

  • append.* : appends a line after the export section.
    • * is a number which is used to order the lines. We have no choice here as properties have unique keys.
    • a line might be filtered by a filter.* property.
  • filter.* : filters the line * according to the LDAP filter specification.
    • the line is appended only if the filter returns true.
  • script.dir : the directory where the script should be placed
  • : used on linux to set the shebang.
  • : sets the script filename (extension will be appended automatically).
  • unset : a comma separated list of alias not to set.

Unix scripts will be chmoded to a+x to allow execution.

Echo Actor ( under discussion )

Ouputs data to a file.


  • write or append to file
  • input can come from
    • file on disk
    • property value
    • inner elements with CDATA sections


<cs:public name="my.script" actor="echo">
      <cs:property key="append" value="true"/>
      <cs:property key="input" value="text"/>
      <cs:property key="some.key">these</cs:property>
      <cs:property key="text"><![CDATA[
# Here you can write virtually anything. Constructs like
# ${some.key} would of course be expanded.
${BJAM} $*
      <cs:attribute name="bjam" alias="BJAM" component="boost-1.36.0"/>
      <cs:attribute name="include" alias="BOOST_INCLUDE" component="boost-1.36.0"/>
      <cs:attribute name="libs" alias="BOOST_LIBS" component="boost-1.36.0"/>
   <cs:products base="${buckminster.home}/script">
      <cs:path path=""/>

Back to the top