Getting Started

The full build is usually running on your CI server. This build produces all the artifacts required for partial builds. Partial builds are running on development computers - based on artifacts produced by the full build.

To achieve this, full-build lets you define the universe of all projects (it’s called an anthology) - it can be splitted among different repositories (if you have different teams working on different products). Note that projects are converted to work with full-build. They are still regular *proj using MsBuild but are adapted in a way to allow partial builds (you can still use MsBuild, XBuild, VisualStudio 2015+ or Xamarin Studio 6+).

Once the anthology is built, developers can work using partial builds and still resynchronize with master build when they are required to.

Download following tools, unzip them in your tools folder and ensure they are available in your path:

To use full-build, you will need to create:

  • master repository : first of all, create an empty repository (either Git, Gerrit or Mercurial). This will be the master repository. Ensure developers have read access. Allow write access to people in charge of configuration.
  • master artifacts : then create a public share. Full build artifacts will be pushed there and should be available to anyone. Ensure everyone has read access. Allow write access to people in charge of configuration (including CI).

In tutorial, you will learn to configure full-build and use it on two repositories:

The goal is to setup a workspace using given repositories, getting rid of NuGet packages and build everything from sources only.


This tutorial assumes following configuration:

  • master repository :
  • master artifacts : \buildartifacts\buildoutput

Create a new workspace using command:

fullbuild setup git \\buildartifacts\buildoutput c:\src\myworkspace 
cd c:\src\myworkspace

Under c:\src\myworkspace, full-build has initialized everything to start a new anthology configuration from scratch. Now, you can start adding external repositories. They have to be converted later to be compatible with full-build.

Add nuget sources:

fullbuild nuget add

Add repositories using command:

fullbuild repo add cassandra-sharp 
fullbuild repo add cassandra-sharp-contrib

Now clone all repositories:

fullbuild clone *

It’s now time to convert everything and see the benefits of full-build:

fullbuild convert *

If everything is ok, you have now successfuly added projects to the anthology !

You can now start building and check if everything is ok:

fullbuild view all * 
fullbuild build all
fullbuild test all

And voilà, you are all set! Eventually commit and push everything to start collaborating with your teams:

fullbuild exec --all "echo *** committing %FB_NAME% && git co -m conversion && git push" 

Steps to configure Continuous Integration (CI role is to build all sources)

Following steps must be orchestrated on CI:

  • clone master repository (fullbuild init folder master_repository)
  • cd folder
  • clone all respositories using full-build (fullbuild clone *)
  • generate a view with all sources (fullbuild view all *`)
  • build all sources (fullbuild build all)
  • test assemblies (fullbuild test all)
  • generate change log (fullbuild history)
  • generate a new version (fullbuild publish)
  • publish artifacts and create a baseline (fullbuild push)

Steps to create partial build (Developer environment or CI partial build)

  • clone master repository (fullbuild init folder master_repository)
  • cd folder
  • clone required repositories (fullbuild clone repoName)
  • build a view with sources selection filter (fullbuild view mypartialview repoName/*)
  • build view sources (fullbuild build mypartialview)
  • test view sources (fullbuild test mypartialview)