brightbox-cli 0.17.1 → 0.17.2

data/lib/brightbox-cli/vendor/fog/lib/fog/ecloud/requests/compute/configure_network_ip.rb

@@ -6,7 +6,7 @@ module Fog
 
         def validate_network_ip_data(network_ip_data)
           valid_opts = [:id, :href, :name, :status, :server, :rnat]
-          unless valid_opts.all? { |opt| network_ip_data.keys.include?(opt) }
+          unless valid_opts.all? { |opt| network_ip_data.has_key?(opt) }
             raise ArgumentError.new("Required data missing: #{(valid_opts - network_ip_data.keys).map(&:inspect).join(", ")}")
           end
         end

data/lib/brightbox-cli/vendor/fog/lib/fog/ecloud/requests/compute/configure_vapp.rb

@@ -6,7 +6,7 @@ module Fog
 
         def validate_vapp_data(vapp_data)
           valid_opts = [:name, :cpus, :memory, :disks]
-          unless valid_opts.all? { |opt| vapp_data.keys.include?(opt) }
+          unless valid_opts.all? { |opt| vapp_data.has_key?(opt) }
             raise ArgumentError.new("Required Vapp data missing: #{(valid_opts - vapp_data.keys).map(&:inspect).join(", ")}")
           end
         end

data/lib/brightbox-cli/vendor/fog/lib/fog/ecloud/requests/compute/instantiate_vapp_template.rb

@@ -6,7 +6,7 @@ module Fog
 
         def validate_instantiate_vapp_template_options(catalog_item_uri, options)
           valid_opts = [:name, :vdc_uri, :network_uri, :cpus, :memory, :row, :group]
-          unless valid_opts.all? { |opt| options.keys.include?(opt) }
+          unless valid_opts.all? { |opt| options.has_key?(opt) }
             raise ArgumentError.new("Required data missing: #{(valid_opts - options.keys).map(&:inspect).join(", ")}")
           end
 

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

@@ -8,6 +8,8 @@ module Fog
     class Libvirt < Fog::Service
 
       requires :libvirt_uri
+      recognizes :libvirt_username, :libvirt_password
+      recognizes :libvirt_ip_command
 
       model_path 'fog/libvirt/models/compute'
       model       :server
@@ -60,7 +62,7 @@ module Fog
             end
 
           rescue ::Libvirt::ConnectionError
-            raise Fog::Errors::Error.new("Error making a connection to libvirt URI #{@uri.uri}:\n#{$!}")
+            raise Fog::Errors::Error.new("Error making a connection to libvirt URI #{uri.uri}:\n#{$!}")
           end
 
         end
@@ -84,10 +86,12 @@ module Fog
               end
             end
           end
-          newuri=uri+append
-          return newuri
+          uri+append
         end
 
+        def respond_to?(method, *)
+          super or @connection.respond_to? method
+        end
 
         # hack to provide 'requests'
         def method_missing(method_sym, *arguments, &block)

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

@@ -26,10 +26,8 @@ module Fog
               node_info[param]=nil
             end
           end
-          node_info[:uri]=connection.connection.uri
+          node_info[:uri]=connection.uri
           data << { :raw => node_info }
-          require 'pp'
-          pp node_info
           load(data)
         end
 

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

@@ -48,100 +48,73 @@ module Fog
         # @returns server/domain created
         def initialize(attributes={} )
 
-          self.xml  ||= nil unless attributes[:xml]
-          self.persistent ||=true unless attributes[:persistent]
-          self.cpus ||=1 unless attributes[:cpus]
-          self.memory_size ||=256 *1024 unless attributes[:memory_size]
-          self.name ||="fog-#{SecureRandom.random_number*10E14.to_i.round}" unless attributes[:name]
-
-          self.os_type ||="hvm" unless attributes[:os_type]
-          self.arch ||="x86_64" unless attributes[:arch]
-
-          self.domain_type ||="kvm" unless attributes[:domain_type]
-
-          self.iso_file ||=nil unless attributes[:iso_file]
-          self.iso_dir ||="/var/lib/libvirt/images" unless attributes[:iso_dir]
-
-          self.volume_format_type ||=nil unless attributes[:volume_format_type]
-          self.volume_capacity ||=nil unless attributes[:volume_capacity]
-          self.volume_allocation ||=nil unless attributes[:volume_allocation]
-
-          self.volume_name ||=nil unless attributes[:volume_name]
-          self.volume_pool_name ||=nil unless attributes[:volume_pool_name]
-          self.volume_template_name ||=nil unless attributes[:volume_template_name]
-
-          self.network_interface_type ||="nat" unless attributes[:network_interface_type]
-          self.network_nat_network ||="default" unless attributes[:network_nat_network]
-          self.network_bridge_name ||="br0" unless attributes[:network_bridge_name]
+          # 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') if uuid
+          raise Fog::Errors::Error.new('Resaving an existing server may create a duplicate') unless new?
 
           validate_template_options
 
-          xml=xml_from_template if xml.nil?
+          xml ||= xml_from_template
 
           create_or_clone_volume
 
-          xml=xml_from_template
+          xml = xml_from_template
 
           # We either now have xml provided by the user or generated by the template
           begin
-            if !xml.nil?
-              domain=nil
-              if self.persistent
-                domain=connection.raw.define_domain_xml(xml)
-              else
-                domain=connection.raw.create_domain_xml(xml)
-              end
-              self.raw=domain
+            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 = Hash.new
 
