fog 1.23.0 → 1.42.1

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

@@ -1,391 +0,0 @@
-require 'fog/compute/models/server'
-require 'fog/libvirt/models/compute/util/util'
-require 'net/ssh/proxy/command'
-
-module Fog
-  module Compute
-    class Libvirt
-      class Server < Fog::Compute::Server
-        include Fog::Compute::LibvirtUtil
-        attr_reader :xml
-
-        identity :id, :aliases => 'uuid'
-
-        attribute :cpus
-        attribute :cputime
-        attribute :os_type
-        attribute :memory_size
-        attribute :max_memory_size
-        attribute :name
-        attribute :arch
-        attribute :persistent
-        attribute :domain_type
-        attribute :uuid
-        attribute :autostart
-        attribute :nics
-        attribute :volumes
-        attribute :active
-        attribute :boot_order
-        attribute :display
-
-        attribute :state
-
-        # The following attributes are only needed when creating a new vm
-        #TODO: Add depreciation warning
-        attr_accessor :iso_dir, :iso_file
-        attr_accessor :network_interface_type ,:network_nat_network, :network_bridge_name
-        attr_accessor :volume_format_type, :volume_allocation,:volume_capacity, :volume_name, :volume_pool_name, :volume_template_name, :volume_path
-        attr_accessor :password
-
-        # Can be created by passing in :xml => "<xml to create domain/server>"
-        # or by providing :template_options => {
-        #                :name => "", :cpus => 1, :memory_size => 256 , :volume_template
-        #   }
-
-        def initialize(attributes={} )
-          @xml = attributes.delete(:xml)
-          verify_boot_order(attributes[:boot_order])
-          super defaults.merge(attributes)
-          initialize_nics
-          initialize_volumes
-        end
-
-        def new?
-          uuid.nil?
-        end
-
-        def save
-          raise Fog::Errors::Error.new('Saving an existing server may create a duplicate') unless new?
-          create_or_clone_volume unless xml or @volumes
-          @xml ||= to_xml
-          self.id = (persistent ? service.define_domain(xml) : service.create_domain(xml)).uuid
-          reload
-        rescue => e
-          raise Fog::Errors::Error.new("Error saving the server: #{e}")
-        end
-
-        def start
-          return true if active?
-          service.vm_action(uuid, :create)
-          reload
-          true
-        end
-
-        def mac
-          nics.first.mac if nics && nics.first
-        end
-
-        def disk_path
-          volumes.first.path if volumes and volumes.first
-        end
-
-        def destroy(options={ :destroy_volumes => false})
-          poweroff unless stopped?
-          service.vm_action(uuid, :undefine)
-          volumes.each { |vol| vol.destroy } if options[:destroy_volumes]
-          true
-        end
-
-        def reboot
-          service.vm_action(uuid, :reboot)
-        end
-
-        def poweroff
-          service.vm_action(uuid, :destroy)
-        end
-
-        def shutdown
-          service.vm_action(uuid, :shutdown)
-        end
-
-        def resume
-          service.vm_action(uuid, :resume)
-        end
-
-        def suspend
-          service.vm_action(uuid, :suspend)
-        end
-
-        def stopped?
-          state == "shutoff"
-        end
-
-        def ready?
-          state == "running"
-        end
-
-        #alias methods
-        alias_method :halt,    :poweroff
-        alias_method :stop,    :shutdown
-        alias_method :active?, :active
-
-        def volumes
-          # lazy loading of volumes
-          @volumes ||= (@volumes_path || []).map{|path| service.volumes.all(:path => path).first }
-        end
-
-        def private_ip_address
-          ip_address(:private)
-        end
-
-        def public_ip_address
-          ip_address(:public)
-        end
-
-        def ssh(commands)
-          requires :ssh_ip_address, :username
-
-          ssh_options={}
-          ssh_options[:password] = password unless password.nil?
-          ssh_options[:proxy]= ssh_proxy unless ssh_proxy.nil?
-
-          super(commands, ssh_options)
-        end
-
-        def ssh_proxy
-          # if this is a direct connection, we don't need a proxy to be set.
-          return nil unless connection.uri.ssh_enabled?
-          user_string= service.uri.user ? "-l #{service.uri.user}" : ""
-          Net::SSH::Proxy::Command.new("ssh #{user_string} #{service.uri.host} nc %h %p")
-        end
-
-        # Transfers a file
-        def scp(local_path, remote_path, upload_options = {})
-          requires :ssh_ip_address, :username
-
-          scp_options = {}
-          scp_options[:password] = password unless self.password.nil?
-          scp_options[:key_data] = [private_key] if self.private_key
-          scp_options[:proxy]= ssh_proxy unless self.ssh_proxy.nil?
-
-          Fog::SCP.new(ssh_ip_address, username, scp_options).upload(local_path, remote_path, upload_options)
-        end
-
-        # Sets up a new key
-        def setup(credentials = {})
-          requires :public_key, :ssh_ip_address, :username
-
-          credentials[:proxy]= ssh_proxy unless ssh_proxy.nil?
-          credentials[:password] = password unless self.password.nil?
-          credentails[:key_data] = [private_key] if self.private_key
-
-          commands = [
-            %{mkdir .ssh},
-            #              %{passwd -l #{username}}, #Not sure if we need this here
-            #              %{echo "#{Fog::JSON.encode(attributes)}" >> ~/attributes.json}
-          ]
-          if public_key
-            commands << %{echo "#{public_key}" >> ~/.ssh/authorized_keys}
-          end
-
-          # wait for domain to be ready
-          Timeout::timeout(360) do
-            begin
-              Timeout::timeout(8) do
-                Fog::SSH.new(ssh_ip_address, username, credentials.merge(:timeout => 4)).run('pwd')
-              end
-            rescue Errno::ECONNREFUSED
-              sleep(2)
-              retry
-            rescue Net::SSH::AuthenticationFailed, Timeout::Error
-              retry
-            end
-          end
-          Fog::SSH.new(ssh_ip_address, username, credentials).run(commands)
-        end
-
-        def update_display attrs = {}
-          service.update_display attrs.merge(:uuid => uuid)
-          reload
-        end
-
-        # can't use deprecate method, as the value is part of the display hash
-        def vnc_port
-          Fog::Logger.deprecation("#{self.class} => #vnc_port is deprecated, use #display[:port] instead [light_black](#{caller.first})[/]")
-          display[:port]
-        end
-
-        private
-        attr_accessor :volumes_path
-
-        # This retrieves the ip address of the mac address
-        # It returns an array of public and private ip addresses
-        # Currently only one ip address is returned, but in the future this could be multiple
-        # if the server has multiple network interface
-        def addresses(service=service, options={})
-          mac=self.mac
-
-          # Aug 24 17:34:41 juno arpwatch: new station 10.247.4.137 52:54:00:88:5a:0a eth0.4
-          # Aug 24 17:37:19 juno arpwatch: changed ethernet address 10.247.4.137 52:54:00:27:33:00 (52:54:00:88:5a:0a) eth0.4
-          # Check if another ip_command string was provided
-          ip_command_global=service.ip_command.nil? ? 'grep $mac /var/log/arpwatch.log|sed -e "s/new station//"|sed -e "s/changed ethernet address//g" |sed -e "s/reused old ethernet //" |tail -1 |cut -d ":" -f 4-| cut -d " " -f 3' : service.ip_command
-          ip_command_local=options[:ip_command].nil? ? ip_command_global : options[:ip_command]
-
-          ip_command="mac=#{mac}; server_name=#{name}; "+ip_command_local
-
-          ip_address=nil
-
-          if service.uri.ssh_enabled?
-
-            # Retrieve the parts we need from the service to setup our ssh options
-            user=service.uri.user #could be nil
-            host=service.uri.host
-            keyfile=service.uri.keyfile
-            port=service.uri.port
-
-            # Setup the options
-            ssh_options={}
-            ssh_options[:keys]=[ keyfile ] unless keyfile.nil?
-            ssh_options[:port]=port unless keyfile.nil?
-            ssh_options[:paranoid]=true if service.uri.no_verify?
-
-            begin
-              result=Fog::SSH.new(host, user, ssh_options).run(ip_command)
-            rescue Errno::ECONNREFUSED
-              raise Fog::Errors::Error.new("Connection was refused to host #{host} to retrieve the ip_address for #{mac}")
-            rescue Net::SSH::AuthenticationFailed
-              raise Fog::Errors::Error.new("Error authenticating over ssh to host #{host} and user #{user}")
-            end
-
-            # Check for a clean exit code
-            if result.first.status == 0
-              ip_address=result.first.stdout.strip
-            else
-              # We got a failure executing the command
-              raise Fog::Errors::Error.new("The command #{ip_command} failed to execute with a clean exit code")
-            end
-
-          else
-            # It's not ssh enabled, so we assume it is
-            if service.uri.transport=="tls"
-              raise Fog::Errors::Error.new("TlS remote transport is not currently supported, only ssh")
-            end
-
-            # Execute the ip_command locally
-            # Initialize empty ip_address string
-            ip_address=""
-
-            IO.popen("#{ip_command}") do |p|
-              p.each_line do |l|
-                ip_address+=l
-              end
-              status=Process.waitpid2(p.pid)[1].exitstatus
-              if status!=0
-                raise Fog::Errors::Error.new("The command #{ip_command} failed to execute with a clean exit code")
-              end
-            end
-
-            #Strip any new lines from the string
-            ip_address=ip_address.chomp
-          end
-
-          # The Ip-address command has been run either local or remote now
-
-          if ip_address==""
-            #The grep didn't find an ip address result"
-            ip_address=nil
-          else
-            # To be sure that the command didn't return another random string
-            # We check if the result is an actual ip-address
-            # otherwise we return nil
-            unless ip_address=~/^(\d{1,3}\.){3}\d{1,3}$/
-              raise Fog::Errors::Error.new(
-                        "The result of #{ip_command} does not have valid ip-address format\n"+
-                            "Result was: #{ip_address}\n"
-                    )
-            end
-          end
-
-          return { :public => [ip_address], :private => [ip_address]}
-        end
-
-        def ip_address(key)
-          addresses[key].nil? ? nil : addresses[key].first
-        end
-
-        def initialize_nics
-          if nics
-            nics.map! { |nic| nic.is_a?(Hash) ? service.nics.new(nic) : nic }
-          else
-            self.nics = [service.nics.new({:type => network_interface_type, :bridge => network_bridge_name, :network => network_nat_network})]
-          end
-        end
-
-        def initialize_volumes
-          if attributes[:volumes] && !attributes[:volumes].empty?
-            @volumes = attributes[:volumes].map { |vol| vol.is_a?(Hash) ? service.volumes.new(vol) : vol }
-          end
-        end
-
-        def create_or_clone_volume
-          options = {:name => volume_name || default_volume_name}
-          # Check if a disk template was specified
-          if volume_template_name
-            template_volume = service.volumes.all(:name => volume_template_name).first
-            raise Fog::Errors::Error.new("Template #{volume_template_name} not found") unless template_volume
-            begin
-              volume = template_volume.clone("#{options[:name]}")
-            rescue => e
-              raise Fog::Errors::Error.new("Error creating the volume : #{e}")
-            end
-          else
-            # If no template volume was given, let's create our own volume
-            options[:pool_name]   = volume_pool_name   if volume_pool_name
-            options[:format_type] = volume_format_type if volume_format_type
-            options[:capacity]    = volume_capacity    if volume_capacity
-            options[:allocation]  = volume_allocation  if volume_allocation
-
-            begin
-              volume = service.volumes.create(options)
-            rescue => e
-              raise Fog::Errors::Error.new("Error creating the volume : #{e}")
-            end
-          end
-          @volumes.nil? ? @volumes = [volume] : @volumes << volume
-        end
-
-        def default_iso_dir
-          "/var/lib/libvirt/images"
-        end
-
-        def default_volume_name
-          "#{name}.#{volume_format_type || 'img'}"
-        end
-
-        def defaults
-          {
-            :persistent             => true,
-            :cpus                   => 1,
-            :memory_size            => 256 *1024,
-            :name                   => randomized_name,
-            :os_type                => "hvm",
-            :arch                   => "x86_64",
-            :domain_type            => "kvm",
-            :iso_dir                => default_iso_dir,
-            :network_interface_type => "network",
-            :network_nat_network    => "default",
-            :network_bridge_name    => "br0",
-            :boot_order             => default_boot_order,
-            :display                => default_display
-          }
-        end
-
-        def default_boot_order
-          %w[hd cdrom network]
-        end
-
-        def verify_boot_order order = []
-          if order
-            order.each do |b|
-              raise "invalid boot order, possible values are: hd, network and/or cdrom" unless default_boot_order.include?(b)
-            end
-          end
-        end
-
-        def default_display
-          {:port => '-1', :listen => '127.0.0.1', :type => 'vnc', :password => '' }
-        end
-      end
-    end
-  end
-end

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

