knife-softlayer 0.0.2

data/lib/chef/knife/flavor/base.rb

@@ -0,0 +1,177 @@
+#
+# Author:: Matt Eldridge (<matt.eldridge@us.ibm.com>)
+# © Copyright IBM Corporation 2014.
+#
+# LICENSE: Apache 2.0 (http://www.apache.org/licenses/)
+#
+
+require 'chef/knife'
+
+class Chef
+  class Knife
+    module SoftlayerFlavorBase
+
+      ##
+      # Return the flavors table or the options table.
+      # @param [Boolean] show_all
+      # @return [Hash]
+      def table_info(show_all=false)
+        if show_all
+          options_table
+        else
+          flavors_table
+        end
+      end
+
+      ##
+      # Build table of all VM configuration options.
+      # @return [Hash]
+      def options_table
+        columns = [
+            ui.color("| CORES", :bold, :white, :green),
+            ui.color("| RAM", :bold, :white, :green),
+            ui.color("| DISK", :bold, :white, :green),
+            ui.color("| OS", :bold, :white, :green),
+            ui.color("| NETWORK [MBS]", :bold, :white, :green),
+            ui.color("| DATACENTER", :bold, :white, :green)
+        ]
+
+        opts = connection.getCreateObjectOptions
+        cpu = opts['processors']
+        ram = opts['memory']
+        disk = opts['blockDevices'].sort_by{|d| d['itemPrice']['item']['description'] unless d['itemPrice'].nil? }
+        os = opts['operatingSystems']
+        net = opts['networkComponents']
+        datacenter = opts['datacenters']
+
+        i = 0
+        until i >= opts.keys.map{|key| opts[key].count }.sort.last do
+          columns << (cpu[i].nil? ? '|  ' : '|  ' + cpu[i]['itemPrice']['item']['description'])
+          columns << (ram[i].nil? ? '|  ' : '|  ' + ram[i]['template']['maxMemory'].to_s + " [#{ram[i]['itemPrice']['item']['description']}]")
+          columns << (disk[i].nil? ? '|  ' : '|  ' + disk[i]['itemPrice']['item']['description'])
+          columns << (os[i].nil? ? '|  ' : '|  ' + os[i]['template']['operatingSystemReferenceCode'])
+          columns << (net[i].nil? ? '|  ' : '|  ' + net[i]['template']['networkComponents'].first['maxSpeed'].to_s)
+          columns << (datacenter[i].nil? ? '|  ' : '|  ' + datacenter[i]['template']['datacenter']['name'])
+          i+=1
+        end
+        columns
+      end
+
+      ##
+      # Build the VM "flavor" table.
+      # @return [Hash]
+      def flavors_table
+        # We don't have "flavors" actually, you can just pick from the menu.
+        # Let's shim in place the standard openstack flavors so people can get started without making loads of decisions.
+
+        columns = [
+            ui.color("| FLAVOR", :bold, :green),
+            ui.color("| CORES", :bold, :green),
+            ui.color("| RAM", :bold, :green),
+            ui.color("| DISK", :bold, :green)
+        ]
+
+        # tiny
+        columns << "| tiny"
+        columns << "| 1"
+        columns << "| 1024"
+        columns << "| 25GB [LOCAL]"
+
+        # small
+        columns << "| small"
+        columns << "| 2"
+        columns << "| 2048"
+        columns << "| 100GB [LOCAL]"
+
+
+        # medium
+        columns << "| medium"
+        columns << "| 4"
+        columns << "| 4096"
+        columns << "| 150GB [LOCAL]"
+
+
+        # large
+        columns << "| large"
+        columns << "| 8"
+        columns << "| 8192"
+        columns << "| 200GB [LOCAL]"
+
+
+        # xlarge
+        columns << "| xlarge"
+        columns << "| 16"
+        columns << "| 16384"
+        columns << "| 300GB [LOCAL]"
+      end
+
+      def self.load_flavor(flavor)
+        self.send(flavor.to_s)
+      end
+
+
+      private
+
+      ##
+      # Set options for a "tiny" instance.
+      # @return [Hash]
+      def self.tiny
+        {
+            'startCpus' => 1,
+            'maxMemory' => 1024,
+            'localDiskFlag' => true,
+            'blockDevices' => [{'device' => 0, 'diskImage' => {'capacity' => 25 } }]
+        }
+      end
+
+      ##
+      # Set options for a "small" instance.
+      # @return [Hash]
+      def self.small
+        {
+            'startCpus' => 2,
+            'maxMemory' => 2048,
+            'localDiskFlag' => true,
+            'blockDevices' => [{'device' => 0, 'diskImage' => {'capacity' => 100 } }]
+        }
+      end
+
+      ##
+      # Set options for a "medium" instance.
+      # @return [Hash]
+      def self.medium
+        {
+            'startCpus' => 4,
+            'maxMemory' => 4096,
+            'localDiskFlag' => true,
+            'blockDevices' => [{'device' => 0, 'diskImage' => {'capacity' => 25 } },{'device' => 2, 'diskImage' => {'capacity' => 150 } }]
+        }
+      end
+
+      ##
+      # Set options for a "large" instance.
+      # @return [Hash]
+      def self.large
+        {
+            'startCpus' => 8,
+            'maxMemory' => 8192,
+            'localDiskFlag' => true,
+            'blockDevices' => [{'device' => 0, 'diskImage' => {'capacity' => 25 } },{'device' => 2, 'diskImage' => {'capacity' => 200 } }]
+        }
+      end
+
+      ##
+      # Set options for an "xlarge" instance.
+      # @return [Hash]
+      def self.xlarge
+        {
+            'startCpus' => 16,
+            'maxMemory' => 16384,
+            'localDiskFlag' => true,
+            'blockDevices' => [{'device' => 0, 'diskImage' => {'capacity' => 25 } },{'device' => 2, 'diskImage' => {'capacity' => 300 } }]
+        }
+      end
+
+    end
+  end
+end

