knife-vcloud 0.2.3 → 1.0.0

data/lib/chef/knife/{vc_catalog_item_show.rb → catalog/vc_catalog_item_show.rb}

@@ -1,6 +1,6 @@
 #
 # Author:: Stefano Tortarolo (<stefano.tortarolo@gmail.com>)
-# Copyright:: Copyright (c) 2012
+# Copyright:: Copyright (c) 2012-2013
 # License:: Apache License, Version 2.0
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
@@ -16,39 +16,39 @@
 # limitations under the License.
 #
 
-require 'chef/knife/vc_common'
-
 class Chef
   class Knife
     class VcCatalogItemShow < Chef::Knife
       include Knife::VcCommon
+      include Knife::VcCatalogCommon
 
-      banner "knife vc catalog item show [CATALOG_ID] (options)"
+      banner "knife vc catalog item show [CATALOG_ITEM] (options)"
 
       def run
         $stdout.sync = true
 
-        item_id = @name_args.first
+        item_arg = @name_args.first
 
         connection.login
+        catalog_item = get_catalog_item(item_arg)
+        connection.logout
 
         header = [
             ui.color('Name', :bold),
             ui.color('Template ID', :bold)
         ]
 
-        description, items = connection.show_catalog_item item_id
-        connection.logout
-
-        puts "#{ui.color('Description:', :cyan)} #{description}"
+        ui.msg "#{ui.color('Description:', :cyan)} #{catalog_item[:description]}"
         list = header
         list.flatten!
-        items.each do |k, v|
-          list << (k || '')
-          list << (v || '')
+
+        catalog_item[:items].each do |item|
+          list << (item[:name] || '')
+          list << (item[:id] || '')
+          # TODO: show VMs using this item? item[:vms_hash]
         end
 
-        puts ui.list(list, :columns_across, 2)
+        ui.msg ui.list(list, :columns_across, 2)
       end
     end
   end

data/lib/chef/knife/{vc_catalog_show.rb → catalog/vc_catalog_show.rb}

@@ -1,6 +1,6 @@
 #
 # Author:: Stefano Tortarolo (<stefano.tortarolo@gmail.com>)
-# Copyright:: Copyright (c) 2012
+# Copyright:: Copyright (c) 2012-2013
 # License:: Apache License, Version 2.0
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
@@ -16,39 +16,36 @@
 # limitations under the License.
 #
 
-require 'chef/knife/vc_common'
-
 class Chef
   class Knife
     class VcCatalogShow < Chef::Knife
       include Knife::VcCommon
+      include Knife::VcCatalogCommon
 
-      banner "knife vc catalog show [CATALOG_ID] (options)"
+      banner "knife vc catalog show [CATALOG] (options)"
 
       def run
         $stdout.sync = true
 
-        catalog_id = @name_args.first
-
+        catalog_arg = @name_args.shift
         connection.login
+        catalog = get_catalog(catalog_arg)
+        connection.logout
 
         header = [
             ui.color('Name', :bold),
             ui.color('ID', :bold)
         ]
 
-        description, items = connection.show_catalog catalog_id
-        connection.logout
-
-        puts "#{ui.color('Description:', :cyan)} #{description}"
+        ui.msg "#{ui.color('Description:', :cyan)} #{catalog[:description]}"
         list = header
         list.flatten!
-        items.each do |k, v|
+        sort_by_key(catalog[:items]).each do |k, v|
           list << (k || '')
           list << (v || '')
         end
 
-        puts ui.list(list, :columns_across, 2)
+        ui.msg ui.list(list, :columns_across, 2)
       end
     end
   end

data/lib/chef/knife/common/vc_bootstrap_common.rb