@@ -1,21 +0,0 @@
-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={})
-          load(service.list_domains(filter))
-        end
-
-        def get(uuid)
-          data = service.list_domains(:uuid => uuid)
-          new data.first if data
-        end
-      end
-    end
-  end
-end

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

@@ -1,6 +0,0 @@
-<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

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

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

@@ -1,54 +0,0 @@
-<domain type='<%= domain_type %>'>
-  <name><%= name %></name>
-  <memory><%= memory_size %></memory>
-  <vcpu><%= cpus %></vcpu>
-  <os>
-    <type arch='<%= arch %>'><%= os_type %></type>
-<% boot_order.each do |dev| -%>
-    <boot dev='<%= dev %>'/>
-<% end -%>
-  </os>
-  <features>
-    <acpi/>
-    <apic/>
-    <pae/>
-  </features>
-  <clock offset='utc'/>
-  <devices>
-<% volumes.each do |vol| -%>
-    <disk type='file' device='disk'>
-      <driver name='qemu' type='<%= vol.format_type %>'/>
-      <source file='<%= vol.path %>'/>
-      <%# we need to ensure a unique target dev -%>
-      <target dev='vd<%= ('a'..'z').to_a[volumes.index(vol)] %>' bus='virtio'/>
-    </disk>
-<% end -%>
-<% if iso_file -%>
-    <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 -%>
-<% nics.each do |nic| -%>
-    <interface type='<%= nic.type %>'>
-      <source <%= nic.type == 'bridge' ? "bridge='#{nic.bridge}'" : "network='#{nic.network}'" %> />
-      <model type='<%= nic.model %>'/>
-    </interface>
-<% end -%>
-    <serial type='pty'>
-      <target port='0'/>
-    </serial>
-    <console type='pty'>
-      <target port='0'/>
-    </console>
-    <input type='tablet' bus='usb'/>
-    <input type='mouse' bus='ps2'/>
-    <graphics type='<%= display[:type] %>' port='<%= display[:port] %>' autoport='yes' <% if display[:listen] and !(display[:listen].empty?)  %> listen='<%= display[:listen] %>'<% end %> <% if display[:password] and !(display[:password].empty?) %>passwd='<%=display[:password] %>'<% end %> />
-    <video>
-      <model type='cirrus' vram='9216' heads='1'/>
-    </video>
-  </devices>
-</domain>

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

