brightbox-cli 0.17.4 → 0.17.5

data/lib/brightbox-cli/vendor/fog/lib/fog/libvirt/models/compute/node.rb

@@ -0,0 +1,45 @@
+require 'fog/core/model'
+
+module Fog
+  module Compute
+    class Libvirt
+
+      class Node < Fog::Model
+
+        identity :uri
+
+        attribute :model
+        attribute :memory
+        attribute :cpus
+        attribute :mhz
+        attribute :nodes
+        attribute :sockets
+        attribute :cores
+        attribute :threads
+        
+        attribute :type
+        attribute :version
+        attribute :uri
+        attribute :node_free_memory
+        attribute :max_vcpus
+
+        private
+
+        def raw
+          @raw
+        end
+
+        def raw=(new_raw)
+          @raw = new_raw
+
+          raw_attributes = new_raw
+
+          merge_attributes(raw_attributes)
+        end
+
+      end
+
+    end
+  end
+
+end

data/lib/brightbox-cli/vendor/fog/lib/fog/libvirt/models/compute/nodes.rb

@@ -0,0 +1,38 @@
+require 'fog/core/collection'
+require 'fog/libvirt/models/compute/node'
+
+module Fog
+  module Compute
+    class Libvirt
+
+      class Nodes < Fog::Collection
+
+        model Fog::Compute::Libvirt::Node
+
+        def all(filter=nil)
+          data=[]
+          node_info=Hash.new
+          [:model, :memory, :cpus, :mhz, :nodes, :sockets, :cores, :threads].each do |param|
+            begin
+              node_info[param]=connection.node_get_info.send(param)
+            rescue ::Libvirt::RetrieveError
+              node_info[param]=nil
+            end
+          end
+          [:type, :version, :node_free_memory, :max_vcpus].each do |param|
+            begin
+              node_info[param] = connection.send(param)
+            rescue ::Libvirt::RetrieveError
+              node_info[param]=nil
+            end
+          end
+          node_info[:uri]=connection.uri
+          data << { :raw => node_info }
+          load(data)
+        end
+
+
+      end #class
+    end #Class
+  end #module
+end #Module

data/lib/brightbox-cli/vendor/fog/lib/fog/libvirt/models/compute/pool.rb

@@ -0,0 +1,200 @@
+require 'fog/core/model'
+
+module Fog
+  module Compute
+    class Libvirt
+
+      class Pool < Fog::Model
+
+        identity :uuid
+
+        # These attributes are only used for creation
+        attribute :xml
+        attribute :create_persistent
+        attribute :create_auto_build
+
+        # Can be created by passing in XML
+        def initialize(attributes={} )
+          self.xml  ||= nil unless attributes[:xml]
+          self.create_persistent  ||= true unless attributes[:create_persistent]
+          self.create_auto_build ||= true unless attributes[:create_auto_build]
+          super
+        end
+
+        def save
+          requires :xml
+          unless xml.nil?
+            pool=nil
+            if self.create_persistent
+              pool=connection.raw.define_storage_pool_xml(xml)
+            else
+              pool=connection.raw.create_storage_pool_xml(xml)
+            end
+            self.raw=pool
+            true
+          else
+            raise Fog::Errors::Error.new('Creating a new pool requires proper xml')
+            false
+          end
+        end
+
+
+        # Start the pool = make it active
+        # Performs a libvirt create (= start)
+        def start
+          requires :raw
+
+          @raw.create
+        end
+
+        # Stop the pool = make it non-active
+        # Performs a libvirt destroy (= stop)
+        def stop
+          requires :raw
+
+          @raw.destroy
+        end
+
+        # Shuts down the pool
+        def shutdown
+          requires :raw
+
+          @raw.destroy
+          true
+        end
+
+        # Build this storage pool
+        def build
+          requires :raw
+
+          @raw.build unless @raw.nil?
+        end
+
+        # Destroys the storage pool
+        def destroy( destroy_options={})
+          requires :raw
+
+          # Shutdown pool if active
+          @raw.destroy if @raw.active?
+
+          # Delete corresponding data in this pool
+          # @raw.delete
+
+          # If this is a persistent domain we need to undefine it
+          @raw.undefine if @raw.persistent?
+
+        end
+
+        # Set autostart value of the storage pool (true|false)
+        def auto_start=(flag)
+          requires :raw
+
+          @raw.auto_start(flag)
+        end
+
+        # Is the pool active or not?
+        def active?
+          requires :raw
+
+          @raw.active?
+        end
+
+        # Will the pool autostart or not?
+        def auto_start?
+          requires :raw
+
+          @raw.autostart?
+        end
+
+        # Is the pool persistent or not?
+        def persistent?
+          requires :raw
+          @raw.persistent?
+        end
+
+        # Returns the xml description of the current pool
+        def xml_desc
+          requires :raw
+
+          @raw.xml_desc unless @raw.nil?
+        end
+
+
+        # Retrieves the name of the pool
+        def name
+          requires :raw
+          @raw.name
+        end
+
+        # Retrieves the uuid of the pool
+        def uuid
+          requires :raw
+          @raw.uuid
+        end
+
+        # Retrieves the allocated disk space of the pool
+        def allocation
+          requires :raw
+          @raw.info.allocation
+        end
+
+        # Retrieves the capacity of disk space of the pool
+        def capacity
+          requires :raw
+          @raw.info.capacity
+        end
+
+        # Retrieves the number of volumes available in this pool
+        def num_of_volumes
+          requires :raw
+          @raw.num_of_volumes
+        end
+
+        def state
+          requires :raw
+
+          #INACTIVE = INT2NUM(VIR_STORAGE_POOL_INACTIVE)     virStoragePoolState
+          #BUILDING = INT2NUM(VIR_STORAGE_POOL_BUILDING)
+          #RUNNING  = INT2NUM(VIR_STORAGE_POOL_RUNNING)
+          #DEGRADED = INT2NUM(VIR_STORAGE_POOL_DEGRADED)
+          #INACCESSIBLE = INT2NUM(VIR_STORAGE_POOL_INACCESSIBLE)
+          states=[:inactive, :building,:running,:degrated,:inaccessible]
+
+          return states[@raw.info.state]
+
+        end
+
+        # Retrieves the volumes of this pool
+        def volumes
+
+          volumes=Array.new
+          @raw.list_volumes.each do |volume|
+            fog_volume=connection.volumes.all(:name => volume).first
+            volumes << fog_volume
+          end
+          return volumes
+        end
+
+        private
+
+        def raw
+          @raw
+        end
+
+        def raw=(new_raw)
+          @raw = new_raw
+
+          raw_attributes = {
+            :uuid => new_raw.uuid,
+
+          }
+
+          merge_attributes(raw_attributes)
+        end
+
+      end
+
+    end
+  end
+
+end

