knife-clc 0.0.1 → 0.0.2.pre

data/lib/knife-clc/base.rb

@@ -0,0 +1,56 @@
+require_relative 'base/config_options'
+
+require 'hirb'
+require 'clc'
+require 'knife-clc/version'
+
+module Knife
+  module Clc
+    module Base
+      def self.included(command_class)
+        ConfigOptions.attach(command_class)
+      end
+
+      def connection
+        @connection ||= ::Clc::Client.new(
+          :username => config[:clc_username],
+          :password => config[:clc_password],
+          :endpoint => config[:clc_endpoint],
+          :verbosity => config[:verbosity]
+        )
+      end
+
+      def context
+        @context ||= {}
+      end
+
+      def run
+        $stdout.sync = true
+
+        parse_and_validate_parameters
+
+        if errors.any?
+          show_errors
+          show_usage
+          exit 1
+        else
+          execute
+        end
+      end
+
+      def parse_and_validate_parameters
+      end
+
+      def execute
+      end
+
+      def errors
+        @errors ||= []
+      end
+
+      def show_errors
+        errors.each { |message| ui.error message }
+      end
+    end
+  end
+end

data/lib/knife-clc/bootstrap/bootstrapper.rb

@@ -0,0 +1,92 @@
+require_relative 'validator'
+require_relative 'connectivity_helper'
+require_relative 'subcommand_loader'
+
+require_relative 'methods/async_linux_package'
+require_relative 'methods/async_windows_package'
+require_relative 'methods/sync_linux_ssh'
+require_relative 'methods/sync_windows_winrm'
+
+module Knife
+  module Clc
+    module Bootstrap
+      class Bootstrapper
+        attr_reader :cloud_adapter, :config, :errors
+
+        def initialize(params)
+          @cloud_adapter = params.fetch(:cloud_adapter)
+          @config = params.fetch(:config)
+          @errors = params.fetch(:errors)
+        end
+
+        def sync_bootstrap(server)
+          sync_bootstrap_method.execute(server)
+        end
+
+        def async_bootstrap(launch_parameters)
+          async_bootstrap_method.execute(launch_parameters)
+        end
+
+        def prepare
+          validator.validate
+        end
+
+        private
+
+        def validator
+          @validator ||= Validator.new(
+            :connection => cloud_adapter.connection,
+            :config => config,
+            :errors => errors
+          )
+        end
+
+        def connectivity_helper
+          @connectivity_helper ||= ConnectivityHelper.new
+        end
+
+        def subcommand_loader
+          @subcommand_loader ||= SubcommandLoader.new
+        end
+
+        def sync_bootstrap_method
+          case config[:clc_bootstrap_platform]
+          when 'linux'
+            Methods::SyncLinuxSsh.new(
+              :cloud_adapter => cloud_adapter,
+              :config => config,
+              :connectivity_helper => connectivity_helper,
+              :subcommand_loader => subcommand_loader
+            )
+          when 'windows'
+            Methods::SyncWindowsWinrm.new(
+              :cloud_adapter => cloud_adapter,
+              :config => config,
+              :connectivity_helper => connectivity_helper,
+              :subcommand_loader => subcommand_loader
+            )
+          else
+            raise 'No suitable bootstrap method found'
+          end
+        end
+
+        def async_bootstrap_method
+          case config[:clc_bootstrap_platform]
+          when 'linux'
+            Methods::AsyncLinuxPackage.new(
+              :config => config,
+              :subcommand_loader => subcommand_loader
+            )
+          when 'windows'
+            Methods::AsyncWindowsPackage.new(
+              :config => config,
+              :subcommand_loader => subcommand_loader
+            )
+          else
+            raise 'No suitable bootstrap method found'
+          end
+        end
+      end
+    end
+  end
+end

data/lib/knife-clc/bootstrap/config_options.rb