@@ -0,0 +1,208 @@
+#
+# Author:: Stefano Tortarolo (<stefano.tortarolo@gmail.com>)
+# Copyright:: Copyright (c) 2013
+# 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
+    module VcBootstrapCommon
+      def self.included(includer)
+        includer.class_eval do
+          deps do
+            require 'chef/knife/bootstrap'
+            require 'chef/knife/bootstrap_windows_winrm'
+            require 'chef/knife/core/windows_bootstrap_context'
+            Chef::Knife::Bootstrap.load_deps
+          end
+
+          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,]+/) },
+            :default => []
+
+          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 :bootstrap_windows,
+            :long => "--[no-]bootstrap-windows",
+            :description => "The machine to be bootstrapped is Windows",
+            :boolean => true,
+            :default => false
+
+          option :bootstrap_proxy,
+            :long => "--bootstrap-proxy PROXY_URL",
+            :description => "The proxy server for the node being bootstrapped",
+            :proc => Proc.new { |v| Chef::Config[:knife][:bootstrap_proxy] = v }
+
+          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",
+            :proc => Proc.new { |key| Chef::Config[:knife][:ssh_port] = key },
+            :default => 22
+
+          option :ssh_gateway,
+            :short => "-G GATEWAY",
+            :long => "--ssh-gateway GATEWAY",
+            :description => "The ssh gateway",
+            :proc => Proc.new { |key| Chef::Config[:knife][:ssh_gateway] = key }
+
+          option :forward_agent,
+            :short => "-A",
+            :long => "--forward-agent",
+            :description => "Enable SSH agent forwarding",
+            :boolean => true
+
+          option :identity_file,
+            :short => "-i IDENTITY_FILE",
+            :long => "--identity-file IDENTITY_FILE",
+            :description => "The SSH identity file used for authentication"
+
+          option :host_key_verify,
+            :long => "--[no-]host-key-verify",
+            :description => "Verify host key, enabled by default.",
+            :boolean => true,
+            :default => true
+
+          option :max_tries,
+            :long => "--max-tries MAX_TRIES",
+            :description => "Max number of connection tries for each VM",
+            :default => 5
+
+          option :secret,
+            :short => "-s SECRET",
+            :long  => "--secret ",
+            :description => "The secret key to use to encrypt data bag item values",
+            :proc => Proc.new { |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 => Proc.new { |sf| Chef::Config[:knife][:secret_file] = sf }
+
+          option :template_file,
+            :long => "--template-file TEMPLATE_FILE",
+            :description => "Template file to use for bootstrap",
+            :proc => Proc.new { |sf| Chef::Config[:knife][:template_file] = tf }
+
+          Chef::Config[:knife][:hints] ||= {"vcloud" => {}}
+          option :hint,
+            :long => "--hint HINT_FILE",
+            :description => "Specify Ohai Hint to be set on the bootstrap target.",
+            :proc => Proc.new { |path| Chef::Config[:knife][:hints]["vcloud"] = path ? JSON.parse(::File.read(path)) : Hash.new }
+        end
+      end
+
+      def bootstrap_vm(vm_name, id, addresses)
+        ui.msg "Bootstrap VM: #{vm_name}..."
+
+        max_tries = locate_config_value(:max_tries)
+        ssh_port = locate_config_value(:ssh_port)
+
+        # Stop at the first reachable IP address
+        reachable_ip = nil
+        addresses.each do |address|
+          tries = 1
+
+          until tries > max_tries
+            ui.info "Trying to reach #{address} (try #{tries}/#{max_tries})"
+
+            if test_connection_ssh(address, ssh_port)
+              reachable_ip = address
+              break
+            end
+            tries += 1
+          end
+          break if reachable_ip
+        end
+
+        if reachable_ip
+          ui.msg "Bootstrap IP: #{reachable_ip}"
+          bootstrap_for_node(reachable_ip).run
+        else
+          ui.warn "No reachable IPs. Not bootstrapping."
+        end
+      end
+
+      private
+        def test_connection_ssh(hostname, port)
+          socket = TCPSocket.new(hostname, port)
+
+          result = IO.select([socket], nil, nil, @test_connection_timeout)
+          if result
+            ui.info("\t#{hostname}:#{port} replied with: #{socket.gets}")
+            true
+          else
+            false
+          end
+        rescue Errno::ETIMEDOUT, Errno::EPERM => e
+          ui.info("\tUnable to reach #{hostname}:#{port} => #{e.message}")
+          false
+        rescue SocketError, Errno::ECONNREFUSED, Errno::EHOSTUNREACH, Errno::ENETUNREACH, Errno::ECONNRESET => e
+          ui.info("\tUnable to reach #{hostname}:#{port} => #{e.message}")
+          sleep 2
+          false
+        ensure
+          socket && socket.close
+        end
+
+        def bootstrap_for_node(fqdn)
+          bootstrap = Chef::Knife::Bootstrap.new
+          bootstrap.name_args = [fqdn]
+          bootstrap.config[:ssh_user] = locate_config_value(:ssh_user) || "root"
+          bootstrap.config[:ssh_password] = locate_config_value(:ssh_password)
+          bootstrap.config[:use_sudo] = true unless locate_config_value(:ssh_user) == 'root'
+          bootstrap.config[:ssh_user] = locate_config_value(:ssh_user)
+          bootstrap.config[:ssh_password] = config[:ssh_password]
+          bootstrap.config[:ssh_port] = locate_config_value(:ssh_port)
+          bootstrap.config[:ssh_gateway] = locate_config_value(:ssh_gateway)
+          bootstrap.config[:forward_agent] = locate_config_value(:forward_agent)
+          bootstrap.config[:identity_file] = locate_config_value(:identity_file)
+          bootstrap.config[:manual] = true
+          bootstrap.config[:host_key_verify] = locate_config_value(:host_key_verify)
+
+          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] = locate_config_value(:secret)
+          bootstrap.config[:encrypted_data_bag_secret_file] = locate_config_value(:secret_file)
+
+          bootstrap
+        end
+    end
+  end
+end

