knife-openstack 0.8.1 → 0.9.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 95a3012f4a18397d8840ffad36f4aa5545b15d17
+  data.tar.gz: a3a46d384665f841b14f8a25c3db3a6e9ff844ef
+SHA512:
+  metadata.gz: d10c999e511ea659c126a0d03584e9c3bea328620013e885de993426ccd8734503835e0a35dc138c460734451bd81b49a7f48d11d12189c05eec03fc6dfc46ef
+  data.tar.gz: c6abb54a3f2a3119e727c981828f59bcfe41522c7b264d82c7476a4687619f91fc776efeaa613f331c325b079ccb0092367d6c39e1a84bfeb20d658796cf268c

data/CHANGELOG.md

@@ -1,14 +1,18 @@
-## v0.8.1
+## v0.9.0
+* KNIFE-231 added ability to specify arbitrary bootstrap network ID
+* KNIFE-277 knife openstack "ERROR: No IP address available for bootstrapping."
+* KNIFE-310 "knife openstack server list" will fail with boot from volume instances
+* KNIFE-435 Support user data for OpenStack server create
+* https://github.com/opscode/chef-rfc/pull/7/
 
+## v0.8.1
 * KNIFE-296 knife-windows overrides -i, -p, -P and -x options with winrm values
 * KNIFE-304 enable setting the ssh port for knife-openstack
 
 ## v0.8.0
-
 * KNIFE-221 Windows bootstrapping (winrm-based) support for knife-openstack (Chirag Jog)
 
 ## v0.7.1
-
 * KNIFE-261 file permissions fixed
 
 ## v0.7.0

data/README.md

@@ -38,6 +38,10 @@ If your OpenStack deployment is over SSL, but does not have a valid certificate,
 
     knife[:openstack_insecure] = true
 
+If you need to use alternate service endpoints for communicating with OpenStack, you can set the following option:
+
+    knife[:openstack_endpoint_type] = "internalURL"
+
 You also have the option of passing your OpenStack API Username/Password into the individual knife subcommands using the `-A` (or `--openstack-username`) `-K` (or `--openstack-password`) command options
 
     # provision a new image named kb01

data/lib/chef/knife/openstack_base.rb

@@ -59,18 +59,25 @@ class Chef
             :description => "Your OpenStack API endpoint",
             :proc => Proc.new { |endpoint| Chef::Config[:knife][:openstack_auth_url] = endpoint }
 
+          option :openstack_endpoint_type,
+            :long => "--openstack-endpoint-type ENDPOINT_TYPE",
+            :description => "OpenStack endpoint type to use (publicURL, internalURL, adminURL)",
+            :proc => Proc.new { |type| Chef::Config[:knife][:openstack_endpoint_type] = type }
+
           option :openstack_insecure,
             :long => "--insecure",
             :description => "Ignore SSL certificate on the Auth URL",
             :boolean => true,
             :default => false,
             :proc => Proc.new { |key| Chef::Config[:knife][:openstack_insecure] = key }
+
         end
       end
 
       def connection
         Chef::Log.debug("openstack_username #{Chef::Config[:knife][:openstack_username]}")
         Chef::Log.debug("openstack_auth_url #{Chef::Config[:knife][:openstack_auth_url]}")
+        Chef::Log.debug("openstack_endpoint_type #{Chef::Config[:knife][:openstack_endpoint_type] || 'publicURL' }")
         Chef::Log.debug("openstack_tenant #{Chef::Config[:knife][:openstack_tenant]}")
         Chef::Log.debug("openstack_insecure #{Chef::Config[:knife][:openstack_insecure].to_s}")
 
@@ -80,6 +87,7 @@ class Chef
             :openstack_username => Chef::Config[:knife][:openstack_username],
             :openstack_api_key => Chef::Config[:knife][:openstack_password],
             :openstack_auth_url => Chef::Config[:knife][:openstack_auth_url],
