knife-cloud 1.0.0.rc.0

data/lib/chef/knife/cloud/command.rb

@@ -0,0 +1,101 @@
+#
+# Author:: Kaustubh Deorukhkar (<kaustubh@clogeny.com>)
+# Copyright:: Copyright (c) 2013 Opscode, 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.
+#
+
+require 'chef/knife'
+require "chef/knife/cloud/helpers"
+require 'chef/knife/cloud/exceptions'
+
+class Chef
+  class Knife
+
+    class Cloud
+      class Command < Chef::Knife
+        include Cloud::Helpers
+        attr_accessor :service, :custom_arguments
+
+        def run
+          begin
+            # Set dafult config
+            set_default_config
+
+            # validate compulsory params
+            validate!
+
+            # validate command pre-requisites (cli options)
+            validate_params!
+
+            # setup the service
+            @service = create_service_instance
+
+            service.ui = ui # for interactive user prompts/messages
+
+            # Perform any steps before handling the command
+            before_exec_command
+
+            # exec the actual cmd
+            execute_command
+
+            # Perform any steps after handling the command
+            after_exec_command
+          rescue CloudExceptions::KnifeCloudError => e
+            Chef::Log.debug(e.message)
+            exit 1
+          end
+        end
+
+        def create_service_instance
+          raise Chef::Exceptions::Override, "You must override create_service_instance in #{self.to_s} to create cloud specific service"
+        end
+
+        def execute_command
+          raise Chef::Exceptions::Override, "You must override execute_command in #{self.to_s}"
+        end
+
+        # Derived classes can override before_exec_command and after_exec_command
+        def before_exec_command
+        end
+
+        def after_exec_command
+        end
+
+        def set_default_config
+        end
+
+        def validate!(*keys)
+          # validates necessary options/params to carry out the command.
+          # subclasses to implement this.
+          errors = []
+          keys.each do |k|
+            errors << "You did not provide a valid '#{pretty_key(k)}' value." if locate_config_value(k).nil?
+          end
+          error_message = ""
+          raise CloudExceptions::ValidationError, error_message if errors.each{|e| ui.error(e); error_message = "#{error_message} #{e}."}.any?
+        end
+
+        def validate_params!
+        end
+
+        def pretty_key(key)
+          key.to_s.gsub(/_/, ' ').gsub(/\w+/){ |w| (w =~ /(ssh)|(aws)/i) ? w.upcase  : w.capitalize }
+        end
+
+      end # class Command
+    end
+  end
+end
+

data/lib/chef/knife/cloud/exceptions.rb

@@ -0,0 +1,38 @@
+#
+# Copyright:: Copyright (c) 2013 Opscode, 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 Cloud
+      class CloudExceptions
+        class KnifeCloudError < RuntimeError; end
+        class CloudAPIException < KnifeCloudError; end
+        class ServiceConnectionError < KnifeCloudError; end
+        class ValidationError < KnifeCloudError; end
+        class ServerCreateError < KnifeCloudError; end
+        class ServerSetupError < KnifeCloudError; end
+        class ServerDeleteError < KnifeCloudError; end
+        class ServerCreateDependenciesError < KnifeCloudError; end
+        class BootstrapError < KnifeCloudError; end
+        class ServerShowError < KnifeCloudError; end
+        class ChefServerError < KnifeCloudError; end
+        class NetworkNotFoundError < KnifeCloudError; end
+      end
+    end
+  end
+end
+

data/lib/chef/knife/cloud/fog/options.rb

@@ -0,0 +1,29 @@
+#
+# Author:: Kaustubh Deorukhkar (<kaustubh@clogeny.com>)
+# Copyright:: Copyright (c) 2013 Opscode, Inc.
+#
+
+class Chef
+  class Knife
+    class Cloud
+      module FogOptions
+
+        def self.included(includer)
+          includer.instance_eval do
+            option :fog_version,
+              :long => "--fog-version version",
+              :description => "Fog gem version to use. Use the ruby gem version strings",
+              :default => "",
+              :proc => Proc.new { |v| Chef::Config[:knife][:cloud_fog_version] = v}
+
+            option :api_endpoint,
+              :long => "--api-endpoint ENDPOINT",
+              :description => "Your API endpoint. Eg, for Eucalyptus it can be 'http://ecc.eucalyptus.com:8773/services/Eucalyptus'",
+              :proc => Proc.new { |endpoint| Chef::Config[:knife][:api_endpoint] = endpoint }
+
+          end
+        end
+      end
+    end
+  end
+end