data/lib/chef/knife/common/vc_catalog_common.rb

@@ -0,0 +1,58 @@
+#
+# Author:: Stefano Tortarolo (<stefano.tortarolo@gmail.com>)
+# Copyright:: Copyright (c) 2013
+# 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
+    module VcCatalogCommon
+      def self.included(includer)
+        includer.class_eval do
+          option :vcloud_catalog,
+                 :long => "--catalog CATALOG_NAME",
+                 :description => "Catalog to whom Catalog Item belongs",
+                 :proc => Proc.new { |key| Chef::Config[:knife][:vcloud_catalog] = key }
+        end
+      end
+
+      def get_catalog(catalog_arg)
+        catalog = nil
+        org_name = locate_org_option
+
+        org = connection.get_organization_by_name org_name
+        catalog = connection.get_catalog_by_name org, catalog_arg
+
+        raise ArgumentError, "Catalog #{catalog_arg} not found" unless catalog
+        catalog
+      end
+
+      def get_catalog_item(catalog_item_arg)
+        item = nil
+        catalog_name = locate_config_value(:vcloud_catalog)
+
+        unless catalog_name
+          notice_msg("--catalog not specified, assuming CATALOG_ITEM is an ID")
+          item = connection.get_catalog_item catalog_item_arg
+        else
+          catalog = get_catalog(catalog_name)
+          item = connection.get_catalog_item_by_name catalog[:id], catalog_item_arg
+        end
+        raise ArgumentError, "Catalog Item #{catalog_item_arg} not found" unless item
+        item
+      end
+    end
+  end
+end

data/lib/chef/knife/common/vc_common.rb