+            :openstack_endpoint_type => Chef::Config[:knife][:openstack_endpoint_type],
             :openstack_tenant => Chef::Config[:knife][:openstack_tenant],
             :connection_options => {
               :ssl_verify_peer => !Chef::Config[:knife][:openstack_insecure]
@@ -120,22 +128,21 @@ class Chef
         end
       end
 
-      # http://tickets.opscode.com/browse/KNIFE-248
       def primary_private_ip_address(addresses)
-        if addresses['private']
-          return addresses['private'].last['addr']
-        end
+        primary_network_ip_address(addresses, 'private')
       end
 
       #we use last since the floating IP goes there
       def primary_public_ip_address(addresses)
-        if addresses['public']
-          return addresses['public'].last['addr']
+        primary_network_ip_address(addresses, 'public')
+      end
+
+      def primary_network_ip_address(addresses, network_name)
+        if addresses[network_name]
+          return addresses[network_name].last['addr']
         end
       end
 
     end
   end
 end
-
-

data/lib/chef/knife/openstack_server_create.rb

@@ -1,8 +1,8 @@
 #
-# Author:: Seth Chisamore (<schisamo@opscode.com>)
-# Author:: Matt Ray (<matt@opscode.com>)
+# Author:: Seth Chisamore (<schisamo@getchef.com>)
+# Author:: Matt Ray (<matt@getchef.com>)
 # Author:: Chirag Jog (<chirag@clogeny.com>)
-# Copyright:: Copyright (c) 2011-2013 Opscode, Inc.
+# Copyright:: Copyright (c) 2011-2014 Chef Software, Inc.
 # License:: Apache License, Version 2.0
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
@@ -24,7 +24,6 @@ require 'chef/knife/winrm_base'
 class Chef
   class Knife
     class OpenstackServerCreate < Knife
-
       include Knife::OpenstackBase
       include Chef::Knife::WinrmBase
 
@@ -70,6 +69,17 @@ class Chef
       :default => "-1",
       :description => "Request to associate a floating IP address to the new OpenStack node. Assumes IPs have been allocated to the project. Specific IP is optional."
 
+      option :bootstrap_network,
+      :long => '--bootstrap-network NAME',
+      :default => 'public',
+      :description => "Specify network for bootstrapping. Default is 'public'."
+
+      option :network,
+      :long => "--no-network",
+      :boolean => true,
+      :default => true,
+      :description => "Use first available network for bootstrapping if 'public' and 'private' are unavailable."
+
       option :private_network,
       :long => "--private-network",
       :description => "Use the private IP for bootstrapping rather than the public IP",
@@ -154,7 +164,19 @@ class Chef
       :long => "--server-create-timeout timeout",
       :description => "How long to wait until the server is ready; default is 600 seconds",
       :default => 600,
-      :proc => Proc.new { |v| Chef::Config[:knife][:server_create_timeouts] = v}
+      :proc => Proc.new { |v| Chef::Config[:knife][:server_create_timeouts] = v }
+
+      option :first_boot_attributes,
+      :short => "-j JSON_ATTRIBS",
+      :long => "--json-attributes JSON_ATTRIBS",
+      :description => "A JSON string to be added to the first run of chef-client",
+      :proc => lambda { |o| JSON.parse(o) },
+      :default => {}
+
+      option :user_data,
+      :long => "--user-data USER_DATA",
+      :description => "The file path containing user data information for this server",
+      :proc => Proc.new { |user_data| open(user_data) { |f| f.read }  }
 
       def tcp_test_ssh(hostname, port)
         tcp_socket = TCPSocket.new(hostname, port)
@@ -240,217 +262,228 @@ class Chef
             config[:identity_file] = locate_config_value(:kerberos_keytab_file)
           end
         end
-        #servers require a name, generate one if not passed
+        # servers require a name, generate one if not passed
         node_name = get_node_name(config[:chef_node_name])
 
         server_def = {
-        :name => node_name,
-        :image_ref => locate_config_value(:image),
-        :flavor_ref => locate_config_value(:flavor),
-        :security_groups => locate_config_value(:security_groups),
-        :key_name => locate_config_value(:openstack_ssh_key_id)
-      }
-
-      Chef::Log.debug("Name #{node_name}")
-      Chef::Log.debug("Image #{locate_config_value(:image)}")
-      Chef::Log.debug("Flavor #{locate_config_value(:flavor)}")
-      Chef::Log.debug("Requested Floating IP #{locate_config_value(:floating_ip)}")
-      Chef::Log.debug("Security Groups #{locate_config_value(:security_groups)}")
-      Chef::Log.debug("Creating server #{server_def}")
-
-      begin
-        server = connection.servers.create(server_def)
-      rescue Excon::Errors::BadRequest => e
-        response = Chef::JSONCompat.from_json(e.response.body)
-        if response['badRequest']['code'] == 400
-          if response['badRequest']['message'] =~ /Invalid flavorRef/
-            ui.fatal("Bad request (400): Invalid flavor specified: #{server_def[:flavor_ref]}")
-            exit 1
+          :name => node_name,
+          :image_ref => locate_config_value(:image),
+          :flavor_ref => locate_config_value(:flavor),
+          :security_groups => locate_config_value(:security_groups),
+          :key_name => locate_config_value(:openstack_ssh_key_id),
+          :user_data => locate_config_value(:user_data)
+        }
+
+        Chef::Log.debug("Name #{node_name}")
+        Chef::Log.debug("Image #{locate_config_value(:image)}")
+        Chef::Log.debug("Flavor #{locate_config_value(:flavor)}")
+        Chef::Log.debug("Requested Floating IP #{locate_config_value(:floating_ip)}")
+        Chef::Log.debug("Security Groups #{locate_config_value(:security_groups)}")
+        Chef::Log.debug("User Data #{locate_config_value(:user_data)}")
+        Chef::Log.debug("Creating server #{server_def}")
+
+        begin
+          server = connection.servers.create(server_def)
+        rescue Excon::Errors::BadRequest => e
+          response = Chef::JSONCompat.from_json(e.response.body)
+          if response['badRequest']['code'] == 400
+            if response['badRequest']['message'] =~ /Invalid flavorRef/
+              ui.fatal("Bad request (400): Invalid flavor specified: #{server_def[:flavor_ref]}")
+              exit 1
+            else
+              ui.fatal("Bad request (400): #{response['badRequest']['message']}")
+              exit 1
+            end
           else
