fog 0.11.0 → 1.0.0

data/lib/fog/libvirt/models/compute/servers.rb

@@ -0,0 +1,78 @@
+require 'fog/core/collection'
+require 'fog/libvirt/models/compute/server'
+
+module Fog
+  module Compute
+    class Libvirt
+
+      class Servers < Fog::Collection
+
+        model Fog::Compute::Libvirt::Server
+
+        def all(filter=nil)
+          data=[]
+          filter={} if filter.nil?
+          include_defined=filter.has_key?(:defined) ? filter[:defined] : true  
+          include_active=filter.has_key?(:active) ? filter[:active] : true  
+
+          unless filter.has_key?(:name) || filter.has_key?(:uuid)
+            if include_defined
+              connection.raw.list_defined_domains.map do |domain|
+                data << { :raw => connection.raw.lookup_domain_by_name(domain) }
+              end
+            end
+            if include_active
+              connection.raw.list_domains.each do |domain|
+                data << { :raw => connection.raw.lookup_domain_by_id(domain) }
+              end
+            end
+          else
+            domain=nil
+            begin
+              domain=self.get_by_name(filter[:name]) if filter.has_key?(:name)
+              domain=self.get_by_uuid(filter[:uuid]) if filter.has_key?(:uuid)
+
+            rescue ::Libvirt::RetrieveError
+              return nil
+            end
+            unless domain.nil?
+              data << { :raw => domain }
+            end
+          end
+
+          load(data)
+        end
+
+        def get(uuid)
+          self.all(:uuid => uuid).first
+        end
+
+        def bootstrap(new_attributes = {})
+          raise 'Not Implemented'
+          # server = create(new_attributes)
+          # server.start
+          # server.wait_for { ready? }
+          # server.setup(:password => server.password)
+          # server
+        end
+
+        # private #making these internals private screws up reload
+
+        # Retrieve the server by uuid
+        def get_by_uuid(uuid)
+          server=connection.raw.lookup_domain_by_uuid(uuid)
+          return server
+          #          new(:raw => machine)
+        end
+
+        # Retrieve the server by name
+        def get_by_name(name)
+          server=connection.raw.lookup_domain_by_name(name)
+          return server
+          #          new(:raw => machine)
+        end
+
+      end #class
+    end #Class
+  end #module
+end #Module

data/lib/fog/libvirt/models/compute/templates/network.xml.erb

@@ -0,0 +1,6 @@
+<network>
+  <name><%= name %></name>
+  <forward mode='<%= network_mode %>'/>
+  <bridge name='<%= bridge_name %>' stp='on' delay='0' />
+  </ip>
+</network>

data/lib/fog/libvirt/models/compute/templates/pool.xml.erb

@@ -0,0 +1,6 @@
+<pool type="dir">
+    <name><%= name %></name>
+    <target>
+      <path><%= path %></path>
+    </target>
+</pool>

data/lib/fog/libvirt/models/compute/templates/server.xml.erb

@@ -0,0 +1,57 @@
+<domain type='<%= domain_type %>'>
+  <name><%= name %></name>
+  <memory><%= memory_size %></memory>
+  <vcpu><%= cpus %></vcpu>
+  <os>
+    <type arch='<%= arch %>'><%= os_type %></type>
+    <boot dev='hd'/>
+  <% if !iso_file.nil? %>
+
+    <boot dev='cdrom'/>
+  <% end %>
+  </os>
+  <features>
+    <acpi/>
+    <apic/>
+    <pae/>
+  </features>
+  <clock offset='utc'/>
+  <devices>
+    <disk type='file' device='disk'>
+      <driver name='qemu' type='<%= volume_format_type %>'/>
+      <source file='<%= "#{volume_path}" %>'/>
+      <target dev='vda' bus='virtio'/>
+    </disk>
+  <% if !iso_file.nil? %>
+    <disk type='file' device='cdrom'>
+      <driver name='qemu' type='raw'/>
+      <source file='<%= "#{iso_dir}/#{iso_file}" %>'/>
+      <target dev='hdc' bus='ide'/>
+      <readonly/>
+      <address type='drive' controller='0' bus='1' unit='0'/>
+    </disk>
+  <% end %>
+    <% if network_interface_type=="bridge" %>
+        <interface type="bridge">
+        <source bridge='<%= network_bridge_name %>'/>
+        <model type='virtio'/>
+      <% end %>
+    <% if network_interface_type=="nat" %>
+        <interface type='network'>
+      <source network='<%= network_nat_network %>'/>
+      <model type='virtio'/>
+    <% end %>
+    </interface>
+    <serial type='pty'>
+      <target port='0'/>
+    </serial>
+    <console type='pty'>
+      <target port='0'/>
+    </console>
+    <input type='mouse' bus='ps2'/>
+    <graphics type='vnc' port='-1' autoport='yes' keymap='en-us'/>
+    <video>
+      <model type='cirrus' vram='9216' heads='1'/>
+    </video>
+  </devices>
+</domain>

