fog--fog/lib/fog/xenserver/examples/creating_servers.md

# Creating servers (VMs) and templates

The basic server creation steps are detailed in the getting started tutorial.

Now let's do something a little bit more complex and probably more useful in
day-to-day operations. That is:

1. Uploading a VHD image.
2. Create a new template with it.
3. Spin a new server using the recently added template.

## Part I: Upload the VHD

Assuming we have an image file 'ubuntu.vhd' ready to be uploaded, let's create
the connection to the XenServer host and upload the image to the storage repository,
using SSH. The code also assumes that you have a file storage repository mounted
somewhere in /var/run/sr-mount/#{sr-UUID} (the standard XenServer base directory
for mounted storage repositories).

    require 'fog'                                                               
    require 'net/scp'
    require 'uuidtools'
    
    #
    # Create the connection to the XenServer host
    #
    xenserver = Fog::Compute.new({
      :provider           => 'XenServer',
      :xenserver_url      => 'xenserver-test',
      :xenserver_username => 'root',
      :xenserver_password => 'secret',
    })


We'll be uploading the image to the "Local File SR" storage repository, so
we need the reference to this SR (Storage Repository):
  
    sr = xenserver.storage_repositories.find { |sr| sr.name ==  "Local File SR" }

XenServer uses UUIDs to store images in the storage repositories, so we will
emulate that behavior, creating a new UUID for our image and uploading it.

    #
    # Use the excelent uuidtools gem to create the new UUID
    # for the image
    #
    image_uuid = UUIDTools::UUID.random_create.to_s


To upload the new image using SCP, we need the destination directory, where the
SR is mounted. In our case, the storage repository mount point is 
/var/run/sr-mount/#{sr.uuid} (where sr.uuid is the UUID of the storage
repository). We will upload the new image there:

    sr_mount_point = "/var/run/sr-mount/#{sr.uuid}"
    # Target image file path. We will upload the local image to the destination
    # using SCP
    destination = File.join(sr_mount_point, "#{image_uuid}.vhd")
    # source image, located in the current directory
    source = 'ubuntu.vhd'
    # Use the XenServer root credentials to upload
    Net::SSH.start('xenserver-test', 'root', :password => 'secret') do |ssh|              
      ssh.scp.upload!(source, destination) do |ch, name, sent, total|              
        # print progress
        p = (sent.to_f * 100 / total.to_f).to_i.to_s                        
        print "\rProgress: #{p}% completed"                     
      end                                                                   
    end 

We need to let the XenServer know, that there's a new image:

    sr.scan
 
Now that XenServer is aware of the new image, get its reference
and set the image name attribute to 'ubuntu-template'

    ubuntu_vdi = xenserver.vdis.find { |vdi| vdi.uuid == image_uuid }
    ubuntu_vdi.set_attribute 'name_label', 'ubuntu-template'

Good! the image is ready to be used.

## Part II: create the server template

We have the image ready to be used by our new template.

Templates are regular servers, so let's create one with 512 MB of RAM, 1 CPU
and a network card. The main difference with a regular server from an API 
point of view is that we will not start it.

We will also create the template as PV (paravirtual):

    server_mem = (512 * 1024 * 1024).to_s 
    server = xenserver.servers.new :name               => "ubuntu-template",
                                   # Required when using Server.new
                                   :affinity           => xenserver.hosts.first,
                                   :other_config       => {},
                                   :pv_bootloader      => 'pygrub',          # PV related
                                   :hvm_boot_policy    => '',                # PV related
                                   :pv_args            => '-- console=hvc0', # PV related
                                   :memory_static_max  => mem,
                                   :memory_static_min  => mem,
                                   :memory_dynamic_max => mem,                       
                                   :memory_dynamic_min => mem 
    server.save

We need to attach the disk image to a VBD and to the server

    xenserver.vbds.create :server => server, :vdi => ubuntu_vdi

Note that we're using Server.new here, instead of Server.create.
Server.create would start the server, and that's not what we want here.

Let's add the NIC (VIF or virtual interface) to the server.

I have a network in my XenServer named "Pool-wide network associated with eth0"
bridged to the physical eth0 NIC and I will attach the new NIC to that network.

Don't be scared by the VIF creation code. There are easier ways to create a
VIF, and we'll be dealing with that and some other cases in the networking 
tutorial (TODO).

First, let's find the network since we'll need the reference.

    net = xenserver.networks.find { |n| n.name == 'Pool-wide network associated with eth0' }

To create the VM VIF, we need to set some attributes and use the 
create_vif_custom request:

    vif_attr = {
      'MAC_autogenerated' => 'True',
      'VM'                => server.reference, # we need the VM reference here
      'network'           => net.reference, # we need the Network reference here
      'MAC'               => '', # ignored, since we use autogeneration
      'device'            => '0',
      'MTU'               => '0',
      'other_config'      => {},
      'qos_algorithm_type' => 'ratelimit',                                 
      'qos_algorithm_params' => {}
    }
    xenserver.create_vif_custom vif_attr
    

The template is now ready to be used and we can list it!

    xenserver.servers.custom_templates.find { |t| puts t.name }

## Party III: spin a new server using the brand new template

Now that we have the template in place, it's easy to create as many servers
as you want. All of them will share hardware specs with the template. That is,
512 MB of RAM, 1 CPU, 1 NIC attached to the 'Pool-wide network...':

    xenserver.servers.create :name => 'my-brand-new-server',
                             :template_name => 'ubuntu-template'


# The End

Pretty similar code is used by knife-xenserver (http://github.com/bvox/knife-xenserver)
to upload new templates. Have a look at it if you're interested, it's full of
examples and fog/xenserver tricks to manage XenServer/XCP hosts.

The full source code used in this tutorial is available at:

https://github.com/bvox/fog-xenserver-examples/blob/master/upload_template_and_create.rb

Enjoy!