@@ -0,0 +1,66 @@
+require 'chef/knife/bootstrap'
+require 'chef/knife/bootstrap_windows_winrm'
+
+module Knife
+  module Clc
+    module Bootstrap
+      class ConfigOptions
+        def self.attach(command_class)
+          command_class.class_eval do
+            option :clc_bootstrap,
+              :long => '--bootstrap',
+              :description => '[Bootstrap] Bootstrap launched server',
+              :boolean => true,
+              :default => false,
+              :on => :head
+
+            option :clc_bootstrap_private,
+              :long => '--bootstrap-private',
+              :description => '[Bootstrap] Bootstrap from private network. Requires client or SSH gateway to have an access to private network of the server',
+              :boolean => true,
+              :default => false,
+              :on => :head
+
+            option :clc_bootstrap_platform,
+              :long => '--bootstrap-platform PLATFORM',
+              :description => '[Bootstrap] Sets bootstrapping server platform as windows or linux. Derived automatically by default',
+              :on => :head
+          end
+
+          attach_platform_specific_options(command_class)
+        end
+
+        # TODO AS: Once bootstrapper has separate platform modules - rework this
+        def self.attach_platform_specific_options(command_class)
+          linux_options = Chef::Knife::Bootstrap.options.dup
+          windows_options = Chef::Knife::BootstrapWindowsWinrm.options.dup
+
+          windows_specific_option_keys = windows_options.keys - linux_options.keys
+          linux_specific_option_keys = linux_options.keys - windows_options.keys
+
+          linux_specific_option_keys.each do |linux_key|
+            description = linux_options[linux_key][:description]
+            linux_options[linux_key][:description] = '(Linux Only) ' + description
+          end
+
+          windows_specific_option_keys.each do |windows_key|
+            description = windows_options[windows_key][:description]
+            windows_options[windows_key][:description] = '(Windows Only) ' + description
+          end
+
+          windows_options.each do |name, settings|
+            settings[:description] = '[Bootstrap] ' + settings[:description]
+          end
+
+          linux_options.each do |name, settings|
+            settings[:description] = '[Bootstrap] ' + settings[:description]
+          end
+
+          command_class.options
+            .merge!(linux_options)
+            .merge!(windows_options)
+        end
+      end
+    end
+  end
+end

data/lib/knife-clc/bootstrap/connectivity_helper.rb

@@ -0,0 +1,39 @@
+require 'net/ssh'
+require 'socket'
+
+class ConnectivityHelper
+  def test_tcp(params)
+    host = params.fetch(:host)
+    port = params.fetch(:port)
+
+    socket = TCPSocket.new(host, port)
+    if readable = IO.select([socket], [socket], nil, 5)
+      yield if block_given?
+      true
+    else
+      false
+    end
+  rescue SocketError, Errno::ECONNREFUSED, Errno::EHOSTUNREACH, Errno::ENETUNREACH, IOError, Errno::EPERM, Errno::ETIMEDOUT
+    false
+  ensure
+    socket && socket.close
+  end
+
+  def test_ssh_tunnel(params)
+    host = params.fetch(:host)
+    port = params.fetch(:port)
+    gateway = params.fetch(:gateway)
+
+    gateway_user, gateway_host = gateway.split('@')
+    gateway_host, gateway_port = gateway_host.split(':')
+
+    gateway = Net::SSH::Gateway.new(gateway_host, gateway_user, :port => gateway_port || 22)
+    status = false
+    gateway.open(host, port) do |local_tunnel_port|
+      status = test_tcp(:host => 'localhost', :port => local_tunnel_port)
+    end
+    status
+  rescue SocketError, Errno::ECONNREFUSED, Errno::EHOSTUNREACH, Errno::ENETUNREACH, IOError, Errno::EPERM, Errno::ETIMEDOUT
+    false
+  end
+end

data/lib/knife-clc/bootstrap/methods/async_linux_package.rb