data/lib/fog/libvirt/models/compute/templates/volume.xml.erb

@@ -0,0 +1,14 @@
+<volume>
+        <name><%= name %></name>
+        <allocation unit="<%= allocation_unit %>"><%= allocation_size %>"></allocation>
+        <capacity unit="<%= capacity_unit %>"><%= capacity_size %>"></capacity>
+        <target>
+          <format type="<%= format_type %>"/>
+          <permissions>
+            <owner>0</owner>
+            <group>0</group>
+            <mode>0744</mode>
+            <label>virt_image_t</label>
+          </permissions>
+        </target>
+</volume>

data/lib/fog/libvirt/models/compute/uri.rb

@@ -0,0 +1,142 @@
+require 'uri'
+require 'cgi'
+
+
+module Fog
+  module Compute
+    module LibvirtUtil
+
+      class URI
+
+        attr_reader :uri
+
+        def initialize(uri)
+          @parsed_uri=::URI.parse(uri)
+          @uri=uri
+          return self
+        end
+
+        # Transport will be part of the scheme
+        # The part after the plus sign
+        # f.i. qemu+ssh
+        def transport
+          scheme=@parsed_uri.scheme
+          return nil if scheme.nil?
+
+          return scheme.split(/\+/)[1]
+        end
+
+        def scheme
+          return @parsed_uri.scheme
+        end
+
+        def driver
+          scheme=@parsed_uri.scheme
+          return nil if scheme.nil?
+
+          return scheme.split(/\+/).first
+        end
+
+        def ssh_enabled?
+          if remote?
+            return transport.include?("ssh")
+          else
+            return false
+          end
+        end
+
+        def remote?
+          return !transport.nil?
+        end
+
+        def user
+          @parsed_uri.user
+        end
+
+        def host
+          @parsed_uri.host
+        end
+
+        def port
+          @parsed_uri.port
+        end
+
+        def password
+          @parsed_uri.password
+        end
+
+        def name
+          value("name")
+        end
+
+        def command
+          value("command")
+        end
+
+        def socket
+          value("socket")
+        end
+
+        def keyfile
+          value("command")
+        end
+
+        def netcat
+          value("netcat")
+        end
+
+        def no_verify?
+          no_verify=value("no_verify")
+          return false if no_verify.nil?
+
+          if no_verify.to_s=="0"
+            return false
+          else
+            return true
+          end
+        end
+
+        def verify?
+          return !no_verify?
+        end
+
+        def no_tty?
+          no_tty=value("no_tty")
+
+          return false if no_tty.nil?
+
+          if no_tty=="0"
+            return false
+          else
+            return true
+          end
+
+        end
+
+        def tty?
+          return !no_tty?
+        end
+
+        def pkipath
+          value("pkipath")
+        end
+
+
+        # A libvirt URI allows you to specify extra params
+        # http://libvirt.org/remote.html
+        private
+        def value(name)
+          params=CGI.parse(@parsed_uri.query)
+          if params.has_key?(name)
+            return params[name].first
+          else
+            return nil
+          end
+        end
+
+
+      end
+    end
+  end
+end
+

data/lib/fog/libvirt/models/compute/util.rb

@@ -0,0 +1,25 @@
+require "rexml/document"
+require 'erb'
+require 'ostruct'
+
+module Fog
+  module Compute
+    module LibvirtUtil
+
+      # finds a value from xml
+      def document path, attribute=nil
+        return nil if new?
+        xml = REXML::Document.new(@xml_desc)
+        attribute.nil? ? xml.elements[path].text : xml.elements[path].attributes[attribute]
+      end
+
+      class ErbBinding < OpenStruct
+        def get_binding
+          return binding()
+        end
+      end
+
+
+    end
+  end
+end

data/lib/fog/libvirt/models/compute/volume.rb