-            ui.fatal("Bad request (400): #{response['badRequest']['message']}")
-            exit 1
+            ui.fatal("Unknown server error (#{response['badRequest']['code']}): #{response['badRequest']['message']}")
+            raise e
           end
-        else
-          ui.fatal("Unknown server error (#{response['badRequest']['code']}): #{response['badRequest']['message']}")
-          raise e
         end
-      end
 
-      msg_pair("Instance Name", server.name)
-      msg_pair("Instance ID", server.id)
+        msg_pair("Instance Name", server.name)
+        msg_pair("Instance ID", server.id)
+
+        print "\n#{ui.color("Waiting for server", :magenta)}"
+
+        # wait for it to be ready to do stuff
+        server.wait_for(Integer(locate_config_value(:server_create_timeout))) { print "."; ready? }
+
+        puts("\n")
+
+        msg_pair("Flavor", server.flavor['id'])
+        msg_pair("Image", server.image['id'])
+        msg_pair("SSH Identity File", config[:identity_file])
+        msg_pair("SSH Keypair", server.key_name) if server.key_name
+        msg_pair("SSH Password", server.password) if (server.password && !server.key_name)
+        Chef::Log.debug("Addresses #{server.addresses}")
+
+        msg_pair("Public IP Address", primary_public_ip_address(server.addresses)) if primary_public_ip_address(server.addresses)
+        msg_pair("Private IP Address", primary_private_ip_address(server.addresses)) if primary_private_ip_address(server.addresses)
+
+        floating_address = locate_config_value(:floating_ip)
+        Chef::Log.debug("Floating IP Address requested #{floating_address}")
+        unless (floating_address == '-1') # no floating IP requested
+          addresses = connection.addresses
+          # floating requested without value
+          if floating_address.nil?
+            free_floating = addresses.find_index { |a| a.fixed_ip.nil? }
+            if free_floating.nil? # no free floating IP found
+              ui.error("Unable to assign a Floating IP from allocated IPs.")
+              exit 1
+            else
+              floating_address = addresses[free_floating].ip
+            end
+          end
+          server.associate_address(floating_address)
+          # bit of a hack, but server.reload takes a long time
+          (server.addresses['public'] ||= []) << { "version" => 4, "addr" => floating_address }
+          msg_pair("Floating IP Address", floating_address)
+        end
 