data/lib/brightbox-cli/vendor/fog/lib/fog/libvirt/models/compute/pools.rb

@@ -0,0 +1,60 @@
+require 'fog/core/collection'
+require 'fog/libvirt/models/compute/pool'
+
+module Fog
+  module Compute
+    class Libvirt
+
+      class Pools < Fog::Collection
+
+        model Fog::Compute::Libvirt::Pool
+
+        def all(filter=nil)
+          data=[]
+          if filter.nil?
+            connection.raw.list_storage_pools.each do |poolname|
+              pool=connection.raw.lookup_storage_pool_by_name(poolname)
+              data << { :raw => pool }
+            end
+            connection.raw.list_defined_storage_pools.each do |poolname|
+              data << {
+                :raw => connection.raw.lookup_storage_pool_by_name(poolname)
+              }
+            end
+          else
+            pool=nil
+            begin
+              pool=get_by_uuid(filter[:uuid]) if filter.has_key?(:uuid)
+              pool=get_by_name(filter[:name]) if filter.has_key?(:name)
+            rescue ::Libvirt::RetrieveError
+              return nil
+            end
+            data << { :raw => pool}
+          end
+
+          load(data)
+        end
+
+        def get(uuid)
+          self.all(:uuid => uuid).first
+        end
+
+        #private # Making these private, screws up realod
+        # Retrieve the pool by uuid
+        def get_by_uuid(uuid)
+          pool=connection.raw.lookup_storage_pool_by_uuid(uuid)
+          return pool
+        end
+
+        # Retrieve the pool by name
+        def get_by_name(name)
+          pool=connection.raw.lookup_storage_pool_by_name(name)
+          return pool
+          #          new(:raw => pool)
+        end
+
+      end #class
+
+    end #Class
+  end #module
+end #module

data/lib/brightbox-cli/vendor/fog/lib/fog/libvirt/models/compute/server.rb