@@ -0,0 +1,176 @@
+require 'fog/core/model'
+require 'fog/libvirt/models/compute/util'
+require 'rexml/document'
+require 'erb'
+require 'securerandom'
+
+module Fog
+  module Compute
+    class Libvirt
+
+      class Volume < Fog::Model
+
+        include Fog::Compute::LibvirtUtil
+
+        identity :id , :aliases => 'key'
+
+        attribute :pool_name
+
+        attribute :xml
+
+        attribute :key
+        attribute :path
+        attribute :name
+        attribute :capacity
+        attribute :allocation
+        attribute :format_type
+
+        # Can be created by passing in :xml => "<xml to create volume>"
+        # A volume always belongs to a pool, :pool_name => "<name of pool>"
+        #
+        # @returns volume created
+        def initialize(attributes={} )
+          self.xml  ||= nil unless attributes[:xml]
+          self.key  = nil
+          self.format_type ||= "raw" unless attributes[:format_type]
+          extension = self.format_type=="raw" ? "img" : self.format_type
+          self.name ||= "fog-#{SecureRandom.random_number*10E14.to_i.round}.#{extension}" unless attributes[:name]
+          self.capacity ||= "10G" unless attributes[:capacity]
+          self.allocation ||= "1G" unless attributes[:allocation]
+          super
+
+          #We need a connection to calculate the poolname
+          #This is why we do this after super
+          self.pool_name  ||= default_pool_name unless attributes[:pool_name]
+        end
+
+        # Try to guess the default/first pool of no pool_name was specificed
+        def default_pool_name
+          default_name="default"
+          default_pool=@connection.pools.all(:name => default_name)
+
+          if default_pool.nil?
+            first_pool=@connection.pools.first
+            if first_pool.nil?
+              raise Fog::Errors::Error.new('We could not find a pool called "default" and there was no other pool defined')
+            else
+              default_name=first_pool.name
+            end
+          end
+          return default_name
+        end
+
+        # Takes a pool and either :xml or other settings
+        def save
+          requires :pool_name
+
+          raise Fog::Errors::Error.new('Resaving an existing volume may create a duplicate') if key
+
+          xml=xml_from_template if xml.nil?
+
+          begin
+            volume=nil
+            pool=connection.raw.lookup_storage_pool_by_name(pool_name)
+            volume=pool.create_volume_xml(xml)
+            self.raw=volume
+            true
+          rescue
+            raise Fog::Errors::Error.new("Error creating volume: #{$!}")
+            false
+          end
+
+        end
+
+        def split_size_unit(text)
+          matcher=text.match(/(\d+)(.+)/)
+          size=matcher[1]
+          unit=matcher[2]
+          return size , unit
+        end
+
+        # Create a valid xml for the volume based on the template
+        def xml_from_template
+
+          allocation_size,allocation_unit=split_size_unit(self.allocation)
+          capacity_size,capacity_unit=split_size_unit(self.capacity)
+
+          template_options={
+            :name => self.name,
+            :format_type => self.format_type,
+            :allocation_size => allocation_size,
+            :allocation_unit => allocation_unit,
+            :capacity_size => capacity_size,
+            :capacity_unit => capacity_unit
+          }
+
+          # We only want specific variables for ERB
+          vars = ErbBinding.new(template_options)
+          template_path=File.join(File.dirname(__FILE__),"templates","volume.xml.erb")
+          template=File.open(template_path).readlines.join
+          erb = ERB.new(template)
+          vars_binding = vars.send(:get_binding)
+          result=erb.result(vars_binding)
+          return result
+        end
+
+        # Destroy a volume
+        def destroy
+          requires :raw
+          raw.delete
+          true
+        end
+
+        # Wipes a volume , zeroes disk
+        def wipe
+          requires :raw
+          raw.wipe
+          true
+        end
+
+        # Clones this volume to the name provided
+        def clone(name)
+          pool=@raw.pool
+          xml = REXML::Document.new(self.xml)
+          xml.root.elements['/volume/name'].text=name
+          xml.root.elements['/volume/key'].text=name
+          xml.delete_element('/volume/target/path')
+          pool.create_volume_xml_from(xml.to_s,@raw)
+          return connection.volumes.all(:name => name).first
+        end
+
+        #def xml_desc
+          #requires :raw
+          #raw.xml_desc
+        #end
+
+        private
+        def raw
+          @raw
+        end
+
+        def raw=(new_raw)
+          @raw = new_raw
+
+          xml = REXML::Document.new(new_raw.xml_desc)
+          format_type=xml.root.elements['/volume/target/format'].attributes['type']
+
+          raw_attributes = {
+            :key => new_raw.key,
+            :id => new_raw.key,
+            :path => new_raw.path,
+            :name => new_raw.name,
+            :format_type => format_type,
+            :allocation => new_raw.info.allocation,
+            :capacity => new_raw.info.capacity,
+            :xml => new_raw.xml_desc
+          }
+
+          merge_attributes(raw_attributes)
+        end
+
+      end
+
+    end
+  end
+
+end