-      print "\n#{ui.color("Waiting for server", :magenta)}"
+        Chef::Log.debug("Addresses #{server.addresses}")
+        Chef::Log.debug("Public IP Address actual: #{primary_public_ip_address(server.addresses)}") if primary_public_ip_address(server.addresses)
 
-      # wait for it to be ready to do stuff
-      server.wait_for(Integer(locate_config_value(:server_create_timeout))) { print "."; ready? }
+        # private_network means bootstrap_network = 'private'
+        config[:bootstrap_network] = 'private' if config[:private_network]
 
-      puts("\n")
+        unless config[:network] # --no-network
+          bootstrap_ip_address = primary_public_ip_address(server.addresses) ||
+            primary_private_ip_address(server.addresses) ||
+            server.addresses.first
+          Chef::Log.debug("No Bootstrap Network: #{config[:bootstrap_network]}")
+        else
+          bootstrap_ip_address = primary_network_ip_address(server.addresses, config[:bootstrap_network])
+          Chef::Log.debug("Bootstrap Network: #{config[:bootstrap_network]}")
+        end
 
-      msg_pair("Flavor", server.flavor['id'])
-      msg_pair("Image", server.image['id'])
-      msg_pair("SSH Identity File", config[:identity_file])
-      msg_pair("SSH Keypair", server.key_name) if server.key_name
-      msg_pair("SSH Password", server.password) if (server.password && !server.key_name)
-      Chef::Log.debug("Addresses #{server.addresses}")
-      msg_pair("Public IP Address", primary_public_ip_address(server.addresses)) if primary_public_ip_address(server.addresses)
+        Chef::Log.debug("Bootstrap IP Address: #{bootstrap_ip_address}")
+        if bootstrap_ip_address.nil?
+          ui.error("No IP address available for bootstrapping.")
+          exit 1
+        end
 
-      floating_address = locate_config_value(:floating_ip)
-      Chef::Log.debug("Floating IP Address requested #{floating_address}")
-      unless (floating_address == '-1') #no floating IP requested
-        addresses = connection.addresses
-        #floating requested without value
-        if floating_address.nil?
-          free_floating = addresses.find_index {|a| a.fixed_ip.nil?}
-          if free_floating.nil? #no free floating IP found
-            ui.error("Unable to assign a Floating IP from allocated IPs.")
-            exit 1
-          else
-            floating_address = addresses[free_floating].ip
-          end
+        if locate_config_value(:bootstrap_protocol) == 'winrm'
+          print "\n#{ui.color("Waiting for winrm", :magenta)}"
+          print(".") until tcp_test_winrm(bootstrap_ip_address, locate_config_value(:winrm_port))
+          bootstrap_for_windows_node(server, bootstrap_ip_address).run
+        else
+          Chef::Log.debug("Waiting for sshd on IP address: #{bootstrap_ip_address} and port: #{locate_config_value(:ssh_port)}")
+          print "\n#{ui.color("Waiting for sshd", :magenta)}"
+          print(".") until tcp_test_ssh(bootstrap_ip_address, locate_config_value(:ssh_port)) {
+            sleep @initial_sleep_delay ||= 10
+            puts("done")
+          }
+          bootstrap_for_node(server, bootstrap_ip_address).run
+        end
+        puts "\n"
+        msg_pair("Instance Name", server.name)
+        msg_pair("Instance ID", server.id)
+        msg_pair("Flavor", server.flavor['id'])
+        msg_pair("Image", server.image['id'])
+        msg_pair("SSH Keypair", server.key_name) if server.key_name
+        msg_pair("SSH Password", server.password) if (server.password && !server.key_name)
+        server.addresses.each do |name,addr|
+          msg_pair("Network", name)
+          msg_pair("  IP Address", addr[0]['addr'])
         end