@@ -1,26 +0,0 @@
-<volume>
-        <name><%= name %></name>
-        <allocation unit="<%= split_size_unit(allocation)[1] %>"><%= split_size_unit(allocation)[0] %></allocation>
-        <capacity unit="<%= split_size_unit(capacity)[1] %>"><%= split_size_unit(capacity)[0] %></capacity>
-        <target>
-          <format type="<%= format_type %>"/>
-          <permissions>
-            <owner>0</owner>
-            <group>0</group>
-            <mode>0744</mode>
-            <label>virt_image_t</label>
-          </permissions>
-        </target>
-        <% if backing_volume -%>
-        <backingStore>
-          <path><%= backing_volume.path %></path>
-          <format type="<%= backing_volume.format_type %>"/>
-          <permissions>
-            <owner>0</owner>
-            <group>0</group>
-            <mode>0744</mode>
-            <label>virt_image_t</label>
-          </permissions>
-        </backingStore>
-        <% end -%>
-</volume>

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

@@ -1,138 +0,0 @@
-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("keyfile")
-        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)
-          unless @parsed_uri.query.nil?
-            params=CGI.parse(@parsed_uri.query)
-            if params.key?(name)
-              return params[name].first
-            else
-              return nil
-            end
-          else
-            return nil
-          end
-        end
-      end
-    end
-  end
-end

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

@@ -1,32 +0,0 @@
-require 'nokogiri'
-require 'erb'
-require 'ostruct'
-require 'securerandom'
-
-module Fog
-  module Compute
-    module LibvirtUtil
-      def xml_element(xml, path, attribute=nil)
-        xml = Nokogiri::XML(xml)
-        attribute.nil? ? (xml/path).first.text : (xml/path).first[attribute.to_sym]
-      end
-
-      def xml_elements(xml, path, attribute=nil)
-         xml = Nokogiri::XML(xml)
-         attribute.nil? ? (xml/path).map : (xml/path).map{|element| element[attribute.to_sym]}
-      end
-
-      def to_xml template_name = nil
-        # figure out our ERB template filename
-        erb = template_name || self.class.to_s.split("::").last.downcase
-        path     = File.join(File.dirname(__FILE__), "..", "templates", "#{erb}.xml.erb")
-        template = File.read(path)
-        ERB.new(template, nil, '-').result(binding)
-      end
-
-      def randomized_name
-        "fog-#{(SecureRandom.random_number*10E14).to_i.round}"
-      end
-    end
-  end
-end