@@ -0,0 +1,41 @@
+module Knife
+  module Clc
+    module Bootstrap
+      module Methods
+        class AsyncLinuxPackage
+          attr_reader :config, :subcommand_loader
+
+          def initialize(params)
+            @config = params.fetch(:config)
+            @subcommand_loader = params.fetch(:subcommand_loader)
+          end
+
+          def execute(launch_parameters)
+            launch_parameters['packages'] ||= []
+            launch_parameters['packages'].concat(packages_for_async_bootstrap)
+          end
+
+          private
+
+          def packages_for_async_bootstrap
+            [{
+              'packageId' => 'a5d9d04369df4276a4f98f2ca7f7872b',
+              'parameters' => {
+                'Mode' => 'Ssh',
+                'Script' => bootstrap_script
+              }
+            }]
+          end
+
+          def bootstrap_script
+            bootstrap_command.render_template
+          end
+
+          def bootstrap_command
+            subcommand_loader.load(:class => Chef::Knife::Bootstrap, :config => config)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/knife-clc/bootstrap/methods/async_windows_package.rb

@@ -0,0 +1,69 @@
+require 'chef/knife/bootstrap_windows_winrm'
+
+module Knife
+  module Clc
+    module Bootstrap
+      module Methods
+        class AsyncWindowsPackage
+          COMBINED_SCRIPT_PATH = 'C:/bootstrap.bat'
+          LINES_PER_PARTIAL_SCRIPT = 100
+
+          attr_reader :config, :subcommand_loader
+
+          def initialize(params)
+            @config = params.fetch(:config)
+            @subcommand_loader = params.fetch(:subcommand_loader)
+          end
+
+          def execute(launch_parameters)
+            launch_parameters['packages'] ||= []
+            launch_parameters['packages'].concat(packages_for_async_bootstrap)
+          end
+
+          private
+
+          def packages_for_async_bootstrap
+            split_script(bootstrap_script).map do |partial_script|
+              {
+                'packageId' => 'a5d9d04369df4276a4f98f2ca7f7872b',
+                'parameters' => {
+                  'Mode' => 'PowerShell',
+                  'Script' => partial_script
+                }
+              }
+            end
+          end
+
+          def split_script(script)
+            partial_scripts = script.lines.each_slice(LINES_PER_PARTIAL_SCRIPT).map do |lines|
+              appending_script(lines.join).tap { |script| ensure_windows_newlines(script) }
+            end
+
+            partial_scripts.push(COMBINED_SCRIPT_PATH)
+          end
+
+          def appending_script(script_to_append)
+            "$script = @'\n" +
+            script_to_append +
+            "'@\n" +
+            "$script | out-file #{COMBINED_SCRIPT_PATH} -Append -Encoding ASCII\n"
+          end
+
+          def ensure_windows_newlines(script)
+            script.gsub!("\r\n", "\n")
+            script.gsub!("\n", "\r\n")
+          end
+
+          def bootstrap_command
+            subcommand_loader.load(:class => Chef::Knife::BootstrapWindowsWinrm, :config => config)
+          end
+
+          def bootstrap_script
+            command = bootstrap_command
+            command.render_template(command.load_template(config[:bootstrap_template]))
+          end
+        end
+      end
+    end
+  end
+end

data/lib/knife-clc/bootstrap/methods/sync_linux_ssh.rb

@@ -0,0 +1,67 @@
+module Knife
+  module Clc
+    module Bootstrap
+      module Methods
+        class SyncLinuxSsh
+          attr_reader :cloud_adapter, :config, :connectivity_helper, :subcommand_loader
+
+          def initialize(params)
+            @cloud_adapter = params.fetch(:cloud_adapter)
+            @config = params.fetch(:config)
+            @connectivity_helper = params.fetch(:connectivity_helper)
+            @subcommand_loader = params.fetch(:subcommand_loader)
+          end
+
+          def execute(server)
+            cloud_adapter.ensure_server_powered_on(server)
+
+            fqdn = get_server_fqdn(server)
+            wait_for_sshd(fqdn)
+
+            command = subcommand_loader.load(:class => Chef::Knife::Bootstrap, :config => config)
+
+            username, password = config.values_at(:ssh_user, :ssh_password)
+            unless username && password
+              creds = cloud_adapter.get_server_credentials(server)
+              command.config.merge!(:ssh_user => creds['userName'], :ssh_password => creds['password'])
+            end
+
+            command.name_args = [fqdn]
+            command.config[:chef_node_name] ||= server['name']
+
+            command.run
+          end
+
+          private
+
+          def wait_for_sshd(hostname)
+            expire_at = Time.now + 30
+            port = config[:ssh_port] || 22
+
+            if gateway = config[:ssh_gateway]
+              until connectivity_helper.test_ssh_tunnel(:host => hostname, :port => port, :gateway => gateway)
+                raise 'Could not establish tunneled SSH connection with the server' if Time.now > expire_at
+              end
+            else
+              until connectivity_helper.test_tcp(:host => hostname, :port => port)
+                raise 'Could not establish SSH connection with the server' if Time.now > expire_at
+              end
+            end
+          end
+
+          def get_server_fqdn(server)
+            if indirect_bootstrap?
+              cloud_adapter.get_private_ip(server)
+            else
+              cloud_adapter.get_public_ip(server)
+            end
+          end
+
+          def indirect_bootstrap?
+            config[:clc_bootstrap_private] || config[:ssh_gateway]
+          end
+        end
+      end
+    end
+  end
+end