-        server.associate_address(floating_address)
-        #a bit of a hack, but server.reload takes a long time
-        (server.addresses['public'] ||= []) << {"version"=>4,"addr"=>floating_address}
-        msg_pair("Floating IP Address", floating_address)
+        msg_pair("Environment", config[:environment] || '_default')
+        msg_pair("Run List", config[:run_list].join(', '))
       end
 
-      Chef::Log.debug("Addresses #{server.addresses}")
-      Chef::Log.debug("Public IP Address actual: #{primary_public_ip_address(server.addresses)}") if primary_public_ip_address(server.addresses)
-
-      msg_pair("Private IP Address", primary_private_ip_address(server.addresses)) if primary_private_ip_address(server.addresses)
-
-      #which IP address to bootstrap
-      bootstrap_ip_address = primary_public_ip_address(server.addresses) if primary_public_ip_address(server.addresses)
-      if config[:private_network]
-        bootstrap_ip_address = primary_private_ip_address(server.addresses)
+      def bootstrap_for_windows_node(server, bootstrap_ip_address)
+        bootstrap = Chef::Knife::BootstrapWindowsWinrm.new
+        bootstrap.name_args = [bootstrap_ip_address]
+        bootstrap.config[:winrm_user] = locate_config_value(:winrm_user) || 'Administrator'
+        bootstrap.config[:winrm_password] = locate_config_value(:winrm_password)
+        bootstrap.config[:winrm_transport] = locate_config_value(:winrm_transport)
+        bootstrap.config[:winrm_port] = locate_config_value(:winrm_port)
+        bootstrap_common_params(bootstrap, server.name)
       end
 
-      Chef::Log.debug("Bootstrap IP Address: #{bootstrap_ip_address}")
-      if bootstrap_ip_address.nil?
-        ui.error("No IP address available for bootstrapping.")
-        exit 1
+      def bootstrap_common_params(bootstrap, server_name)
+        bootstrap.config[:chef_node_name] = config[:chef_node_name] || server_name
+        bootstrap.config[:run_list] = config[:run_list]
+        bootstrap.config[:prerelease] = config[:prerelease]
+        bootstrap.config[:bootstrap_version] = locate_config_value(:bootstrap_version)
+        bootstrap.config[:distro] = locate_config_value(:distro)
+        bootstrap.config[:template_file] = locate_config_value(:template_file)
+        bootstrap.config[:bootstrap_proxy] = locate_config_value(:bootstrap_proxy)
+        bootstrap.config[:environment] = config[:environment]
+        bootstrap.config[:encrypted_data_bag_secret] = config[:encrypted_data_bag_secret]
+        bootstrap.config[:encrypted_data_bag_secret_file] = config[:encrypted_data_bag_secret_file]
+        # let ohai know we're using OpenStack
+        Chef::Config[:knife][:hints] ||= {}
+        Chef::Config[:knife][:hints]['openstack'] ||= {}
+        bootstrap
       end
 
-      if locate_config_value(:bootstrap_protocol) == 'winrm'
-        print "\n#{ui.color("Waiting for winrm", :magenta)}"
-        print(".") until tcp_test_winrm(bootstrap_ip_address, locate_config_value(:winrm_port))
-        bootstrap_for_windows_node(server, bootstrap_ip_address).run
-      else
-        Chef::Log.debug("Waiting for sshd on IP address: #{bootstrap_ip_address} and port: #{locate_config_value(:ssh_port)}")
-        print "\n#{ui.color("Waiting for sshd", :magenta)}"
-        print(".") until tcp_test_ssh(bootstrap_ip_address, locate_config_value(:ssh_port)) {
-          sleep @initial_sleep_delay ||= 10
-          puts("done")
-        }
-        bootstrap_for_node(server, bootstrap_ip_address).run
+      def bootstrap_for_node(server, bootstrap_ip_address)
+        bootstrap = Chef::Knife::Bootstrap.new
+        bootstrap.name_args = [bootstrap_ip_address]
+        bootstrap.config[:ssh_user] = config[:ssh_user]
+        bootstrap.config[:ssh_port] = config[:ssh_port]
+        bootstrap.config[:identity_file] = config[:identity_file]
+        bootstrap.config[:host_key_verify] = config[:host_key_verify]
+        bootstrap.config[:use_sudo] = true unless config[:ssh_user] == 'root'
+        bootstrap_common_params(bootstrap, server.name)
       end