-          unless self.volume_name.nil?
-            volume_options[:name]=self.volume_name
-          else
-            extension = self.volume_format_type.nil? ? "img" : self.volume_format_type
-            volume_name = "#{self.name}.#{extension}"
-            volume_options[:name]=volume_name
-          end
+          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)
+            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.length==1
+            raise Fog::Errors::Error.new("Template #{self.volume_template_name} not found") unless template_volumes.empty?
 
-            orig_volume=template_volumes.first
-            self.volume_format_type=orig_volume.format_type unless self.volume_format_type
-            volume=orig_volume.clone("#{volume_options[:name]}")
+            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
+            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 unless self.volume_format_type.nil?
-            volume_options[:capacity]=self.volume_capacity unless self.volume_capacity.nil?
-            volume_options[:allocation]=self.volume_allocation unless self.volume_allocation.nil?
+            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 unless self.volume_format_type
+              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
@@ -158,27 +131,27 @@ module Fog
         def xml_from_template
 
           template_options={
-            :cpus => self.cpus,
-            :memory_size => self.memory_size,
-            :domain_type => self.domain_type,
-            :name => self.name,
-            :iso_file => self.iso_file,
-            :iso_dir => self.iso_dir,
-            :os_type => self.os_type,
-            :arch => self.arch,
-            :volume_path => self.volume_path,
-            :volume_format_type => self.volume_format_type,
-            :network_interface_type => self.network_interface_type,
-            :network_nat_network => self.network_nat_network,
-            :network_bridge_name => self.network_bridge_name
+            :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)
-          result=erb.result(vars_binding)
-          return result
+          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
@@ -202,10 +175,14 @@ module Fog
         # In fog a destroy means the remove of a machine
         def destroy(options={ :destroy_volumes => false})
           requires :raw
-          if @raw.active?
-            @raw.destroy
-          end
+          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
@@ -215,7 +192,7 @@ module Fog
 
         # Alias for poweroff
         def halt
-           poweroff
+          poweroff
         end
 
         # In libvirt a destroy means a hard power-off of the domain
@@ -250,7 +227,10 @@ module Fog
                 when 5 then "shutoff"
                 when 6 then "crashed"
                 end
-          return state
+        end
+
+        def stopped?
+          state == "shutoff"
         end
 
         def ready?
@@ -259,20 +239,15 @@ module Fog
 
         def stop
           requires :raw
-
           @raw.shutdown
         end
 
-        #def xml_desc
-          #requires :raw
-          #raw.xml_desc
-        #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
 
@@ -282,7 +257,7 @@ module Fog
           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}; "+ip_command_local
+          ip_command="mac=#{mac}; server_name=#{name}; "+ip_command_local
 
           ip_address=nil
 
@@ -480,21 +455,20 @@ module Fog
         # Retrieves the mac address from parsing the XML of the domain
         def mac
           mac = document("domain/devices/interface/mac", "address")
-          return mac
         end
 
         def vnc_port
-
           port = document("domain/devices/graphics[@type='vnc']", "port")
-          return port
         end
 
+        def disk_path
+          document("domain/devices/disk/source", "file")
+        rescue
+          []
+        end
 
         private
-
-        def raw
-          @raw
-        end
+        attr_reader :raw
 
         def raw=(new_raw)
           @raw = new_raw
@@ -516,13 +490,33 @@ module Fog
           merge_attributes(raw_attributes)
         end
 
+        def randomized_name
+          "fog-#{SecureRandom.random_number*10E14.to_i.round}"
+        end
 
-        # finds a value from xml
-        def document path, attribute=nil
-          xml = REXML::Document.new(self.xml)
-          attribute.nil? ? xml.elements[path].text : xml.elements[path].attributes[attribute]
+        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
 

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

@@ -44,7 +44,8 @@ module Fog
         end
 
         def get(uuid)
-          self.all(:uuid => uuid).first
+          vm = all(:uuid => uuid)
+          vm.first if vm
         end
 
         def bootstrap(new_attributes = {})

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

@@ -9,7 +9,7 @@ module Fog
       # finds a value from xml
       def document path, attribute=nil
         return nil if new?
-        xml = REXML::Document.new(@xml_desc)
+        xml = REXML::Document.new(self.xml)
         attribute.nil? ? xml.elements[path].text : xml.elements[path].attributes[attribute]
       end
 
@@ -19,7 +19,6 @@ module Fog
         end
       end
 
-
     end
   end
 end

data/lib/brightbox-cli/vendor/fog/lib/fog/providers.rb

@@ -1,6 +1,8 @@
 require 'fog/aws'
 require 'fog/bluebox'
 require 'fog/brightbox'
+require 'fog/cloudstack'
+require 'fog/clodo'
 require 'fog/dnsimple'
 require 'fog/dnsmadeeasy'
 require 'fog/dynect'

data/lib/brightbox-cli/vendor/fog/lib/fog/rackspace/dns.rb

@@ -5,12 +5,20 @@ module Fog
   module DNS
     class Rackspace < Fog::Service
 
+      class CallbackError < Fog::Errors::Error
+        attr_reader :response, :message, :details
+        def initialize(response)
+          @response = response
+          @message = response.body['error']['message']
+          @details = response.body['error']['details']
+        end
+      end
+
       US_ENDPOINT = 'https://dns.api.rackspacecloud.com/v1.0'
       UK_ENDPOINT = 'https://lon.dns.api.rackspacecloud.com/v1.0'
 
       requires :rackspace_api_key, :rackspace_username
-      recognizes :rackspace_auth_url
-      recognizes :rackspace_auth_token
+      recognizes :rackspace_auth_url, :rackspace_auth_token, :rackspace_dns_endpoint
 
       model_path 'fog/rackspace/models/dns'
       model       :record