data/lib/chef/knife/softlayer.rb

@@ -0,0 +1,14 @@
+#
+# Author:: Matt Eldridge (<matt.eldridge@us.ibm.com>)
+# © Copyright IBM Corporation 2014.
+#
+# LICENSE: Apache 2.0 (http://www.apache.org/licenses/)
+#
+
+require "knife-softlayer/version"
+
+module Knife
+  module Softlayer
+    # Your code goes here...
+  end
+end

data/lib/chef/knife/softlayer_base.rb

@@ -0,0 +1,167 @@
+#
+# Author:: Matt Eldridge (<matt.eldridge@us.ibm.com>)
+# © Copyright IBM Corporation 2014.
+#
+# LICENSE: Apache 2.0 (http://www.apache.org/licenses/)
+#
+
+require 'chef/knife'
+
+class Chef
+  class Knife
+    module SoftlayerBase
+
+      # :nodoc:
+      def self.included(includer)
+        includer.class_eval do
+
+          deps do
+            require 'softlayer_api'
+            require 'readline'
+            require 'chef/json_compat'
+            require 'net/ssh'
+            require 'net/ssh/multi'
+          end
+
+          option :softlayer_credential_file,
+                 :long => "--softlayer-credential-file FILE",
+                 :description => "File containing SoftLayer credentials as used by `softlayer_api` Ruby gem.",
+                 :proc => Proc.new { |key| Chef::Config[:knife][:softlayer_credential_file] = key }
+
+          option :softlayer_username,
+                 :short => "-U USERNAME",
+                 :long => "--softlayer-username KEY",
+                 :description => "Your SoftLayer Username",
+                 :proc => Proc.new { |key| Chef::Config[:knife][:softlayer_access_key_id] = key }
+
+          option :softlayer_api_key,
+                 :short => "-K SECRET",
+                 :long => "--softlayer-api-key SECRET",
+                 :description => "Your SoftLayer API Key",
+                 :proc => Proc.new { |key| Chef::Config[:knife][:softlayer_secret_access_key] = key }
+        end
+      end
+
+      ##
+      # Returns a connection to a SoftLayer API Service Endpoint.
+      # @param [Symbol] service
+      # @return [SoftLayer::Service]
+      def connection(service=:cci)
+        SoftLayer::Service.new(
+            SoftlayerBase.send(service),
+            :username => Chef::Config[:knife][:softlayer_username],
+            :api_key => Chef::Config[:knife][:softlayer_api_key]
+        )
+      end
+
+      ##
+      # Returns identifier string for the SoftLayer Virtual Guest service.
+      # @return [String]
+      def self.cci
+        'SoftLayer_Virtual_Guest'
+        end
+
+      ##
+      # Returns identifier string for the SoftLayer Product Package service.
+      # @return [String]
+      def self.package
+        'SoftLayer_Product_Package'
+      end
+
+      ##
+      # Returns identifier string for the SoftLayer Product Order service.
+      # @return [String]
+      def self.order
+        'SoftLayer_Product_Order'
+      end
+
+      ##
+      # Returns identifier string for the SoftLayer Subnet Ordering service.
+      # @return [String]
+      def self.subnet
+        'SoftLayer_Container_Product_Order_Network_Subnet'
+      end
+
+      ##
+      # Returns identifier string for the SoftLayer User Account service.
+      # @return [String]
+      def self.account
+        'SoftLayer_Account'
+      end
+
+      ##
+      # Returns identifier string for the SoftLayer Global IP service.
+      # @return [String]
+      def self.global_ip
+        'SoftLayer_Network_Subnet_IpAddress_Global'
+      end
+
+      ##
+      # Returns id of a particular SoftLayer ordering package.
+      # @return [String]
+      def self.non_server_package_id
+        0 # this package contains everything that isn't a server on the SoftLayer API
+      end
+
+      ##
+      # Queries the SoftLayer API and returns the "category code" required for ordering a Global IPv4 address.
+      # @return [Integer]
+      def self.global_ipv4_cat_code
+        SoftLayer::Service.new(
+            SoftlayerBase.send(:package),
+            :username => Chef::Config[:knife][:softlayer_username],
+            :api_key => Chef::Config[:knife][:softlayer_api_key]
+        ).object_with_id(non_server_package_id).object_mask('isRequired', 'itemCategory').getConfiguration.map do |item|
+          item['itemCategory']['id'] if item['itemCategory']['categoryCode'] == 'global_ipv4'
+        end.compact.first
+      end
+
+      ##
+      # Queries the SoftLayer API and returns the "price code" required for ordering a Global IPv4 address.
+      # @return [Integer]
+      def self.global_ipv4_price_code
+        SoftLayer::Service.new(
+            SoftlayerBase.send(:package),
+            :username => Chef::Config[:knife][:softlayer_username],
+            :api_key => Chef::Config[:knife][:softlayer_api_key]
+        ).object_with_id(non_server_package_id).object_mask('id', 'item.description', 'categories.id').getItemPrices.map do |item|
+          item['id'] if item['categories'][0]['id'] == SoftlayerBase.global_ipv4_cat_code
+        end.compact.first
+      end
+
+      ##
+      # Constructs an order required for purchasing a Global IPv4 address.
+      # @return [Hash]
+      def self.build_global_ipv4_order
+        {
+            "complexType" => SoftlayerBase.subnet,
+            "packageId" => non_server_package_id,
+            "prices" => [{"id"=>SoftlayerBase.global_ipv4_price_code}],
+            "quantity" => 1
+        }
+      end
+
+      ##
+      # Locates a config value.
+      # @param [String] key
+      # @return [String]
+      def locate_config_value(key)
+        key = key.to_sym
+        config[key] || Chef::Config[:knife][key]
+      end
+
+      ##
+      # A CLI output formatting wrapper.
+      # @param [String] label
+      # @param [String] value
+      # @param [Symbol] color
+      # @return [String]
+      def msg_pair(label, value, color=:cyan)
+        if value && !value.to_s.empty?
+          puts "#{ui.color(label, color)}: #{value}"
+        end
+      end
+
+    end
+  end
+end

