weave/site/building.md

title, layout

title	layout
Building Weave	default

You only need to build weave if you want to work on the weave codebase (or you just enjoy building software).

Apart from the weave shell script, weave is delivered as a set of container images. There is no distribution-specific packaging, so in principle it shouldn't matter which Linux distribution you build under. But naturally, Docker is a prerequisite (version 1.3.0 or later). And it is difficult to build under Fedora because Fedora does not include static libraries. So we recommend building under Ubuntu.

You can also build in a container under any system that supports Docker. And you can run Ubuntu in a VM and build there. These options are described below.

Building directly on Ubuntu

The weave git repository should be cloned into $GOPATH/src/github.com/zettio/weave, in accordance with (the go workspace conventions)[https://golang.org/doc/code.html#Workspaces]:

$ WEAVE=github.com/zettio/weave
$ git clone https://$WEAVE $GOPATH/src/$WEAVE
$ cd $GOPATH/src/$WEAVE

Several prerequisites are needed to build weave. To install these, in the weave directory do:

$ make prerequisites

Then to actually build, simply do:

$ make

This will build the weave components and package them into three Docker images (zettio/weave, zettio/weavedns, and zettio/weavetools). These are then exported (as weave.tar, weavends.tar and weavetools.tar).

Building in a Docker container

As a preliminary step, we create a container image based on Ubuntu that has all the prerequisites. This avoids the need to download and install them for each build. In the weave directory, do:

$ docker build -t zettio/weave-build build

Next we run a container based on that image. That container requires access to the Docker daemon on the host, via /var/run/docker.sock. If you are building under a Fedora or RHEL Docker host (or another distribution that uses SELinux), and you have SELinux set to enforcing mode, it will block attempts to access /var/run/docker.sock inside the container. See dpw/selinux-dockersock for a way to work around this problem.

To perform a build, run:

$ docker run -v /var/run/docker.sock:/var/run/docker.sock zettio/weave-build https://github.com/zettio/weave.git

This will clone the weave git repository, then do the build.

When the build completes, the resulting images are stored in docker on the host, as when building directly under Ubuntu. The exported images are present under /var/tmp/ inside the container, and can be retrieved using docker cp if needed.

The container arguments are passed to git clone, so for example, you can build from a forked repository and a specific branch with:

$ docker run -v /var/run/docker.sock:/var/run/docker.sock zettio/weave-build -b <branch name> <repo URI>

Alternatively, you might want to build from a weave source tree already present on the host. You can do this by using the -v option to bind the bind your go workspace containing the weave repository to /home/go inside the container. No container arguments should be passed in this case:

$ docker run -v /var/run/docker.sock:/var/run/docker.sock -v <host gopath>:/home/go zettio/weave-build

This will leave the intermediate build artifacts on the host, so that you can modify the weave source code and rebuild quickly.

Building using Vagrant

If you aren't running Linux, or otherwise don't want to run the docker daemon outside a VM, you can use Vagrant to run a development environment. You'll probably need to install VirtualBox too, for Vagrant to run VMs in.

First, check out the code:

$ git clone https://github.com/zettio/weave
$ cd weave

The Vagrantfile in the top directory constructs a VM that has

• docker installed
• go tools installed
• weave dependencies installed
• $GOPATH set to ~
• the local working directory mapped as a synced folder into the right place in $GOPATH

Once you are in the working directory you can issue

$ vagrant up

and wait for a while (don't worry, the long download and package installation is done just once). The working directory is sync'ed with ~/src/github.com/zettio/weave on the VM, so you can edit files and use git and so on in the regular filesystem.

To build and run the code, you need to use the VM. To log in and build the weave image, do

$ vagrant ssh
vm$ cd src/github.com/zettio/weave
vm$ make

The docker daemon is also running in this VM, so you can then do

vm$ sudo ./weave launch
vm$ docker ps

and so on.

You can provide extra Vagrant configuration by putting a file Vagrant.local in the same place as Vagrantfile; for instance, to forward additional ports.