@@ -0,0 +1,165 @@
+#
+# Author:: Stefano Tortarolo (<stefano.tortarolo@gmail.com>)
+# Copyright:: Copyright (c) 2012-2013
+# 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.
+#
+
+require 'chef/knife'
+require 'date'
+
+class Chef
+  class Knife
+    module VcCommon
+      def self.included(includer)
+        includer.class_eval do
+
+          deps do
+            require 'vcloud-rest/connection'
+            require 'chef/api_client'
+          end
+
+          option :vcloud_url,
+                 :short => "-H URL",
+                 :long => "--url URL",
+                 :description => "The vCloud endpoint URL",
+                 :proc => Proc.new { |url| Chef::Config[:knife][:vcloud_url] = url }
+
+          option :vcloud_user_login,
+                 :short => "-U USER",
+                 :long => "--user-login USER",
+                 :description => "Your vCloud User",
+                 :proc => Proc.new { |key| Chef::Config[:knife][:vcloud_user_login] = key }
+
+          option :vcloud_password_login,
+                 :short => "-P SECRET",
+                 :long => "--password-login SECRET",
+                 :description => "Your vCloud secret key",
+                 :proc => Proc.new { |key| Chef::Config[:knife][:vcloud_password_login] = key }
+
+          option :vcloud_org_login,
+                 :long => "--org-login ORGANIZATION",
+                 :description => "Your vCloud Organization",
+                 :proc => Proc.new { |key| Chef::Config[:knife][:vcloud_org_login] = key }
+
+          option :vcloud_api_version,
+                 :short => "-A API_VERSION",
+                 :long => "--api-version API_VERSION",
+                 :description => "vCloud API version (1.5 and 5.1 supported)",
+                 :proc => Proc.new { |key| Chef::Config[:knife][:vcloud_api_version] = key }
+
+          option :vcloud_system_admin,
+                 :long => "--[no-]system-admin",
+                 :description => "Set to true if user is a vCloud System Administrator",
+                 :proc => Proc.new { |key| Chef::Config[:knife][:vcloud_system_admin] = key },
+                 :boolean => true,
+                 :default => false
+
+          option :vcloud_org,
+                 :long => "--org ORG_NAME",
+                 :description => "Organization to use (only for System Administrators)",
+                 :proc => Proc.new { |key| Chef::Config[:knife][:vcloud_org] = key }
+        end
+      end
+
+      def connection
+        unless @connection
+          @connection = VCloudClient::Connection.new(
+              locate_config_value(:vcloud_url),
+              locate_config_value(:vcloud_user_login),
+              locate_config_value(:vcloud_password_login),
+              locate_config_value(:vcloud_org_login),
+              locate_config_value(:vcloud_api_version)
+          )
+        end
+
+        @connection
+      end
+
+      # Locate the correct organization option
+      #
+      # System Administrators can browse several organizations and thus --org
+      # can be used to specify different organizations
+      #
+      # Only --org-login is valid for other users
+      def locate_org_option
+        org = locate_config_value(:vcloud_org_login)
+
+        if locate_config_value(:vcloud_system_admin)
+          return locate_config_value(:vcloud_org) || org
+        end
+
+        if locate_config_value(:vcloud_org)
+          ui.warn("--org option is available only for vCloud System Administrators. " \
+                  "Using --org-login ('#{org}').")
+        end
+        return org
+      end
+
+      def out_msg(label, value)
+        if value && !value.empty?
+          ui.msg("#{ui.color(label, :cyan)}: #{value}")
+        end
+      end
+
+      def notice_msg(value)
+        if value && !value.empty?
+          ui.info("#{ui.color('Note:', :bold)} #{value}")
+        end
+      end
+
+      def locate_config_value(key)
+        key = key.to_sym
+        Chef::Config[:knife][key] || config[key]
+      end
+
+      def wait_task(connection, task_id)
+        result = connection.wait_task_completion task_id
+
+        elapsed = humanize_elapsed_time(result[:start_time], result[:end_time])
+
+        out_msg("Summary",
+          "Status: #{ui.color(result[:status], :cyan)} - time elapsed: #{elapsed}")
+
+        if result[:errormsg]
+          ui.warn(ui.color("ATTENTION: #{result[:errormsg]}", :red))
+        end
+
+        result[:errormsg].nil?
+      end
+
+      def pretty_symbol(key)
+        key.to_s.gsub('_', ' ').capitalize
+      end
+
+      def sort_by_key(collection)
+        collection.sort_by {|k, v| k }
+      end
+
+      private
+        def humanize_elapsed_time(start_time, end_time)
+          start_time = Time.parse(start_time || Time.now)
+          end_time = Time.parse(end_time || Time.now)
+          secs = (end_time - start_time)
+
+          [[60, :seconds],
+            [60, :minutes],
+            [24, :hours]].map do |count, name|
+            secs, n = secs.divmod(count)
+            "#{n} #{name}" unless n <= 0
+          end.compact.reverse.join(' ')
+        end
+    end
+  end
+end