-      puts "\n"
-      msg_pair("Instance Name", server.name)
-      msg_pair("Instance ID", server.id)
-      msg_pair("Flavor", server.flavor['id'])
-      msg_pair("Image", server.image['id'])
-      msg_pair("SSH Keypair", server.key_name) if server.key_name
-      msg_pair("SSH Password", server.password) if (server.password && !server.key_name)
-      msg_pair("Public IP Address", primary_public_ip_address(server.addresses)) if primary_public_ip_address(server.addresses)
-      msg_pair("Private IP Address", primary_private_ip_address(server.addresses)) if primary_private_ip_address(server.addresses)
-      msg_pair("Environment", config[:environment] || '_default')
-      msg_pair("Run List", config[:run_list].join(', '))
-    end
-
-    def bootstrap_for_windows_node(server, bootstrap_ip_address)
-      bootstrap = Chef::Knife::BootstrapWindowsWinrm.new
-      bootstrap.name_args = [bootstrap_ip_address]
-      bootstrap.config[:winrm_user] = locate_config_value(:winrm_user) || 'Administrator'
-      bootstrap.config[:winrm_password] = locate_config_value(:winrm_password)
-      bootstrap.config[:winrm_transport] = locate_config_value(:winrm_transport)
-      bootstrap.config[:winrm_port] = locate_config_value(:winrm_port)
-      bootstrap_common_params(bootstrap, server.name)
-    end
 
-    def bootstrap_common_params(bootstrap, server_name)
-      bootstrap.config[:chef_node_name] = config[:chef_node_name] || server_name
-      bootstrap.config[:run_list] = config[:run_list]
-      bootstrap.config[:prerelease] = config[:prerelease]
-      bootstrap.config[:bootstrap_version] = locate_config_value(:bootstrap_version)
-      bootstrap.config[:distro] = locate_config_value(:distro)
-      bootstrap.config[:template_file] = locate_config_value(:template_file)
-      bootstrap.config[:bootstrap_proxy] = locate_config_value(:bootstrap_proxy)
-      bootstrap.config[:environment] = config[:environment]
-      bootstrap.config[:encrypted_data_bag_secret] = config[:encrypted_data_bag_secret]
-      bootstrap.config[:encrypted_data_bag_secret_file] = config[:encrypted_data_bag_secret_file]
-      # let ohai know we're using OpenStack
-      Chef::Config[:knife][:hints] ||= {}
-      Chef::Config[:knife][:hints]['openstack'] ||= {}
-      bootstrap
-    end
-
-    def bootstrap_for_node(server, bootstrap_ip_address)
-      bootstrap = Chef::Knife::Bootstrap.new
-      bootstrap.name_args = [bootstrap_ip_address]
-      bootstrap.config[:ssh_user] = config[:ssh_user]
-      bootstrap.config[:ssh_port] = config[:ssh_port]
-      bootstrap.config[:identity_file] = config[:identity_file]
-      bootstrap.config[:host_key_verify] = config[:host_key_verify]
-      bootstrap.config[:use_sudo] = true unless config[:ssh_user] == 'root'
-      bootstrap_common_params(bootstrap, server.name)
-    end
-
-    def flavor
-      @flavor ||= connection.flavors.get(locate_config_value(:flavor))
-    end
-
-    def image
-      @image ||= connection.images.get(locate_config_value(:image))
-    end
+      def flavor
+        @flavor ||= connection.flavors.get(locate_config_value(:flavor))
+      end
 
-    def is_floating_ip_valid
-      address = locate_config_value(:floating_ip)
-      if address == '-1' #no floating IP requested
-        return true
+      def image
+        @image ||= connection.images.get(locate_config_value(:image))
       end