@@ -0,0 +1,526 @@
+require 'fog/core/model'
+require 'fog/libvirt/models/compute/util'
+require 'net/ssh/proxy/command'
+require 'rexml/document'
+require 'erb'
+require 'securerandom'
+
+
+module Fog
+  module Compute
+    class Libvirt
+
+      class Server < Fog::Model
+
+        include Fog::Compute::LibvirtUtil
+
+        identity :id, :aliases => 'uuid'
+        attribute :xml
+
+        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 :state
+
+        # The following attributes are only needed when creating a new vm
+        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
+        attr_writer   :private_key, :private_key_path, :public_key, :public_key_path, :username
+
+        # 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
+        #   :}
+        #
+        # @returns server/domain created
+        def initialize(attributes={} )
+
+          # setup all attributes.
+          defaults.merge(attributes).each do |k,v|
+            eval("self.#{k}= v") if self.respond_to?("#{k}=")
+          end
+
+          super
+        end
+
+        def new?
+          uuid.nil?
+        end
+
+        def save
+
+          raise Fog::Errors::Error.new('Resaving an existing server may create a duplicate') unless new?
+
+          validate_template_options
+
+          xml ||= xml_from_template
+
+          create_or_clone_volume
+
+          xml = xml_from_template
+
+          # We either now have xml provided by the user or generated by the template
+          begin
+            if xml
+              self.raw = persistent ? connection.raw.define_domain_xml(xml) : connection.raw.create_domain_xml(xml)
+            end
+          rescue
+            raise Fog::Errors::Error.new("Error saving the server: #{$!}")
+          end
+        end
+
+        #TODO move all of this to the volume class
+        def create_or_clone_volume
+
+          volume_options = Hash.new
+
+          volume_options[:name] = volume_name || default_volume_name
+
+          # Check if a disk template was specified
+          unless self.volume_template_name.nil?
+
+            template_volumes = connection.volumes.all(:name => self.volume_template_name)
+
+            raise Fog::Errors::Error.new("Template #{self.volume_template_name} not found") unless template_volumes.empty?
+
+            orig_volume = template_volumes.first
+            volume      = orig_volume.clone("#{volume_options[:name]}")
+
+            # if we cloned it, it has the original volume type.
+            self.volume_format_type = orig_volume.format_type
+            # This gets passed to the domain to know the path of the disk
+            self.volume_path        = volume.path
+
+          else
+            # If no template volume was given, let's create our own volume
+
+            volume_options[:format_type] = self.volume_format_type if volume_format_type
+            volume_options[:capacity]    = self.volume_capacity    if volume_capacity
+            volume_options[:allocation]  = self.volume_allocation  if volume_allocation
+
+            begin
+              volume                    = connection.volumes.create(volume_options)
+              self.volume_path          = volume.path
+              self.volume_format_type ||= volume.format_type
+            rescue
+              raise Fog::Errors::Error.new("Error creating the volume : #{$!}")
+            end
+
+          end
+        end
+
+        def validate_template_options
+          unless self.network_interface_type.nil?
+            raise Fog::Errors::Error.new("#{self.network_interface_type} is not a supported interface type") unless ["nat", "bridge"].include?(self.network_interface_type)
+          end
+        end
+
+        def xml_from_template
+
+          template_options={
+            :cpus                   => cpus,
+            :memory_size            => memory_size,
+            :domain_type            => domain_type,
+            :name                   => name,
+            :iso_file               => iso_file,
+            :iso_dir                => iso_dir,
+            :os_type                => os_type,
+            :arch                   => arch,
+            :volume_path            => volume_path,
+            :volume_format_type     => volume_format_type,
+            :network_interface_type => network_interface_type,
+            :network_nat_network    => network_nat_network,
+            :network_bridge_name    => network_bridge_name
+          }
+          vars          = ErbBinding.new(template_options)
+          template_path = File.join(File.dirname(__FILE__),"templates","server.xml.erb")
+          template      = File.open(template_path).readlines.join
+          erb           = ERB.new(template)
+          vars_binding  = vars.send(:get_binding)
+
+          erb.result(vars_binding)
+        end
+
+        def username
+          @username ||= 'root'
+        end
+
+        def start
+          requires :raw
+
+          unless @raw.active?
+            begin
+              @raw.create
+              true
+            rescue
+              false
+            end
+          end
+        end
+
+        # In libvirt a destroy means a hard power-off of the domain
+        # In fog a destroy means the remove of a machine
+        def destroy(options={ :destroy_volumes => false})
+          requires :raw
+          poweroff unless stopped?
+          #TODO: add handling of failure
+          @raw.undefine
+
+          if options[:destroy_volumes]
+            # volumes.all filters do not handle nil keys well
+            connection.volumes.all(:path => disk_path).each { |vol| vol.destroy}
+          end
+        end
+
+        def reboot
+          requires :raw
+          @raw.reboot
+        end
+
+        # Alias for poweroff
+        def halt
+          poweroff
+        end
+
+        # In libvirt a destroy means a hard power-off of the domain
+        # In fog a destroy means the remove of a machine
+        def poweroff
+          requires :raw
+          @raw.destroy
+        end
+
+        def shutdown
+          requires :raw
+          @raw.shutdown
+        end
+
+        def resume
+          requires :raw
+          @raw.resume
+        end
+
+        def suspend
+          requires :raw
+          @raw.suspend
+        end
+
+        def to_fog_state(raw_state)
+          state=case raw_state
+                when 0 then "nostate"
+                when 1 then "running"
+                when 2 then "blocked"
+                when 3 then "paused"
+                when 4 then "shutting-down"
+                when 5 then "shutoff"
+                when 6 then "crashed"
+                end
+        end
+
+        def stopped?
+          state == "shutoff"
+        end
+
+        def ready?
+          state == "running"
+        end
+
+        def stop
+          requires :raw
+          @raw.shutdown
+        end
+
+        # 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
+        #
+        #TODO: move this into the util class
+        def addresses(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=@connection.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' : @connection.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 @connection.uri.ssh_enabled?
+
+            # Retrieve the parts we need from the connection to setup our ssh options
+            user=connection.uri.user #could be nil
+            host=connection.uri.host
+            keyfile=connection.uri.keyfile
+            port=connection.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 connection.uri.no_verify?
+
+            # TODO: we need to take the time into account, when IP's are re-allocated, we might be executing
+            # On the wrong host
+
+            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
+
+            #TODO: We currently just retrieve the ip address through the ip_command
+            #TODO: We need to check if that ip_address is still valid for that mac-address
+
+            # 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 @connection.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 private_ip_address
+          ip_address(:private)
+        end
+
+        def public_ip_address
+          ip_address(:public)
+        end
+
+        def ip_address(key)
+          ips=addresses[key]
+          unless ips.nil?
+            return ips.first
+          else
+            return nil
+          end
+        end
+
+        def private_key_path
+          @private_key_path ||= Fog.credentials[:private_key_path]
+          @private_key_path &&= File.expand_path(@private_key_path)
+        end
+
+        def private_key
+          @private_key ||= private_key_path && File.read(private_key_path)
+        end
+
+        def public_key_path
+          @public_key_path ||= Fog.credentials[:public_key_path]
+          @public_key_path &&= File.expand_path(@public_key_path)
+        end
+
+        def public_key
+          @public_key ||= public_key_path && File.read(public_key_path)
+        end
+
+        def ssh(commands)
+          requires :public_ip_address, :username
+
+          #requires :password, :private_key
+          ssh_options={}
+          ssh_options[:password] = password unless password.nil?
+          ssh_options[:key_data] = [private_key] if private_key
+          ssh_options[:proxy]= ssh_proxy unless ssh_proxy.nil?
+
+          Fog::SSH.new(public_ip_address, @username, ssh_options).run(commands)
+
+        end
+
+
+        def ssh_proxy
+          proxy=nil
+          if @connection.uri.ssh_enabled?
+            relay=connection.uri.host
+            user_string=""
+            user_string="-l #{connection.uri.user}" unless connection.uri.user.nil?
+            proxy = Net::SSH::Proxy::Command.new("ssh #{user_string} "+relay+" nc %h %p")
+            return proxy
+          else
+            return nil
+            # This is a direct connection, so we don't need a proxy to be set
+          end
+        end
+
+        # Transfers a file
+        def scp(local_path, remote_path, upload_options = {})
+          requires :public_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(public_ip_address, username, scp_options).upload(local_path, remote_path, upload_options)
+        end
+
+
+        # Sets up a new key
+        def setup(credentials = {})
+          requires :public_key, :public_ip_address, :username
+          require 'multi_json'
+
+          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 "#{MultiJson.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(public_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(public_ip_address, username, credentials).run(commands)
+        end
+
+        # Retrieves the mac address from parsing the XML of the domain
+        def mac
+          mac = document("domain/devices/interface/mac", "address")
+        end
+
+        def vnc_port
+          port = document("domain/devices/graphics[@type='vnc']", "port")
+        end
+
+        def disk_path
+          document("domain/devices/disk/source", "file")
+        rescue
+          []
+        end
+
+        private
+        attr_reader :raw
+
+        def raw=(new_raw)
+          @raw = new_raw
+
+          raw_attributes = {
+            :id => new_raw.uuid,
+            :uuid => new_raw.uuid,
+            :name => new_raw.name,
+            :max_memory_size => new_raw.info.max_mem,
+            :cputime => new_raw.info.cpu_time,
+            :memory_size => new_raw.info.memory,
+            :vcpus => new_raw.info.nr_virt_cpu,
+            :autostart => new_raw.autostart?,
+            :os_type => new_raw.os_type,
+            :xml => new_raw.xml_desc,
+            :state => self.to_fog_state(new_raw.info.state)
+          }
+
+          merge_attributes(raw_attributes)
+        end
+
+        def randomized_name
+          "fog-#{SecureRandom.random_number*10E14.to_i.round}"
+        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 => "nat",
+            :network_nat_network    => "default",
+            :network_bridge_name    => "br0"
+          }
+        end
+
+      end
+
+    end
+  end
+
+end