knife-hp 0.3.1 → 0.4.0

data/CHANGELOG.md

@@ -1,14 +1,14 @@
-# TODO #
-This is a list of features currently lacking and (eventually) under development:
-* should we sort the image list like the HP console does? segmented by Public/Partner/Private? "knife hp image list partner"?
-* should the node.name and node.id be the same (might have to fix this in the ohai plugin since this appears unavailable for setting)
-* take either the flavor ID or the flavor name for server create
-* take either the image ID or the image name for server create
-* Show the flavor and image names in `hp server list`
-* Validate ohai cloud support (waiting on OHAI-425)
+## v0.4.0
+* Upgrade to support 13.5 HP Helion Public Cloud Services. For more information check https://docs.hpcloud.com/migration-overview/
+* KNIFE-444 knife-hp incompatible with hpcloud v13.5
+* Added support for HP's regions (US East and US West) and the availability zones within those regions
+* Added 'knife hp network list'
+* Added floating IP address support
+* Added --networks to specify networks to attach to
+* Replaced --private-network with --bootstrap-network
 
 ## v0.3.1
-* KNIFE-309 knife hp server list fails with nil image
+* KNIFE-309 knife hp server list fails with nil image from boot from volume
 
 ## v0.3.0
 * update dependency on to Fog 1.10.0

data/README.md

@@ -1,7 +1,9 @@
 Knife HP
 ========
 
-This is the official Opscode Knife plugin for HP Cloud Compute. This plugin gives knife the ability to create, bootstrap and manage instances in the HP Cloud.
+This is the official Opscode Knife plugin for HP Helion Public Cloud Compute. This plugin gives knife the ability to create, bootstrap and manage instances in the HP Public Cloud 13.5 and later. You may need to go to https://horizon.hpcloud.com and enable Compute under "Activate Services" for the Availability Zones you wish to use. To properly configure your networks (include a router for external access), please refer to https://docs.hpcloud.com/hpcloudconsole.
+
+If you are still using the older version of the API, you may need version 0.3.1 of this plugin, HP's migration and upgrade instructions are here: https://docs.hpcloud.com/migration-overview-reference/.
 
 Please refer to the [CHANGELOG](CHANGELOG.md) for version history.
 
@@ -19,13 +21,13 @@ Depending on your system's configuration, you may need to run this command with
 
 # Configuration #
 
-In order to communicate with HP Compute Cloud's API you will need to tell Knife the Access Key ID, the Secret Key and Tenant ID (found on the "API Keys" page). You may also override the auth URI and availability zone. The easiest way to accomplish this is to create these entries in your `knife.rb` file:
+In order to communicate with HP Helion Compute Cloud's API you will need to tell Knife the Access Key ID, the Secret Key and Tenant ID (found on the "API Keys" page). You may also override the auth URI and availability zone. The easiest way to accomplish this is to create these entries in your `knife.rb` file:
 
     knife[:hp_access_key] = "Your HP Cloud Access Key ID"
     knife[:hp_secret_key] = "Your HP Cloud Secret Key"
     knife[:hp_tenant_id]  = "Your HP Cloud Tenant ID"
     knife[:hp_auth_uri]   = "Your HP Cloud Auth URI" (optional, default is 'https://region-a.geo-1.identity.hpcloudsvc.com:35357/v2.0/')
-    knife[:hp_avl_zone]   = "Your HP Cloud Availability Zone" (optional, default is 'az1', choices are 'az1', 'az2' or 'az3')
+    knife[:hp_avl_zone]   = "Your HP Cloud Availability Zone" (optional, default is 'region-a.geo-1', the other option is 'region-b.geo-1').
 
 If your knife.rb file will be checked into a SCM system (ie readable by others) you may want to read the values from environment variables:
 
@@ -41,7 +43,7 @@ You also have the option of passing your HP Cloud API options from the command l
     `-K` (or `--hp-secret`) your HP Cloud Secret Key
     `-T` (or `--hp-tenant`) your HP Cloud Tenant ID
     `--hp-auth` your HP Cloud Auth URI (optional, default is 'https://region-a.geo-1.identity.hpcloudsvc.com:35357/v2.0/')
-    `-Z` (or `--hp-zone`) your HP Cloud Availability Zone (optional, default is 'az1', choices are 'az1', 'az2' or 'az3')
+    `-Z` (or `--hp-zone`) your HP Cloud Availability Zone (optional, default is 'region-a.geo-1', the other option is 'region-b.geo-1')
 
     knife hp server create -A 'MyUsername' -K 'MyPassword' -T 'MyTenant' -f 101 -I 120 -S hpkeypair -i ~/.ssh/hpkeypair.pem -r 'role[webserver]'
 
@@ -59,46 +61,51 @@ This plugin provides the following Knife subcommands. Specific command options c
 knife hp server create
 ----------------------
 