-      addresses = connection.addresses
-      return false if addresses.empty? #no floating IPs
-      #floating requested without value
-      if address.nil?
-        if addresses.find_index {|a| a.fixed_ip.nil?}
+
+      def is_floating_ip_valid
+        address = locate_config_value(:floating_ip)
+        if address == '-1' # no floating IP requested
+          return true
+        end
+        addresses = connection.addresses
+        return false if addresses.empty? # no floating IPs
+        # floating requested without value
+        if address.nil?
+          if addresses.find_index { |a| a.fixed_ip.nil? }
+            return true
+          else
+            return false # no floating IPs available
+          end
+        end
+        # floating requested with value
+        if addresses.find_index { |a| a.ip == address }
           return true
         else
-          return false #no floating IPs available
+          return false # requested floating IP does not exist
         end
       end
-      #floating requested with value
-      if addresses.find_index {|a| a.ip == address}
-        return true
-      else
-        return false #requested floating IP does not exist
-      end
-    end
 
-    def validate!
-      super([:image, :openstack_username, :openstack_password, :openstack_auth_url])
+      def validate!
+        super([:image, :openstack_username, :openstack_password, :openstack_auth_url])
 
-      if flavor.nil?
-        ui.error("You have not provided a valid flavor ID. Please note the options for this value are -f or --flavor.")
-        exit 1
-      end
+        if flavor.nil?
+          ui.error("You have not provided a valid flavor ID. Please note the options for this value are -f or --flavor.")
+          exit 1
+        end
 
-      if image.nil?
-        ui.error("You have not provided a valid image ID. Please note the options for this value are -I or --image.")
-        exit 1
-      end
+        if image.nil?
+          ui.error("You have not provided a valid image ID. Please note the options for this value are -I or --image.")
+          exit 1
+        end
 
-      if !is_floating_ip_valid
-        ui.error("You have either requested an invalid floating IP address or none are available.")
-        exit 1
+        if !is_floating_ip_valid
+          ui.error("You have either requested an invalid floating IP address or none are available.")
+          exit 1
+        end
       end
-    end
 
-    #generate a random name if chef_node_name is empty
-    def get_node_name(chef_node_name)
-      return chef_node_name unless chef_node_name.nil?
-      #lazy uuids
-      chef_node_name = "os-"+rand.to_s.split('.')[1]
+      # generate a random name if chef_node_name is empty
+      def get_node_name(chef_node_name)
+        return chef_node_name unless chef_node_name.nil?
+        # lazy uuids
+        chef_node_name = "os-" + rand.to_s.split('.')[1]
+      end
     end
   end
 end
-end

data/lib/chef/knife/openstack_server_delete.rb

@@ -70,9 +70,10 @@ class Chef
             msg_pair("Instance ID", server.id)
             msg_pair("Flavor", server.flavor['id'])
             msg_pair("Image", server.image['id'])
-            msg_pair("Public IP Address", primary_public_ip_address(server.addresses)) if primary_public_ip_address(server.addresses)
-            msg_pair("Private IP Address", primary_private_ip_address(server.addresses)) if primary_private_ip_address(server.addresses)
-
+            server.addresses.each do |name,addr|
+              msg_pair("Network", name)
+              msg_pair("  IP Address", addr[0]['addr'])
+            end
 
             puts "\n"
             confirm("Do you really want to delete this server")

data/lib/chef/knife/openstack_server_list.rb

@@ -58,7 +58,11 @@ class Chef
               server_list << ''
             end
             server_list << server.flavor['id'].to_s
-            server_list << server.image['id'].to_s
+            if server.image
+              server_list << server.image['id']
+            else
+              server_list << ""
+            end
             server_list << server.key_name
             server_list << begin
                              state = server.state.to_s.downcase

data/lib/knife-openstack/version.rb

@@ -1,6 +1,6 @@
 module Knife
   module OpenStack
-    VERSION = "0.8.1"
+    VERSION = '0.9.0'
     MAJOR, MINOR, TINY = VERSION.split('.')
   end
 end

data/spec/unit/openstack_server_create_spec.rb

@@ -10,10 +10,10 @@ require 'chef/knife/bootstrap_windows_winrm'
 describe Chef::Knife::OpenstackServerCreate do
   before do
 