data/lib/chef/knife/softlayer_delete.rb

@@ -0,0 +1,6 @@
+#
+# Author:: Matt Eldridge (<matt.eldridge@us.ibm.com>)
+# © Copyright IBM Corporation 2014.
+#
+# LICENSE: Apache 2.0 (http://www.apache.org/licenses/)
+#

data/lib/chef/knife/softlayer_flavor_list.rb

@@ -0,0 +1,44 @@
+#
+# Author:: Matt Eldridge (<matt.eldridge@us.ibm.com>)
+# © Copyright IBM Corporation 2014.
+#
+# LICENSE: Apache 2.0 (http://www.apache.org/licenses/)
+#
+
+require 'chef/knife/softlayer_base'
+require 'chef/knife/flavor/base'
+
+class Chef
+  class Knife
+    class SoftlayerFlavorList < Knife
+
+      include Knife::SoftlayerBase
+      include Knife::SoftlayerFlavorBase
+
+      banner 'knife softlayer flavor list (options)'
+
+      option :all,
+        :short => "-a",
+        :long => "--all",
+        :description => "Display all available configuration options for launching an instance.",
+        :default => false
+
+      ##
+      # Run the procedure to list softlayer VM flavors or display all available options.
+      # @return [nil]
+      def run
+        table_data = table_info(config[:all])
+        if config[:all]
+          puts ui.list(table_data, :columns_across, 6)
+          msg = "These options can be used in place of 'flavors'; See `knife softlayer server create --help` for details.\n"
+        else
+          puts ui.list(table_data, :columns_across, 4)
+          msg = "'flavors' provided here for convenience; SoftLayer allows you to choose a configuration a la carte.\nFor a full list of available instance options use --all with the `knife softlayer flavor list` subcommand."
+        end
+        puts ui.color("\nNOTICE: ", :yellow)
+        puts ui.color(msg)
+      end
+
+    end
+  end
+end