data/lib/chef/knife/cloud/fog/service.rb

@@ -0,0 +1,200 @@
+#
+# Author:: Kaustubh Deorukhkar (<kaustubh@clogeny.com>)
+# Author:: Prabhu Das (<prabhu.das@clogeny.com>)
+# Copyright:: Copyright (c) 2013 Opscode, Inc.
+#
+
+require 'chef/knife/cloud/service'
+require 'chef/knife/cloud/exceptions'
+
+class Chef
+  class Knife
+    class Cloud
+      class FogService < Service
+
+        def initialize(options = {})
+          load_fog_gem
+          super
+        end
+
+        def load_fog_gem
+          begin
+            # Load specific version of fog. Any other classes/modules using fog are loaded after this.
+            gem "fog", Chef::Config[:knife][:cloud_fog_version]
+            require 'fog'
+            Chef::Log.debug("Using fog version: #{Gem.loaded_specs["fog"].version}")
+          rescue Exception => e
+            Chef::Log.error "Error loading fog gem."
+            exit 1
+          end
+        end
+
+        def connection
+          add_api_endpoint
+          @connection ||= begin
+            connection  = Fog::Compute.new(@auth_params)
+                          rescue Excon::Errors::Unauthorized => e
+                            error_message = "Connection failure, please check your username and password."
+                            ui.fatal(error_message)
+                            raise CloudExceptions::ServiceConnectionError, "#{e.message}. #{error_message}"
+                          rescue Excon::Errors::SocketError => e
+                            error_message = "Connection failure, please check your authentication URL."
+                            ui.fatal(error_message)
+                            raise CloudExceptions::ServiceConnectionError, "#{e.message}. #{error_message}"
+                          end
+        end
+
+        def network
+          @network ||= begin
+            network = Fog::Network.new(@auth_params)
+                      rescue Excon::Errors::Unauthorized => e
+                        error_message = "Connection failure, please check your username and password."
+                        ui.fatal(error_message)
+                        raise CloudExceptions::ServiceConnectionError, "#{e.message}. #{error_message}"
+                      rescue Excon::Errors::SocketError => e
+                        error_message = "Connection failure, please check your authentication URL."
+                        ui.fatal(error_message)
+                        raise CloudExceptions::ServiceConnectionError, "#{e.message}. #{error_message}"
+                      rescue Fog::Errors::NotFound => e
+                        error_message = "No Network service found. This command is unavailable with current cloud."
+                        ui.fatal(error_message)
+                        raise CloudExceptions::NetworkNotFoundError, "#{e.message}. #{error_message}"
+                      end
+        end
+
+        # cloud server specific implementation methods for commands.
+        def create_server(options = {})
+          begin
+            add_custom_attributes(options[:server_def])
+            server = connection.servers.create(options[:server_def])
+          rescue Excon::Errors::BadRequest => e
+            response = Chef::JSONCompat.from_json(e.response.body)
+            if response['badRequest']['code'] == 400
+              message = "Bad request (400): #{response['badRequest']['message']}"
+              ui.fatal(message)
+            else
+              message = "Unknown server error (#{response['badRequest']['code']}): #{response['badRequest']['message']}"
+              ui.fatal(message)
+            end
+            raise CloudExceptions::ServerCreateError, message
+          rescue Fog::Errors::Error => e
+            raise CloudExceptions::ServerCreateError, e.message
+          end
+
+          print "\n#{ui.color("Waiting for server [wait time = #{options[:server_create_timeout]}]", :magenta)}"
+
+          # wait for it to be ready to do stuff
+          server.wait_for(Integer(options[:server_create_timeout])) { print "."; ready? }
+
+          puts("\n")
+          server
+        end
+
+        def delete_server(server_name)
+          begin
+            server = get_server(server_name)
+            msg_pair("Instance Name", get_server_name(server))
+            msg_pair("Instance ID", server.id)
+
+            puts "\n"
+            ui.confirm("Do you really want to delete this server")
+
+            # delete the server
+            server.destroy
+          rescue NoMethodError
+            error_message = "Could not locate server '#{server_name}'."
+            ui.error(error_message)
+            raise CloudExceptions::ServerDeleteError, error_message
+          rescue Excon::Errors::BadRequest => e
+            handle_excon_exception(CloudExceptions::ServerDeleteError, e)
+          end
+        end
+
+        ["servers", "images", "networks"].each do |resource_type|
+          define_method("list_#{resource_type}") do
+            begin
+              case resource_type
+              when "networks"
+                network.method(resource_type).call.all
+              else
+                connection.method(resource_type).call.all
+              end
+            rescue Excon::Errors::BadRequest => e
+              handle_excon_exception(CloudExceptions::CloudAPIException, e)
+            end
+          end
+        end
+
+        def handle_excon_exception(exception_class, e)
+          error_message = if e.response
+                            response = Chef::JSONCompat.from_json(e.response.body)
+                            "Unknown server error (#{response['badRequest']['code']}): #{response['badRequest']['message']}"
+                          else
+                            "Unknown server error : #{e.message}"
+                          end
+          ui.fatal(error_message)
+          raise exception_class, error_message
+        end
+
+        def list_resource_configurations
+          begin
+            flavors = connection.flavors.all
+          rescue Excon::Errors::BadRequest => e
+            handle_excon_exception(CloudExceptions::CloudAPIException, e)
+          end
+        end
+
+        def delete_server_on_failure(server = nil)
+          server.destroy if ! server.nil?
+        end
+
+        def add_api_endpoint
+          raise Chef::Exceptions::Override, "You must override add_api_endpoint in #{self.to_s} to add endpoint in auth_params for connection"
+        end
+
+        def get_server_name(server)
+          server.name
+        end
+
+        def get_server(instance_id)
+          begin
+            server = connection.servers.get(instance_id)
+          rescue Excon::Errors::BadRequest => e
+            handle_excon_exception(CloudExceptions::KnifeCloudError, e)
+          end
+        end
+
+        def get_image(name_or_id)
+          connection.images.find{|img| img.name =~ /#{name_or_id}/ || img.id == name_or_id }
+        end
+
+        def get_flavor(name_or_id)
+          connection.flavors.find{|f| f.name == name_or_id || f.id == name_or_id }
+        end
+
+        def server_summary(server, columns_with_info = [])
+          # columns_with_info is array of hash with label, key and attribute extraction callback, ex [{:label => "Label text", :key => 'key', value => 'the_actual_value', value_callback => callback_method to extract/format the required value}, ...]
+          list = []
+          columns_with_info.each do |col_info|
+            value = if col_info[:value].nil?
+                      (col_info[:value_callback].nil? ? server.send(col_info[:key]).to_s : col_info[:value_callback].call(server.send(col_info[:key])))
+                    else
+                      col_info[:value]
+                    end
+            if !(value.nil? || value.empty?)
+              list << ui.color(col_info[:label], :bold)
+              list << value
+            end
+          end
+          puts ui.list(list, :uneven_columns_across, 2) if columns_with_info.length > 0
+        end
+
+        def is_image_windows?(image)
+          image_info = connection.images.get(image)
+          !image_info.nil? ? image_info.platform == 'windows' : false
+        end
+
+      end
+    end
+  end
+end

data/lib/chef/knife/cloud/helpers.rb

@@ -0,0 +1,39 @@
+#
+# Copyright:: Copyright (c) 2013 Opscode, 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 Cloud
+      module Helpers
+
+        # Additional helpers
+        def msg_pair(label, value, color=:cyan)
+          if value && !value.to_s.empty?
+            puts "#{ui.color(label, color)}: #{value}"
+          end
+        end
+
+        def locate_config_value(key)
+          key = key.to_sym
+          config[key] || Chef::Config[:knife][key]
+        end
+
+      end
+    end
+  end
+end
+

data/lib/chef/knife/cloud/list_resource_command.rb

@@ -0,0 +1,97 @@
+#
+# Author:: Prabhu Das (<prabhu.das@clogeny.com>)
+# Copyright:: Copyright (c) 2013-14 Chef, 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.
+#
+
+require 'chef/knife/cloud/command'
+
+class Chef
+  class Knife
+    class Cloud
+      class ResourceListCommand < Command
+
+        def initialize(argv=[])
+          super argv
+          # columns_with_info is array of hash with label, key and attribute extraction callback, ex [{:label => "Label text", :key => 'key', value_callback => callback_method to extract/format the required value}, ...]
+          @columns_with_info = []
+          @sort_by_field = "id" # default sort by id
+        end
+
+        def execute_command
+          # exec the cmd
+          resources = query_resource
+
+          # handle the response
+          list(resources)
+        end
+
+        def query_resource
+          # specific resource type must override this.
+          raise Chef::Exceptions::Override, "You must override query_resource in #{self.to_s} to return resources."
+        end
+
+        def is_resource_filtered?(attribute, value)
+          # resource_filters is array of filters in form {:attribute => attribute-name, :regex => 'filter regex value'}
+          return false if @resource_filters.nil?
+          @resource_filters.each do |filter|
+            if attribute == filter[:attribute] and value =~ filter[:regex]
+              return true
+            end
+          end
+          false
+        end
+        
+        # Derived class can override this to add more functionality.
+        def get_resource_col_val(resource)
+          resource_filtered = false
+          list = []
+          @columns_with_info.each do |col_info|
+            value = (col_info[:value_callback].nil? ? resource.send(col_info[:key]).to_s : col_info[:value_callback].call(resource.send(col_info[:key])))
+            if !config[:disable_filter]
+              resource_filtered = true if is_resource_filtered?(col_info[:key], value)
+            end
+            list << value
+          end
+          return list unless resource_filtered
+        end
+
+        # When @columns_with_info is nil display all
+        def list(resources)
+          # display column wise only if @columns_with_info is specified, else as a json for readable display.
+          begin
+            resource_list = @columns_with_info.map { |col_info| ui.color(col_info[:label], :bold) } if @columns_with_info.length > 0
+            resources.sort_by{|x| x.send(@sort_by_field).downcase }.each do |resource|
+              if @columns_with_info.length > 0
+                list = get_resource_col_val(resource)
+                resource_list.concat(list) unless list.nil?
+              else
+                puts resource.to_json
+                puts "\n"
+              end
+            end
+
+          rescue => e
+            ui.fatal("Unknown resource error : #{e.message}")
+            raise e
+          end
+          puts ui.list(resource_list, :uneven_columns_across, @columns_with_info.length) if @columns_with_info.length > 0
+        end
+
+      end # class ResourceListCommand
+    end
+  end
+end
+

data/lib/chef/knife/cloud/list_resource_options.rb

@@ -0,0 +1,21 @@
+
+class Chef
+  class Knife
+    class Cloud
+      module ResourceListOptions
+
+        def self.included(includer)
+          includer.class_eval do
+
+            option :disable_filter,
+            :long => "--disable-filter",
+            :description => "Disable filtering of the current resource listing.",
+            :boolean => true,
+            :default => false
+          end
+        end
+
+      end
+    end
+  end
+end

data/lib/chef/knife/cloud/server/create_command.rb

@@ -0,0 +1,165 @@
+#
+# Copyright:: Copyright (c) 2013 Opscode, 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.
+#
+require 'chef/knife/cloud/command'
+require 'chef/knife/cloud/exceptions'
+require 'chef/knife/cloud/chefbootstrap/bootstrapper'
+
+class Chef
+  class Knife
+    class Cloud
+      class ServerCreateCommand < Command
+        attr_accessor :server, :create_options
+
+        def initialize(argv=[])
+          super argv
+          # columns_with_info is array of hash with label, key and attribute extraction callback, ex [{:label => "Label text", :key => 'key', value_callback => callback_method to extract/format the required value}, ...]
+          @columns_with_info = []
+        end
+
+        def validate_params!
+          # set param vm_name to a random value if the name is not set by the user (plugin)
+          config[:chef_node_name] = get_node_name(locate_config_value(:chef_node_name), locate_config_value(:chef_node_name_prefix))
+
+          # validate ssh_user, ssh_password, identity_file for ssh bootstrap protocol and winrm_password for winrm bootstrap protocol
+          errors = []
+
+          if locate_config_value(:bootstrap_protocol) == 'ssh'
+            if locate_config_value(:identity_file).nil? && locate_config_value(:ssh_password).nil?
+              errors << "You must provide either Identity file or SSH Password."
+            end
+          elsif locate_config_value(:bootstrap_protocol) == 'winrm'
+            if locate_config_value(:winrm_password).nil?
+              errors << "You must provide Winrm Password."
+            end
+          else
+            errors << "You must provide a valid bootstrap protocol. options [ssh/winrm]. For linux type images, options [ssh]"
+          end
+          error_message = ""
+          raise CloudExceptions::ValidationError, error_message if errors.each{|e| ui.error(e); error_message = "#{error_message} #{e}."}.any?
+        end
+
+        def before_exec_command
+          begin
+            post_connection_validations
+            service.create_server_dependencies
+          rescue CloudExceptions::ServerCreateDependenciesError => e
+            ui.fatal(e.message)
+            service.delete_server_dependencies
+            raise e
+          end
+        end
+
+        def execute_command
+          begin
+            @server = service.create_server(create_options)
+          rescue CloudExceptions::ServerCreateError => e
+            ui.fatal(e.message)
+            # server creation failed, so we need to rollback only dependencies.
+            service.delete_server_dependencies
+            raise e
+          end
+          service.server_summary(@server, @columns_with_info)
+        end
+
+        # Derived classes can override after_exec_command and also call cleanup_on_failure if any exception occured.
+        def after_exec_command
+          begin
+            # bootstrap the server
+            bootstrap
+          rescue CloudExceptions::BootstrapError => e
+            ui.fatal(e.message)
+            cleanup_on_failure
+            raise e
+          rescue => e
+            error_message = "Check if --bootstrap-protocol and --image-os-type is correct. #{e.message}"
+            ui.fatal(error_message)
+            cleanup_on_failure
+            raise e, error_message
+          end
+        end
+
+        def cleanup_on_failure
+          if config[:delete_server_on_failure]
+            service.delete_server_dependencies
+            service.delete_server_on_failure(@server)
+          end
+        end
+
+        # Bootstrap the server
+        def bootstrap
+          before_bootstrap
+          @bootstrapper = Bootstrapper.new(config)
+          Chef::Log.debug("Bootstrapping the server...")
+          ui.info("Bootstrapping the server by using #{ui.color("bootstrap_protocol", :cyan)}: #{config[:bootstrap_protocol]} and #{ui.color("image_os_type", :cyan)}: #{config[:image_os_type]}")
+          @bootstrapper.bootstrap
+          after_bootstrap
+        end
+
+        # any cloud specific initializations/cleanup we want to do around bootstrap.
+        def before_bootstrap
+          ssh_override_winrm if locate_config_value(:bootstrap_protocol) == 'ssh'
+        end
+
+        def after_bootstrap
+          service.server_summary(@server, @columns_with_info)
+        end
+
+        # knife-plugin can override set_default_config to set default config by using their own mechanism.
+        def set_default_config
+          config[:image_os_type] = 'windows' if config[:bootstrap_protocol] == 'winrm'
+        end
+
+        #generate a random name if chef_node_name is empty
+        def get_node_name(chef_node_name, prefix)
+          return chef_node_name unless chef_node_name.nil?
+          #lazy uuids
+          chef_node_name = "#{prefix}-"+rand.to_s.split('.')[1]
+        end
+
+        def post_connection_validations
+        end
+
+        private
+
+        # Here, ssh config override winrm config
+        def ssh_override_winrm
+          # unchanged ssh_user and changed winrm_user, override ssh_user
+          if locate_config_value(:ssh_user).eql?(options[:ssh_user][:default]) &&
+              !locate_config_value(:winrm_user).eql?(options[:winrm_user][:default])
+            config[:ssh_user] = locate_config_value(:winrm_user)
+          end
+          # unchanged ssh_port and changed winrm_port, override ssh_port
+          if locate_config_value(:ssh_port).eql?(options[:ssh_port][:default]) &&
+              !locate_config_value(:winrm_port).eql?(options[:winrm_port][:default])
+            config[:ssh_port] = locate_config_value(:winrm_port)
+          end
+          # unset ssh_password and set winrm_password, override ssh_password
+          if locate_config_value(:ssh_password).nil? &&
+              !locate_config_value(:winrm_password).nil?
+            config[:ssh_password] = locate_config_value(:winrm_password)
+          end
+          # unset identity_file and set kerberos_keytab_file, override identity_file
+          if locate_config_value(:identity_file).nil? &&
+              !locate_config_value(:kerberos_keytab_file).nil?
+            config[:identity_file] = locate_config_value(:kerberos_keytab_file)
+          end          
+        end
+      end # class ServerCreateCommand
+    end
+  end
+end
+