-    @openstack_connection = mock(Fog::Compute::OpenStack)
+    @openstack_connection = double(Fog::Compute::OpenStack)
     @openstack_connection.stub_chain(:flavors, :get).and_return ('flavor_id')
-    @openstack_connection.stub_chain(:images, :get).and_return mock('image_id')
-    @openstack_connection.stub_chain(:addresses).and_return [mock('addresses', {
+    @openstack_connection.stub_chain(:images, :get).and_return double('image_id')
+    @openstack_connection.stub_chain(:addresses).and_return [double('addresses', {
           :instance_id => nil,
           :ip => '111.111.111.111',
           :fixed_ip => true
@@ -39,8 +39,8 @@ describe Chef::Knife::OpenstackServerCreate do
     @knife_openstack_create.stub(:print)
 
 
-    @openstack_servers = mock()
-    @new_openstack_server = mock()
+    @openstack_servers = double()
+    @new_openstack_server = double()
 
     @openstack_server_attribs = { :name => 'Mock Server',
       :id => 'id-123456',
@@ -71,12 +71,22 @@ describe Chef::Knife::OpenstackServerCreate do
       @options[:floating_ip][:default].should == '-1'
       @options[:host_key_verify][:default].should == true
       @options[:private_network][:default].should == false
+      @options[:network][:default].should == true
+      @options[:bootstrap_network][:default].should == 'public'
       @options[:run_list][:default].should == []
       @options[:security_groups][:default].should == ['default']
       @options[:server_create_timeout][:default].should == 600
       @options[:ssh_port][:default].should == '22'
       @options[:ssh_user][:default].should == 'root'
     end
+
+    it "doesn't set an OpenStack endpoint type by default" do
+        Chef::Config[:knife][:openstack_endpoint_type].should == nil
+    end
+
+    it "user_data should be empty" do
+        Chef::Config[:knife][:user_data].should == nil
+    end
   end
 
   describe "run" do

metadata

@@ -1,8 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: knife-openstack
 version: !ruby/object:Gem::Version
-  version: 0.8.1
-  prerelease: 
+  version: 0.9.0
 platform: ruby
 authors:
 - Seth Chisamore
@@ -10,118 +9,104 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-06-14 00:00:00.000000000 Z
+date: 2014-03-07 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: fog
   requirement: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - '>='
       - !ruby/object:Gem::Version
         version: 1.10.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - '>='
       - !ruby/object:Gem::Version
         version: 1.10.0
 - !ruby/object:Gem::Dependency
   name: chef
   requirement: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - '>='
       - !ruby/object:Gem::Version
         version: 0.10.10
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - '>='
       - !ruby/object:Gem::Version
         version: 0.10.10
 - !ruby/object:Gem::Dependency
   name: knife-windows
   requirement: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - '>='
       - !ruby/object:Gem::Version
         version: '0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - '>='
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
   name: rspec-core
   requirement: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - '>='
       - !ruby/object:Gem::Version
         version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - '>='
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
   name: rspec-expectations
   requirement: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - '>='
       - !ruby/object:Gem::Version
         version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - '>='
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
   name: rspec-mocks
   requirement: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - '>='
       - !ruby/object:Gem::Version
         version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - '>='
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
   name: rspec_junit_formatter
   requirement: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - '>='
       - !ruby/object:Gem::Version
         version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - '>='
       - !ruby/object:Gem::Version
         version: '0'
 description: OpenStack Compute Support for Chef's Knife Command
@@ -153,27 +138,26 @@ files:
 - spec/unit/openstack_server_create_spec.rb
 homepage: https://github.com/opscode/knife-openstack
 licenses: []
+metadata: {}
 post_install_message: 
 rdoc_options: []
 require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement
-  none: false
   requirements:
-  - - ! '>='
+  - - '>='
     - !ruby/object:Gem::Version
       version: '0'
 required_rubygems_version: !ruby/object:Gem::Requirement
-  none: false
   requirements:
-  - - ! '>='
+  - - '>='
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 1.8.25
+rubygems_version: 2.0.14
 signing_key: 
-specification_version: 3
+specification_version: 4
 summary: OpenStack Compute Support for Chef's Knife Command
 test_files:
 - spec/spec_helper.rb