data/lib/chef/knife/softlayer_list.rb

@@ -0,0 +1,6 @@
+#
+# Author:: Matt Eldridge (<matt.eldridge@us.ibm.com>)
+# © Copyright IBM Corporation 2014.
+#
+# LICENSE: Apache 2.0 (http://www.apache.org/licenses/)
+#

data/lib/chef/knife/softlayer_server_create.rb

@@ -0,0 +1,343 @@
+#
+# Author:: Matt Eldridge (<matt.eldridge@us.ibm.com>)
+# © Copyright IBM Corporation 2014.
+#
+# LICENSE: Apache 2.0 (http://www.apache.org/licenses/)
+#
+
+require 'chef/knife/softlayer_base'
+require 'chef/knife/flavor/base'
+
+class Chef
+  class Knife
+    class SoftlayerServerCreateError < StandardError; end
+    class SoftlayerServerCreate < Knife
+
+      attr_reader :cci
+
+      include Knife::SoftlayerBase
+
+      banner 'knife softlayer server create (options)'
+
+      option :flavor,
+        :long => '--flavor FLAVOR',
+        :short => '-f FLAVOR',
+        :description => 'Pre-configured packages of computing resources.  See `knife softlayer flavor list` for details.'
+
+      option :hostname,
+        :long => '--hostname VALUE',
+        :short => '-H VALUE',
+        :description => 'The hostname SoftLayer will assign to the VM instance.'
+
+      option :domain,
+        :long => '--domain VALUE',
+        :short => '-D VALUE',
+        :description => 'The FQDN SoftLayer will assign to the VM instance.',
+        :default => 'example.com'
+
+      option :cores,
+        :long => '--cores VALUE',
+        :short => '-C VALUE',
+        :description => 'The number of virtual cores SoftLayer will assign to the VM instance.',
+        :default => 1
+
+      option :os_code,
+        :long => '--os-code VALUE',
+        :short => '-O VALUE',
+        :description => 'A valid SoftLayer operating system code.  See `knife softlayer flavor list --all` for a list of valid codes.',
+        :default => 'UBUNTU_LATEST'
+
+      option :ram,
+        :long => '--ram VALUE',
+        :short => '-R VALUE',
+        :description => 'The number of virtual cores SoftLayer will assign to the VM instance.',
+        :default => 1024
+
+      option :block_storage,
+        :long => '--block-storage VALUE',
+        :short => '-B VALUE',
+        :description => 'The size in GB of the block storage devices (disks) for this instance. Specify 1 - 5 entries in a comma separated list following the format "dev:size".  Example: "0:25,2:500" would be a 25GB volume on device 0 (the root partition) and a 100GB volume on on device 2. [NOTE: SoftLayer VMs always reserve device 1 for a swap device.] ',
+        :default => '0:25'
+
+      option :nic,
+        :long => '--network-interface-speed VALUE',
+        :short => '-n VALUE',
+        :description => 'The maximum speed of the public NIC available to the instance.',
+        :default => 10
+
+      option :bill_monthly,
+        :long => '--bill-monthly',
+        :description => 'Flag to bill monthly instead of hourly, minimum charge of one month.',
+        :default => false
+
+      option :single_tenant,
+        :long => '--single-tenant',
+        :description => 'Create a CCI VM with a dedicated physical host.',
+        :boolean => true,
+        :default => false
+
+      option :san_storage,
+        :long => '--san-storage',
+        :description => 'Create a CCI VM with SAN based block storage [disk].',
+        :boolean => true,
+        :default => false
+
+      option :datacenter,
+        :long => '--datacenter VALUE',
+        :description => 'Create a CCI VI in a particular datacenter.'
+
+      option :tags,
+             :short => "-T T=V[,T=V,...]",
+             :long => "--tags Tag=Value[,Tag=Value...]",
+             :description => "The tags for this server",
+             :proc => Proc.new { |tags| tags.split(',') }
+
+      option :chef_node_name,
+             :short => "-N NAME",
+             :long => "--node-name NAME",
+             :description => "The Chef node name for your new node",
+             :proc => Proc.new { |key| Chef::Config[:knife][:chef_node_name] = key }
+
+
+      option :ssh_user,
+             :short => "-x USERNAME",
+             :long => "--ssh-user USERNAME",
+             :description => "The ssh username",
+             :default => "root"
+
+      option :ssh_password,
+             :short => "-P PASSWORD",
+             :long => "--ssh-password PASSWORD",
+             :description => "The ssh password"
+
+      option :ssh_port,
+             :short => "-p PORT",
+             :long => "--ssh-port PORT",
+             :description => "The ssh port",
+             :default => "22",
+             :proc => Proc.new { |key| Chef::Config[:knife][:ssh_port] = key }
+
+      option :ssh_gateway,
+             :short => "-w GATEWAY",
+             :long => "--ssh-gateway GATEWAY",
+             :description => "The ssh gateway server",
+             :proc => Proc.new { |key| Chef::Config[:knife][:ssh_gateway] = key }
+
+      option :identity_file,
+             :short => "-i IDENTITY_FILE",
+             :long => "--identity-file IDENTITY_FILE",
+             :description => "The SSH identity file used for authentication"
+
+      option :prerelease,
+             :long => "--prerelease",
+             :description => "Install the pre-release chef gems"
+
+      option :bootstrap_version,
+             :long => "--bootstrap-version VERSION",
+             :description => "The version of Chef to install",
+             :proc => Proc.new { |v| Chef::Config[:knife][:bootstrap_version] = v }
+
+      option :bootstrap_proxy,
+             :long => "--bootstrap-proxy PROXY_URL",
+             :description => "The proxy server for the node being bootstrapped",
+             :proc => Proc.new { |p| Chef::Config[:knife][:bootstrap_proxy] = p }
+
+      option :distro,
+             :short => "-d DISTRO",
+             :long => "--distro DISTRO",
+             :description => "Bootstrap a distro using a template; default is 'chef-full'",
+             :proc => Proc.new { |d| Chef::Config[:knife][:distro] = d },
+             :default => "chef-full"
+
+      option :template_file,
+             :long => "--template-file TEMPLATE",
+             :description => "Full path to location of template to use",
+             :proc => Proc.new { |t| Chef::Config[:knife][:template_file] = t },
+             :default => false
+
+      option :run_list,
+             :short => "-r RUN_LIST",
+             :long => "--run-list RUN_LIST",
+             :description => "Comma separated list of roles/recipes to apply",
+             :proc => lambda { |o| o.split(/[\s,]+/) }
+
+      option :secret,
+             :short => "-s SECRET",
+             :long => "--secret ",
+             :description => "The secret key to use to encrypt data bag item values",
+             :proc => lambda { |s| Chef::Config[:knife][:secret] = s }
+
+      option :secret_file,
+             :long => "--secret-file SECRET_FILE",
+             :description => "A file containing the secret key to use to encrypt data bag item values",
+             :proc => lambda { |sf| Chef::Config[:knife][:secret_file] = sf }
+
+      option :json_attributes,
+             :short => "-j JSON",
+             :long => "--json-attributes JSON",
+             :description => "A JSON string to be added to the first run of chef-client",
+             :proc => lambda { |o| JSON.parse(o) }
+
+      option :host_key_verify,
+             :long => "--[no-]host-key-verify",
+             :description => "Verify host key, enabled by default.",
+             :boolean => true,
+             :default => true
+
+      option :bootstrap_protocol,
+             :long => "--bootstrap-protocol protocol",
+             :description => "protocol to bootstrap windows servers. options: winrm/ssh",
+             :proc => Proc.new { |key| Chef::Config[:knife][:bootstrap_protocol] = key },
+             :default => nil
+
+      option :fqdn,
+             :long => "--fqdn FQDN",
+             :description => "Pre-defined FQDN",
+             :proc => Proc.new { |key| Chef::Config[:knife][:fqdn] = key },
+             :default => nil
+
+      option :assign_global_ip,
+             :long => "--assign-global-ip IpAdress",
+             :description => "Assign an existing SoftLayer Global IP address.",
+             :default => nil
+
+      option :new_global_ip,
+             :long => "--new-global-ip",
+             :description => "Order a new SoftLayer Global IP address and assign it to the instance."
+
+      option :hint,
+             :long => "--hint HINT_NAME[=HINT_FILE]",
+             :description => "Specify Ohai Hint to be set on the bootstrap target.  Use multiple --hint options to specify multiple hints.",
+             :proc => Proc.new { |h|
+               Chef::Config[:knife][:hints] ||= {}
+               name, path = h.split("=")
+               Chef::Config[:knife][:hints][name] = path ? JSON.parse(::File.read(path)) : Hash.new
+             }
+
+      ##
+      # Run the procedure to create a SoftLayer VM and bootstrap it.
+      # @return [nil]
+      def run
+
+        $stdout.sync = true
+
+        config[:os_code] =~ /^WIN_/ and raise SoftlayerServerCreateError, "#{ui.color("Windows VMs not currently supported.", :red)}"
+
+        if config[:flavor]
+          @template = SoftlayerFlavorBase.load_flavor(config[:flavor])
+        else
+          @template = {}
+          @template['startCpus'] = config[:cores]
+          @template['maxMemory'] = config[:ram]
+          @template['localDiskFlag'] = !config[:san_storage]
+          @template['blockDevices'] = config[:block_storage].split(',').map do |i|
+            dev, cap = i.split(':')
+            {'device' => dev, 'diskImage' => {'capacity' => cap } }
+            end
+        end
+
+        @template['complexType'] = SoftlayerBase.cci
+        @template['hostname'] = config[:hostname]
+        @template['domain'] = config[:domain]
+        @template['dedicatedAccountHostOnlyFlag'] = config[:single_tenant]
+        @template['operatingSystemReferenceCode'] = config[:os_code]
+        @template['hourlyBillingFlag'] = config[:bill_monthly]
+        @template['networkComponents'] = [{ 'maxSpeed' => config[:nic]}]
+
+        @template['datacenter'] = { 'name' => config[:datacenter] } if config[:datacenter]
+
+        @response = connection.createObject(@template)
+
+        puts ui.color("Launching SoftLayer CCI, this may take a few minutes.", :green)
+
+        begin
+          @cci = connection.object_mask('mask.operatingSystem.passwords.password').object_with_id(@response['id']).getObject
+          sleep 1
+          putc('.')
+        end while @cci['operatingSystem'].nil? or @cci['operatingSystem']['passwords'].empty?
+
+        linux_bootstrap(@cci).run
+
+        if config[:new_global_ip] || config[:assign_global_ip]
+          if config[:new_global_ip]
+            begin
+              order = SoftlayerBase.build_global_ipv4_order
+              response = connection(:order).placeOrder(order)
+              global_ip_id = response['placedOrder']['account']['globalIpv4Records'].first['id']
+
+              if global_ip_id
+                puts ui.color('Global IP Address successfully created.', :green)
+              else
+                raise 'Unable to find Global IP Address ID.  Address not created.'
+              end
+            rescue Exception => e
+              puts ui.color('We have encountered a problem ordering the requested global IP.  The transaction may not have completed.', :red)
+              puts ui.color(e.message, :yellow)
+            end
+          end
+
+          if config[:assign_global_ip]
+            global_ip_id = connection(:account).object_mask('ipAddress').getGlobalIpv4Records.map do |global_ip|
+              global_ip['id'] if global_ip['ipAddress']['ipAddress'] == config[:assign_global_ip]
+            end.compact.first
+            if global_ip_id
+              puts ui.color('Global IP Address ID found.', :green)
+            end
+          end
+
+          puts ui.color('Assigning Global IP Address to Instance.', :green)
+          connection(:global_ip).object_with_id(global_ip_id).route(@cci['primaryIpAddress'])
+
+          puts ui.color('Global IP Address has been assigned.', :green)
+          puts ui.color('Global IP Address will not function without networking rules on the endpoint operating system.  See http://knowledgelayer.softlayer.com/learning/global-ip-addresses for details.', :yellow)
+
+        end
+
+      end
+
+      # @param [Hash] cci
+      # @return [Chef::Knife::Bootstrap]
+      def linux_bootstrap(cci)
+        bootstrap = Chef::Knife::Bootstrap.new
+        bootstrap.name_args = [cci['primaryIpAddress']]
+        bootstrap.config[:ssh_user] = config[:ssh_user]
+        bootstrap.config[:ssh_password] = cci['operatingSystem']['passwords'].first['password']
+        bootstrap.config[:ssh_port] = config[:ssh_port]
+        bootstrap.config[:ssh_gateway] = config[:ssh_gateway]
+        bootstrap.config[:identity_file] = config[:identity_file]
+        bootstrap.config[:chef_node_name] = locate_config_value(:chef_node_name) || cci['id']
+        bootstrap.config[:use_sudo] = true unless config[:ssh_user] == 'root'
+        bootstrap.config[:host_key_verify] = config[:host_key_verify]
+        shared_bootstrap(bootstrap)
+      end
+
+      # @param [Chef::Knife::Bootstrap] bootstrap
+      # @return [Chef::Knife::Bootstrap]
+      def shared_bootstrap(bootstrap)
+        bootstrap.config[:run_list] = config[:run_list]
+        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[:environment] = locate_config_value(:environment)
+        bootstrap.config[:prerelease] = config[:prerelease]
+        bootstrap.config[:first_boot_attributes] = locate_config_value(:json_attributes) || {}
+        bootstrap.config[:encrypted_data_bag_secret] = locate_config_value(:encrypted_data_bag_secret)
+        bootstrap.config[:encrypted_data_bag_secret_file] = locate_config_value(:encrypted_data_bag_secret_file)
+        bootstrap.config[:secret] = locate_config_value(:secret)
+        bootstrap.config[:secret_file] = locate_config_value(:secret_file)
+        bootstrap.config[:tags] = locate_config_value(:tags)
+        bootstrap.config[:fqdn] = locate_config_value(:fqdn)
+        Chef::Config[:knife][:hints] ||= {}
+        Chef::Config[:knife][:hints]['softlayer'] ||= {}
+        bootstrap
+      end
+
+      def windows_bootstrap(server, fqdn)
+        # TODO: Windows support....
+      end
+
+    end
+  end
+end
+
+