Initial commit
diff --git a/BuildBot.md b/BuildBot.md
new file mode 100644
index 0000000..ed991b5
--- /dev/null
+++ b/BuildBot.md
@@ -0,0 +1,141 @@
+[TOC]
+
+# BuildBot
+
+We run a continuous build of the Ganeti unittests and vcluster qa using [buildbot](http://trac.buildbot.net/). The official [Ganeti buildbot](http://buildbot.ganeti.org) is running on [~okeanos](http://okeanos.grnet.gr), powered by [Synnefo](http://www.synnefo.org/) and Ganeti! We kindly thank grnet for their support.
+
+Link to the web interface: http://buildbot.ganeti.org/ganeti/tgrid?length=25
+
+# Overview
+
+As usual in buildbot, there are two parts:
+
+ * the master machine, publicly accessible over HTTP
+ * the slaves, which only need to talk to the master
+
+Setup of the master machine is straightforward (it only needs to run
+buildbot), with the note that the global buildbot configuration is
+non-trivial.
+
+The setup of the slaves, however, is more complex. Each slave needs to
+be able to build Ganeti, with all the required dependencies, which are
+“non-trivial” so to say.
+
+Currently we have the following slaves defined:
+
+ * debian wheezy 64bit
+ * debian jessie 64bit
+ * ubuntu 13.04 64bit
+ * fedora 21 64bit
+
+Feel free to prepare a new slave and ask us to add it to buildbot! The
+only requirement is to be able to build Ganeti with all or most of its
+dependencies (we can make exceptions if needed).
+
+# Virtual cluster (VCluster) QA
+
+In addition to just build Ganeti and run unit tests, there is also a QA
+build on a virtual cluster defined on buildbot. The rough overview of the process is:
+
+ * A buildslave builds Ganeti (the Fedora slave is used currently)
+ * It uploads Ganeti to the QA machine
+ * A large number of Ganeti commands are executed by the buildslave via `ssh` on the QA machine
+ * A cluster is initialized
+ * Virtual nodes (additional node daemons running on the QA machine) are added
+ * Diskless instances for the fake hypervisor are created (but not actually run)
+
+There are a number of requirements for this setup to work:
+ * All runtime dependencies of Ganeti have to be installed on the QA machine
+ * The buildslave has to have SSH access to the QA machine
+ * In particular, the `buildbot` user on the buildslave has to be able to connect as `root` without password to the QA machine
+ * SELinux interferes badly with the SSH based tests. That's why it's disabled on the buildslave and the QA machine
+
+Currently we have the following QA machines defined:
+
+ * fedora 64bit (the driving buildslave is also running fedora 64bit)
+
+See also the [detailed description on how to setup a vcluster](Vcluster.md).
+
+# KVM cluster QA
+
+Apart from the virtual cluster, we also have a QA on a real cluster. The cluster
+is formed of 3 debian wheezy VMs. These machines use kvm as hypervisor and a private
+network on `eth1` as replication network. The master IP and the instance IPs also
+all live the 192.168.0/24 on `eth1`.
+
+The QA is run from the wheezy buildslave (snf-14476.vm.okeanos.grnet.gr).
+
+# Buildbot machines
+
+ * master: buildbot.ganeti.org or snf-13819.vm.okeanos.grnet.gr
+ * wheezy: snf-14476.vm.okeanos.grnet.gr
+ * jessie: snf-472938.vm.okeanos.grnet.gr
+ * ubuntu 13.04: snf-68991.vm.okeanos.grnet.gr
+ * fedora 21: snf-69083.vm.okeanos.grnet.gr
+ * QA-VCluster, fedora 21: snf-69749.vm.okeanos.grnet.gr
+ * QA KVM-Cluster, debian wheezy: snf-192771.vm.okeanos.grnet.gr, snf-192805.vm.okeanos.grnet.gr, snf-192809.vm.okeanos.grnet.gr
+
+# Buildmaster users
+
+The users (which can cancel builds, force builds, etc.) are managed by
+hand (as we shouldn't need any user beside a generic one), in
+`/srv/buildbot/masters/ganeti/htpasswd`. Note that htpasswd (from
+apache2-utils) needs to be run with `-d`, as buildbot 0.8.6p1 doesn't
+yet support md5/sha digests.
+
+# Slave setup
+
+While the slaves are setup by slack, not everything was automated.
+
+Initial setup means just installing slack, and pointing
+`/etc/slack.conf` to localhost (assuming you ssh into the machines
+with an rsync server running on your machine and exported to the slave on the correct port through the -R parameter of ssh):
+
+```
+…
+SOURCE=rsync://localhost/slack
+…
+```
+
+Then afterwards running slack should be enough.
+
+Note that for tests involving exclusive storage (`exclusive-storage-instance-tests` and `cluster-exclusive-storage` options in the QA configuration) you need to have more than one LVM physical volume in the default volume group.
+
+## Debian test build slaves
+
+On grnet, the base images come with NetManager and a number of other
+daemons that are useful for desktop use; as the VMs don't have lots of
+memory, I've disabled them and switched back to plain
+`/etc/network/interfaces`.
+
+On wheezy, pyinotify throws epydoc into a fit, so the solution (urgh!)
+is to hand-modify `/usr/share/pyshared/pyinotify.py` and remove the
+`class _PyinotifyLogger(logging.getLoggerClass())` definition (this
+was removed as well in an upstream commit,
+`98c5f41a6e2e90827a63ff1b878596f4080481cc`).
+
+## Starting/stopping
+
+The buildmaster setup is automatically started, as the buildbot is
+installed from Debian packages. Manually starting/stopping/reconfiguring is possible via:
+
+```
+cd /srv/buildbot/masters/ganeti
+buildbot stop|start|checkconfig|reconfig
+tail -f twistd.log
+```
+
+The wheezy slave is started/stopped as well (for the same reason,
+automatically from packages), but the squeeze slave is only started at
+boot time from `/etc/rc.local`. All slaves are located under
+`/srv/buildbot/slaves`, so starting/stopping them is a matter of:
+
+```
+cd /srv/buildbot/slaves/unittests-wheezy64
+buildslave stop|start
+```
+
+# Source code
+
+The source code is stored in Git under git.ganeti.org, in the
+[buildbot repository](http://git.ganeti.org/buildbot.git/).
\ No newline at end of file
diff --git a/CommonIssues.md b/CommonIssues.md
new file mode 100644
index 0000000..4d07ed1
--- /dev/null
+++ b/CommonIssues.md
@@ -0,0 +1,347 @@
+[TOC]
+
+# Common Issues
+This document provides troubleshooting tips for issues commonly encountered by Ganeti users.
+
+# Networking problems
+
+## Instances aren't reachable
+
+If the instances you create are unreachable, you may have one of two main problems:
+
+* Networking hasn’t been configured on the OS of the instance. Depending on which hypervisor you’re using, use `gnt-instance console` or connect to the VNC console to access to the instance and configure its networking.
+* The network configuration on the host or on Ganeti is not correct. Check all of the instance’s network interface settings to make sure they’re correct. If applicable, check to see if the host’s IP forwarding and iptables rules are correctly set.
+
+## `gnt-cluster init` fails complaining with the error message "Cluster IP already active"
+
+Each Ganeti cluster of _n_ nodes needs at least _n+1_ IP addresses: one IP address for each node, plus an extra IP address that represents the cluster itself and that is “floating” across the nodes. Specifically, the cluster address is active on a network interface of the master node, and it is migrated to the new master when the master node is failed over.
+
+`gnt-cluster init` tries to take ownership of this IP address and assign it to the master of the cluster being initialized. Before taking ownership of the address, this command checks whether the address is already active (as it should _not_ be active). If the IP address is already active on a machine, the error message “Cluster IP already active” is triggered.
+
+To resolve this error:
+
+1. Make sure that the IP is actually the IP that needs to become the cluster IP, as opposed to the IP of the main network interface of one node.
+2. If the IP address is in fact the correct IP, find the machine on which that IP (`$MASTER_IP`) is active, and the interface (`$MASTER_NETDEV`) to which the IP is assigned.
+3. On said machine, execute the following command as root:
+
+ ```sh
+ ip addr del "$MASTER_IP" dev "$MASTER_NETDEV"
+ ```
+4. Run `gnt-cluster` init on the master to initialize the cluster.
+
+## DHCP: Best Practices
+
+ * Currently, Ganeti does not ship a DHCP server. Therefore, a custom DHCP server must be employed.
+ * To start/configure a DHCP server, there are several hooks which can be used to customize network interfaces through scripts.
+ * Instance MAC addresses and IP addresses should be unique within a single host. Otherwise, NAT through iptables can be used to translate instance IP addresses to unique IP addresses within the host.
+ * The [Ganeti OS installation redesign](http://docs.ganeti.org/ganeti/master/html/design-os.html) design doc employs a DHCP server to assign IP addresses to instances. This doc is a good starting point for learning more about using DHCP with Ganeti.
+
+# Instance console issues
+
+**To exit the console at any time:** Type `CTRL+]`. This method works on both Xen and KVM.
+
+**If nothing is displayed on the console:** Try pressing `Enter`.
+
+**If the console doesn’t work:**
+
+ * Double-check that the master can log in to the node as root, without a password.
+ * Check that your instance configuration has a “getty” on the right port. For example:
+ * On KVM, you need a getty on ttyS0
+ * On Xen pvm, you need a getty on hvc0
+ * How you configure this option depends on your distribution. See examples for Debian and Ubuntu on Ganeti's [instance-debootstrap os](http://git.ganeti.org/?p=instance-debootstrap.git;a=blob;f=create;h=c276b042daa190899cbfecff26fa8dfb4ad93034;hb=HEAD).
+ * If you added the correct line to `inittab`, `/etc/init`, or `/etc/event.d`, remember to restart init (you can use `killall -HUP init`) or reboot the instance to verify that your setup works.
+ * If you have absolutely no instance access, try stopping the instance using `gnt-instance activate disks`, and then mounting the disks to add the relevant configuration.
+
+# Instance disk access
+
+Because all instances are different, some of these steps might be redundant for your instance. If the instance is running LVM or some other peculiar config, you may need to take additional steps. The following commands work for a standard instance with a partition inside a block device:
+
+ 1. Stop the instance.
+ 1. Run `gnt-instance activate-disks <instance-name>` and note the path of the device (the path after the last “:”).
+ 1. If the device is a file, run `losetup -f <file>` , and then use `losetup -a` to find the correct device.
+ 1. Run `kpartx -a <device>` (this is either the activate-disks device or the losetup device).
+ 1. Run `mount` on `/dev/mapper/<device>p<int>`, substituting the appropriate variables for the device name and the partition number you want to access.
+ 1. Perform the previous steps in reverse order:
+ 1. `umount`
+ 1. `kpartx -d <device>`
+ 1. `losetup -d /dev/loop<int>` (If you used `losetup` before)
+ 1. `gnt-instance deactivate-disks` (Optional; use if you plan to start the instance immediately)
+
+
+# Instance migration/move problems
+
+## The instance move is taking too long.
+All traffic in inter- and intra-cluster moves is transferred using socat and encrypted by default. In intra-cluster moves, the encryption tends to be the limiting factor for the speed of moves. Allowing more options for encryption, including no encryption at all, is a planned feature for 2.12.
+
+If security is of no concern, one useful trick is to convert the instance to use a disk template with redundancy (e.g. DRBD). Failing the instance over and changing disk templates again can significantly outperform a standard instance move.
+
+For moves in which the speed of the network connection is the problem, try using the `--compress` option provided by all operations performing instance moves in 2.10. This option can help reduce the amount of data sent over the network by compressing the instance image.
+
+## A cross-cluster instance move is preventing other actions.
+Unfortunately, this is a known issue that will be addressed in Ganeti 2.12 by using opportunistic locking in instance moves.
+
+## I receive a certificate error when trying to start an instance move.
+The move-instance tool uses RAPI, which requires the _rapi.pem_ certificate file to be passed to it as an argument. If the instance is being moved between clusters, both of the clusters’ RAPI certificate files must be provided.
+
+## I have some other mysterious issue with instance moves/migration.
+We recommend first checking the import/export scripts of the used OS image. Ganeti uses these scripts to perform moves and migrations, and the scripts often go untested prior to events such as moves and migrations.
+
+# Upgrades: Best practices
+
+## Ganeti versions:
+ * If the version of Ganeti you’re upgrading is version 2.10 or higher, you can simply use `gnt-cluster upgrade --to=2.xx` on the master node.
+ * For older versions, follow Ganeti’s Upgrade notes.
+
+*** note
+**Note:** Instances can remain alive during an upgrade.
+***
+
+## Node OS
+ * If your cluster has at least 3 nodes using DRBD, the safest way to upgrade is node by node, upgrading the master node last:
+ 1. Remove a node from the cluster:
+
+ ```sh
+ gnt-node modify -D yes "$NODE"
+ hbal -L -X
+ gnt-node modify -O yes "$NODE"
+ ```
+ 2. Upgrade the node OS.
+ 3. Re-add the node to the cluster:
+
+ ```sh
+ gnt-node add --readd "$NODE"
+ ```
+ * If you have sufficient resources, you can also set up a new cluster with the new OS system, and then use the inter-cluster instance move to transfer the instances.
+
+## DRBD versions
+While we don’t recommend using different DRBD versions within a single node group for an extended period of time, Ganeti still works reliably with an non-homogenous DRBD setup during the upgrade process. The safest way to upgrade DRBD versions is node by node, upgrading the master node last:
+
+1. Remove a node from the cluster:
+
+ ```sh
+ gnt-node modify -D yes "$NODE"
+ hbal -L -X
+ gnt-node modify -O yes "$NODE"
+ ```
+2. Upgrade the node OS.
+3. Re-add the node to the cluster:
+
+ ```
+ gnt-node add --readd "$NODE"
+ ```
+
+# Snapshots and backups
+
+## Does Ganeti support LVM snapshots?/How do I make a LVM snapshot in Ganeti?
+There is some confusion regarding the use of LVM snapshots in Ganeti. Ganeti does not support LVM snapshots, in the sense that it doesn’t support creation of minimal-size snapshots that persist, grow as needed, and that can be used to restore a state. Lack of support for these types of LVM snapshopts is due to the slowdown users experience after significant changes are made and the LVM snapshots grow too large.
+
+Ganeti _does_ use LVM snapshots to create a stable view of a volume currently in use which needs to be backed up, but the snapshot is deleted once a backup is made.
+
+## How do I make a backup of an instance?
+The `gnt-backup export` command can be used to export an instance to any node in the cluster. The backup contains the data and the configuration of the instance, and can be found in the `/srv/ganeti/export/$instance` directory.
+
+## I’m experiencing a mysterious issue with gnt-backup.
+Much like in the case of instance moves, export and import scripts are often to blame for strange behavior, especially if said scripts are untested beforehand. We recommend first checking the import/export scripts of the used OS image.
+
+# RBD/Ceph: Best practices for installation and setup
+
+Ganeti doesn’t require any kind of special Ceph configuration. To deploy and configure RBD/Ceph:
+
+1. Follow the deployment and configuration instructions on the [Ceph website](http://ceph.com/docs/master/start/). Ganeti doesn’t use the Ceph Filesystem or MDSes, so you can skip these sections of Ceph’s instructions.
+2. Once Ceph is up and running and you configure a RADOS block device storage pool for Ganeti (by default named `rbd`), tell Ganeti to use RBD:
+
+ ```sh
+ gnt-cluster modify --enabled-disk-templates rbd \
+ --ipolicy-disk-templates rbd
+ ```
+3. Now that RBD is enabled, specify the pool Ganeti should use. The default value is `rbd`, so on a fresh cluster, this step is a no-op.
+
+ ```sh
+ gnt-cluster modify -D rbd:pool=rbd
+ ```
+4. Configure Ceph on all Ganeti notes by following the [Installing RBD](http://docs.ganeti.org/ganeti/master/html/install.html#installing-rbd) instructions of the Ganeti installation tutorial. For example:
+
+ ```sh
+ # This wil run the same command on all nodes in your cluster.
+ # NOTE: On Ganeti nodes, /etc/ceph/ceph.conf must at least enumerate the
+ # IP addresses and ports of all Ceph monitors.
+ dsh -Mf /var/lib/ganeti/ssconf_node_list \
+ "apt-get update;
+ apt-get install ceph-common;
+ scp $HOSTNAME:/etc/ceph/ceph.conf /etc/ceph/"
+ ```
+5. Verify that all nodes can access Ceph. If this command completes on all nodes, you're good to go.
+
+ ```sh
+ dsh -Mf /var/lib/ganeti/ssconf_node_list rbd list
+ ```
+6. If all has gone well up to this point, you can start your first RBD instance. For example:
+
+ ```sh
+ gnt-instance add -t rbd -s 80G helloworld.example.org
+ ```
+7. If you’re using Ganeti 2.10 or newer and KVM, you can exploit its native support for Ceph and get a free performance boost by enabling userspace support:
+
+ ```sh
+ gnt-cluster modify -D rbd:access=userspace
+ ```
+
+**Note:** Gluster configuration is very similar. To configure Gluster:
+
+1. Deploy Gluster.
+2. Install client-side support for Gluster on all nodes.
+3. Enable the Gluster disk template.
+4. Configure the remote host and volume Ganeti should use.
+
+# Instance installation problems
+
+## OS installation problems
+See the [Ganeti OS installation redesign](http://docs.ganeti.org/ganeti/master/html/design-os.html) document for troubleshooting information.
+
+## How do I set a root password/key? How do I set a root password/key with hooks?
+
+Setting a root password or key for the OS you're installing is highly dependent on the OS scripts you use. Here’s an example related to the instance-debootstrap OS install scripts:
+
+By default, `instance-debootstrap` resets the root password so that newly-created instances have an empty password. Therefore, you don't need any special steps to provide access to the instance.
+
+If you need a password immediately for the instance as it’s being created, you have to use a hook. The complete instructions are in the [README file of the instance-debootstrap package](http://git.ganeti.org/?p=instance-debootstrap.git;a=blob_plain;f=README;hb=HEAD). The process can be summarized as follows:
+
+1. Copy the file `examples/hooks/defaultpasswords` to `$sysconfdir/ganeti/instance-debootstrap/hooks/`.
+2. Copy the data file `examples/hooks/confdata/defaultpasswords` to `$sysconfdir/ganeti/instance-debootstrap/hooks/confdata/`.
+3. Modify the data file accordingly to your needs. The file syntax is such that each line represents a user, with the format `username:password`.
+4. After copying the two files, run the instance creation as usual to automatically execute the files.
+
+## Selecting a kernel for the instances
+
+The kernel is specified in the hypervisor parameters and can be modified. For example:
+
+```sh
+gnt-cluster modify -H
+kvm:kernel_path=/boot/vmlinuz-2.6-kvmU,initrd_path=/boot/initrd-2.6-kvmU
+```
+
+
+# Failure scenarios and recovering from failure scenarios
+
+## Master failures/After a failure, two nodes think they are master
+When the master node fails to connect to the rest of the network because of a network failure, you simply need to fix the network. Once the network is fixed, the master recovers automatically.
+
+In the case of a more serious failure, a master failover is needed. A master failover must be triggered manually. To perform a master failover:
+
+1. Make sure that the original failed master won't start again while a new master is present, preferably by physically shutting down the node.
+2. To upgrade one of the master candidates to the master, issue the following command on the machine you intend to be the new master:
+
+ ```sh
+ gnt-cluster master-failover
+ ```
+3. Offline the old master so the new master doesn't try to communicate with it. Issue the following command:
+
+ ```sh
+ gnt-node modify --offline yes oldmaster
+ ```
+4. If there were any DRBD instances on the old master node, they can be failed over by issuing the following commands:
+
+ ```sh
+ gnt-node evacuate -s oldmaster
+ gnt-node evacuate -p oldmaster
+ ```
+5. Any _plain_ instances on the old master need to be recreated again.
+
+## Re-adding nodes
+When a failed node (either a regular or master node) is repaired and ready to be added to the cluster, reinstall Ganeti on the node and then re-add it to the cluster using the following command:
+
+```sh
+gnt-node add --readd nodename
+```
+
+After re-adding a node, it's a good idea to run `hbal --luxi --print-commands` on the master node to obtain the list of commands to balance the cluster and populate the new node with instances. Running `hbal --luxi --exec` executes the commands directly.
+
+## Particular case: 2 node cluster
+If the master node fails on a 2 node cluster, upgrading the non-master node to become the new master requires special handling. This is because a master needs to obtain a majority of votes from the rest of the network to ensure there is no other master running. In the case of a cluster with only two nodes, neither node can obtain the majority.
+
+To fail over the master node on a 2 node cluster:
+
+1. Issue the following command on the new master:
+
+ ```sh
+ gnt-cluster master-failover --no-voting
+ ```
+2. Manually start the master daemon with the following command:
+
+ ```sh
+ ganeti-masterd --no-voting
+ ```
+3. Run the following command to ensure that the cluster is consistent again:
+
+ ```sh
+ gnt-cluster redist-conf
+ ```
+
+## Ganeti’s autorepair (in)capabilities
+Ganeti’s _ganeti-watcher_ daemon makes sure that all instances marked as up are running. It also reactivates secondary DRBD block devices of instances on nodes that are rebooted. In sum, it tries to ensure that if a node is rebooted, all affected instances are eventually fixed and brought to their original state.
+
+Ganeti doesn’t perform failovers automatically; they must be triggered manually. However, there are tools that help the administrator perform common related tasks:
+ * `gnt-node evacuate`: Moves instances from a given node
+ * `hbal`: Automates the task of distributing instances evenly on the nodes. Displays a list of recommended commands or performs them automatically.
+
+# DRBD/storage problems
+
+## Degraded/unsynced disks
+DRBD disks can experience various error states, some of which Ganeti can recover from (semi-) automatically.
+ * If the connection between the primary and secondary DRBD node is lost, Ganeti automatically reconnects the DRBD pair with the (regularly executed) Ganeti watcher. If you want to manually reconnect the DRBD pair, you can issue the command `gnt-instance activate-disks` for the instance (even while the instance is running). DRBD automatically syncs the changed portions of the disks from the primary node to the secondary node.
+ * If disks (either primary or secondary) fail and have to be replaced, you can use `gnt-instance replace-disks` to recreate and resync those disks and return them to a fully functional and replicated state.
+
+## Performance problems
+There is no single source of DRBD performance problems, and thus, no single solution. There are a few good starting points for diagnosing such problems:
+ * Make sure that you have a dedicated replication network configured by specifying the proper secondary IPs for all nodes in the cluster.
+ * Verify the DRBD-related disk parameter documented in the [gnt-cluster man page](http://docs.ganeti.org/ganeti/current/html/man-gnt-cluster.html) (especially `resync-rate`, `protocol`, and the `dynamic-resync`-related parameters).
+ * Refer to the [Optimizing DRBD performance](http://www.drbd.org/users-guide/p-performance.html) guide.
+
+## Maximum size of disks
+The maximum size of DRBD devices which can be created through Ganeti is 4TB (see [Issue 256: DRBD Volume above 4TB not working](https://code.google.com/p/ganeti/issues/detail?id=256)).
+
+To create larger DRBD devices, you must set up the devices manually and use them via the blockdev disk template. However, you will lose all automatic DRBD management performed by Ganeti, as well as the possibility to failover/migrate instances to their secondary node.
+
+## Converting disk templates
+Ganeti can convert between DRBD and plain LVM volumes. To accomplish this conversion, use `gnt-instance modify` and provide the desired new disk template with the `--disk-template` command line parameter. Refer to the [gnt-instance man page](http://docs.ganeti.org/ganeti/current/html/man-gnt-instance.html) for further details. Ganeti does not support any other disk template conversion.
+
+## drbd8-utils and Ubuntu
+Upgrades to the drbd8-utils package in Ubuntu have resulted in some DRBD 8.4 syntax requirements spilling into DRBD 8.3 tools as well. Ganeti's attempts to execute previously valid commands fail unless the compatibility executable is used instead of the one linked by default. A temporary way to resolve this:
+
+```sh
+mv /sbin/drbdsetup /sbin/drbdsetup84
+ln -s /lib/drbd/drbdsetup-83 /sbin/drbdsetup
+```
+
+For more details, look at the forum topic:
+https://groups.google.com/forum/#!msg/ganeti/MkCNmzF6hu8/kTPOELyEkdsJ
+
+# Cleanup issues
+
+## gnt-node add fails when an old cluster wasn't cleaned up properly
+
+The message `Unhandled Ganeti error: Given cluster certificate does not match local key` can indicate that an old `/var/lib/ganeti/server.pem` certificate (on the node to be added) still exists. If you ran a cluster cleanup script to wipe your cluster, make sure to run it on all nodes that shall be added to the new cluster.
+
+# htools: Debugging hail/hbal
+
+Tips and tricks for debugging hail and hbal:
+
+ * Before debugging hail, verify that the dom0 resources (in particular, memory) are set to reasonable values. If hail can’t allocate new instances, it’s very likely that dom0 is using an unreasonably large amount of a node’s memory.
+ * hail speaks the iallocator protocol (for more information, see [Ganeti automatic instance allocation](http://docs.ganeti.org/ganeti/current/html/iallocator.html)), so debugging hail is possible independent of any cluster.
+ * hail supports the text format via the `-t` option, which provides the cluster configuration in text format. You can generate a text format description of the current live state of the cluster by running `hbal -L -S config`, which creates a file named _config.original_.
+ * hbal also supports the `-t` option and therefore can be debugged in a way similar to hail.
+ * To verify what data is passed to hail by `gnt-instance add`, use the `-I` option to specify your own instance allocator. This option can also be a script that saves the input and returns a constant output.
+ * To determine the largest instance size that still fits onto the cluster according to htool’s understanding, use tiered allocation, as provided by `hspace -L`.
+
+# Using gnt-`*` commands
+
+Tips for gnt-`*` commands:
+
+ * Commas inside parameters have to be escaped with a backslash, because Ganeti uses commas as separators.
+
+# Other helpful documentation
+
+Here you find some documentation that Ganeti users provided:
+
+ * [A Ganeti cheat sheet](https://nsrc.org/workshops/2014/sanog23-virtualization/raw-attachment/wiki/Agenda/ganeti.pdf)
+ * https://nsrc.org/workshops/2014/sanog23-virtualization/raw-attachment/wiki/Agenda/ganeti-settings.pdf
\ No newline at end of file
diff --git a/DeveloperGuidelines.md b/DeveloperGuidelines.md
new file mode 100644
index 0000000..c63a5d7
--- /dev/null
+++ b/DeveloperGuidelines.md
@@ -0,0 +1,221 @@
+[TOC]
+
+# Developer guidelines for contributing to Ganeti
+
+This page details the rules that need to be followed when contributing code or
+documentation to the Ganeti project.
+
+# Contributor License Agreement (CLA)
+
+The first requirement is that either your and/or your employer sign the
+[individual](http://code.google.com/legal/individual-cla-v1.0.html) or
+[corporate](http://code.google.com/legal/corporate-cla-v1.0.html) Contributor
+License Agreement. Which one is needed depends on your particular case.
+
+# Code
+
+Since migrating the source code repository to [Git](http://git-scm.com/) (see
+SourceCode for details), only a limited number of people have commit access.
+Please send your patches to the [ganeti-devel@googlegroups.com](http://groups.google.com/group/ganeti-devel) mailing list to get it reviewed and committed.
+
+## Git repository and Github mirror
+
+You can find all Ganeti related repositories at http://git.ganeti.org.
+
+There is also a [Ganeti mirror on Github](https://github.com/ganeti/ganeti), which you can fork and send pull requests to as an alternative to the `git format-patch / git send-email` workflow detailed below. Pull requests are automatically forwarded to the [ganeti-devel@googlegroups.com](http://groups.google.com/group/ganeti-devel) mailing list, where the patch can then be discussed.
+
+You can find a tutorial on creating pull requests [here](https://help.github.com/articles/using-pull-requests/#before-you-begin).
+
+## Source tree organization
+
+Development of new features for the next major or minor version goes on in the
+`master` branch. Bug fixes and small changes in earlier versions are done on the `stable-x.y` branch, and gradually merged all the way into master.
+
+Please read the README or INSTALL files on how to build from source code.
+ReleaseProcess describes how to build new releases.
+
+Also, [please follow our code style guides](http://docs.ganeti.org/ganeti/master/html/dev-codestyle.html).
+
+## Preparing patches for submission
+
+### Checking patches
+
+If you have more than a trivial fix it's better to make sure that the static checks are fine before sending the patches. This can be done by running the command:
+
+```
+make commit-check
+```
+
+For this, you need to have `pylint` and `hlint` installed.
+The output of these tools can change significantly from one version to the other, and some errors might happen to be signalled only by some versions, so we had to standardize on a specific version as the official one Ganeti has to be validated against. You can find the version number (for Ganeti's current master branch) at: http://docs.ganeti.org/ganeti/master/html/devnotes.html
+
+### Commit messages
+
+Commit messages should be informative and well-worded. Example:
+
+```
+Short summary line (60 characters long at most, no period at end)
+
+Detailed explanation if necessary, wrapped at ~72 chars/line. Can also be in multiple paragraphs.
+If the commit modified more than four lines of code, the explanation is required and must contain at least 20 characters.
+ * Use itemized list if several things were done in the same patch
+ * But consider doing them in different patches
+```
+
+### Formatting and sending patches
+
+The patch to send should be a proper patch created by Git and signed by you. The patch can be created with the following command:
+
+```
+git format-patch -s --subject-prefix=... ...
+```
+
+The `-s` options adds the required ''Signed-off-by'' tag to the end of the patch.
+
+Each patch should have a subject prefix indicating the branch it's directed to (for ganeti-core) or the separate repository it's for. For example patches for ganeti-core branch-2.6 should be generated by passing the option `--subject-prefix="PATCH branch-2.6"` to `git format-patch`.
+
+Officially recognized prefix tags are:
+
+ * **PATCH stable-2.x** for patches directed at ganeti stable-2.x
+ * **PATCH master** for patches directed at the development tree
+ * **PATCH instance-debootstrap** for patches directed at the ganeti-instance-deboostrap repository
+
+When sending a patch series, it is customary to include cover letter (`--cover-letter` option).
+
+Also note that you can change `PATCH` to `RFC` if you want to send a
+patch/series just for discussion, rather than to propose its inclusion right
+away (it's basically an invite for more feedback).
+
+
+## More details on git workflow
+
+This section offers a few more details on the git workflow we recommend.
+
+When you begin your work with completely fresh repository, first do the following:
+
+```sh
+# Clone the repository.
+
+git clone git://git.ganeti.org/ganeti.git && cd ganeti
+./autogen.sh
+./configure --localstatedir=/var --sysconfdir=/etc
+# Confirm that all the components that you need are present.
+```
+
+
+The following represents a generic work cycle, from check-out to sending a patch.
+
+```sh
+# View branches; checkout the desired branch.
+
+git branch -a
+git checkout -b new_branch_name origin/master #or stable-X.Y etc
+
+# Coding, coding, coding -- one patch at a time!
+# Review your handiwork.
+git diff
+
+# If you make non-trivial changes you should run a commit-check
+make commit-check
+
+# For trivial changes you can use a check specific to your change, e.g. for haskell code run `make hs-check`
+
+# Describe and commit your handiwork to your local branch.
+git status
+git commit -a
+
+# Other possibility: git add <filename> && git commit
+# Note: git add <filename> -p lets you add parts of the file
+
+gitk --all # Handy GUI for reviewing changes in context.
+
+# You may further edit and then amend a previously committed change
+git add <forgotten-file>
+git commit --amend
+
+# You may also go back and change older patches in patch series
+git rebase -i HEAD~<number of commits>
+
+# Before sending a patch, make sure your local repo is up to date
+git pull
+
+# Creating a nice mailable patch for the list
+git format-patch --cover-letter -s --subject-prefix="PATCH branch-x.y" origin/branch-x.y
+# Describe the patch series in the cover letter before sending your patches
+
+# Make sure your `.git/config` has working email settings.
+git send-email 0001-<commit message>.patch # use --dry-run to see what would be emailed
+# For patch series you need to send each file
+
+# Read comments, if fixes are required
+git pull
+# Write the fix
+git diff # Paste the diff to the appropriate thread
+# Or commit your change and submit it to mailing list with `--in-reply-to=<id>`
+git commit -m "Fix for commit: <..>"
+
+# After getting all LGTMs you need to squash your fixes to original commits
+git rebase -i <...>
+```
+
+## Constants
+
+If you are contributing code that depends on (global) constants or
+that depends on values which other people might find interesting to
+configure easily then it is important to make these constants
+available globally. Since Ganeti 2.10, the proper way of adding
+constants to Ganeti is to add them in Haskell, even if these constants
+will only be used in Python.
+
+The reason for this is that, at compile time, Ganeti will typecheck
+the constants and it will convert them to Python, just like, before
+Ganeti 2.10, Python constants were converted to Haskell. You can find
+the Haskell to Python generated constants in `lib/_constants.py`._
+
+Then, if the constants you have added are used in Python, and not just
+in Haskell, you should an entry in 'lib/constants.py' to re-export the
+desired constants to the Python codebase. You can follow the other
+entries in 'lib/constants.py' as a guideline.
+
+
+# Useful git repository config snippet
+
+This snippet might be useful when working with the Ganeti git repo and
+shall be added to `.git/config` of the cloned repository.
+
+```
+[branch]
+ autosetuprebase = always
+[sendemail]
+ chainreplyto = false
+ to = ganeti-devel@googlegroups.com
+ thread = false
+ confirm = compose
+ suppressfrom = true
+[format]
+ signoff = true
+ thread = shallow
+```
+
+For further details what each of this options does have a look at `git help
+config`.
+
+# Testing / Debugging Ganeti
+
+To run a single python test, run it as:
+
+```sh
+PYTHONPATH=`pwd` python test/py/ganeti.utils.process_unittest.py TestRunCmd.testTimeoutOutputAfterTerm
+```
+
+To get logging output, set the `LOGTOSTDERR` environment variable. For example:
+
+```sh
+LOGTOSTDERR=1 PYTHONPATH=`pwd` python test/py/ganeti.utils.process_unittest.py TestRunCmd.testTimeoutOutputAfterTerm
+```
+
+
+# Wiki updates
+
+The wiki can be updated by members directly. Non-members need to send their
+requested changes to the mailing list.
\ No newline at end of file
diff --git a/DistroStatus.md b/DistroStatus.md
new file mode 100644
index 0000000..104f5c5
--- /dev/null
+++ b/DistroStatus.md
@@ -0,0 +1,23 @@
+# Ganeti integration in Linux distributions
+
+The following table details the current status of Ganeti in Linux distributions as known to the Ganeti team.
+
+
+| **Distribution** | **Ganeti version** as of 2016-03-15 | **Comment** |
+|:----------------------------|:---------------------------------------------------------------------|:------------|
+| Debian Squeeze (backports) | [2.5.2](http://packages.debian.org/squeeze-backports/ganeti2) | |
+| Debian Wheezy (oldstable) | [2.5.2](http://packages.debian.org/wheezy/ganeti2) | |
+| Debian Wheezy (backports) | [2.11.6](http://packages.debian.org/wheezy-backports/ganeti) | |
+| Debian Jessie (stable) | [2.12.4](http://packages.debian.org/jessie/ganeti) | |
+| Debian Jessie (backports) | [2.15.2](http://packages.debian.org/jessie-backports/ganeti) | |
+| Debian Stretch (testing) | [2.15.2](http://packages.debian.org/stretch/ganeti) | |
+| Debian Sid (unstable) | [2.15.2](http://packages.debian.org/sid/ganeti) | |
+| Ubuntu Lucid (10.04) | [2.0.5](http://packages.ubuntu.com/lucid/ganeti2) (universe) | |
+| Ubuntu Oneiric (11.10) | [2.4.2](http://packages.ubuntu.com/oneiric/ganeti2) (universe) | |
+| Ubuntu Precise (12.04) | [2.4.5](http://packages.ubuntu.com/precise/ganeti2) (universe) | |
+| Ubuntu Precise (Debian PPA) | [2.12.6](https://launchpad.net/~pkg-ganeti-devel/+archive/lts) | Maintained by the Ganeti Debian maintainers (pkg-ganeti-devel@lists.alioth.debian.org) |
+| Ubuntu Quantal (12.10) | [2.5.2](http://packages.ubuntu.com/quantal/ganeti2) (universe) | |
+| Ubuntu Raring (13.04) | [2.5.2](http://packages.ubuntu.com/raring/ganeti2) (universe) | |
+| Ubuntu Trusty (14.04) | [2.9.3](http://packages.ubuntu.com/trusty/ganeti) (universe) | see UbuntuTrustyDependencies for a list of working dependencies for Trusty Tahr |
+| Ubuntu Trusty (Debian PPA) | [2.12.6](https://launchpad.net/~pkg-ganeti-devel/+archive/lts) | Maintained by the Ganeti Debian maintainers (pkg-ganeti-devel@lists.alioth.debian.org) |
+| Gentoo | [1.x & 2.x](http://packages.gentoo.org/package/app-emulation/ganeti) | Maintained by <ramereth@gentoo.org>, for a simple howto see http://wiki.osuosl.org/public/ganeti/cluster_gentoo |
\ No newline at end of file
diff --git a/DocumentationByCategory.md b/DocumentationByCategory.md
new file mode 100644
index 0000000..1010ad5
--- /dev/null
+++ b/DocumentationByCategory.md
@@ -0,0 +1,38 @@
+#Documentation by Category
+
+Below is a categorized list of Ganeti documentation.
+
+# Development process
+ * [BuildBot](BuildBot.md): Setup of the public buildbot infrastructure.
+ * [DeveloperGuidelines](DeveloperGuidelines.md): Developer guidelines for contributing to Ganeti.
+ * [QA](QA.md): Understanding Ganeti QA.
+ * [ReleaseProcess](ReleaseProcess.md): How to perform a new Ganeti release.
+
+
+# Extensions
+ * [DrbdDeviceMonitoring](DrbdDeviceMonitoring.md): Monitoring DRBD devices with Nagios.
+ * [GanetiInVagrant](GanetiInVagrant.md): Testing or trying out a Ganeti environment inside of Vagrant.
+ * [GanetiInVirtualBox](GanetiInVirtualBox.md): Creating a Ganeti environment in VirtualBox.
+ * [PerformanceTuning](PerformanceTuning.md): Some tips about improve performance on your cluster.
+ * [PhysicalToVirtual](PhysicalToVirtual.md): Physical to virtual transfers using `ganeti-p2v-transfer`.
+ * [SystemTemplateWithFAI](SystemTemplateWithFAI.md): How to build a system template that uses FAI for setup of instances.
+
+
+# Plugins
+ * [ExtStorageProviders](ExtStorageProviders.md): A list of Ganeti ExtStorage Providers.
+ * [OSDefinitions](OSDefinitions.md): A list of Ganeti OS Definitions.
+
+
+# Misc
+ * [CommonIssues](CommonIssues.md): A troubleshooting guide for issues commonly encountered by Ganeti users.
+ * [DistroStatus](DistroStatus.md): Ganeti integration in Linux distributions.
+ * [GanetiFAQ](GanetiFAQ.md): Answers to the most frequently asked questions about Ganeti.
+ * [Publications](Publications.md): Publications of the Ganeti project on conferences/in journals/etc.
+ * [SummerOfCode2013Ideas](SummerOfCode2013Ideas.md): Ideas for Google Summer of Code 2013.
+ * [SummerOfCode2014Ideas](SummerOfCode2014Ideas.md): Ideas for Google Summer of Code 2013.
+ * [SummerOfCode2015Ideas](SummerOfCode2015Ideas.md): Ideas for Google Summer of Code 2013.
+ * [SummerOfCode2016Ideas](SummerOfCode2016Ideas.md): Ideas for Google Summer of Code 2013.
+
+---
+
+[Alphabetical index of documentation](.)
\ No newline at end of file
diff --git a/Downloads.md b/Downloads.md
new file mode 100644
index 0000000..4b66191
--- /dev/null
+++ b/Downloads.md
@@ -0,0 +1,18 @@
+# Downloads
+
+The latest version of Ganeti is available at http://downloads.ganeti.org. Ganeti downloadable files are electronically signed with a GPG key.
+
+ * **Key:** `6AA8276A Ganeti (Release signing key) <ganeti@googlegroups.com>`
+ * **Fingerprint:** `7A8D 09A0 12E9 1D94 56E2 996B A876 A343 6AA8 276A`
+
+## Current versions
+ * [Ganeti 2.17](http://downloads.ganeti.org/releases/2.17/) (beta1)
+ * [Ganeti 2.16](http://downloads.ganeti.org/releases/2.16/) (rc1)
+ * [Ganeti 2.15](http://downloads.ganeti.org/releases/2.15/) (Stable)
+ * [Ganeti 2.14](http://downloads.ganeti.org/releases/2.14/) (Old Stable)
+ * [Ganeti 2.13](http://downloads.ganeti.org/releases/2.13/) (Old Stable)
+ * [Ganeti 2.12](http://downloads.ganeti.org/releases/2.12/) (Old Stable)
+ * [Ganeti 2.11](http://downloads.ganeti.org/releases/2.11/) (Old Stable)
+ * [Ganeti 2.10](http://downloads.ganeti.org/releases/2.10/) (Old Stable)
+ * [Ganeti 2.9](http://downloads.ganeti.org/releases/2.9/) (Old Stable)
+ * [Ganeti 2.8](http://downloads.ganeti.org/releases/2.8) (Old stable)
\ No newline at end of file
diff --git a/DrbdDeviceMonitoring.md b/DrbdDeviceMonitoring.md
new file mode 100644
index 0000000..d51211e
--- /dev/null
+++ b/DrbdDeviceMonitoring.md
@@ -0,0 +1,137 @@
+[TOC]
+
+# DRBD Device Monitoring
+
+# Install
+
+## On all Ganeti nodes
+just install `check_drbd` (http://www.monitoringexchange.org/attachment/download/Check-Plugins/Operating-Systems/Linux/check_drbd/check_drbd) somewhere in the path.
+
+
+By default, this script will return CRITICAL if a device is unconfigured, and UNKNOWN if a device does not exists.
+These situations can happen with Ganeti when:
+
+* A VM is down
+* A VM is down and a node has been rebooted (then the drbd device disappears).
+
+You may want to patch `check_drbd` like this to avoid "false" alerts:
+
+```
+--- check_drbd 2010-01-26 09:10:16.000000000 +0100
++++ /usr/local/bin/check_drbd 2010-01-26 09:06:23.000000000 +0100
+@@ -38,7 +38,7 @@
+ 'WFConnection' => { 'value' => 'CRITICAL', 'type' => 'cs' },
+ 'WFReportParams' => { 'value' => 'CRITICAL', 'type' => 'cs' },
+ 'Connected' => { 'value' => 'OK', 'type' => 'cs' },
+- 'Unconfigured' => { 'value' => 'CRITICAL', 'type' => 'cs' },
++ 'Unconfigured' => { 'value' => 'OK', 'type' => 'cs' },
+ # DRBD 0.6
+ 'SyncingAll' => { 'value' => 'WARNING', 'type' => 'cs' },
+ 'SyncingQuick' => { 'value' => 'WARNING', 'type' => 'cs' },
+@@ -261,7 +261,7 @@
+ }
+ foreach my $device (@devices) {
+ if (!(defined($cs{$device}))) {
+- &myexit('UNKNOWN',"Could not find device $device");
++ &myexit('OK',"Could not find device $device");
+ }
+ $check{$device} = 1;
+ }
+```
+
+## On Ganeti master
+Put this script somewhere in the path (`/usr/local/bin/drbd_gen_nagios.sh` for example):
+
+```bash
+#!/bin/bash
+#
+# Copyright (C) 2009 Maxence Dunnewind <maxence@dunnewind.net>
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program. If not, see <http://www.gnu.org/licenses/>.
+
+gnt-instance list --no-header --separator=: -o name|while read vm;do
+ TMP_FILE=$(mktemp)
+ gnt-instance info -s $vm > $TMP_FILE
+ NODE_A=$(grep "nodeA" $TMP_FILE|grep -o "[^ ]\+,"|head -1|sed
+'s/,//')
+ NODE_B=$(grep "nodeB" $TMP_FILE|grep -o "[^ ]\+,"|head -1|sed
+'s/,//')
+ DEV_A=$(grep "nodeA" $TMP_FILE|cut -d "=" -f 2)
+ DEV_B=$(grep "nodeB" $TMP_FILE|cut -d "=" -f 2)
+ rm -rf $TMP_FILE
+ for disk in $DEV_A;do
+ echo "define service {"
+ echo " host_name $NODE_A"
+ echo " service_description DRBD instance $vm /
+device n° $disk"
+ echo " check_command check_drbd!$disk"
+ echo " use generic-service"
+ echo "}"
+ echo ""
+ done
+ for disk in $DEV_B;do
+ echo "define service {"
+ echo " host_name $NODE_B"
+ echo " service_description DRBD instance $vm /
+device n° $disk"
+ echo " check_command check_drbd!$disk"
+ echo " use generic-service"
+ echo "}"
+ echo ""
+ done
+done
+```
+
+**Important** : This script only define drbd checks, so you already need
+to have the hosts configured in your nagios.
+
+## On nagios
+Define `check_drbd`, which will use `check_by_ssh` to call the `check_drbd`
+script on the nodes.
+
+```bash
+define command{
+ command_name check_drbd
+ command_line /usr/lib/nagios/plugins/check_by_ssh -H $HOSTADDRESS$ -l root -C "/usr/local/bin/check_drbd -d $ARG1$"
+}
+```
+
+for example in `/etc/nagiosX/conf.d/command.cfg`.
+
+Also, be sure nagios user can connect using ssh without password. If you don't have defined that, you need to:
+
+```bash
+# su - nagios
+# ssh-keygen
+Generating public/private rsa key pair.
+Enter file in which to save the key (/var/run/nagios3/.ssh/id_rsa): /etc/nagios3/id_rsa
+Enter passphrase (empty for no passphrase):
+Enter same passphrase again:
+```
+
+Don't forget to replace the file. If you keep /var/run, your key will be deleted after next reboot. Also, keep the passphrase empty. Then, copy the `id_rsa.pub` under `/root/.ssh/authorized_keys` on all your hosts. You can also add a "from" field and a "command" one to limit access:
+
+```
+from="1.1.1.1",command="/usr/local/bin/check_drbd" ssh-rsa AAAAB3NzaC1yc2EAAAABIwA...
+```
+
+# Use
+To generate the config, after a new instance has been added / removed, or after a replace-disks, run:
+
+```sh
+drbd_gen_nagios.sh > drbd.cfg
+```
+
+On the Ganeti master, then just copy the generated file into your Nagios
+`conf.d` directory, and check the config and restart Nagios.
\ No newline at end of file
diff --git a/EditingTheConfiguration.md b/EditingTheConfiguration.md
new file mode 100644
index 0000000..56f710b
--- /dev/null
+++ b/EditingTheConfiguration.md
@@ -0,0 +1,28 @@
+# Editing the Configuration
+
+You are here. You do not want to be here. Ganeti is missing that one feature you need and someone recommended that you edit the configuration. This page will tell you how, and try to dissuade you from doing so unless really necessary.
+
+# Why you should (not) edit the configuration
+
+We generally do not encourage people to edit the configuration, but there are certain SNAFUs that are easiest to get out of by making a small change to the configuration. We try to fix these, so please make an issue, comment on an existing one, or ask around for alternative solutions in IRC or on the mailing list.
+
+For resiliency purposes, the configuration is distributed and checked for unauthorized modifications, and changing it is intentionally not easy. You will have to go through a precise series of steps, and should you stray too far, the situation may go beyond repair. This is why you should not make a habit out of it.
+
+# How to edit the configuration
+
+1. Pause the watcher with `gnt-cluster watcher pause 6h`. Give yourself more time if needed.
+2. Drain the job queue with `gnt-cluster queue drain`
+3. Wait until all jobs have been completed, as seen with `gnt-job list`
+4. Stop Ganeti on the master node.
+5. Backup your configuration. This is usually `/var/lib/ganeti/config.data`
+6. Seriously, create a backup.
+7. Make the current configuration readable by prettifying the JSON file, e.g. `/usr/lib/ganeti/tools/fmtjson <config.data >config.readable`
+8. Make the edits that you want to make to the readable configuration.
+9. Replace the current configuration with the modified readable one.
+10. Start Ganeti on the master node.
+11. Undrain the queue with `gnt-cluster queue undrain`
+12. Run `gnt-cluster redist-conf`
+13. Make sure all is well with `gnt-cluster verify`, and whatever specific checks you need
+14. Unpause the watcher with `gnt-cluster watcher continue`
+
+If anything goes wrong, you can restore the old configuration by using the same procedure. If you changed the state of the cluster in the meantime, Ganeti might complain upon seeing the state of the configuration not match reality.
\ No newline at end of file
diff --git a/ExtStorageProviders.md b/ExtStorageProviders.md
new file mode 100644
index 0000000..14eba00
--- /dev/null
+++ b/ExtStorageProviders.md
@@ -0,0 +1,58 @@
+[TOC]
+
+# External Storage Providers
+
+This is a list of all known Ganeti ExtStorage providers.
+
+You may find some of them included in the Ganeti source code under `examples/extstorage/`. If you have a working ExtStorage provider and would like to share it with the Ganeti community, please send us an email on the Ganeti public list, along with a link to your provider, and we will include it in this list.
+
+# ExtStorage interface
+
+ExtStorage providers plug into Ganeti's ExtStorage interface and allow you to integrate Ganeti with external shared storage, most commonly SAN appliances. To learn more about the ExtStorage interface, see the following links:
+
+* [Ganeti ExtStorage Interface slides from GanetiCon2013](https://docs.google.com/a/google.com/file/d/0B934VF_cTqnwc0NGcEx4OXl3NDA/edit)
+* [Ganeti ExtStorage Interface man page](http://docs.ganeti.org/ganeti/master/html/man-ganeti-extstorage-interface.html)
+* [Ganeti ExtStorage Interface design doc](http://docs.ganeti.org/ganeti/master/html/design-shared-storage.html#introduction-of-the-external-storage-interface)
+
+To read an example of how to install and configure an ExtStorage provider see this [Google Groups email thread](https://groups.google.com/forum/?fromgroups=#!searchin/ganeti-devel/shared-filer/ganeti-devel/kGTje2FP94k/in8s6RVFQqQJ), explaining how to set up the ExtStorage interface.
+
+# ExtStorage providers list
+
+## Shared Filer
+
+This is the sample provider submitted along with the ExtStorage Interface, to act as the example on how users can implement their own ExtStorage providers. It does not interact with a SAN device; it handles VM disks as plain files under a shared directory, which is configurable via the `shared_dir` ext-param (to showcase how ext-params work).
+
+Essentially, it implements Ganeti's native `-t sharedfile` suppport, over the ExtStorage Interface.
+To learn more on how to set it up, see the corresponding [Google Groups email thread](https://groups.google.com/forum/?fromgroups=#!searchin/ganeti-devel/shared-filer/ganeti-devel/kGTje2FP94k/in8s6RVFQqQJ).
+
+Provider's link: https://code.grnet.gr/projects/extstorage/repository/revisions/master/show/shared-filer
+
+## RBD
+
+This is a second sample provider that implements Ganeti's native RBD support (`-t rbd`), over the ExtStorage interface. It is meant to act as an example of a more complex provider. The recommended way to integrate Ganeti with Ceph's RADOS is via the native RBD support and not this provider.
+
+Provider's link: https://code.grnet.gr/projects/extstorage/repository/revisions/master/show/rbd
+
+## IBM Storwize Family
+
+This provider integrates Ganeti with the IBM Storwize product family. It has been tested to work with IBM Storwize v7000.
+
+Provider's link: https://code.grnet.gr/projects/extstorage/repository/revisions/master/show/svc
+
+## HP EVA Storage
+
+This provider integrates Ganeti with the HP EVA Storage Array.
+
+Provider's link: https://github.com/DSI-Universite-Rennes2/hpeva
+
+## ZFS
+
+This provider integrates Ganeti with [ZFS](http://en.wikipedia.org/wiki/ZFS).
+
+Provider's link: https://github.com/ffzg/ganeti-extstorage-zfs
+
+## cLVM and "Shared" LVM
+
+This provider allows Ganeti to use clustered LVM or LVM volumes on shared storage.
+
+Provider's link: http://www.goodbytez.de/ganeti/README
\ No newline at end of file
diff --git a/GanetiAndSSL.md b/GanetiAndSSL.md
new file mode 100644
index 0000000..ce9dbf2
--- /dev/null
+++ b/GanetiAndSSL.md
@@ -0,0 +1,46 @@
+[TOC]
+
+# Ganeti and SSL
+
+From 2.11 onwards, Ganeti has a new way of handling SSL certificiates. The details of this can be read in the design doc [Ganeti Node Security](http://git.ganeti.org/?p=ganeti.git;a=blob;f=doc/design-node-security.rst;h=05d28b001ae1407850c837d833a34510d2d57623;hb=HEAD).
+
+To summarize, instead of only one SSL certificate `server.pem` file, we added individual client SSL certificate `client.pem` files to each node. A list of client certificate fingerprints of master candidate nodes is maintained in the configuration and distributed to all nodes as an `ssconf_master_candidate_certs` file.
+
+However, this has turned out to have more problems than we expected. There a couple of known bugs which might render your cluster uncommunicative. This document shows you some hints and quick fixes for some of those situations.
+
+# CN-encodings
+
+[Issue 1094](https://code.google.com/p/ganeti/issues/detail?id=1094) reported a problem which can cut off SSL communication between Ganeti clusters if different openssl/gnutls versions are running inside a cluster or if the server.pem is very old so that it was created with a different openssl/gnutls version than the new client.pem.
+
+If you experience problems with nodes being unreachable by RPC, you might be affected by this. In particular in clusters where all nodes do not have identical OpenSSL or GNUTLS versions, this is likely to happen after a master failover.
+
+We fixed this by now, but in case you end up with an affected Ganeti version and you need to make it usable to upgrade the cluster, you might need to use the following trick to run a cluster without `client.pem`.
+
+# Ensure state of new SSL setup
+
+The new handling of SSL certificates in Ganeti has still some weaknesses. If you discover communication errors between your nodes on your cluster at version 2.12 or later, please check that the following things are correct:
+
+ * All nodes have the **same** `/var/lib/ganeti/server.pem` file.
+ * All nodes have a `/var/lib/ganeti/client.pem` file, which should be **different** for each node.
+ * All nodes have a `/var/lib/ganeti/ssconf_master_candidate_certs` file.
+
+### Fixes
+
+ * If only the `server.pem` file is missing or inconsistent across nodes, just copy the file from the master node to all other nodes. Restart Ganeti on all nodes to make sure the daemons pick up the new certificate.
+ * If the `client.pem` and/or the `ssconf_master_certificates_certs` is missing only on one or very few nodes (but not on the master node), your best bet is to re-add those nodes as there is no way to renew the certificates for one node only.
+ * If the `client.pem` and/or the `ssconf_master_certificates_certs` is missing on the master node or one a lot of nodes in the cluster, your best bet is to follow the instruction in the next Section "Run Ganeti without client certificates" and **afterwards** run `gnt-cluster-renew-crypto --new-node-certificates`. The latter will then create new `client.pem` and `ssconf_master_candidate_certs`.
+
+
+# Run Ganeti without client certificates
+
+It is possible to temporarily run a 2.12+ cluster without client.pem certificates. This can be used as a last resort if you get hit by a bug.
+
+However, note that this is not tested well, because it was only meant as a temporary state of a cluster. If you run a cluster this way, you should closely monitor operations like adding nodes, promoting/demoting nodes to/from master candidate, and master failovers.
+
+To run a 2.12+ cluster with the SSL setup of a pre-2.12 cluster (without client certificates), you need to do the following:
+
+ 1. Pause the Ganeti watcher for a while so that it will not restart Ganeti daemons.
+ 2. Shutdown the Ganeti daemons on all nodes (e.g. `/etc/init.d/ganeti stop`).
+ 3. Remove (or move away) the two files `/var/lib/ganeti/client.pem` and `/var/lib/ganeti/ssconf_master_candidate_certs` on all nodes. It is important that this is done consistently across the cluster.
+ 4. Restart all Ganeti daemons on all nodes again (e.g. `/etc/init.d/ganeti start`)
+ 5. Run `gnt-cluster verify` to make sure everything is fine again. You will get a nagging message that you should run `gnt-cluster renew-crypto --new-node-certificates`. You need to ignore this as long as you want to run the cluster in pre-2.12 state.
\ No newline at end of file
diff --git a/GanetiFAQ.md b/GanetiFAQ.md
new file mode 100644
index 0000000..97b82c6
--- /dev/null
+++ b/GanetiFAQ.md
@@ -0,0 +1,280 @@
+[TOC]
+
+# Ganeti Frequenty Asked Questions
+
+# Versions supported
+
+## Which versions of Ganeti are supported/maintained?
+
+http://docs.ganeti.org/ lists the latest stable version of Ganeti. The core Ganeti team supports and maintains the two most recent stable versions of Ganeti.
+
+However, the Ganeti team also fixes high severity bugs in older versions. The decision whether or not to fix a bug in an older version of Ganeti is made on a case-by-case basis, and depends on the complexity of the fix, the impact of the fix on existing users, and the risk of the fix introducing regressions.
+
+In practical terms, our policy means that we support at minimum security issues in older versions of Ganeti shipped by some major Linux distributions (which usually means the last security-supported version is the one present in Debian stable). This support is bug-driven only.
+
+## Which distributions have Ganeti available as packages? Are there RPMs for Ganeti?
+
+The following distributions package Ganeti:
+
+| **Distribution** | **Package name** |
+|:-----------------|:-----------------|
+| Debian | [Wheezy](http://packages.debian.org/wheezy/ganeti2) `ganeti2` |
+| | [Jessie](http://packages.debian.org/jessie/ganeti2) `ganeti` |
+| | We recommend using the newer Ganeti versions in [wheezy-backports](http://packages.debian.org/wheezy-backports/ganeti2). |
+| Ubuntu | Up to [Saucy](http://packages.ubuntu.com/trusty/ganeti): `ganeti2` |
+| | As of [Trusty](http://packages.ubuntu.com/trusty/ganeti): `ganeti` |
+| RPMs (RHEL/CentOS/Scientific Linux and Fedora) | See the current packaging effort at [GitHub](https://github.com/jfut/ganeti-rpm). |
+| Gentoo | See the current [ebuild file](http://packages.gentoo.org/package/app-emulation/ganeti). |
+
+## What guest operating systems does Ganeti support?
+
+Ganeti does not place any restrictions on guest operating systems. However, the limitations of the selected hypervisor still apply (e.g. xen-pvm can’t run Windows guests).
+
+Ganeti relies on user-provided OS installation scripts to install guest operating systems. These scripts allow for very flexible installation scenarios and are documented at http://docs.ganeti.org/. It is also possible to boot an instance from an image and then manually install the OS.
+
+## Which versions of Xen does Ganeti support?
+
+From Ganeti 2.6 onwards, the supported Xen versions are:
+ * 3.0.3 and later 3.x versions
+ * 4.x, tested up to 4.4
+See the [Ganeti installation tutorial](http://docs.ganeti.org/ganeti/current/html/install.html#id2) for updates.
+
+## Which Xen toolstacks are supported by Ganeti?
+
+Ganeti supports the following Xen toolstacks:
+
+| **Version** | **Xen toolstacks supported** |
+|:------------|:-----------------------------|
+| Before Ganeti 2.6 | **xm** only |
+| Ganeti 2.6 and later| Both **xm** and **xl** toolstacks are supported, but must be specified at configure time |
+| Ganeti 2.10 and later | **xl** toolstack is supported, with the option to switch between the toolstacks at runtime using a hypervisor parameter |
+
+## What projects are related to/built on Ganeti?
+
+Below is a list of Ganeti-related projects of which we’re aware. Contact us if you want your project to be added!
+
+ * Cloud toolstack based on Ganeti
+ * [Synnefo](http://www.synnefo.org/)
+ * [Okeanos](https://okeanos.grnet.gr/opensource/) (public cloud based upon Synnefo)
+ * Web UI projects
+ * [Ganeti Web Manager](http://ganeti-webmgr.readthedocs.org/en/latest/)
+ * [genetimgr](http://ganetimgr.readthedocs.org/en/latest/)
+ * Ganeti OS implementations
+ * instance-debootstrap: git://git.ganeti.org/instance-debootstrap.git (maintained by the Ganeti development team at Google)
+ * [Ganeti instance image](https://code.osuosl.org/projects/ganeti-image)
+ * [snf-image](https://code.grnet.gr/projects/snf-image)
+
+## What is the status of the SAN support of Ganeti?
+
+SAN is fully supported in version 2.9., using the ExtStorage Interface. This interface is a contribution from [GRNET](http://en.wikipedia.org/wiki/Greek_Research_and_Technology_Network). For more information, see:
+
+ * The [Ganeti ExtStorage Interface slides](https://docs.google.com/a/google.com/file/d/0B934VF_cTqnwc0NGcEx4OXl3NDA/edit) from GanetiCon2013
+ * The [Google Groups email thread](https://groups.google.com/forum/?fromgroups=#!searchin/ganeti-devel/shared-filer/ganeti-devel/kGTje2FP94k/in8s6RVFQqQJ) explaining how to set up the ExtStorage interface
+ * The ExtStorage man page describes the interface and its usage further: http://docs.ganeti.org/ganeti/master/html/man-ganeti-extstorage-interface.html
+
+You may need to write your own ExtStorageProvider scripts to comply with the interface.
+
+# Google and Ganeti
+
+## What is the meaning of the word "Ganeti"?
+
+The name "Ganeti" does not actually have a meaning. As one of the first team members of Ganeti put it "It was the best random name that we could come up with." It was chosen to be kind of unique in the sense of if you google for it, it will be the first hit, which it still is, this has nothing to do with that Google supports the project.
+
+## Do the Google developers or a third party offer paid support for Ganeti?
+
+Google does not offer paid support for Ganeti, nor do we know/recommend/endorse any third party that may do so. That being said, Ganeti the software is fully open and easily understandable by a good Linux admin/developer, and you can address questions to the following mailing lists:
+
+ * User discussions: [ganeti@googlegroups.com](mailto:ganeti@googlegroups.com)
+ * Ganeti development: [ganeti-devel@googlegroups.com](mailto:ganeti-devel@googlegroups.com)
+
+## How is Ganeti used internally at Google?
+
+Google uses Ganeti to provision virtual machines inside its corporate network. We have Ganeti clusters in offices and data centers, and use these clusters to provide basic network services, virtual workstations, and general Linux servers. Google doesn’t use Ganeti for production infrastructure.
+
+## What are the future plans for Ganeti?
+
+We’d like to scale Ganeti further (more nodes, instances, and parallel jobs) and to integrate interesting networking/virtualization/storage technologies as they become available. We don’t have a precise long term roadmap as of now.
+
+# Best practices
+
+## How does Ganeti interact with other cluster solutions (OVF support, instance exports, etc.)?
+
+You can easily convert a previously-exported Ganeti instance into an OVF package by using ovfconverter from the tools directory of the source code. The OVF package is supported by VMWare, VirtualBox, and some additional virtualization software.
+
+You can also use an instance exported from a tool such as VMWare or VirtualBox and convert it to a Ganeti config file using the command `gnt-backup import`.
+
+The document [Ganeti Instance Import/Export using Open Virtualization Format](http://docs.ganeti.org/ganeti/current/html/design-ovf-support.html) has a more detailed description of the internal design of the converter, as well as a list of the available command line options.
+
+## How do I deploy Ganeti technically?
+You can deploy Ganeti by following the [Ganeti installation tutorial](http://docs.ganeti.org/ganeti/master/html/install.html). The main steps include:
+
+ * Installing the base operating system
+ * Installing the required dependences
+ * Installing Ganeti from the packages provided by the chosen Linux distribution (or compiling Ganeti from source code)
+ * Installing at least one operating system support package
+ * Initializing the cluster with gnt-cluster init and configuring the cluster using the appropriate `gnt-*` commands.
+
+**Note:** The [Ganeti walk-through](http://docs.ganeti.org/ganeti/current/html/walkthrough.html) provides more information on initializing and configuring the cluster.
+
+## What type of cluster users/deployment configurations does Ganeti serve well?
+
+Ganeti is very suitable for small/medium deployments, and for starting small and then scaling up. It’s easy to start with even just 1 or 3 physical nodes, and then to add more nodes as needed. Managing a few clusters comprising up to 120-150 nodes should be easy for a good Linux admin or two capable of using configuration management (CFEngine, Puppet, Chef, etc.).
+
+If you plan to scale your infrastructure to a large deployment (tens of clusters and thousands of nodes), management by someone with Python/Haskell knowledge, and the ability to use/deploy extra tools to coordinate such a big infrastructure, is advisable.
+
+
+## What are known large and notable Ganeti deployments?
+
+Large and notable Ganeti deployments include:
+
+|**Deployment** | **Description** | **Scale** |
+|:--------------|:----------------|:----------|
+|[debian.org](http://www.debian.org/) | Linux distribution | 5 servers, 70 VMs |
+|[fsffrance.org](http://fsffrance.org) | | |
+|Google | Part of Google’s corporate computing infrastructure | |
+|[grnet.gr](https://www.grnet.gr) | Greek Research & Technology Network| 10 clusters, >6000 VMs|
+|[osuosl.org](http://osuosl.org) | Oregon State University Open Source Lab | 10 clusters, ~120 VMs|
+|[skroutz.gr](http://www.skroutz.gr) | Price comparison engine | 20 nodes, >100 VMs, 3 locations|
+
+## Is automation of the Ganeti deployment process available?
+There is no automated deployment process for Ganeti. However, since Ganeti version 2.11, you can upgrade an existing Ganeti cluster ( >2.10 ) using the single command: `gnt-cluster upgrade`.
+
+## What are best practices for Ganeti network configuration?
+The ideal Ganeti configuration requires two separate networks (or at least two separate VLANs):
+
+ * **Primary network:** Includes all the nodes and provides connection to the external world
+ * **Secondary network:** Used to replicate instance traffic across nodes
+
+## How do you secure Ganeti instances, network-wise?
+See [Security in Ganeti](http://docs.ganeti.org/ganeti/master/html/security.html) for security best practices and discussion of Ganeti components that require particular attention on matters security-related.
+
+## How do you shield instances from each other?
+Security-wise, disks of instances are separate logical volumes and are wiped before they’re attached to an instance. Other than separating instance disks, Ganeti relies on the hypervisor to separate instances. Newer versions of Ganeti (>= 2.12) also contain some measures to mitigate compromise of a node, should an instance manage to escape the hypervisor. See [Security in Ganeti](http://docs.ganeti.org/ganeti/master/html/security.html) for more details.
+
+Performance-wise, [Partitioned Ganeti](http://docs.ganeti.org/ganeti/current/html/design-partitioned.html) allows resources, up to the level of individual spindles, to be individually assigned to instances.
+
+## Is it possible to have nested virtualization on Ganeti (i.e. to use Ganeti nodes as VMs themselves)?
+Yes. Ganeti itself makes no assumption about running on real hardware. Of course, in order to use nested virtualization, you must use virtualization solutions that are able to run inside each other. KVM at all levels is one popular nested virtualization solution. In fact, some developers use such a KVM setup for developing Ganeti. Additionally, the Ganeti buildbot ([buildbot.ganeti.org](http://buildbot.ganeti.org/)) runs completely on Ganeti VMs and includes a proper (KVM-based) QA.
+
+## What are best practices for setting up a cluster with respect to (geo) redundancy?
+Ganeti has no concept of geo location; the most closely-related concept to geo location is a node group. Nodes in any particular node group are assumed to be equivalent for usage, which means that they’re equivalent to existing in the same location. Therefore, if two nodes require geo redundancy, they need to be located in separate node groups. Instances are only moved between node groups upon explicit request, and deciding how to allocate instances among geo locations is the user’s responsibility.
+
+To avoid two instances that provide the same service (such as DNS) from ending up on the same physical node, we recommend that you use exclusion tags. For more information, see the [hbal man page](http://docs.ganeti.org/ganeti/current/html/man-hbal.html).
+
+## What are best practices for setting up monitoring/Nagios with Ganeti?
+The health status of a Ganeti cluster can be verified with the command `gnt-cluster verify`. Ganeti-specific information can be obtained via the [ganeti-mond](http://docs.ganeti.org/ganeti/current/html/man-ganeti-mond.html). Individual Ganeti instances are best monitored independently of Ganeti with the same setup you’d use to monitor a physical machine.
+
+## What are best practices for setting up configuration management (Puppet) with Ganeti?
+Answer: It’s a good idea to use configuration management to fully and automatically install nodes, as well as to maintain consistent node configuration across a cluster. In particular, we recommend configuring specific (rather than minimal) versions to avoid surprises with available updates.
+
+# Features: Storage
+
+## What distributed storage models does Ganeti support?
+
+Ganeti introduced native [Ceph RBD](http://ceph.com/ceph-storage/block-storage/) support in Ganeti version 2.6. Native support for [Gluster](http://www.gluster.org/about/) volumes was introduced in Ganeti 2.11. If the performance tradeoffs of true distributed storage are unacceptable to you, Ganeti also has excellent support for the limited-replica [DRBD](http://www.drbd.org/) technology.
+
+Users of Ganeti 2.7 and newer versions may use the [external storage backend](http://docs.ganeti.org/ganeti/master/html/man-ganeti-extstorage-interface.html) to provide support for other storage systems, distributed or otherwise. You can also support distributed storage models through the "shared file" mechanism, so long as you can provide transparent replication of the shared file storage directory across all nodes (for example, with an NFS mount point).
+
+In all cases, storage deployment and configuration is a task left to the administrator. Ganeti is simply configured to use an existing RBD pool, Gluster volume, or file system directory for instance data storage.
+
+For more details on Ganeti and storage, see the [Ganeti administrator’s guide](http://docs.ganeti.org/ganeti/master/html/admin.html#disk-template) and the [Ganetti installation tutorial](http://docs.ganeti.org/ganeti/master/html/install.html#installing-rbd).
+
+## Does Ganeti support backups and snapshots?
+
+Ganeti supports backup of instances. Support for backup compression was added in the Ganeti 2.11 release. Instance snapshotting is not yet available.
+
+## What is the current status of distributed storage support?
+
+As of January 2014, support for Ceph is mature. Gluster support is not tested well as it is maintained as a best effort.
+
+## Does Ganeti support instances with disks of different types (for example, a DRBD and a shared file disk)?
+
+Support for instances with disks of different types is a planned feature. We worked a bit on it, but it is not finished yet.
+
+## Does Ganeti support multiple volume groups or storage classes
+
+Ganeti supports instances with multiple volume groups. Simply create instances overriding the "vg" attribute for the disk parameter. Examples on how to do this can be found in [Hochschule Darmstadt Wiki](https://wiki.fbihome.de/Netzwerk:VM).
+
+
+# Features: Cloud
+
+## How does Ganeti compare to other cloud solutions (OpenStack, Cloudstack, OpenNebula, XenCluster, libvirt, etc.)?
+
+In comparison to other cloud solutions, Ganeti is much more lightweight. Ganeti is quite simple to set up and has very few dependencies on the required infrastructure. For example, Ganeti doesn’t even require a database. Also, Ganeti’s scope is more limited than other cloud solutions: it is made to manage small- to medium-sized clusters, rather than huge clouds and doesn’t provide a management UI out of the box. For a more in-depth comparison of VMWare, OpenStack, and Ganeti, see the [IaaS presentation](http://www.slideshare.net/gpaterno1/comparing-iaas-vmware-vs-openstack-vs-googles-ganeti-28016375).
+
+libvirt, on the other hand, is only a library which abstracts over different virtualization technologies. It does not provide any cluster management features. While Ganeti can be used as abstraction for the supported hypervisors, this functionality is not the main purpose of Ganeti.
+
+
+# Features: Fault tolerance/high availability
+
+## How does Ganeti provide fault tolerance?
+Ganeti supports redundant storage solutions, the most important of which is DRBD. Ganeti also distributes instances to ensure that the secondary nodes have enough memory to immediately start an instance, should the primary node break.
+
+## Does Ganeti support automatic failover?
+Yes, Ganeti supports automatic failover. Automatic failover is opt-in, as some Ganeti system administrators prefer to either manually respond to breakages or to delegate such responses to some other system to take actions via RAPI.
+
+`harep` is Ganeti’s auto-repair tool. `harep` can fix DRBD breakage, migrate and failover instances, and (as a last resort) reinstall instances. `harep` only acts on clusters, node groups, or instances for which a tag is set allowing the tool to take action.
+
+As of Ganeti 2.17 there is work ongoing to create a maintenance daemon which subsumes harep and adds more features. See details [here](http://git.ganeti.org/?p=ganeti.git;a=blob;f=doc/design-repaird.rst;hb=HEAD).
+
+# Features: Misc
+
+## What interfaces can be used to manipulate Ganeti?
+
+All of Ganeti’s functionality is exposed through a set of command line tools, which are comprehensively documented in their corresponding [man pages](http://docs.ganeti.org/ganeti/current/html/manpages.html).
+
+A subset of Ganeti’s functionality is available through a web interface: the [Remote API (RAPI)](http://docs.ganeti.org/ganeti/current/html/rapi.html). RAPI provides a REST-ful view of all the entities in a cluster, allowing them to be manipulated and queried. To address security concerns, RAPI provides authentication and encryption.
+
+## What Ganeti management consoles are available?
+
+While Ganeti itself does not provide a web management console, outside developers who manage large Ganeti deployments have developed solutions for this purpose and have made them available to the public.
+
+One simple solution is Oregon State University Open Source Lab’s [Ganeti Web Manager](https://github.com/osuosl/ganeti_webmgr), a Django-based web application that exposes the commands accessible via the RAPI in a user-friendly way.
+
+[Synnefo](http://www.synnefo.org/) provides a more feature-rich UI; however, the UI relies on Synnefo abstractions and cannot be used to manage a plain Ganeti cluster.
+
+## Does Ganeti support containers as a form of limited virtualization?
+
+Yes. Ganeti supports [LXC](http://linuxcontainers.org/) and chroot-based environments, allowing instances to be created as though a real hypervisor were used. However, those are not tested well and are maintained on a best-effort basis.
+
+## What are the size limitations in Ganeti? (Number of nodes, instances, size of disks, number of disks)
+
+**Nodes:** This number can range from 1 to 150. If you’re implementing a large number of nodes, they should ideally span multiple node groups. However, Ganeti does not strictly enforce this limit of 150. It is possible to create bigger clusters, you will just have to face performance issues then.
+
+**Instances:** This number is difficult to recommend, as it depends upon the specification of the node, the size of the instance, etc. There is no hard limit Ganeti enforces.
+
+**Size and number of disks:** These numbers are difficult to recommend, as they depend upon the resources available in the nodes. There is no hard limit Ganeti enforces.
+
+## What is the status of Open vSwitch?
+
+There is a design document describing the integration of Ganeti and Open vSwitch (see [doc/html/design-openvswitch.html](http://docs.ganeti.org/ganeti/master/html/design-openvswitch.html)). This design document is still being implemented; currently, Ganeti can configure an Open vSwitch switch on nodes and also associate VLANs to instances’ NICs.
+
+There have also been external experiments integrating Ganeti and Open vSwitch, most notably, the [AFOYI experiment](https://afoyi.com/blog/converting-ganeti-to-use-open-vswitch/) and [integration of KVM and Open vSwitch](https://afoyi.com/blog/converting-ganeti-to-use-open-vswitch/).
+
+## What is the status of USB support? What are USB best practices?
+
+USB devices can be passed directly to KVM instances when they are created (see man/gnt-instance.html for more information). For Xen, Ganeti currently simply enables USB support for domU, but does not add any USB devices. It is possible to add USB devices manually from dom0 (see [Xen USB Passthrough](http://wiki.xen.org/wiki/Xen_USB_Passthrough) for details). Patches for USB device support for Xen are welcome.
+
+## What's the status of instance OS image support?
+
+OS image support is currently under development and was planned for release as part of Ganeti 2.11. See doc/html/design-os.html for a description of how OS images can be used as part of the OS installation for instances. However, this is not finished.
+
+
+
+
+# Design decisions
+
+## Why does Ganeti use Haskell? What are Ganeti’s plans with respect to increasing or decreasing the ratio of Haskell code?
+
+Ganeti first used Haskell as an experiment when we needed a compiled language that could perform fast computations on cluster metadata. Eventually, we found that Haskell had advantages in its type safety that made it easy for us to develop better code with fewer common errors without having to write extensive “type-specific” unit tests. At this point, we decided to expand our use of Haskell.
+
+Only "infrastructural" code (job queue, locking) that was already very complicated in Python has been ported to Haskell. We’ll continue to use Python for Logical Units, backend RPCs, and hypervisor, storage, and networking implementations.
+
+There are two main reasons why Haskell constitutes a low barrier:
+
+ * Haskell doesn’t have any runtime dependency on the target systems.
+ * For setup, Haskell only requires a development environment.
+
+For good examples of setup, see the Ganeti documentation (in particular, [Haskell requirements](http://docs.ganeti.org/ganeti/master/html/install-quick.html#haskell-requirements)) and codebase (in particular, [devel/build_chroot](http://git.ganeti.org/?p=ganeti.git;a=blob;f=devel/build_chroot;h=39bec386535dbf16283af592792ea90b732a794c;hb=HEAD)).
+
+If some part of the Haskell codebase is too inflexible for your use, the Ganeti team is happy to help you understand how to customize the codebase, or how to make the codebase more modular and scriptable, if possible.
\ No newline at end of file
diff --git a/GanetiInVagrant.md b/GanetiInVagrant.md
new file mode 100644
index 0000000..be4ff76
--- /dev/null
+++ b/GanetiInVagrant.md
@@ -0,0 +1,114 @@
+[TOC]
+
+# Ganeti in Vagrant
+
+This document explains how you can easily test and try out Ganeti without needing a lot of extra hardware. This also provides a way for you to try out Ganeti on various platforms more easily.
+
+See [GitHub](https://github.com/ramereth/vagrant-ganeti) for the most up to date documentation.
+
+# Requirements
+
+ * VirtualBox >=4.1.x
+ * Vagrant >=1.0.3
+
+# Setup
+
+1. Install VirtualBox by going to their [download page](https://www.virtualbox.org/wiki/Downloads).
+2. Install Vagrant
+ ```
+ gem install vagrant
+ ```
+3. Clone repository
+
+ ```
+ git clone git://github.com/ramereth/vagrant-ganeti.git
+ ```
+4. Initialize submodule(s)
+
+ ```
+ git submodule update --init
+ ```
+
+# Using Vagrant
+
+The Vagrantfile is setup to where you can deploy one, two, or three nodes depending on your use case. `Node1` will have Ganeti already initialized while the other two will only have Ganeti installed and primed.
+
+For more information on how to use Vagrant, please [check out their site](http://vagrantup.com/docs/index.html).
+
+## Starting a single node
+
+```
+vagrant up node1
+vagrant ssh node1
+```
+
+## Starting node2
+
+NOTE: Root password is 'vagrant'.
+
+```
+vagrant up node2
+vagrant ssh node1
+gnt-node add -s 33.33.34.12 node2
+```
+
+## Starting node3
+
+NOTE: Root password is 'vagrant'.
+
+```
+vagrant up node3
+vagrant ssh node1
+gnt-node add -s 33.33.34.13 node3
+```
+
+# Accessing the nodes
+
+Add the following to your `/etc/hosts` files for easier access locally.
+
+```
+33.33.33.10 ganeti.example.org
+33.33.33.11 node1.example.org
+33.33.33.12 node2.example.org
+33.33.33.13 node3.example.org
+```
+
+All the nodes are using `hostonly` networking with the following IP addresses:
+
+ * ganeti.example.org (cluster IP) = 33.33.33.10
+ * node1.example.org = 33.33.33.11
+ * node2.example.org = 33.33.33.12
+ * node3.example.org = 33.33.33.13
+
+Additionally, I have setup several VM DNS names in the `/etc/hosts` of each node that you can use:
+
+ * instance1.example.org
+ * instance2.example.org
+ * instance3.example.org
+ * instance4.example.org
+
+
+
+The RAPI user setup for use on the cluster uses the following credentials.
+
+ * user: vagrant
+ * pass: vagrant
+
+# Running different Ganeti versions
+
+This repo has been setup to deal with a variety of Ganeti versions for testing. Currently it only supports 2.4.X, 2.5.X, 2.6.x and any git tagged releases. To switch between the versions do the following:
+
+ 1. edit `modules/ganeti_tutorial/node{1-3}.pp`
+ 2. if using git, change `git` to `true`
+ 3. change `ganeti_version` to desired version
+ 4. redeploy the VMs (destroy, up)
+
+# Node Operating System
+
+By default we use Ubuntu 11.10 for our node OS but we do have support for the following operating systems. Just run the vagrant commands from inside the appropriate folder.
+
+ * Debian 6 (debian-6)
+ * Debian 7 (debian-7)
+ * CentOS 6 (centos-6)
+ * CentOS 5 (work in progress)
+ * Ubuntu 12.10 (work in progress)
\ No newline at end of file
diff --git a/GanetiInVirtualBox.md b/GanetiInVirtualBox.md
new file mode 100644
index 0000000..01200fc
--- /dev/null
+++ b/GanetiInVirtualBox.md
@@ -0,0 +1,274 @@
+[TOC]
+
+# Ganeti in VirtualBox
+
+Here's a method for getting a Ganeti environment set up in VirtualBox on a workstation. This procedure isn't difficult, but there are a lot of steps. I've made a few choices that may or may not suit you:
+
+ 1. I'm using dnsmasq to handle internal dhcp and dns.
+ 2. I've allocated 768M ram per virtual node for 2G ram dedicated to VirtualBox. You can probably get away with less ram per node, like say 512M. Don't be afraid to get better hardware to make your life much much easier.
+ 3. I'm using VirtualBox host-only networking to create the required networks.
+ 4. I'm using debian stable (squeeze) as the operating system for the nodes.
+
+# Setting up the host
+
+1. install the required packages:
+
+ ```
+ sudo aptitude install virtualbox-ose dnsmasq clusterssh
+ ```
+2. Download Debian stable ISO.
+3. Select what netblocks you want to use, non-routable is recommended. I chose to use 192.168.10.0/24 for the normal netblocks, and 192.168.20.0/24 for the replication netblock.
+
+# Setting up VirtualBox
+
+## Create virtual networks
+In File->Preferences->Network, create two host-only networks. Configure them as follows:
+
+```
+vboxnet0:
+IPv4 Address: 192.168.10.254
+IPv4 Network Mask: 255.255.255.0
+DHCP Server: Disabled
+
+vboxnet1:
+IPv4 Address: 192.168.20.254
+IPv4 Network Mask: 255.255.255.0
+DHCP Server: Disabled
+```
+
+## Create nodes
+Choose where to put your disk images under File->Settings->General->Default Hard Disk Folder.
+
+For each desired node:
+
+ 1. Create a new virtual machine in VirtualBox
+ 2. Set the OS to debian 64bit
+ 3. Give it 768M of ram, 8G sparse hard drive named `<node>`.
+ 4. Set first nic to Host-only Adapter, Name: vboxnet0, Type: PCnet-FAST III, Promiscuous Mode: Allow All.
+ 5. Set second nic to Host-only Adapter, Name vboxnet1, Type PCnet-FAST III, Promiscuous Mode: Allow All.
+ 6. Add another 100G sparse hard drive (this will be used for xenvg) named `<node>vg`.
+ 7. Mount debian stable ISO in virtual cd drive.
+
+Add hosts to `/etc/hosts`:
+
+```sh
+# Nodes
+192.168.10.1 node1
+192.168.10.2 node2
+192.168.10.3 node3
+
+# Clusters
+192.168.10.4 cluster1
+
+# Replication network
+192.168.20.1 node1rep
+192.168.20.2 node2rep
+192.168.20.3 node3rep
+
+# Instances
+192.168.10.101 inst1
+192.168.10.102 inst2
+192.168.10.103 inst3
+```
+
+Configure dnsmasq by editing `/etc/dnsmasq.conf`, replacing all "`<MAC>`" with the MAC addresses of the virtual NICs, in the format 00:00:00:00:00.
+
+```sh
+interface=vboxnet0,vboxnet1
+
+dhcp-range=vboxnet0,192.168.10.1,192.168.10.253,12h
+dhcp-range=vboxnet1,192.168.20.1,192.168.20.253,12h
+
+dhcp-host=<MAC>,node1,1d
+dhcp-host=<MAC>,node2,1d
+dhcp-host=<MAC>,node3,1d
+
+dhcp-host=<MAC>,node1rep,1d
+dhcp-host=<MAC>,node2rep,1d
+dhcp-host=<MAC>,node3rep,1d
+
+# Don't hand out default route on replication network
+dhcp-option = net:vboxnet1, option:router
+```
+
+Add to /etc/rc.local:
+
+```
+iptables -F FORWARD
+iptables -A FORWARD -i vboxnet0 -j ACCEPT
+iptables -t nat -F POSTROUTING
+iptables -t nat -A POSTROUTING -s 192.168.10.0/24 -j MASQUERADE
+```
+
+Enable forwarding in /etc/sysctl.conf:
+
+```
+net.ipv4.ip_forward=1
+```
+
+standalone code block
+
+```bash
+# Install xen packages:
+aptitude install xen-hypervisor-4.0-amd64 linux-image-xen-amd64
+
+# Fix grub2's xen handling
+mv -i /etc/grub.d/10_linux /etc/grub.d/50_linux
+echo "" >> /etc/default/grub
+echo "# Disable OS prober to prevent virtual machines on logical volumes from appearing in the boot menu." >> /etc/default/grub
+echo "GRUB_DISABLE_OS_PROBER=true" >> /etc/default/grub
+update-grub2
+```
+
+End of block
+
+# Setting up node
+
+For each node
+
+* Boot machine off debian ISO, install debian stable.
+* Setup remote administration:
+
+ ```
+ aptitude install openssh-server
+ ```
+* Set up ssh keys so you can ssh in as root without password.
+
+
+For all nodes in parallel. Switch to using clusterssh to work on all nodes at once.
+
+```
+cssh root@node{1..3}
+```
+
+ * Setup NTP
+ * Install NTP.
+
+ ```
+ aptitude install ntp ntpdate
+ ```
+ * Edit /etc/ntp.conf, replace all server lines with
+
+ ```
+ server 192.168.10.254 iburst
+ ```
+ * Do initial sync and restart ntpd
+
+ ```
+ invoke-rc.d ntp stop
+ ntpdate 192.168.10.254
+ invoke-rc.d ntp start
+ ```
+
+ * Install Xen following the [Debian wiki](http://wiki.debian.org/Xen) instructions.
+
+```bash
+# Install xen packages:
+aptitude install xen-hypervisor-4.0-amd64 linux-image-xen-amd64
+
+# Fix grub2's xen handling
+mv -i /etc/grub.d/10_linux /etc/grub.d/50_linux
+echo "" >> /etc/default/grub
+echo "# Disable OS prober to prevent virtual machines on logical volumes from appearing in the boot menu." >> /etc/default/grub
+echo "GRUB_DISABLE_OS_PROBER=true" >> /etc/default/grub
+update-grub2
+```
+
+ * Check to see what packages ganeti2 in experimental would pull in, but do not install the package.
+
+ ```sh
+ aptitude -t experimental install ganeti2
+ ```
+ * Install all the deps for ganeti2 (plus a few extras that we need).
+
+ ```sh
+ aptitude install dbus debootstrap drbd8-utils dump
+ ganeti-instance-debootstrap iputils-arping javascript-common kpartx libaio1 \
+ libasound2 libasyncns0 libbluetooth3 libbrlapi0.5 libcurl3-gnutls libdbus-1-3 \
+ libdirectfb-1.2-9 libflac8 libjs-jquery libogg0 libpulse0 libsdl1.2debian \
+ libsdl1.2debian-alsa libsndfile1 libsvga1 libsysfs2 libts-0.0-0 libvdeplug2 \
+ libvorbis0a libvorbisenc2 libx86-1 libxi6 libxtst6 lvm2 python-openssl \
+ python-pyinotify python-pyparsing python-simplejson qemu-kvm socat tsconf \
+ wwwconfig-common x11-common rsync tcpdump python-pycurl python-paramiko
+ ```
+
+ * Follow the steps [here](http://docs.ganeti.org/ganeti/current/html/install.html#xen-settings), starting with "Xen settings" and stopping after "Configuring LVM", making the following modifications.
+ * We're using grub2, so skip the part about boot options and set the dom0 memory limit with
+
+ ```bash
+ echo 'GRUB_CMDLINE_XEN_DEFAULT="dom0_mem=256M"' >> /etc/default/grub
+ update-grub2
+ ```
+ * DRBD is already installed from the above aptitude command, but still needs configuration. This probably just means doing the following
+
+ ```sh
+ echo drbd minor_count=128 usermode_helper=/bin/true >> /etc/modules
+ ```
+ * Network configuration is replaced by editing /etc/network/interfaces to be
+
+```
+auto xen-br0
+iface xen-br0 inet dhcp
+ bridge_ports eth0
+ bridge_stp off
+ bridge_fd 0
+
+auto eth1
+iface eth1 inet dhcp
+```
+
+ * The lvm device is `/dev/sdb`.
+
+ * Reboot into the xen dom0.
+
+
+# Setting up Ganeti
+
+Distribute Ganeti tarball:
+
+```sh
+make dist
+for host in node{1..3}; do
+ scp ganeti-*.tar.gz root@$host:
+done
+```
+
+Install Ganeti on all nodes:
+
+```sh
+./configure --prefix=/usr --sysconfdir=/etc --localstatedir=/var \
+ --with-os-search-path=/srv/ganeti/os,/usr/share/ganeti/os
+make && make install
+```
+
+For one node in each cluster (node1 in this example):
+
+ * Initalise cluster:
+
+ ```
+ gnt-cluster init -s 192.168.20.1 cluster1
+ ```
+ * Add other nodes to cluster:
+
+ ```
+ gnt-node add -s 192.168.20.2 node2
+ gnt-node add -s 192.168.20.3 node3
+ ```
+ * Configure Xen parameters:
+
+ ```sh
+ # Use initrd
+ gnt-cluster modify -H xen-pvm:initrd_path=/boot/initrd-2.6-xenU
+ # Use correct root device
+ gnt-cluster modify -H xen-pvm:root_path=/dev/xvda1
+ ```
+ * Now, you should be able to create an instance:
+
+ ```
+ gnt-instance add -o debootstrap+default -s 500m -t drbd -n node1:node2 inst1
+ ```
+ * But if you want the instance to get the right IP address from dhcp, look up its MAC address in `gnt-instance info` and add a line to `/etc/dnsmasq.conf`:
+
+ ```
+ dhcp-host=aa:00:00:fe:8a:7f,inst1,192.168.10.101
+ ```
\ No newline at end of file
diff --git a/OSDefinitions.md b/OSDefinitions.md
new file mode 100644
index 0000000..0bdbeab
--- /dev/null
+++ b/OSDefinitions.md
@@ -0,0 +1,55 @@
+[TOC]
+
+# OS Definitions
+
+This is a list of all known Ganeti OS definitions.
+
+You may find some of them included in the Ganeti source code under `examples/os/`. If you have a working OS definition and would like to share it with the Ganeti community, please send us an email on the Ganeti public list, along with a link to your definition, and we will include it in this list.
+
+# OS interface
+
+An OS definition plugs into Ganeti's OS interface and prepares the instance's newly provisioned disk, executing all the required customization operations needed, before Ganeti spawns the instance (with that disk as its first disk). To learn more about the OS interface see the following links:
+
+ * [OS Interface man page](http://docs.ganeti.org/ganeti/master/man/ganeti-os-interface.html)
+ * [OS installation redesign](http://docs.ganeti.org/ganeti/master/html/design-os.html)
+
+# OS definitions list
+
+## ganeti-instance-debootstrap
+
+This is the official sample OS definition provided by the Ganeti team.
+
+Definition's link: http://git.ganeti.org/?p=instance-debootstrap.git;a=summary
+
+## ganeti-instance-image
+
+From the official site:
+Ganeti Instance Image is guest OS definition for Ganeti that uses either filesystem dumps or tar ball images to deploy instances. The goal of this OS definition is to allow fast and flexible installation of instances without the need for external tools such as debootstrap. It was originally based on ganeti-instance-debootstrap.
+
+Definition's link: https://code.osuosl.org/projects/ganeti-image
+
+## ganeti-os-defs
+
+From the official site:
+In a few words this package contain 2 OS definition to handle fully (KVM and XEN) virtualized Windows and Linux machines:
+
+ * linux-image -> definition to handle fully virtualized Linux systems.
+ * raw-image -> definition to handle fully virtualized machines (such as Windows).
+
+Definition's link: http://sourceforge.net/p/ganeti-os-defs/home/Home/
+
+## snf-image
+
+From the official site:
+snf-image is a Ganeti OS definition. It allows Ganeti to launch instances from predefined or untrusted custom Images. The whole process of deploying an Image onto the block device, as provided by Ganeti, is done in complete isolation from the physical host, enhancing robustness and security.
+snf-image supports KVM and Xen based Ganeti clusters.
+
+snf-image is an advanced OS definition that runs all customization tasks (e.g., setting passwords, injecting files, setting hostnames) inside a virtualized environment (helper VM) for maximum security. It is designed, implemented and maintained by the [Synnefo](http://www.synnefo.org) team and officially supports the following guest OSes:
+
+ * **Linux:** Debian, Ubuntu/Kubuntu, CentOS, Fedora, OpenSUSE
+ * **Windows:** Windows 2008 R2 (on Google Code), Windows 2012
+ * **BSD:** FreeBSD, NetBSD, OpenBSD
+
+snf-image also supports all images created with the [snf-image-creator](http://www.synnefo.org/docs/snf-image-creator/latest/) tool.
+
+Definition's link: http://www.synnefo.org/docs/snf-image/latest/
\ No newline at end of file
diff --git a/PerformanceTuning.md b/PerformanceTuning.md
new file mode 100644
index 0000000..fcedc24
--- /dev/null
+++ b/PerformanceTuning.md
@@ -0,0 +1,99 @@
+[TOC]
+
+# Performance Tuning
+
+This is work in progress, to be peer reviewed.
+
+(Initial document based on 1 experience and based on some disparate notes. Don't just apply these settings without extensive testing!)
+
+This page should evolve to a best practice guide on how to tune different parts of a ganeti cluster, for better performance.
+
+# KVM
+
+## Host CPU
+
+Passes the Host CPU through to the VM, allowing the VM to use all the
+features the host CPU has, speeding up certain workloads (like using aes-ni for faster crypto).
+
+```bash
+gnt-cluster modify -H kvm:cpu_type=host # entire cluster
+gnt-instance modify -H cpu_type=host [vm] # single VM
+```
+
+In case that your cluster has nodes with different CPUs, note that a live migration between two different CPU types could crash the instance. Ganeti will not warn you about this at the moment, so you will have to handle the migrations between such nodes yourself. Although Ganeti could provide support for this in the future, it does not at the moment. See [issue 895](https://code.google.com/p/ganeti/issues/detail?id=895).
+
+## KSM
+
+KSM periodically merges same memory pages, increasing the amount of available memory. While Ganeti does not explicitly support KSM or account for memory oversubscription, KSM can be used to relieve memory pressure.
+
+To activate:
+
+```bash
+echo 1 > /sys/kernel/mm/ksm/run
+echo 100 > /sys/kernel/mm/ksm/sleep_millisecs
+```
+
+To check status:
+
+```bash
+grep "" /sys/kernel/mm/ksm/*
+> /sys/kernel/mm/ksm/full_scans:203
+> /sys/kernel/mm/ksm/pages_shared:769324
+> /sys/kernel/mm/ksm/pages_sharing:1510361
+> /sys/kernel/mm/ksm/pages_to_scan:100
+> /sys/kernel/mm/ksm/pages_unshared:4712835
+> /sys/kernel/mm/ksm/pages_volatile:602177
+> /sys/kernel/mm/ksm/run:1
+> /sys/kernel/mm/ksm/sleep_millisecs:20
+```
+
+# DRBD
+See also [issue 57](https://code.google.com/p/ganeti/issues/detail?id=57)
+
+## Latency tuning
+As per http://www.drbd.org/users-guide/s-latency-tuning.html:
+
+ 1. Use a dedicated NIC for DRBD replication and configure jumbo frames: set the MTU on that interface as high as possible 7200-9000 -
+ 2. Use the deadline scheduler on the disks used as PVs for the Volume Group(s) used by DRBD
+
+```bash
+gnt-cluster command aptitude install sysfsutils
+cat <<EOF >>/etc/sysfs.conf
+block/sda/queue/scheduler = deadline
+block/sda/queue/iosched/front_merges = 0
+block/sda/queue/iosched/read_expire = 150
+block/sda/queue/iosched/write_expire = 1500
+EOF
+gnt-cluster copyfile /etc/sysfs.conf
+gnt-cluster command /etc/init.d/sysfsutils restart
+
+cat <<EOF >> /etc/sysctl.d/60-drbd-tuning.conf
+# Increase "minimum" (and default)
+# tcp buffer to increase the chance to make progress in IO via tcp,
+# even under memory pressure.
+# These numbers need to be confirmed - probably a bad example.
+#net.ipv4.tcp_rmem = 131072 131072 10485760
+#net.ipv4.tcp_wmem = 131072 131072 10485760
+# reduce water levels to start marketing background (and foreground)
+# write back early. Reduces the chance of resource starvation.
+#vm.dirty_ratio = 10
+#vm.dirty_background_ratio = 4
+EOF
+gnt-cluster copyfile /etc/sysctl.d/60-drbd-tuning.conf
+gnt-cluster command "cat /etc/sysctl.d/*.conf /etc/sysctl.conf | sysctl -p -"
+```
+
+# Networking
+
+Lari Hotari reported on the list that to fix a network performance problem he added the following lines to the intefaces file:
+
+```bash
+pre-up /sbin/ethtool --offload br0 gso off tso off sg off gro off
+pre-up /sbin/ethtool --offload eth0 gso off tso off sg off gro off
+```
+
+(where br0 is the instance bridge, and eth0 the physical network interface).
+
+Reference: [RHEL Virtualization Host Configuration](https://access.redhat.com/knowledge/docs/en-US/Red_Hat_Enterprise_Linux/6/html/Virtualization_Host_Configuration_and_Guest_Installation_Guide/ch10s04.html)
+
+This should apply to both KVM and Xen.
\ No newline at end of file
diff --git a/PhysicalToVirtual.md b/PhysicalToVirtual.md
new file mode 100644
index 0000000..223a8c1
--- /dev/null
+++ b/PhysicalToVirtual.md
@@ -0,0 +1,122 @@
+[TOC]
+
+# Physical to Virtual
+
+ganeti-p2v-transfer is a tool for converting a physical computer into a Ganeti instance. It consists of two parts, a Ganeti instance OS template that allows the instance to be booted to receive the files, and a script that is run on the source machine to make the transfer.
+
+# Requirements
+
+The following external programs are used by this package:
+
+ * [paramiko](http://www.lag.net/paramiko/) is needed on the transfer OS (live image booted on the source machine) for making SSH connections
+ * [pymox](http://code.google.com/p/pymox/) is required to run the unit tests (make check)
+ * [rst2html, from docutils](http://docutils.sourceforge.net/) is needed to build the HTML documentation (make doc)
+
+# Installation
+Determine location of OS template directory configured into Ganeti.
+
+> Short version: If Ganeti was built from source, this is probably `/srv/ganeti/os` only. If Ganeti was installed from a package, `/usr/share/ganeti/os` should be included, so the `--with-os-dir` parameter can be omitted below.
+
+> Long version: Look for "OS Search Path" in the output of `gnt-cluster info`. If not there, look for a variable named `OS_SEARCH_PATH` in `_autoconf.py` in the installed Ganeti files (e.g. `/usr/lib/python2.4/site-packages/ganeti/_autoconf.py`).
+
+> Using the template directory location for `$OS_PATH`, distribute and install the package on the cluster:
+
+```bash
+gnt-cluster copyfile /root/ganeti-p2v-transfer-0.1.tar.gz
+gnt-cluster command "tar xf ganeti-p2v-transfer-0.1.tar.gz &&
+ cd ganeti-p2v-transfer-0.1 &&
+ ./configure --prefix=/usr --localstatedir=/var \
+ --sysconfdir=/etc \
+ --with-os-dir=$OS_PATH &&
+ make install-target"
+```
+
+Configure bootstrap OS
+
+> Edit `/etc/ganeti/instance-p2v-target/p2v-target.conf` to uncomment the appropriate value of `EXTRA_PKGS`. Depending on your setup, you may need to change other values as well. The file `doc/README.debootstrap.html` has more details.
+
+> Copy the edited file to all nodes:
+
+```
+gnt-cluster copyfile /etc/ganeti/instance-p2v-target/p2v-target.conf
+```
+
+Generate bootstrap initrd.
+
+> The bootstrap OS must be started with a specialized initrd that moves all files into RAM before finishing the boot. Create this initrd by running:
+```
+sudo make_ramboot_initrd.py -V $DEB_KERNEL
+```
+> on the master node, where `DEB_KERNEL` is the name of a kernel that can be used to boot a debootstrap instance. That is, if the filename of the kernel is `/boot/vmlinuz-2.6.32-generic`, `DEB_KERNEL` would be `2.6.32-generic`. This command should create the file `/boot/initrd.img-${DEB_KERNEL-ramboot`. Copy this file to the other nodes with:
+
+```bash
+gnt-cluster copyfile /boot/initrd.img-${DEB_KERNEL}-ramboot
+```
+
+Create login keypair
+
+> Users will authenticate to their instances using an SSH keypair generated in advance by the administrator. The public key will be installed into root's `.ssh/authorized_keys` file on the instance, and the private key will be provided to the user so that they can make the transfer. Generate the keys, with no passphrase, using the commands:
+
+```bash
+ssh-keygen -t dsa -N "" -f /etc/ganeti/instance-p2v-target/id_dsa
+gnt-cluster copyfile /etc/ganeti/instance-p2v-target/id_dsa.pub
+```
+> Keep the private key (`/etc/ganeti/instance-p2v-target/id_dsa`) somewhere safe, and give it to users who wish to use the P2V system.
+
+# Workflow
+
+Administrator: create target instance
+
+> Create an instance with the `p2v-target+default` OS and whatever parameters you need. The default kernel and initrd of the instance should be ones that are both compatible with and installed on the source OS. Also pass the `--no-start` flag, because we want to use the specially generated initrd for the boot rather than the default one.
+
+```bash
+gnt-instance add -t<template> -s<size> -o p2v-target+default \
+ -n<nodes> --no-start <hostname>
+```
+> Now boot the instance using the bootstrap kernel and initrd:
+
+```bash
+gnt-instance start -H kernel_path=/boot/vmlinuz-$DEB_KERNEL,\
+ initrd_path=/boot/initrd.img-$DEB_KERNEL-ramboot <hostname>
+```
+
+User: Start the transfer
+
+> Before you begin, you will need the private key corresponding to the public key installed on the instance. Your administrator will provide this to you.
+
+> Boot the source machine from a LiveCD or PXE image. Extract the `ganeti-p2v-transfer` tarball and run:
+
+```bash
+./configure -prefix=/usr --localstatedir=/var \
+ --sysconfdir=/etc
+sudo make install-source
+```
+> This will install the `p2v_transfer.py` script. The script requires the following arguments:
+
+ * `root_dev`: the device file for the disk on which the root filesystem of the source machine is stored
+ * `target_host`: the hostname or IP address of the instance to receive the transfer
+ * `private_key`: the private key obtained from the administrator
+
+> Run the script, and your data will be transferred:
+
+```bash
+sudo p2v_transfer.py $root_dev $target_host $private_key
+```
+
+> When the transfer finishes, the script will shut down the instance. When the Ganeti watcher restarts it, log in and make sure that everything works.
+
+# Troubleshooting
+
+## Bootstrap OS does not boot properly
+
+These instructions suggest building the initrd on a node, for convenience. However, it is possible that there are incompatibilities between the initramfs-tools installed on the node and the kernel that will be used for the bootstrap OS. In this case, the bootstrap OS may not boot, or may not be able to find the root device. If this happens, a good way to improve compatibility is to use a machine that is already running the instance kernel, perhaps a "normal" (non-p2v) instance on the same cluster. Install and run `make_ramboot_initrd.py` on this machine to generate the desired initrd.
+
+Another possibility is that the bootstrap OS does not have enough RAM to complete its boot. Since the bootstrap OS must be copied entirely into RAM, instances with small memory sizes are not supported. I have had good luck using 768MB of instance memory.
+
+## No such script: /usr/share/debootstrap/scripts/squeeze
+
+The version of debootstrap installed on the nodes may not be recent enough to support installing squeeze. Try changing the `SUITE` variable in `/etc/ganeti/instance-p2v-target/p2v-target.conf` to something older:
+
+```bash
+SUITE="lenny"
+```
\ No newline at end of file
diff --git a/Publications.md b/Publications.md
new file mode 100644
index 0000000..6af73ae
--- /dev/null
+++ b/Publications.md
@@ -0,0 +1,37 @@
+# Ganeti Publications
+
+As part of the open source community, the Ganeti Engineering Teams frequently speaks at conferences and publishes material in journals/magazines/etc. Below is a list of previous and upcoming publications of the Ganeti project.
+
+# List of talks and publications
+
+ * Ganeticon 2015: [slides](http://ganeticon.org/)
+ * Ganeticon 2014: [slides](https://sites.google.com/site/ganeticon/home/ganeticon2014?pli=1)
+ * FrOSCon 2014: [slides](http://downloads.ganeti.org/presentations/froscon-2014.pdf), [recording](http://cdn.media.ccc.de/events/froscon/2014/mp4/froscon2014-1303-EN-Ganeti_h264-hq.mp4)
+ * Linuxtag 2014: [slides](http://downloads.ganeti.org/presentations/linuxtag-2014.tar), [recording](http://video.fosdem.org/2014/UD2120_Chavanne/Sunday/Ganeti_the_NewArcane.webm)
+ * FOSDEM 2014: [slides](http://downloads.ganeti.org/presentations/fosdem-2014.tar)
+ * LISA 2013: [slides](https://code.google.com/p/ganeti/downloads/detail?name=lisa-2013-ganeti.tar#makechanges), no recording
+ * LinuxCon/CloudOpen Europe 2013: [slides](http://events.linuxfoundation.org/sites/events/files/slides/LinuxCon.pdf), [video](http://www.youtube.com/watch?v=v0NpwjXEvyQ)
+ * LinuxCon North America: 2013 [slides](http://people.debian.org/~ultrotter/talks/20130917_linuxconna13/ganeti_talk.html)
+ * Ganeticon 2013: [website](https://sites.google.com/site/ganeticon/)
+ * FrOSCon 8/2013: [slides](https://code.google.com/p/ganeti/downloads/detail?name=froscon2013.pdf#makechanges)
+ * LinuxCon Japan 2013: [slides](http://people.debian.org/~ultrotter/talks/20130531_linuxconjp13/ganeti_talk.html), no recording
+ * FOSDEM 2013: [slides](http://people.debian.org/~ultrotter/talks/20130202_fosdem13/ganeti_talk.html), no recording
+ * LISA 2012 talk: [recording](https://www.usenix.org/conference/lisa12/ganeti-your-private-virtualization-cloud-way-google-does-it)
+ * LISA 2012 tutorial: [slides](http://people.debian.org/~ultrotter/talks/20121208_lisa12tutorial/), no public recording
+ * FISL 2012: [recording](http://hemingway.softwarelivre.org/fisl13/high/40t/sala40t-high-201207281400.ogg)
+ * FOSDEM 2012 virt: [slides](http://people.debian.org/~ultrotter/talks/20120205_fosdem12virt/), no recording
+ * FOSDEM 2012 main: [of the code we always have e0205_fosdem12main/ slides](http://people.debian.org/~ultrotter/talks/2012nt), [recording](http://video.fosdem.org/2012/maintracks/janson/ganeti.webm)
+ * Debconf 2012: [recording](http://meetings-archive.debian.net/pub/debian-meetings/2012/debconf12/high/854_Ganeti_how_you_can_use_it_+_how_we_did_it.ogv)
+ * LinuxCon 2011: [slides](http://events.linuxfoundation.org/archive/2011/linuxcon-europe/trotter)
+ * Xen Summit 2011: [slides](https://code.google.com/p/ganeti/downloads/detail?name=XenAtGoogle2011.pdf&can=2&q=)
+ * FISL 2010: [slides](https://ganeti.googlecode.com/files/ganeti-evolution-2010.pdf)
+ * Xen Summit 2008: [slides](https://code.google.com/p/ganeti/downloads/detail?name=Ganeti_XenSummit_Asia_2008.pdf&can=2&q=)
+ * FISL 2008: [recording](http://www.youtube.com/watch?v=GcyNBVbV2JI)
+ * LISA 2007: [recording](http://static.usenix.org/media/events/lisa07/tech/mp3/trotter.mp3)
+
+
+# Planned talks
+
+Upcoming talks to be posted here.
+
+ * (currently none)
\ No newline at end of file
diff --git a/QA.md b/QA.md
new file mode 100644
index 0000000..7327243
--- /dev/null
+++ b/QA.md
@@ -0,0 +1,68 @@
+[TOC]
+
+# Ganeti QA
+
+Testing Ganeti is done by unit tests and by QA. On this wikipage, we document our QA design and setup.
+
+You can run QA on our public [BuildBot](BuildBot.md) setup or on your own test cluster. (TODO: document that).
+
+# Adding Code to QA
+
+The QA scripts can and should be extend when functionality of Ganeti grows. The QA scripts reside in the `qa` directory in the repository. Consider the following steps:
+
+ * Add a new QA script or edit an existing one. Make sure it is called in `ganeti-qa.py`.
+ * If necessary, add new configuration data to the qa-sample.json file. Be aware that this is not the configuration file that is used to actually run the QA on the QA machines, for that you need to change the machine's configuration.
+ * If you add a new qa file `qa_something.py`, don't forget to add it to the `Makefile.in` and run `make pylint-qa` to lint your changes.
+ * If you don't intend to change the QA machines' configuration, but you want to test your code on the QA machines, temporarily enable your tests unconditionally (thus invoking them with `RunTest(...)` instead of `RunTestIf(...)`. Of course, in this case your scripts must use some reasonable defaults, since no (new) configuration is available.
+ * If you added some new QA think about the cleanliness assumptions the test makes, and in which way it might leave traces in case of failure.
+
+# Design ideas
+
+These are a couple of ideas that stand behind QA. Try to comply to them when you extend the QA scripts. If you think, there should be more here, feel free to extend the list.
+
+## General ideas
+
+ * The main idea of QA is to run commands on an actual cluster.
+ * The output of the `gnt-xxx` info commands is in YAML, which makes it easy to parse and check the outcome of the tests.
+
+## Files and their purposes
+
+The QA files and their purposes:
+
+ * `ganeti-qa`, main script to run the QA
+ * `qa_entity` for the various entities of a cluster, like `qa_node`, `qa_instance`
+ * `qa_config` contains utility functions to deal with the QA config
+ * `qa_error` contains definitions of exceptions
+ * `qa_util` contains various helper functions
+
+The QA scripts should depend as little as possible on the Ganeti code. This is not strictly the case right now, since we are dependent on `constants.py` for example, but generally we should try to not add more dependencies.
+
+The different `qa_entity` scripts should not depend on each other. If you have a test that covers more than one entity, you should add this test to the main `ganeti-qa` script.
+
+## Ramp-up and clean-up
+
+ * Right now, a cluster is only created once per QA run and then all tests are run on it. That is no reason to not add more tests for `gnt-cluster init`.
+ * Each test should leave the cluster in the state that it was before the test. Make sure you clean up after yourself. (Currently, there is no function to test this, see [issue 453](http://code.google.com/p/ganeti/issues/detail?id=453) for that.)
+ * Consider running and checking `cluster verify` at the end of each test.
+
+## Test selection
+
+ * Keep in mind that every additional test prolongs the total time QA takes to run.
+ * Make it possible to dis/enable your tests via the config file.
+ * When adding a new parameter to the config file, make up your mind whether or not it should run on which QA setup. Don't forget to update our QA machine's config files if necessary.
+ * It is the test's responsibility to check if it actually makes sense to run. For example if a test makes only sense on drbd instances, it should not run for any other disk template.
+
+## Node and Instance allocation
+
+`qa_config` contains various utility functions to deal with the configuration of the QA.
+
+In particular, it provides functions to acquire nodes and instances.
+
+ * Note that acquired nodes are not marked as busy, thus it is possible to acquire the same node more than once. The idea is just to have some kind of load balancing on the QA nodes to not run all tests on one node and let the others idle.
+ * Note that acquired instances are busy and cannot be acquired by other tests.
+
+## Sets of tests
+
+Most of the tests are single steps in the QA run, except for the instance loop, which loops over a set of disk templates and tests various instance tests on each of those instances.
+
+All the tests enabled in the configuration file are run. If some test is not supported (eg, it doesn't make sense or it's broken), it's the responsibility of the single test to check if the cluster/instance state makes sense for the test or return early. `qa_instance.py` and `qa_config.py` contain helper functions that simplify checking for such conditions, e.g., `IsFailoverSupported`, `IsMigrationSupported` in the former, and `IsTemplateSupported` in the latter.
\ No newline at end of file
diff --git a/ReleaseProcess.md b/ReleaseProcess.md
new file mode 100644
index 0000000..e000fc4
--- /dev/null
+++ b/ReleaseProcess.md
@@ -0,0 +1,148 @@
+[TOC]
+
+# Ganeti Release Process
+
+This is the recommended procedure to perform a new Ganeti release.
+
+# Create a new `stable-*` branch
+
+Releases are performed on stable branches (they are usually named stable-X.Y). In order to create a release, you must have the corresponding stable branch in place to prepare the release. Before releasing, check that all the features and bug fixes that need to be released are present in the correct stable branch. If any features or bug fixes are missing, perform the appropriate merges or cherry-picks.
+
+The steps to create this branch are as follows (we assume that `${BRANCH_VERSION}` holds the new version like `2.10`):
+
+ 1. Prepare and stabilize the master branch such that all tests and QA run through for the commit upon which you want to the branch to be based.
+ 2. Create the stable branch locally:
+
+ ```bash
+ git checkout -b stable-${BRANCH_VERSION}
+ ```
+ 3. Verify that the new branch points at the correct commit (the commit which passed tests and doclint):
+
+ ```bash
+ git show --oneline -s stable-${BRANCH_VERSION}
+ ```
+ 4. Have someone review the branch:
+
+ ```bash
+ git push -u --dry-run origin stable-${BRANCH_VERSION}
+ ```
+ 5. Push the branch with the previous command, but omitting `--dry-run`.
+ 6. Adapt buildbot configurations such that they also build and test the newly created branch. You most likely will need to touch the `master.cfg` and the `json` files of the upgrade tests, creating a new one for the new upgrade step. [Example patch](https://groups.google.com/forum/#!search/$20Adding$20new$20branch$202.11$20to$20buildbot/ganeti-devel/xjhxhvmcA8M/xh1zVZ2gKYIJ) Be aware of different buildbot installations!
+ 7. On master, bump version to the new development version and make sure that `cfgupgrade --downgrade` is a no-op. Note that you would need to add new fields to the new config file `cluster_config-....json` depending on which were added in this version. It is unknown where to get this information from, running `cfgupgrade` on the old one will help or asking your beloved team mates. [Example patch](https://groups.google.com/forum/#!search/%22Prepare$20master$20branch$20for$202.11$20devel$20cycle%22/ganeti-devel/-YNt_nPr0fk/vYmA9jEN7uoJ)
+ 8. On the new stable branch, prepare the release as described below.
+
+
+# Prerequisites
+
+ * Code conforms to the [Ganeti Python style guide](StyleGuide.md). (Adherence to the style guide should be checked during CL reviews.)
+ * There are no high or critical priority bugs in the [Ganeti issue tracker](https://code.google.com/p/ganeti/issues/list). Filter for `Milestone=Release2.11 Type=Defect -status:Fixed`
+ * All commits from the previous stable branch are merged into the version to be released.
+ * Included documentation, readme files, and comments reflect the version to be released (for reference, see commits b830193c2, efe2137a, aff49a15a7).
+ * Make sure that a `doc/design-_version_.rst` file exists (and is linked to from `doc/index.rst`), and that it contains all the design documents implemented or partially implemented in the current version. You must also remove the completely implemented designs from `doc/design-draft.rst`. **Troubleshooting**: If you receive complaints about a file design file that is only linked in a `doc/design-_version_.rst` file which is not present in any TOC, add that file to `doc/index.rst`, in the _hidden_ section.
+ * Make sure that the content is up to date and change the version number in the following locations:
+
+ * `README`
+ * `doc/design-draft.rst`
+ * `doc/hooks.rst`
+ * `doc/iallocator.rst`
+ * `doc/security.rst`
+ * `doc/virtual-cluster.rst`
+ * `cabal/ganeti.template.cabal`
+ * The `NEWS` file is updated.
+ * Unit tests and checks (`make commit-check`) from a pristine checkout do not fail:
+
+ ```bash
+ URL=git://git.ganeti.org/ganeti.git devel/release origin/stable-x.y
+ ```
+ * You have run the test that requires root permissions. Doing so requires having the (optional) `fakeroot` dependency installed.
+ * Burnin has been run for all hypervisor and disk types.
+ * QA suite passes.
+ * Before a release candidate, you made sure that:
+ * The installation guide has been verified and tested. Ganeti must be able to be built with only the minimum required dependencies. You can test this, by setting up a (virtual) machine with a minimal debian (for example netinstall) installed. Then go through the `INSTALL` file, install only the packages described as mandatory and follow the installation instructions.
+ * The upgrade/downgrade procedure has been tested. As the very least:
+ 1. Create an empty cluster with the previous stable version.
+ 2. Add an instance.
+ 3. Upgrade to the version to be released.
+ 4. Check that everything works as expected.
+ 5. Add a new instance.
+ 6. Downgrade to the previous version.
+ 7. Check that everything works.
+ * You compared the .tar.gz obtained with `md5sum <tar_gz_package>./autogen.sh && ./configure && make dist` from a pristine checkout of the code to the .tar.gz of the previous release, and made sure that only expected modifications happened. The [Tardiff](http://tardiff.coolprojects.org/) tool can be handy for this comparison.
+ * You compared the installed files of the new release to installed files of the previous stable release, and made sure that only expected modifications happened. You can compare these files by doing the following:
+ 1. Run the following command for the previous version:
+
+ ```bash
+ ./configure && make && make install DESTDIR=/tmp/ganetiA
+ ```
+
+ 2. Run the following command for the current version:
+
+ ```bash
+ ./configure && make && make install DESTDIR=/tmp/ganetiB
+ ```
+
+ 3. Compare both versions by running:
+
+ ```bash
+ diff -rq /tmp/ganetiA /tmp/ganetiB | grep -v ^Files.*differ$
+ ```
+
+Note that you will get lots of messages like the following:
+
+```
+diff: /tmp/ganeti210/usr/local/share/man/man8/gnt-network.8: No such file or directory
+diff: /tmp/ganeti211/usr/local/share/man/man8/gnt-network.8: No such file or directory
+diff: /tmp/ganeti210/usr/local/share/man/man8/gnt-node.8: No such file or directory
+diff: /tmp/ganeti211/usr/local/share/man/man8/gnt-node.8: No such file or directory
+```
+
+This is expected behavior since there are symlinks that currently point to nirvana due to the `$DESTDIR`.
+
+
+# Prepare the release
+ 1. If you haven't already, update `configure.ac` with the new version.
+ 2. Update the NEWS file with release date.
+ 3. Run `make distcheck` again.
+ 4. Set the environment variable for tag:
+
+ ```bash
+ gnt_major=$(cat configure.ac | grep -o -E 'gnt_version_major.*\[[0-9]+\]' | grep -E -o '[0-9]+'); \
+ gnt_minor=$(cat configure.ac | grep -o -E 'gnt_version_minor.*\[[0-9]+\]' | grep -E -o '[0-9]+'); \
+ gnt_revision=$(cat configure.ac | grep -o -E 'gnt_version_revision.*\[[0-9]+\]' | grep -E -o '[0-9]+'); \
+ gnt_suffix=$(cat configure.ac | grep '\[gnt_version_suffix\]' | sed 's/.*\[.*\].*\[\(.*\)\].*/\1/g'); \
+ gnt_version="${gnt_major}.${gnt_minor}.${gnt_revision}${gnt_suffix}"; \
+ gnt_version_tag=$(echo $gnt_version | tr -d '~'); \
+ echo "Version '$gnt_version', tag 'v$gnt_version_tag'"
+ ```
+ 5. Create the release tag signed by the Ganeti release key.
+
+ ```bash
+ git tag -s -m "Release version $gnt_version_tag" "v$gnt_version_tag"
+ git show "v$gnt_version_tag"
+ ```
+ 6. Check the tag (with `--dry-run`), and then push it (removing `--dry-run`):
+
+ ```bash
+ git push --tags --dry-run
+ ```
+ 7. Create an archive from tag:
+
+ ```
+ URL=git://git.ganeti.org/ganeti.git devel/release v$gnt_version_tag
+ ```
+ 8. Upload the `.tar.gz` archive and (if needed) upload the documentation files to [downloads.ganeti.org](http://downloads.ganeti.org/). Releases must be signed, and the signature must be uploaded.
+ * To sign (on the machine containing the signature key):
+ 1. `gpg --detach-sign <tar_gz_package>`
+ 2. `gpg --verify <signaturefile> <tar_gz_package>`
+ * To create the checksum files:
+ 3. `md5sum <tar_gz_package> > <tar_gz_package>.md5sum`
+ 4. `sha1sum <tar_gz_package> > <tar_gz_package>.sha1sum`
+ 9. Remove the temporary dir used for creating the archive.
+ 10. Send the release announcement to [ganeti@googlegroups.com](mailto:ganeti@googlegroups.com).
+ 11. Update the topic on [irc://irc.freenode.net/ganeti](irc://irc.freenode.net/ganeti).
+ 12. Only for stable releases: Mark all fixed bugs with this branch as release target as released.
+
+# Notes
+
+ * All changes must be reviewed and committed as usual.
+ * Tagging cannot be reviewed, so have someone else review what you're doing.
\ No newline at end of file
diff --git a/SecurityAdvisories.md b/SecurityAdvisories.md
new file mode 100644
index 0000000..ef77bde
--- /dev/null
+++ b/SecurityAdvisories.md
@@ -0,0 +1,42 @@
+# Ganeti Security Advisories
+
+# RAPI DoS and DRBD secret leak vulnerability
+
+Text available at:
+https://groups.google.com/forum/#!topic/ganeti/9bLyzwmmvdg
+
+Advisory available at:
+http://www.ocert.org/advisories/ocert-2015-012.html
+
+
+# Ganeti Config Archive Vulnerability
+
+Published 2014-08-12
+
+Ganeti, an open source virtualisation manager, suffered from an insecure file permission vulnerability that leads to sensitive information disclosure. This issue was fixed with versions 2.10.7 and 2.11.5.
+
+The Ganeti upgrade command ‘gnt-cluster upgrade’ creates an archive of the current configuration of the cluster (e.g. the contents of `/var/lib/ganeti`). The archive is named following the pattern `ganeti*.tar` and is written to `/var/lib/`. Such archives were written with too lax permissions that made it possible to read them as unprivileged user, on the master node.
+
+The configuration archive contains sensitive information, including SSL keys for the inter-node communication via RPC as well as the credentials for the remote API (RAPI). Such information can be used to control various operations of the cluster, including shutting down and removing instances and nodes from the cluster, or assuming the identity of the cluster in a MITM attack.
+
+This vulnerability only affects Ganeti clusters meeting the following criteria:
+
+ * The cluster is running Ganeti version 2.10.0 or higher.
+ * The upgrade command was run, for example when upgrading from 2.10 to 2.11.
+ * Unprivileged users have access to the host machines and in particular to the cluster master node.
+
+With the fixed release, the upgrade command will set the permissions of the archives properly. However, in case previous versions have created an unsafe archive already, the following mitigations are advised:
+
+ * Remove the access to the archive for unprivileged users (for example by running `chmod 400 /var/lib/ganeti*.tar`).
+ * Renew the SSL keys by running `gnt-cluster renew-crypto`. You may need to pass the `--new-cluster-certificate`, `--new-confd-hmac-key`, `--new-rapi-certificate`, `--new-spice-certificate`, `--new-cluster-domain-secret` flags, and (for version 2.11 only) the `--new-node-certificates` flag.
+ * Renew the RAPI credentials by editing the `/var/lib/ganeti/rapi_users` file.
+ * Update RAPI, confd and other clients with the new secrets and certificates, if applicable.
+ * Look for any other information regarded as secret in /var/lib/ganeti and change it. For example VNC and SPICE passwords are not by default kept there, but could, if Ganeti is so configured.
+
+This vulnerability will be published as oCert-2014-006 on ocert.org; CVE ID is pending. Thanks to Apollon Oikonomopoulos for reporting and fixing this issue.
+
+Affected versions: 2.10.0 - 2.10.6, 2.11.0 - 2.11.4
+
+Fixed versions: 2.10.7, 2.11.5
+
+Filed under: CVE-2014-5247 and http://www.ocert.org/advisories/ocert-2014-006.html
\ No newline at end of file
diff --git a/SourceCode.md b/SourceCode.md
new file mode 100644
index 0000000..24bdcb4
--- /dev/null
+++ b/SourceCode.md
@@ -0,0 +1,25 @@
+# Ganeti Source Code
+
+The source code is hosted at [git.ganeti.org](http://git.ganeti.org/). Currently, there are repositories for
+
+ * Ganeti code itself:
+
+ ```sh
+ git clone git://git.ganeti.org/ganeti.git
+ ```
+ * The instance debootstrap OS definition:
+
+ ```sh
+ git clone git://git.ganeti.org/instance-debootstrap.git
+ ```
+ * The NBMA network support:
+
+ ```sh
+ git clone git://git.ganeti.org/nbma.git
+ ```
+
+ * The wiki repository:
+
+ ```sh
+ git clone https://code.google.com/p/ganeti.wiki/
+ ```
\ No newline at end of file
diff --git a/SummerOfCode2013Ideas.md b/SummerOfCode2013Ideas.md
new file mode 100644
index 0000000..03eb23d
--- /dev/null
+++ b/SummerOfCode2013Ideas.md
@@ -0,0 +1,201 @@
+[TOC]
+
+# Summer of Code 2013 Ideas
+
+Ganeti applyed to be a hosting organization for GSoC 2013. This document outlines our ideas.
+
+# Better openvswitch Ganeti support
+
+Objectives:
+
+* Support for openvswitch features on the instance NICs (dynamic vlan configuration, bandwidth control)
+* Openvswitch clustering and tunneling: self configuration, system level networks
+
+Benefits:
+
+* Update Ganeti to support more scalable networking
+* Make it easy to administer an openvswitch installation inside Ganeti
+* Allow inter-vm communication (when requested) without explicit support in the switches config
+
+Requirements:
+
+* Interest in distributed systems and networking
+* Knowledge of Python and Haskell
+* Ability to write high quality code, tests and QA
+* Ability to interact with Ganeti and Openvswitch developers
+* Access to multiple machines (or VMs) to test the project and run QA
+
+# Dynamic networking
+
+Objectives:
+
+* Possibility to use a network interface name instead of an IP address for VNC/spice bind addresses, and for secondary ip
+* Network interfaces (bridges, routes, etc) dynamically configured and unconfigured on nodes as needed by instances
+
+Benefits:
+
+* Increase scalability and ease of configuration
+* Make network configuration more customizable
+* Make network configuration easier to maintain
+
+Requirements:
+
+* Interest in distributed systems and networking
+* Knowledge of Python and Haskell
+* Ability to write high quality code, tests and QA
+* Ability to interact with Ganeti developers and other summer of code students (may interact with the idea above)
+* Access to multiple machines (or VMs) to test the project and run QA
+
+# VDE Ganeti support
+
+Objectives:
+
+* Support for [http://wiki.virtualsquare.org/wiki/index.php/VDE_Basic_Networking VDE] as a possible instance nic
+* Automatically configure a VDE network between Ganeti nodes for instances
+* Support kvm instances with VDE userspace network backends
+
+Benefits:
+
+* Reduce the number of privileges Ganeti requires to run (opening the space to run as non-root)
+* Make it easy to test new network configurations in userspace
+
+Requirements:
+
+* Interest in distributed systems and networking
+* Knowledge of Python and Haskell
+* Ability to write high quality code, tests and QA
+* Ability to interact with Ganeti developers and other summer of code students (may interact with the ideas above)
+* Access to multiple machines (or VMs) to test the project and run QA
+
+Notes:
+
+* Probably should be staffed after the two ideas above
+
+
+
+
+# Better RADOS/Ceph Ganeti support
+
+Objectives:
+
+* Support for userspace mode for RADOS+KVM
+* Support for running RADOS on Ganeti nodes (self-configuring of Ganeti nodes as a RADOS backend)
+
+Benefits:
+
+* Make it easier to deploy a RADOS infrastructure with Ganeti
+* Support the better performance and higher resilience of running RADOS in userspace
+
+Requirements:
+
+* Interest in distributed systems and storage
+* Knowledge of Python and Haskell
+* Ability to write high quality code, tests and QA
+* Ability to interact with Ganeti developers and RADOS developers
+* Access to multiple machines (or VMs) to test the project and run QA
+
+
+# GlusterFS Ganeti support
+
+Objectives:
+
+* Add Gluster as a storage backend
+* Add support for userspace gluster in kvm
+* Support for running gluster on Ganeti nodes (self-configuring of Ganeti nodes as a gluster backend)
+
+Benefits:
+
+* Allow users to deploy Ganeti clusters with Gluster
+* Bring Gluster up to speed w.r.t. RADOS and DRBD in support
+
+Requirements:
+
+* Interest in distributed systems and storage
+* Knowledge of Python and Haskell
+* Ability to write high quality code, tests and QA
+* Ability to interact with Ganeti developers and RADOS developers
+* Access to multiple machines (or VMs) to test the project and run QA
+
+
+# KVM resource constrainment
+
+Objectives:
+
+* `cgroups integration` for more reliable resource constrainment
+* Linux containers integration for better control of what the qemu executable can access
+
+Benefits:
+
+* Better segregation in case of virtualization/qemu breakup
+* Better resource accounting
+
+Requirements:
+
+* Interest in virtualization and security
+* Knowledge of Haskell and Python
+* Ability to write high quality code, tests and QA
+* Ability to interact with Ganeti developers
+- Access to multiple kvm-enabled machines (or VMs) to test the project and run QA
+
+
+# KVM: Hugepages support
+
+Objectives:
+
+* Design a way to support different "memory pools" and fix KVM free memory reporting
+* Handle node hugepage memory correctly in memory reporting
+* Allow to create/start instances on nodes with hugepages without failing for non-hugepages memory accounting
+* Handle the hugepages pool in iallocator/hbal
+* Run benchmarks and report performance of normal instance VS hugepages instance VS THP instance
+
+Benefits:
+
+* Better separation of instance memory and OS memory for KVM
+* Improved performance for hugepages instances
+
+Requirements:
+
+* Interest in virtualization and security
+* Knowledge of Haskell and Python
+* Ability to write high quality code, tests and QA
+* Ability to interact with Ganeti developers
+* Access to multiple kvm-enabled machines to test the project and run QA
+
+
+# Improve linux-HA integration
+
+Objectives:
+
+* Allow Ganeti to automatically set up linux-HA on the cluster
+
+Benefits:
+
+* remove the need for hand-configuration, and make it easy to deploy Ganeti+Linux-HA together
+* add QA of the current linux-HA resources for Ganeti
+* fully enable self-repairing clusters
+
+Requirements:
+
+* Interest in virtualization and security
+* Knowledge of Haskell and Python
+* Ability to write high quality code, tests and QA
+* Ability to interact with Ganeti developers
+* Access to multiple machines in order to thoroughly test the project
+
+# Add Ganeti provider to Vagrant
+
+Objectives:
+* Allow Vagrant to communicate and interact with a Ganeti cluster
+
+Benefits:
+
+* Allow Vagrant users to power their virtual machines via a private Ganeti cloud
+* Gives Vagrant users a testing environment that could scale into the hundreds vms
+* Provides a unified and popular remote command line interface to Ganeti
+
+Requirements:
+
+* Write a Vagrant provider that connects to the Ganeti RAPI which can deploy/connect to a virtual machine
+* Knowledge in Ruby
+* Ability to write high quality code, tests and QA
+* Ability to interact with Ganeti developers
\ No newline at end of file
diff --git a/SummerOfCode2014Ideas.md b/SummerOfCode2014Ideas.md
new file mode 100644
index 0000000..c676159
--- /dev/null
+++ b/SummerOfCode2014Ideas.md
@@ -0,0 +1,86 @@
+[TOC]
+
+# Google Summer of Code 2014
+
+Here are our project ideas for Google Summer of Code 2014
+
+It might be interesting to have a look at [last year's ideas](SummerOfCode2013Ideas.md) as well.
+
+# Project proposals
+
+## Improvements in the monitoring daemon
+(language: Haskell) [design](http://docs.ganeti.org/ganeti/master/html/design-monitoring-agent.html)
+
+ * Implement additional data collectors, for example:
+
+ * [Ganeti daemon status](http://docs.ganeti.org/ganeti/master/html/design-monitoring-agent.html#id13)
+ * [Hypervisor resources report](http://docs.ganeti.org/ganeti/master/html/design-monitoring-agent.html#id14)
+ * [Node OS resources report](http://docs.ganeti.org/ganeti/master/html/design-monitoring-agent.html#id15)
+ * LVM
+ * physical volumes collector
+ * volume groups collector
+ * Ceph or Gluster collectors
+ * Network performance collector
+ * ... and we can consider any other collector you might be interested in
+ * Optimize the currently existing collectors
+ * Implement cache system to decouple between collection and retrieval
+ * Allow different stateful collectors to be queried with different time intervals
+ * Implement plugin interface
+ * Use dynamic memory usage information in hbal/hail
+
+## Improvements to the instance bin-packing tool (hsqueeze)
+(language: Haskell) [design](http://docs.ganeti.org/ganeti/master/html/design-hsqueeze.html)
+
+ * Add -X option to hsqueeze (actually executing the derived packing)
+ * Make hsqueeze use the dynamic CPU data that is now collected thanks to last year's summer of code project
+
+## Configuration daemon
+(language: Haskell)
+[Issue 564: Allow generic queries in ConfD](https://code.google.com/p/ganeti/issues/detail?id=564)
+
+Ganeti confd supports a restrictive set of queries: we'd like to expand its language to be able to query any configuration value from the Ganeti config. Example interesting values could be names and UUIDs for nics and disks, network information, availability of IP addresses in pools.
+
+
+## Improve hypervisor support
+(language: Python)
+
+ * Support for kvm+cgroups for strict resource allocation
+ * Support for kvm+namespaces for added security
+ * Improve linux containers support
+ * Support for hugepages for kvm
+
+## Location awareness
+(language: Haskell)
+
+ * Improve htools (hail, hbal, hsqueeze etc) to provide location awareness, as discussed in GanetiCon.
+ * This would involve modeling better the relationships between different nodes and nodegroups (are they close or far latency-wise? is there a bottleneck?) and instances (which ones are redundancy-ones in a pool? which ones should live close to each other?) to provide better "service-level" allocation instead of simple per-instance one.
+ * This feature would allow to have primary and secondary nodes on different nodegroups, but also to specify which instances should and should not share point of failures (nodegroup, node) as much as possible.
+
+## Improve containers support
+(language: Python)
+
+ * Work with docker.io and LXC to provide strong Ganeti-based Linux containers
+ * Solve container problems like startup, storage, networking, which are different from how traditional VMs work
+
+## KVM resource constrainment
+(language: Python)
+
+Objectives:
+
+ * cgroups integration for more reliable resource constrainment
+ * Linux containers integration for better control of what the qemu executable can access
+
+Benefits:
+
+ * better segregation in case of virtualization/qemu breakup
+ * better resource accounting
+
+## Conversion between disk templates
+(language: Python)
+
+Currently, Ganeti supports only disk conversions between LVM and DRBD. Introduce a generic mechanism to convert between other templates too. This mechanism will need to copy the disks' data for conversion to be possible.
+
+## Authnz support for RAPI
+(language: Python)
+
+Currently the RAPI supports only coarse-grained permissions (read/write). It is easy to implement more fine-grained access control by implementing a pluggable authentication and authorization API. The authentication API will allow authenticating users against different backends, while the authorization API will authorize individual OpCodes before they are submitted to the job queue.
\ No newline at end of file
diff --git a/SummerOfCode2015Ideas.md b/SummerOfCode2015Ideas.md
new file mode 100644
index 0000000..d94af00
--- /dev/null
+++ b/SummerOfCode2015Ideas.md
@@ -0,0 +1,39 @@
+[TOC]
+
+# Google Summer of Code 2015
+
+Here are our project ideas for Google Summer of Code 2015
+
+It might be interesting to have a look at ideas in [2013](SummerOfCode2013Ideas.md) and [2014](SummerOfCode2014Ideas.md).
+
+# Project proposals
+
+## Improvements to the instance bin-packing tool (hsqueeze)
+(language: Haskell) [design](http://docs.ganeti.org/ganeti/master/html/design-hsqueeze.html)
+
+The hsqueeze tool is used to move virtual machines of a cluster to a subset of its physical machines, allowing to powering down the rest of physical machines to conserve energy.
+
+**Task:** Make hsqueeze use the dynamic CPU data that is now collected thanks to previous summer of code projects.
+
+Note: This project is well suited for someone who is already using hsqueeze or who cooperates with an organization that uses it.
+
+## Location awareness
+(language: Haskell) [design](http://docs.ganeti.org/ganeti/2.14/html/design-location.html)
+
+Location awareness allows Ganeti to avoid common physical causes of failures when placing virtual machines on physical nodes.
+
+**Tasks:**
+
+ * Improve the current implementation (i.e., finish implementing the design).
+ * Extends to more aspects of location.
+
+## Monitoring daemon
+(language: Haskell)
+
+The monitoring daemon collects information from physical machines of a Ganeti cluster.
+
+**Tasks:**
+
+ * Implement data collectors for CPU (and maybe memory) usage for Xen-based clusters;
+ * possibly use this information for load-based cluster balancing.
+ * Add an interface for generic plugins that collect arbitrary user-defined data.
\ No newline at end of file
diff --git a/SummerOfCode2016Ideas.md b/SummerOfCode2016Ideas.md
new file mode 100644
index 0000000..b4bf3b4
--- /dev/null
+++ b/SummerOfCode2016Ideas.md
@@ -0,0 +1,29 @@
+[TOC]
+
+# Google Summer of Code 2016
+
+Here are our project ideas for Google Summer of Code 2016
+
+It might be interesting to have a look at ideas in [2015](SummerOfCode2015Ideas.md), [2014](SummerOfCode2014Ideas.md) and [2013](SummerOfCode2013Ideas.md).
+
+# Project proposals
+
+## Optimize balancing speed by accounting for migration speed
+
+hbal usually performs a complex sequence of moves during cluster balancing in order to achieve local optimal cluster state. Unfortunately, some moves may take significant amount of time. In cases where balancing is periodically performed to optimize cluster performance, disk moves can be prohibitively slow (which can be avoided using the `--no-disk-moves` or `--avoid-disk-moves` options). However, instances can be slow to migrate for other reasons, such as a heavily used instance which updates its memory at high speed. Thus, we'd like to have the following features:
+
+ * move/migration time estimation in HTools;
+ * time limits for cluster balancing steps; overall balancing sequence time limit;
+ * an option `--avoid-long-moves` similar to `--avoid-disks-moves`
+
+This project would be based on [the implementation introduced in 2.17](http://docs.ganeti.org/ganeti/2.17/html/design-migration-speed-hbal.html).
+
+## Improve KVM live migration
+
+Live migration on KVM clusters could be improved by adding the following features:
+
+ * Timeouts or live migrations to handle the case of memory being updated faster than it can be copied. If the memory copy isn't completed before that timeout, the VM will be paused and the remainder copied over. This is related to the current migration downtime option, but approaches it from the other end.
+ * Implement KVM postcopy migration support. Refs:
+ * http://wiki.qemu.org/Features/PostCopyLiveMigration
+ * http://grivon.apgrid.org/quick-kvm-migration
+ * https://www.redhat.com/archives/libvir-list/2014-December/msg00093.html
\ No newline at end of file
diff --git a/SystemTemplateWithFAI.md b/SystemTemplateWithFAI.md
new file mode 100644
index 0000000..0052219
--- /dev/null
+++ b/SystemTemplateWithFAI.md
@@ -0,0 +1,93 @@
+[TOC]
+
+# System template with FAI
+
+FAI is a very flexible and pluggable installation framework.
+Apart from being used for network installations in large infrastructures and for building custom installation CDs, it has a "dirinstall" to create a chroot.
+
+This can be a Ganeti disk, too.
+
+Another point for FAI's flexibility: FAI can be used to install systems with many distributions, even a proof of concept for Windows exists.
+
+# Setting up a Ganeti OS template for FAI
+
+Basically, it's just a short patch to run against the "create" script of the default Debian OS template coming with Ganeti.
+
+Just extract the default debian template, copy the full directory (e.g. to the name `fai-os-template`) and replace the file "create" with this code:
+
+```sh
+#!/bin/sh
+
+# Copyright (C) 2007 Google Inc., Henning Sprang - Silpion IT Solutions GmbH
+#
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation; either version 2 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful, but
+# WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+# General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program; if not, write to the Free Software
+# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
+# 02110-1301, USA.
+
+set -e
+
+TEMP=`getopt -o i:b:s: -n '$0' -- "$@"`
+
+if [ $? != 0 ] ; then echo "Terminating..." >&2 ; exit 1 ; fi
+
+# Note the quotes around `$TEMP': they are essential!
+eval set -- "$TEMP"
+
+while true; do
+ case "$1" in
+ -i) instance=$2; shift 2;;
+
+ -b) blockdev=$2; shift 2;;
+
+ -s) swapdev=$2; shift 2;;
+
+ --) shift; break;;
+
+ *) echo "Internal error!"; exit 1;;
+ esac
+done
+if [ -z "$instance" -o -z "$blockdev" -o -z "$swapdev" ]; then
+ echo "Missing -i or -b or -s argument!"
+ exit 1
+fi
+
+mkswap $swapdev
+mke2fs -Fjq $blockdev
+TMPDIR=`mktemp -d` || exit 1
+trap "umount $TMPDIR; rmdir $TMPDIR" EXIT
+mount $blockdev $TMPDIR
+
+fai -N -v -u $instance dirinstall $TMPDIR
+
+# TODO: should go into FAI - XENU-DYNAMIC-NET
+rm -f "$TMPDIR/etc/udev/rules.d/z25_persistent-net.rules"
+
+
+umount $TMPDIR
+rmdir $TMPDIR
+trap - EXIT
+
+exit 0
+```
+
+
+# Configuring FAI
+[FAI](http://www.informatik.uni-koeln.de/fai/) should be installed first before being configured. On Debian and Ubuntu, simply install the package `fai-quickstart`. On other distributions, it's not really tested, just by preference of the developers. But, on the other hand, it should be fairly easy to install, especially if you only want to use the dirinstall feature. If you really find it interesting, the FAI Team will support you to get it running on your favorite distribution.
+
+FAI will do the things you configure it to do. Mainly, classes are configured based on things like a hostname (or many other things), and for each class you can define
+
+ * Which software packages are needed
+ * Which Which configurations they need (based on files to be copied, or edited from defaults)
+
+Giving a full Tutorial about FAI is out of the scope of this document -- see [FAIWiki](http://wiki.fai-project.org) for details, and Henning Sprang's [introductory presentation](http://faiwiki.debian.net/images/7/74/Fai_presentation_extremadura2007.pdf).
\ No newline at end of file
diff --git a/TableOfContents.md b/TableOfContents.md
new file mode 100644
index 0000000..f301c3b
--- /dev/null
+++ b/TableOfContents.md
@@ -0,0 +1,33 @@
+# Table of Contents
+
+## Development process
+- [Buildbot](./BuildBot.md)
+- [Developer guidelines](DeveloperGuidelines.md)
+- [QA](QA.md)
+- [Release process](ReleaseProcess.md)
+
+## Extensions
+- [DRBD device monitoring](DrbdDeviceMonitoring.md)
+- [Ganeti in Vagrant](GanetiInVagrant.md)
+- [Ganeti in Virtualbox](GanetiInVirtualBox.md)
+- [Performance Tuning](PerformanceTuning.md)
+- [Physical to Virtual](PhysicalToVirtual.md)
+- [System template with FAI](SystemTemplateWithFAI.md)
+
+## Plugins
+- [ExtStorage Providers](ExtStorageProviders.md)
+- [OS Definitions](OSDefinitions.md)
+
+## Misc
+- [Common Issues](CommonIssues.md)
+- [Distro status](DistroStatus.md)
+- [Ganeti FAQ](GanetiFAQ.md)
+- [Publications](Publications.md)
+- [2013 Summer of Code ideas](SummerOfCode2013Ideas.md)
+- [2014 Summer of Code ideas](SummerOfCode2014Ideas.md)
+- [2015 Summer of Code ideas](SummerOfCode2015Ideas.md)
+- [2016 Summer of Code ideas](SummerOfCode2016Ideas.md)
+
+---
+
+[Alphabetical index of documentation](.)
\ No newline at end of file
diff --git a/Vcluster.md b/Vcluster.md
new file mode 100644
index 0000000..7a3c5dd
--- /dev/null
+++ b/Vcluster.md
@@ -0,0 +1,172 @@
+[TOC]
+
+# Vcluster
+
+vcluster, meaning "virtual cluster", is a setup where one physical machine pretends to be several Ganeti nodes (by spawning lots of node daemons). It is useful to test stuff which require large clusters to be tested properly.
+
+See the [design doc](http://git.ganeti.org/?p=ganeti.git;a=blob_plain;f=doc/design-virtual-clusters.rst;hb=HEAD) for details.
+
+This wiki page just summarizes the steps that are necessary to set up a vcluster (for example to run a QA) on your own machine.
+
+## Cleaning up previous vclusters
+
+Clean up the remains of previous vclusters:
+
+Delete the vcluster installation files (depends on how you configured the previous installation):
+
+```sh
+rm -rf /srv/ganeti/vcluster/*
+```
+
+Remove network interfaces that might still be there (depends on how you configured them before):
+
+```sh
+ifconfig lo:vcluster:0 down
+ifconfig lo:0 down
+```
+
+## Setting up the machine
+
+Setup the vcluster infrastructure by invoking the `vcluster-setup` tool. It is located in the `ganeti/tools/` directory of your installation. You need to specify the path of the vcluster installation (for example `/srv/ganeti/vcluster`.
+
+```sh
+mkdir -p /srv/ganeti/vcluster/
+[...]/lib/ganeti/tools/vcluster-setup -c 15 -i 9 -n lo:vcluster
+```
+
+The option `-c` enumerates the number of 'virtual' nodes and `-i` the number of instances you intend to use on the vcluster. Make sure that this complies the the configuration of your vcluster QA file. `-n` specifies the name of the network interface. It will be created by the setup, you do not need to set it up yourself.
+
+## The QA config
+
+For a QA to run, you need to configure it with certain limitations. See here some annotated excerpts from a config file:
+
+Name the cluster 'cluster', omit/disregard the rename-name, because renaming does not work on vclusters anyway.
+
+```js
+{
+ "name": "cluster",
+ "#rename": "disabled",
+```
+
+Specify the host name of the physical machine that runs the vcluster and the path where you set up the vcluster.
+
+```js
+ "# Virtual cluster": null,
+ "vcluster-master": "hostname.of.your.machine",
+ "vcluster-basedir": "/srv/ganeti/vcluster",
+```
+
+Specify the following init args so that the QA does not try to edit the /etc/hosts and that drbd-storage is disabled. In newer versions, the option `--no-drbd-storage` needs to be replaced by `--enabled-disk-templates=diskless`.
+
+```js
+ "cluster-init-args": ["--no-etc-hosts", "--no-drbd-storage"],
+
+ "enabled-hypervisors": "fake",
+ "enabled-disk-templates": "diskless",
+```
+
+Various parameters that have shown to be reasonable.
+
+```js
+ "hypervisor-parameters": {},
+ "primary_ip_version": 4,
+
+ "os": "busybox",
+ "mem": "600M",
+ "maxmem": "600M",
+ "minmem": "500M",
+
+ "# Lists of disk sizes": null,
+ "disk": ["512M"],
+ "disk-growth": ["512M"],
+
+ "# Instance policy specs": null,
+ "ispec_mem_size_max": 600,
+ "ispec_disk_size_min": 0,
+ "ispec_disk_count_min": 0,
+```
+
+Specify the NIC that you configured the vcluster setup with.
+
+```js
+ "master-netdev": "lo:vcluster",
+ "default-nicparams": { "mode": "bridged", "link": "yourbridgename" },
+```
+
+Specify up to as many but not more nodes than you specified in the vcluster configuration on the machine. Use actually the names ```nodeX``` here, because the cluster setup assumes those names. Pick the IPs that the vcluster configuration put into the `/etc/hosts` file on the machine.
+
+```js
+ "# Up to 90 nodes would be possible, but gnt-cluster verify can't handle more than this": null,
+ "nodes": [
+ {
+ "# Master node": null,
+ "primary": "node1",
+ "secondary": "192.0.2.10"
+ },
+
+ {
+ "primary": "node2",
+ "secondary": "192.0.2.11"
+ },
+
+# ...
+
+ {
+ "primary": "node15",
+ "secondary": "192.0.2.24"
+ }
+ ],
+
+```
+
+Specify up to as many instances (but not more) than you configured the vcluster with. Use actually the instance names `instanceX` here.
+
+```js
+ "instances": [
+ { "name": "instance1" },
+ { "name": "instance2" },
+#...
+ { "name": "instance9" }
+ ],
+```
+
+For the tests, there are a couple of tests that don't work on vclusters. This is subject to change, so don't assume that this list is exhaustive or correct.
+
+```js
+ "tests": {
+ "default": true,
+ "default-instance-tests": true,
+
+ "# NOTE: The tests below are disabled because they do not work": null,
+ "# properly in virtual clusters. Some could be made to work with": null,
+ "# a bit of work on the QA code.": null,
+
+ "cluster-burnin": false,
+ "cluster-exclusive-storage": false,
+ "cluster-reserved-lvs": false,
+ "env": false,
+ "group-custom-ssh-port": false,
+ "haskell-confd": false,
+ "htools": false,
+ "instance-add-drbd-disk": false,
+ "instance-add-plain-disk": false,
+ "instance-export": false,
+ "instance-import": false,
+ "instance-modify": false,
+ "instance-recreate-disks": false,
+ "instance-remove-drbd-offline": false,
+ "instance-rename": false,
+ "exclusive-storage-instance-tests": false,
+ "test-jobqueue": false,
+
+ "instance-device-hotplug": false,
+
+ "job-list": true,
+
+ },
+}
+```
+
+## Tips and Tricks
+
+ * Fetching the logs: If you want to fetch the logs of a vcluster, don't forget that you need to fetch it from `/srv/ganeti/vcluster` (or whatever you configured) and not from `/var/log/ganeti`.
\ No newline at end of file
diff --git a/logo.png b/logo.png
new file mode 100644
index 0000000..6ccb8f3
--- /dev/null
+++ b/logo.png
Binary files differ
diff --git a/navbar.md b/navbar.md
new file mode 100644
index 0000000..0e4df74
--- /dev/null
+++ b/navbar.md
@@ -0,0 +1,9 @@
+[logo]: /logo.png
+# Ganeti - Cluster-based virtualization management software
+* [Home][home]
+* [Downloads](Downloads.md)
+* [Issues](https://code.google.com/p/ganeti/issues/list)
+* [Source](SourceCode.md)
+* [Admin](https://code.google.com/p/ganeti/admin)
+
+[home]: /DocumentationByCategory.md
