How it works

ANVIL is based along the following system design

  • Having shared components/actions be shared (using object oriented practices)
  • Having specific actions be isolated to its component (and easily readable)
  • Being simple enough to read yet following standard python software development practices and patterns

Directory structure is the following

  • Parent classes located in anvil/, it contains the root install/uninstall/start/stop classes
  • Subclasses in anvil/components/, it contains the individual install classes for each openstack component
  • Running modes implementations in anvil/runners/ (ie fork, screen, upstart)
  • Packaging implementations in anvil/packaging/
  • Image uploading/registry/management (for glance) in anvil/image/
  • Shared classes and utils in anvil/
  • Main entry point/s in anvil/progs/
  • Other various tools in tools/
  • Configuration in conf/ (see below)


Install object model

Here is the install components (default set only) class hierarchy:

From this example the root classes job are:

  • Python install component
  • Ensures pips are installed (child classes specify which pips)
  • Ensures python directories (ie are setup (child classes specify which directories)
  • Package install component
  • Installs packages that are required for install (child classes specify which packages)
  • Sets up and performs parameter replacement on config files (child classes specify which config files)
  • Sets up symlinks to config or other files (child classes specify these symlinks)
  • Tracks what was setup so that it can be removed/uninstalled
  • Component base (used by all install/uninstall/start/stop component classes)
  • Holds configuration object, component name, packaging and other shared members…
  • Allows for overriding of dependency function and pre-run verification

For a install class the following functions are activated (in the following order by anvil/


Performs the main git download (or other download type) to the
application target directory.

Configures the components files (symlinks, configuration and logging

Child class specific function that can be used to do anything before
an install (ie set a ubuntu mysql pre-install root password)

Installs distribution packages, python packages (*pip*), sets up
python directories (ie *python develop*) and any other
child class specific actions.

Child class specific function that can be used to do anything after
an install (ie run *nova-manage db sync*)


For those of you that are brave enough to change stack here are some starting points.


Check out conf/stack.ini for various configuration settings applied (branches, git repositories…). Check out the header of that file for how the customized configuration values are parsed and what they may result in.


Check out conf/distros for the YAML files that describe pkgs/cmds/pips for various distributions which are required by the different OpenStack components to run correctly. The versions and pip names listed for each distribution should be the correct version that is known to work with a given OpenStack release.


Check out conf/templates/ for various component specific settings and files. All of these files are templates with sections or text that needs to be filled in by the stack script to become a complete file.

These files may have strings of the format %NAME% where NAME will most often be adjusted to a real value by the stack script.

An example where this is useful is say for the following line:

admin_token = %SERVICE_TOKEN%

Since the script will either prompt for this value (or generate it for you) we can not have this statically set in a configuration file.