data/lib/knife-clc/bootstrap/methods/sync_windows_winrm.rb

@@ -0,0 +1,61 @@
+module Knife
+  module Clc
+    module Bootstrap
+      module Methods
+        class SyncWindowsWinrm
+          attr_reader :cloud_adapter, :config, :connectivity_helper, :subcommand_loader
+
+          def initialize(params)
+            @cloud_adapter = params.fetch(:cloud_adapter)
+            @config = params.fetch(:config)
+            @connectivity_helper = params.fetch(:connectivity_helper)
+            @subcommand_loader = params.fetch(:subcommand_loader)
+          end
+
+          def execute(server)
+            cloud_adapter.ensure_server_powered_on(server)
+
+            fqdn = get_server_fqdn(server)
+            wait_for_winrm(fqdn)
+
+            command = subcommand_loader.load(:class => Chef::Knife::BootstrapWindowsWinrm, :config => config)
+
+            username, password = config.values_at(:winrm_user, :winrm_password)
+            unless username && password
+              creds = cloud_adapter.get_server_credentials(server)
+              command.config.merge!(:winrm_user => creds['userName'], :winrm_password => creds['password'])
+            end
+
+            command.name_args = [fqdn]
+            command.config[:chef_node_name] ||= server['name']
+
+            command.run
+          end
+
+          private
+
+          def wait_for_winrm(hostname)
+            expire_at = Time.now + 3600
+            port = config[:winrm_port] || 5985
+
+            until connectivity_helper.test_tcp(:host => hostname, :port => port)
+              raise 'Could not establish WinRM connection with the server' if Time.now > expire_at
+            end
+          end
+
+          def get_server_fqdn(server)
+            if indirect_bootstrap?
+              cloud_adapter.get_private_ip(server)
+            else
+              cloud_adapter.get_public_ip(server)
+            end
+          end
+
+          def indirect_bootstrap?
+            config[:clc_bootstrap_private]
+          end
+        end
+      end
+    end
+  end
+end

data/lib/knife-clc/bootstrap/subcommand_loader.rb

@@ -0,0 +1,18 @@
+module Knife
+  module Clc
+    module Bootstrap
+      class SubcommandLoader
+        def load(params)
+          klass = params.fetch(:class)
+          config = params.fetch(:config)
+
+          klass.load_deps
+          command = klass.new
+          command.config.merge!(config)
+          command.configure_chef
+          command
+        end
+      end
+    end
+  end
+end

data/lib/knife-clc/bootstrap/validator.rb