-Provisions a new server in the HP Compute Cloud and then perform a Chef bootstrap (using the SSH protocol). The goal of the bootstrap is to get Chef installed on the target system so it can run Chef Client with a Chef Server. The main assumption is a baseline OS installation exists (provided by the provisioning). It is primarily intended for Chef Client systems that talk to a Chef Server. By default the server is bootstrapped using the [chef-full](https://github.com/opscode/chef/blob/master/chef/lib/chef/knife/bootstrap/chef-full.erb) template. This can be overridden using the `-d` or `--template-file` command options. If you do not pass a node name with `-N NAME` (or `--node-name NAME`) a name will be generated for the node.
+Provisions a new server in the HP Helion Compute Cloud and then perform a Chef bootstrap (using the SSH protocol). The goal of the bootstrap is to get Chef installed on the target system so it can run Chef Client with a Chef Server. The main assumption is a baseline OS installation exists (provided by the provisioning). It is primarily intended for Chef Client systems that talk to a Chef Server. By default the server is bootstrapped using the [chef-full](https://github.com/opscode/chef/blob/master/chef/lib/chef/knife/bootstrap/chef-full.erb) template. This can be overridden using the `-d` or `--template-file` command options. If you do not pass a node name with `-N NAME` (or `--node-name NAME`) a name will be generated for the node.
+
+    knife hp server create -f 101 -I 202e7659-f7c6-444a-8b32-872fe2ed080c -S hpkeypair -i ~/.ssh/hpkeypair.pem
+
+### networking ###
+
+If you do not specify any `--network-ids` and do not specify the `--bootstrap-network`, the server will connect to the default network and boot off of it. If you are not bootstrapping from the HP network, you will need to request a floating IP address to be associated with your node with `--floating-ip` (or `-a`) with or without specifying the IP.
 
-    knife hp server create -f 101 -I 9883 -S hpkeypair -i ~/.ssh/hpkeypair.pem -Z az2 -x ubuntu
+    knife hp server create -a -f 100 -I 202e7659-f7c6-444a-8b32-872fe2ed080c -S hpkeypair -i ~/.ssh/hpkeypair.pem
 
 knife hp server delete
 ----------------------
 
-Deletes an existing server in the currently configured HP Compute Cloud account. <b>PLEASE NOTE</b> - this does not delete the associated node and client objects from the Chef Server without using the `-P` or `--purge` option to purge the client.
+Deletes an existing server in the currently configured HP Helion Compute Cloud account. <b>PLEASE NOTE</b> - this does not delete the associated node and client objects from the Chef Server without using the `-P` or `--purge` option to purge the client.
 
 knife hp server list
 --------------------
 
-Outputs a list of all servers in the currently configured HP Compute Cloud account. <b>PLEASE NOTE</b> - this shows all instances associated with the account, some of which may not be currently managed by the Chef Server.
+Outputs a list of all servers in the currently configured HP Helion Compute Cloud account by Region. <b>PLEASE NOTE</b> - this shows all instances associated with the account, some of which may not be currently managed by the Chef Server.
 
 knife hp flavor list
 --------------------
 
-Outputs a list of all flavors (hardware configuration for a server) available to the currently configured HP Compute Cloud account. Each flavor has a unique combination of virtual cores, disk space and memory capacity. This data may be useful when choosing a flavor id to pass to the `knife hp server create` subcommand.
+Outputs a list of all flavors (hardware configuration for a server) available to the currently configured HP Helion Compute Cloud account. Each flavor has a unique combination of virtual CPUs, disk space and memory capacity. This data may be useful when choosing a flavor id to pass to the `knife hp server create` subcommand.
 
 knife hp image list
 -------------------
 
-Outputs a list of all images available to the currently configured HP Compute Cloud account. An image is a collection of files used to create or rebuild a server. The returned list filtered and does not contain images with "(deprecated)", "(Kernel)" or "(Ramdisk)" in their names (this may be disabled with `--disable-filter`). This data may be useful when choosing an image id to pass to the `knife hp server create` subcommand.
+Outputs a list of all images available to the currently configured HP Helion Compute Cloud account. An image is a collection of files used to create or rebuild a server. The returned list filtered and does not contain images with "(deprecated)", "(Kernel)" or "(Ramdisk)" in their names (this may be disabled with `--disable-filter`). This data may be useful when choosing an image id to pass to the `knife hp server create` subcommand.
 
 knife hp group list
 --------------------
 
-Outputs a list of the security groups available to the currently configured HP Compute Cloud account. Each group may have multiple rules. This data may be useful when choosing your security group(s) to pass to the `knife hp server create` subcommand.
+Outputs a list of the security groups available to the currently configured HP Helion Compute Cloud account by Region. Each group may have multiple rules. This data may be useful when choosing your security group(s) to pass to the `knife hp server create` subcommand.
 
-KNOWN ISSUES
-============
+knife hp network list
+---------------------
 
-* There is no support in Ohai yet, but the empty `/etc/chef/ohai/hints/hp.json` is created. http://tickets.opscode.com/browse/OHAI-425
-* The [CHANGELOG](CHANGELOG.md) has more missing/incomplete features listed.
+Lists the networks available to the currently configured HP Helion Compute Cloud account by Region. This data may be useful when choosing your networks to pass to the `knife hp server create` subcommand.
 
 # License #
 
-Author:: Matt Ray (<matt@opscode.com>)
+Author:: Matt Ray (<matt@getchef.com>)
 
-Copyright:: Copyright (c) 2012-2013 Opscode, Inc.
+Copyright:: Copyright (c) 2012-2014 Chef Software, Inc.
 
 License:: Apache License, Version 2.0
 

data/knife-hp.gemspec

@@ -19,7 +19,7 @@ Gem::Specification.new do |s|
   s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
   s.require_paths = ["lib"]
 
-  s.add_dependency "fog", ">= 1.10.0"
-  s.add_dependency "chef", ">= 0.10.10"
+  s.add_dependency "fog", ">= 1.20"
+  s.add_dependency "chef", ">= 11.0"
 
 end

data/lib/chef/knife/hp_base.rb

@@ -1,6 +1,6 @@
 #
-# Author:: Matt Ray (<matt@opscode.com>)
-# Copyright:: Copyright (c) 2012-2013 Opscode, Inc.
+# Author:: Matt Ray (<matt@getchef.com>)
+# Copyright:: Copyright (c) 2012-2014 Chef Software, Inc.
 # License:: Apache License, Version 2.0
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
@@ -44,7 +44,7 @@ class Chef
           option :hp_secret_key,
           :short => "-K SECRET",
           :long => "--hp-secret SECRET",
-          :description => "Your HP Cloud Secret Key",
+          :description => "Your HP Cloud Access Secret Key",
           :proc => Proc.new { |key| Chef::Config[:knife][:hp_secret_key] = key }
 
           option :hp_tenant_id,
@@ -60,28 +60,47 @@ class Chef
           :proc => Proc.new { |endpoint| Chef::Config[:knife][:hp_auth_uri] = endpoint }
 
           option :hp_avl_zone,
-          :short => "-Z Zone",
-          :long => "--hp-zone Zone",
-          :default => "az1",
-          :description => "Your HP Cloud Availability Zone (az1/az2/az3)",
-          :proc => Proc.new { |key| Chef::Config[:knife][:hp_avl_zone] = key }
+          :short => "-R region",
+          :long => "--hp-region Region",
+          :default => "US-EAST",
+          :description => "Your HP Cloud Region (US-EAST/US-WEST)",
+          :proc => Proc.new { |key| Chef::Config[:knife][:hp_avl_zone] = key.downcase }
+
         end
       end
 
       def connection
-        Chef::Log.debug("hp_access_key: #{Chef::Config[:knife][:hp_access_key]}")
-        Chef::Log.debug("hp_secret_key: #{Chef::Config[:knife][:hp_secret_key]}")
-        Chef::Log.debug("hp_tenant_id: #{Chef::Config[:knife][:hp_tenant_id]}")
         Chef::Log.debug("hp_auth_uri: #{locate_config_value(:hp_auth_uri)}")
-        Chef::Log.debug("hp_avl_zone: #{availability_zone()}")
+        Chef::Log.debug("hp_access_key: #{locate_config_value(:hp_access_key)}")
+        Chef::Log.debug("hp_secret_key: #{locate_config_value(:hp_secret_key)}")
+        Chef::Log.debug("hp_tenant_id: #{locate_config_value(:hp_tenant_id)}")
+        Chef::Log.debug("hp_avl_zone: #{region()}")
         @connection ||= begin
                           connection = Fog::Compute.new(
             :provider => 'HP',
-            :hp_access_key => Chef::Config[:knife][:hp_access_key],
-            :hp_secret_key => Chef::Config[:knife][:hp_secret_key],
-            :hp_tenant_id => Chef::Config[:knife][:hp_tenant_id],
+            :version => :v2,
+            :hp_auth_uri => locate_config_value(:hp_auth_uri),
+            :hp_access_key => locate_config_value(:hp_access_key),
+            :hp_secret_key => locate_config_value(:hp_secret_key),
+            :hp_tenant_id => locate_config_value(:hp_tenant_id),
+            :hp_avl_zone => region()
+            )
+                        end
+      end
+
+      def netconnection
+        Chef::Log.debug("hp_auth_uri: #{locate_config_value(:hp_auth_uri)}")
+        Chef::Log.debug("hp_access_key: #{locate_config_value(:hp_access_key)}")
+        Chef::Log.debug("hp_secret_key: #{locate_config_value(:hp_secret_key)}")
+        Chef::Log.debug("hp_tenant_id: #{locate_config_value(:hp_tenant_id)}")
+        Chef::Log.debug("hp_avl_zone: #{region()}")
+        @connection ||= begin
+                          connection = Fog::HP::Network.new(
             :hp_auth_uri => locate_config_value(:hp_auth_uri),
-            :hp_avl_zone => availability_zone()
+            :hp_access_key => locate_config_value(:hp_access_key),
+            :hp_secret_key => locate_config_value(:hp_secret_key),
+            :hp_tenant_id => locate_config_value(:hp_tenant_id),
+            :hp_avl_zone => region()
             )
                         end
       end
@@ -103,7 +122,7 @@ class Chef
         keys.each do |k|
           pretty_key = k.to_s.gsub(/_/, ' ').gsub(/\w+/){ |w| (w =~ /(ssh)|(hp)/i) ? w.upcase  : w.capitalize }
           if Chef::Config[:knife][k].nil?
-            errors << "You did not provided a valid '#{pretty_key}' value."
+            errors << "You did not provide a valid '#{pretty_key}' value."
           end
         end
 
@@ -112,19 +131,17 @@ class Chef
         end
       end
 
-      def availability_zone()
+      def region()
         case locate_config_value(:hp_avl_zone)
-        when 'az3'
-          return 'az-3.region-a.geo-1'
-        when 'az2'
-          return 'az-2.region-a.geo-1'
+        when 'us-west'
+          Chef::Log.debug("hp_avl_zone: us-west->'region-a.geo-1'")
+          return 'region-a.geo-1'
         else
-          return 'az-1.region-a.geo-1'
+          Chef::Log.debug("hp_avl_zone: us-east->'region-b.geo-1'")
+          return 'region-b.geo-1'
         end
       end
 
     end
   end
 end
-
-

data/lib/chef/knife/hp_flavor_list.rb

@@ -1,6 +1,6 @@
 #
-# Author:: Matt Ray (<matt@opscode.com>)
-# Copyright:: Copyright (c) 2012 Opscode, Inc.
+# Author:: Matt Ray (<matt@getchef.com>)
+# Copyright:: Copyright (c) 2012-2014 Chef Software, Inc.
 # License:: Apache License, Version 2.0
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
@@ -33,16 +33,16 @@ class Chef
         flavor_list = [
           ui.color('ID', :bold),
           ui.color('Name', :bold),
-          ui.color('Cores', :bold),
+          ui.color('VCPUs', :bold),
           ui.color('RAM', :bold),
           ui.color('Disk', :bold),
         ]
-        connection.flavors.sort_by(&:id).each do |flavor|
-          flavor_list << flavor.id.to_s
-          flavor_list << flavor.name
-          flavor_list << flavor.cores.to_s
-          flavor_list << "#{flavor.ram.to_s} MB"
-          flavor_list << "#{flavor.disk.to_s} GB"
+        connection.list_flavors_detail.body['flavors'].sort_by { |h| h['name'] }.each do |flavor|
+          flavor_list << flavor['id']
+          flavor_list << flavor['name']
+          flavor_list << flavor['vcpus'].to_s
+          flavor_list << "#{flavor['ram'].to_s} MB"
+          flavor_list << "#{flavor['disk'].to_s} GB"
         end
         puts ui.list(flavor_list, :uneven_columns_across, 5)
       end

data/lib/chef/knife/hp_group_list.rb

@@ -1,6 +1,6 @@
 #
-# Author:: Matt Ray (<matt@opscode.com>)
-# Copyright:: Copyright (c) 2013 Opscode, Inc.
+# Author:: Matt Ray (<matt@getchef.com>)
+# Copyright:: Copyright (c) 2013-2014 Chef Software, Inc.
 # License:: Apache License, Version 2.0
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
@@ -32,25 +32,27 @@ class Chef
 
         group_list = [
           ui.color('Name', :bold),
+          ui.color('Direction', :bold),
+          ui.color('Type', :bold),
           ui.color('Protocol', :bold),
-          ui.color('From', :bold),
-          ui.color('To', :bold),
-          ui.color('CIDR', :bold),
+          ui.color('Port Range', :bold),
+          ui.color('Remote', :bold),
           ui.color('Description', :bold),
         ]
-        connection.security_groups.sort_by(&:name).each do |group|
-          group.rules.each do |rule|
-            unless rule['ip_protocol'].nil?
+        netconnection.security_groups.sort_by(&:name).each do |group|
+          group.security_group_rules.each do |rule|
+            unless rule['protocol'].nil?
               group_list << group.name
-              group_list << rule['ip_protocol']
-              group_list << rule['from_port'].to_s
-              group_list << rule['to_port'].to_s
-              group_list << rule['ip_range']['cidr']
+              group_list << rule['direction']
+              group_list << rule['ethertype']
+              group_list << rule['protocol']
+              group_list << "#{rule['port_range_min']}-#{rule['port_range_max']}"
+              group_list << rule['remote_ip_prefix']
               group_list << group.description
             end
           end
         end
-        puts ui.list(group_list, :uneven_columns_across, 6)
+        puts ui.list(group_list, :uneven_columns_across, 7)
       end
     end
   end

data/lib/chef/knife/hp_image_list.rb

@@ -1,6 +1,6 @@
 #
-# Author:: Matt Ray (<matt@opscode.com>)
-# Copyright:: Copyright (c) 2012 Opscode, Inc.
+# Author:: Matt Ray (<matt@getchef.com>)
+# Copyright:: Copyright (c) 2012-2014 Chef Software, Inc.
 # License:: Apache License, Version 2.0
 #
 # Licensed under the Apache License, Version 2.0 (the "License");

data/lib/chef/knife/hp_network_list.rb

@@ -0,0 +1,53 @@
+#
+# Author:: Matt Ray (<matt@getchef.com>)
+# Copyright:: Copyright (c) 2014 Chef Software, Inc.
+# License:: Apache License, Version 2.0
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+
+class Chef
+  class Knife
+    class HpNetworkList < Knife
+
+      include Knife::HpBase
+
+      banner "knife hp group list (options)"
+
+      require 'chef/knife/hp_base'
+
+      banner "knife hp network list (options)"
+
+      def run
+
+        validate!
+
+        net_list = [
+          ui.color('Name', :bold),
+          ui.color('ID', :bold),
+          ui.color('Tenant', :bold),
+          ui.color('External', :bold),
+          ui.color('Shared', :bold),
+        ]
+        netconnection.list_networks.body['networks'].sort_by { |h| h['name'] }.each do |network|
+          net_list << network['name']
+          net_list << network['id']
+          net_list << network['tenant_id']
+          net_list << network['router:external'].to_s
+          net_list << network['shared'].to_s
+        end
+        puts ui.list(net_list, :uneven_columns_across, 5)
+      end
+    end
+  end
+end

data/lib/chef/knife/hp_server_create.rb

@@ -1,6 +1,6 @@
 #
-# Author:: Matt Ray (<matt@opscode.com>)
-# Copyright:: Copyright (c) 2012-2013 Opscode, Inc.
+# Author:: Matt Ray (<matt@getchef.com>)
+# Copyright:: Copyright (c) 2012-2014 Chef Software, Inc.
 # License:: Apache License, Version 2.0
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
@@ -56,6 +56,13 @@ class Chef
       :description => "The HP Cloud Key Pair ID",
       :proc => Proc.new { |key| Chef::Config[:knife][:hp_ssh_key_id] = key }
 
+      option :availability_zone,
+      :short => "-Z Zone",
+      :long => "--hp-zone Zone",
+      :default => "az1",
+      :description => "Your HP Cloud Availability Zone within your Region (az1/az2/az3)",
+      :proc => Proc.new { |key| Chef::Config[:knife][:hp_avl_zone] = key }
+
       option :chef_node_name,
       :short => "-N NAME",
       :long => "--node-name NAME",
@@ -117,11 +124,20 @@ class Chef
       :boolean => true,
       :default => true
 
-      option :private_network,
-      :long => '--private-network',
-      :description => 'Use the private IP for bootstrapping rather than the public IP',
-      :boolean => true,
-      :default => false
+      option :networks,
+      :long => "--networks NETWORK_1,NETWORK_2,NETWORK_3",
+      :description => "Comma separated list of the name(s) of the network(s) for the server to attach",
+      :proc => Proc.new { |networks| networks.split(',') }
+
+      option :floating_ip,
+      :short => "-a [IP]",
+      :long => "--floating-ip [IP]",
+      :default => "-1",
+      :description => "Request to associate a floating IP address to server. Assumes IPs have been allocated to the project. Specifying IP is optional."
+
+      option :bootstrap_network,
+      :long => '--bootstrap-network NAME',
+      :description => "Specify network for bootstrapping."
 
       def tcp_test_ssh(hostname)
         tcp_socket = TCPSocket.new(hostname, 22)
@@ -159,120 +175,158 @@ class Chef
         Chef::Log.debug("Flavor #{locate_config_value(:flavor)}")
         Chef::Log.debug("Image #{locate_config_value(:image)}")
         Chef::Log.debug("Group(s) #{config[:security_groups]}")
+        Chef::Log.debug("Availability Zone #{locate_config_value(:availability_zone)}")
+        Chef::Log.debug("Requested Floating IP #{locate_config_value(:floating_ip)}")
         Chef::Log.debug("Key Pair #{Chef::Config[:knife][:hp_ssh_key_id]}")
 
         server_def = {
-        :name => node_name,
-        :flavor_id => locate_config_value(:flavor),
-        :image_id => locate_config_value(:image),
-        :security_groups => config[:security_groups],
-        :key_name => Chef::Config[:knife][:hp_ssh_key_id],
-        :personality => [{
-            "path" => "/etc/chef/ohai/hints/hp.json",
-            "contents" => ''
-          }]
-      }
-
-      server = connection.servers.create(server_def)
-
-      msg_pair("Instance ID", server.id)
-      msg_pair("Instance Name", server.name)
-      msg_pair("Flavor", server.flavor['id'])
-      msg_pair("Image", server.image['id'])
-      msg_pair("Security Group(s)", server.security_groups.collect {|x| x['name']}.join(", "))
-      msg_pair("SSH Key Pair", server.key_name)
-
-      print "\n#{ui.color("Waiting for server", :magenta)}"
-
-      # wait for it to be ready to do stuff
-      server.wait_for { print "."; ready? }
-
-      puts("\n")
-
-      msg_pair("Public IP Address", server.public_ip_address)
-      msg_pair("Private IP Address", server.private_ip_address)
-
-      # bootstrap using private network.
-      if config[:private_network]
-        bootstrap_ip_address = server.private_ip_address
-      else
-        bootstrap_ip_address = server.public_ip_address
+          :name => node_name,
+          :flavor_id => locate_config_value(:flavor),
+          :image_id => locate_config_value(:image),
+          :security_groups => config[:security_groups],
+          :availability_zone => locate_config_value(:availability_zone),
+          :key_name => Chef::Config[:knife][:hp_ssh_key_id]
+        }
+        unless locate_config_value(:networks).nil?
+          server_def[:nics] = locate_config_value(:networks).map do |nic|
+            nic_id = { 'net_id' => nic }
+            nic_id
+          end
+        end
+        Chef::Log.debug("server_def is: #{server_def}")
+
+        server = connection.servers.create(server_def)
+
+        msg_pair("Instance Name", server.name)
+        msg_pair("Instance ID", server.id)
+        msg_pair("Availability zone", server.availability_zone)
+
+        print "\n#{ui.color("Waiting for server", :magenta)}"
+
+        # wait for it to be ready to do stuff
+        server.wait_for { print "."; ready? }
+
+        puts("\n")
+
+        msg_pair("Flavor", server.flavor.name)
+        msg_pair("Image", server.image.name)
+        msg_pair("Security Group(s)", server.security_groups.collect {|x| x['name']}.join(", "))
+        msg_pair("SSH Key Pair", server.key_name)
+
+        Chef::Log.debug("Addresses #{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
+          connection.associate_address(server.id, floating_address)
+          msg_pair("Floating IP Address", floating_address)
+        end
+
+        bootstrap_network = locate_config_value(:bootstrap_network)
+
+        unless bootstrap_network.nil?
+          Chef::Log.debug("Bootstrap specified network: #{bootstrap_network}")
+          bootstrap_ip_address = primary_network_ip_address(server.addresses, bootstrap_network)
+        else
+          if (floating_address == '-1') # no float requested
+            Chef::Log.debug("Bootstrap first network: #{server.addresses.first[0]}")
+            bootstrap_ip_address = server.addresses.first[1][0]['addr']
+          else
+            Chef::Log.debug("Bootstrap floating IP address: #{floating_address}")
+            bootstrap_ip_address = floating_address
+          end
+        end
+
+        print "\n#{ui.color("Waiting for sshd on #{bootstrap_ip_address}", :magenta)}"
+
+        # hack to ensure the nodes have had time to spin up
+        print(".")
+        sleep 30
+        print(".")
+
+        print(".") until tcp_test_ssh(bootstrap_ip_address) {
+          sleep @initial_sleep_delay ||= 10
+          puts("done")
+        }
+
+        bootstrap_for_node(server, bootstrap_ip_address).run
+
+        puts "\n"
+        msg_pair("Instance ID", server.id)
+        msg_pair("Instance Name", server.name)
+        msg_pair("Flavor", server.flavor.name)
+        msg_pair("Image", server.image.name)
+        msg_pair("Security Group(s)", server.security_groups.collect {|x| x['name']}.join(", "))
+        msg_pair("SSH Key Pair", server.key_name)
+        server.addresses.each do |name,addr|
+          msg_pair("Network", name)
+          msg_pair("  IP Address", addr[0]['addr'])
+        end
+        msg_pair("Environment", config[:environment] || '_default')
+        msg_pair("Run List", config[:run_list].join(', '))
       end
 
-      print "\n#{ui.color("Waiting for sshd", :magenta)}"
-
-      # hack to ensure the nodes have had time to spin up
-      print(".")
-      sleep 30
-      print(".")
-
-      print(".") until tcp_test_ssh(bootstrap_ip_address) {
-        sleep @initial_sleep_delay ||= 10
-        puts("done")
-      }
-
-      bootstrap_for_node(server, bootstrap_ip_address).run
-
-      puts "\n"
-      msg_pair("Instance ID", server.id)
-      msg_pair("Instance Name", server.name)
-      msg_pair("Flavor", server.flavor['id'])
-      msg_pair("Image", server.image['id'])
-      msg_pair("Security Group(s)", server.security_groups.collect {|x| x['name']}.join(", "))
-      msg_pair("SSH Key Pair", server.key_name)
-      msg_pair("Public IP Address", server.public_ip_address)
-      msg_pair("Private IP Address", server.private_ip_address)
-      msg_pair("Environment", config[:environment] || '_default')
-      msg_pair("Run List", config[:run_list].join(', '))
-    end
+      def bootstrap_for_node(server, bootstrap_ip_address)
+        bootstrap = Chef::Knife::Bootstrap.new
+        bootstrap.name_args = bootstrap_ip_address
+        bootstrap.config[:run_list] = config[:run_list]
+        bootstrap.config[:ssh_user] = config[:ssh_user]
+        bootstrap.config[:identity_file] = config[:identity_file]
+        bootstrap.config[:host_key_verify] = config[:host_key_verify]
+        bootstrap.config[:chef_node_name] = server.name
+        bootstrap.config[:prerelease] = config[:prerelease]
+        bootstrap.config[:bootstrap_version] = locate_config_value(:bootstrap_version)
+        bootstrap.config[:bootstrap_proxy] = locate_config_value(:bootstrap_proxy)
+        bootstrap.config[:distro] = locate_config_value(:distro)
+        bootstrap.config[:use_sudo] = true unless config[:ssh_user] == 'root'
+        bootstrap.config[:template_file] = locate_config_value(:template_file)
+        bootstrap.config[:environment] = config[:environment]
+        # let ohai know we're using OpenStack
+        Chef::Config[:knife][:hints] ||= {}
+        Chef::Config[:knife][:hints]['hp'] ||= {}
+        bootstrap
+      end
 
-    def bootstrap_for_node(server, bootstrap_ip_address)
-      bootstrap = Chef::Knife::Bootstrap.new
-      bootstrap.name_args = bootstrap_ip_address
-      bootstrap.config[:run_list] = config[:run_list]
-      bootstrap.config[:ssh_user] = config[:ssh_user]
-      bootstrap.config[:identity_file] = config[:identity_file]
-      bootstrap.config[:host_key_verify] = config[:host_key_verify]
-      bootstrap.config[:chef_node_name] = server.name
-      bootstrap.config[:prerelease] = config[:prerelease]
-      bootstrap.config[:bootstrap_version] = locate_config_value(:bootstrap_version)
-      bootstrap.config[:bootstrap_proxy] = locate_config_value(:bootstrap_proxy)
-      bootstrap.config[:distro] = locate_config_value(:distro)
-      bootstrap.config[:use_sudo] = true unless config[:ssh_user] == 'root'
-      bootstrap.config[:template_file] = locate_config_value(:template_file)
-      bootstrap.config[:environment] = config[:environment]
-      bootstrap
-    end
+      def flavor
+        @flavor ||= connection.flavors.get(locate_config_value(:flavor))
+      end
 
-    def flavor
-      @flavor ||= connection.flavors.get(locate_config_value(:flavor))
-    end
+      def image
+        @image ||= connection.images.get(locate_config_value(:image))
+      end
 
-    def image
-      @image ||= connection.images.get(locate_config_value(:image))
-    end
+      def validate!
 
-    def validate!
+        super([:image, :flavor, :hp_access_key, :hp_secret_key, :hp_tenant_id])
 
-      super([:image, :flavor, :hp_access_key, :hp_secret_key, :hp_tenant_id])
+        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
+        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
       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
+      #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 = "hp-"+rand.to_s.split('.')[1]
       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 = "hp-"+rand.to_s.split('.')[1]
-    end
   end
 end
-end

data/lib/chef/knife/hp_server_delete.rb

@@ -1,6 +1,6 @@
 #
-# Author:: Matt Ray (<matt@opscode.com>)
-# Copyright:: Copyright (c) 2012 Opscode, Inc.
+# Author:: Matt Ray (<matt@getchef.com>)
+# Copyright:: Copyright (c) 2012-2014 Chef Software, Inc.
 # License:: Apache License, Version 2.0
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
@@ -64,31 +64,22 @@ class Chef
         @name_args.each do |instance_id|
           begin
             server = connection.servers.get(instance_id)
-            addresses = connection.addresses
 
             msg_pair("Instance ID", server.id)
             msg_pair("Instance Name", server.name)
-            msg_pair("Flavor", server.flavor['id'])
-            msg_pair("Image", server.image['id'])
-            msg_pair("Public IP Address", server.public_ip_address)
-            msg_pair("Private IP Address", server.private_ip_address)
+            msg_pair("Flavor", server.flavor.name)
+            msg_pair("Image", server.image.name)
+            msg_pair("Availability Zone", server.availability_zone)
+            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")
 
             server.destroy
 
-            #HP doesn't free allocated IPs when servers are deleted
-            #if the address is a floating, it's the first entry in the private addresses(?)
-            float = server.addresses['private'][0]['addr']
-            Chef::Log.debug("hp_server_delete: float:#{float}")
-            addresses.each do |address|
-              if !(address.fixed_ip.nil?) && (address.fixed_ip == float)
-                msg_pair("Deleted Floating IP Address", float)
-                address.destroy
-              end
-            end
-
             ui.warn("Deleted server #{server.id}")
 
             if config[:purge]

data/lib/chef/knife/hp_server_list.rb

@@ -1,6 +1,6 @@
 #
-# Author:: Matt Ray (<matt@opscode.com>)
-# Copyright:: Copyright (c) 2012 Opscode, Inc.
+# Author:: Matt Ray (<matt@getchef.com>)
+# Copyright:: Copyright (c) 2012-2014 Chef Software, Inc.
 # License:: Apache License, Version 2.0
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
@@ -34,32 +34,25 @@ class Chef
         server_list = [
           ui.color('Instance ID', :bold),
           ui.color('Name', :bold),
-          ui.color('Public IP', :bold),
-          ui.color('Private IP', :bold),
           ui.color('Flavor', :bold),
           ui.color('Image', :bold),
+          ui.color('Zone', :bold),
           ui.color('Key Pair', :bold),
           ui.color('State', :bold)
         ]
-        connection.servers.all.sort_by(&:id).each do |server|
+        connection.list_servers_detail.body['servers'].sort_by { |h| h['name'] }.each do |server|
           Chef::Log.debug("Server: #{server.to_yaml}")
-          # require 'pry'
-          # binding.pry
-          server_list << server.id.to_s
-          server_list << server.name
-          server_list << (server.public_ip_address or "")
-          server_list << (server.private_ip_address or "")
-          server_list << server.flavor['id'].to_s
-          if server.image
-            server_list << server.image['id']
-          else
-            server_list << ""
-          end
-          server_list << (server.key_name or "")
+
+          server_list << server['id']
+          server_list << server['name']
+          server_list << server['flavor']['id']
+          server_list << server['image']['id']
+          server_list << server['OS-EXT-AZ:availability_zone']
+          server_list << (server['key_name'] or "")
           server_list << begin
-                           state = server.state.to_s.downcase
+                           state = server['status'].downcase
                            case state
-                           when 'shutting-down','terminated','stopping','stopped','active(deleting)','build(deleting)'
+                           when 'shutting-down','terminated','stopping','stopped','active(deleting)','build(deleting)','error'
                              ui.color(state, :red)
                            when 'pending','build(scheduling)','build(spawning)','build(networking)'
                              ui.color(state, :yellow)
@@ -68,11 +61,9 @@ class Chef
                            end
                          end
         end
-        puts ui.list(server_list, :uneven_columns_across, 8)
+        puts ui.list(server_list, :uneven_columns_across, 7)
 
       end
     end
   end
 end
-
-

data/lib/knife-hp/version.rb

@@ -1,6 +1,6 @@
 module Knife
   module Hp
-    VERSION = "0.3.1"
+    VERSION = "0.4.0"
     MAJOR, MINOR, TINY = VERSION.split('.')
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: knife-hp
 version: !ruby/object:Gem::Version
-  version: 0.3.1
+  version: 0.4.0
   prerelease: 
 platform: ruby
 authors:
@@ -10,7 +10,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-06-21 00:00:00.000000000 Z
+date: 2014-05-24 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: fog
@@ -19,7 +19,7 @@ dependencies:
     requirements:
     - - ! '>='
       - !ruby/object:Gem::Version
-        version: 1.10.0
+        version: '1.20'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
@@ -27,7 +27,7 @@ dependencies:
     requirements:
     - - ! '>='
       - !ruby/object:Gem::Version
-        version: 1.10.0
+        version: '1.20'
 - !ruby/object:Gem::Dependency
   name: chef
   requirement: !ruby/object:Gem::Requirement
@@ -35,7 +35,7 @@ dependencies:
     requirements:
     - - ! '>='
       - !ruby/object:Gem::Version
-        version: 0.10.10
+        version: '11.0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
@@ -43,7 +43,7 @@ dependencies:
     requirements:
     - - ! '>='
       - !ruby/object:Gem::Version
-        version: 0.10.10
+        version: '11.0'
 description: HP Cloud Services Cloud support for Chef's Knife command
 email:
 - adam@opscode.com
@@ -65,6 +65,7 @@ files:
 - lib/chef/knife/hp_flavor_list.rb
 - lib/chef/knife/hp_group_list.rb
 - lib/chef/knife/hp_image_list.rb
+- lib/chef/knife/hp_network_list.rb
 - lib/chef/knife/hp_server_create.rb
 - lib/chef/knife/hp_server_delete.rb
 - lib/chef/knife/hp_server_list.rb
@@ -89,7 +90,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 1.8.25
+rubygems_version: 1.8.23.2
 signing_key: 
 specification_version: 3
 summary: HP Cloud Services Cloud support for Chef's Knife command