@@ -0,0 +1,149 @@
+require 'chef/node'
+
+module Knife
+  module Clc
+    module Bootstrap
+      class Validator
+        attr_reader :connection, :config, :errors
+
+        def initialize(params)
+          @connection = params.fetch(:connection)
+          @config = params.fetch(:config)
+          @errors = params.fetch(:errors)
+        end
+
+        def validate
+          return unless config[:clc_bootstrap]
+
+          check_chef_server_connectivity
+
+          if config[:clc_bootstrap_platform]
+            validate_bootstrap_platform
+          else
+            check_server_platform
+          end
+
+          check_server_platform
+          if config[:clc_wait]
+            check_bootstrap_connectivity_params
+          else
+            check_bootstrap_node_connectivity_params
+          end
+        end
+
+        private
+
+        def indirect_bootstrap?
+          config[:clc_bootstrap_private] || config[:ssh_gateway]
+        end
+
+        def check_chef_server_connectivity
+          Chef::Node.list
+        rescue Exception => e
+          errors << 'Could not connect to Chef Server: ' + e.message
+        end
+
+        def check_bootstrap_node_connectivity_params
+          unless Chef::Config[:validation_key]
+            errors << "Validatorless async bootstrap is not supported. Validation key #{Chef::Config[:validation_key]} not found"
+          end
+        end
+
+        def validate_bootstrap_platform
+          unless %w(linux windows).include? config[:clc_bootstrap_platform]
+            errors << "Unsupported bootstrap platform: #{config[:clc_bootstrap_platform]}"
+          end
+        end
+
+        def check_bootstrap_connectivity_params
+          return if indirect_bootstrap?
+
+          if public_ip_requested?
+            check_connectivity_errors
+          else
+            errors << 'Bootstrapping requires public IP access to the server. Ignore this check with --bootstrap-private'
+          end
+        end
+
+        def check_connectivity_errors
+          if config[:clc_bootstrap_platform] == 'windows'
+            errors << "Bootstrapping requires WinRM access to the server" unless winrm_access_requested?
+          else
+            errors << "Bootstrapping requires SSH access to the server" unless ssh_access_requested?
+          end
+        end
+
+        def check_server_platform
+          return unless config[:clc_group] && config[:clc_source_server]
+
+          if template = find_source_template
+            windows_platform = template['osType'] =~ /windows/
+          elsif server = find_source_server
+            windows_platform = server['os'] =~ /windows/
+          end
+
+          if windows_platform
+            config[:clc_bootstrap_platform] = 'windows'
+          else
+            config[:clc_bootstrap_platform] = 'linux'
+          end
+        rescue Clc::CloudExceptions::Error => e
+          errors << "Could not derive server bootstrap platform: #{e.message}. Please set it manually via --bootstrap-platform"
+        end
+
+        def find_source_template
+          group = connection.show_group(config[:clc_group])
+          datacenter_id = group['locationId']
+          connection.list_templates(datacenter_id).find do |template|
+            template['name'] == config[:clc_source_server]
+          end
+        end
+
+        def find_source_server
+          connection.show_server(config[:clc_source_server])
+        end
+
+        def public_ip_requested?
+          config[:clc_allowed_protocols] && config[:clc_allowed_protocols].any?
+        end
+
+
+        def winrm_access_requested?
+          winrm_port = requested_winrm_port
+
+          config[:clc_allowed_protocols].find do |permission|
+            protocol, from, to = permission.values_at('protocol', 'port', 'portTo')
+            next unless protocol == 'tcp'
+            next unless from
+
+            to ||= from
+
+            Range.new(from, to).include? winrm_port
+          end
+        end
+
+        def requested_winrm_port
+          (config[:winrm_port] && Integer(config[:winrm_port])) || 5985
+        end
+
+        def ssh_access_requested?
+          ssh_port = requested_ssh_port
+
+          config[:clc_allowed_protocols].find do |permission|
+            protocol, from, to = permission.values_at('protocol', 'port', 'portTo')
+            next unless protocol == 'tcp'
+            next unless from
+
+            to ||= from
+
+            Range.new(from, to).include? ssh_port
+          end
+        end
+
+        def requested_ssh_port
+          (config[:ssh_port] && Integer(config[:ssh_port])) || 22
+        end
+      end
+    end
+  end
+end

data/lib/knife-clc/bootstrap.rb

@@ -0,0 +1,20 @@
+require_relative 'bootstrap/config_options'
+require_relative 'bootstrap/bootstrapper'
+
+module Knife
+  module Clc
+    module Bootstrap
+      def self.included(command_class)
+        ConfigOptions.attach(command_class)
+      end
+
+      def bootstrapper
+        @bootstrapper = Bootstrapper.new(
+          :cloud_adapter => cloud_adapter,
+          :config => config,
+          :errors => errors
+        )
+      end
+    end
+  end
+end