vagrant-shell 0.2.11 → 0.2.12

data/VERSION

@@ -1 +1 @@
-0.2.11
+0.2.12

data/lib/vagrant-shell/action.rb

@@ -0,0 +1,111 @@
+require "pathname"
+
+require "vagrant/action/builder"
+
+module VagrantPlugins
+  module Shell
+    module Action
+      # Include the built-in modules so we can use them as top-level things.
+      include Vagrant::Action::Builtin
+
+      # This action is called to terminate the remote machine.
+      def self.action_destroy
+        Vagrant::Action::Builder.new.tap do |b|
+          b.use ConfigValidate
+          b.use TerminateInstance
+        end
+      end
+
+      # This action is called when `vagrant provision` is called.
+      def self.action_provision
+        Vagrant::Action::Builder.new.tap do |b|
+          b.use ConfigValidate
+          b.use Call, IsCreated do |env, b2|
+            if !env[:result]
+              b2.use MessageNotCreated
+              next
+            end
+
+            b2.use Provision
+          end
+        end
+      end
+
+      # This action is called to read the SSH info of the machine. The
+      # resulting state is expected to be put into the `:machine_ssh_info`
+      # key.
+      def self.action_read_ssh_info
+        Vagrant::Action::Builder.new.tap do |b|
+          b.use ConfigValidate
+          b.use ReadSSHInfo
+        end
+      end
+
+      # This action is called to read the state of the machine. The
+      # resulting state is expected to be put into the `:machine_state_id`
+      # key.
+      def self.action_read_state
+        Vagrant::Action::Builder.new.tap do |b|
+          b.use ConfigValidate
+          b.use ReadState
+        end
+      end
+
+      # This action is called to SSH into the machine.
+      def self.action_ssh
+        Vagrant::Action::Builder.new.tap do |b|
+          b.use ConfigValidate
+          b.use Call, IsCreated do |env, b2|
+            if !env[:result]
+              b2.use MessageNotCreated
+              next
+            end
+
+            b2.use SSHExec
+          end
+        end
+      end
+
+      def self.action_ssh_run
+        Vagrant::Action::Builder.new.tap do |b|
+          b.use ConfigValidate
+          b.use Call, IsCreated do |env, b2|
+            if !env[:result]
+              b2.use MessageNotCreated
+              next
+            end
+
+            b2.use SSHRun
+          end
+        end
+      end
+
+      # This action is called to bring the box up from nothing.
+      def self.action_up
+        Vagrant::Action::Builder.new.tap do |b|
+          b.use ConfigValidate
+          b.use Call, IsCreated do |env, b2|
+            if env[:result]
+              b2.use MessageAlreadyCreated
+              next
+            end
+
+            b2.use TimedProvision
+            b2.use RunInstance
+          end
+        end
+      end
+
+      # The autoload farm
+      action_root = Pathname.new(File.expand_path("../action", __FILE__))
+      autoload :IsCreated, action_root.join("is_created")
+      autoload :MessageAlreadyCreated, action_root.join("message_already_created")
+      autoload :MessageNotCreated, action_root.join("message_not_created")
+      autoload :ReadSSHInfo, action_root.join("read_ssh_info")
+      autoload :ReadState, action_root.join("read_state")
+      autoload :RunInstance, action_root.join("run_instance")
+      autoload :TimedProvision, action_root.join("timed_provision")
+      autoload :TerminateInstance, action_root.join("terminate_instance")
+    end
+  end
+end

data/lib/vagrant-shell/action/is_created.rb

@@ -0,0 +1,18 @@
+module VagrantPlugins
+  module Shell
+    module Action
+      # This can be used with "Call" built-in to check if the machine
+      # is created and branch in the middleware.
+      class IsCreated
+        def initialize(app, env)
+          @app = app
+        end
+
+        def call(env)
+          env[:result] = env[:machine].state.id != :not_created
+          @app.call(env)
+        end
+      end
+    end
+  end
+end

data/lib/vagrant-shell/action/message_already_created.rb

@@ -0,0 +1,16 @@
+module VagrantPlugins
+  module Shell
+    module Action
+      class MessageAlreadyCreated
+        def initialize(app, env)
+          @app = app
+        end
+
+        def call(env)
+          env[:ui].info(I18n.t("vagrant_shell.already_created"))
+          @app.call(env)
+        end
+      end
+    end
+  end
+end

data/lib/vagrant-shell/action/message_not_created.rb

@@ -0,0 +1,16 @@
+module VagrantPlugins
+  module Shell
+    module Action
+      class MessageNotCreated
+        def initialize(app, env)
+          @app = app
+        end
+
+        def call(env)
+          env[:ui].info(I18n.t("vagrant_shell.not_created"))
+          @app.call(env)
+        end
+      end
+    end
+  end
+end

data/lib/vagrant-shell/action/read_ssh_info.rb

@@ -0,0 +1,38 @@
+require "log4r"
+
+module VagrantPlugins
+  module Shell
+    module Action
+      # This action reads the SSH info for the machine and puts it into the
+      # `:machine_ssh_info` key in the environment.
+      class ReadSSHInfo
+        def initialize(app, env)
+          @app    = app
+          @logger = Log4r::Logger.new("vagrant_shell::action::read_ssh_info")
+        end
+
+        def call(env)
+          env[:machine_ssh_info] = read_ssh_info(env[:machine])
+
+          @app.call(env)
+        end
+
+        def read_ssh_info(machine)
+          return nil if machine.id.nil?
+
+          # Read the DNS info
+          output = %x{ #{machine.provider_config.script} ssh-info #{machine.id} }
+          if $?.to_i > 0
+            raise Errors::ShellError, :message => "Failure: #{env[:machine].provider_config.script} ssh-info #{machine.id}"
+          end
+
+          host,port = output.split(/\s+/)[0,2] # TODO check formatting
+          return {
+            :host => host,
+            :port => port
+          }
+        end
+      end
+    end
+  end
+end

data/lib/vagrant-shell/action/read_state.rb

@@ -0,0 +1,33 @@
+require "log4r"
+
+module VagrantPlugins
+  module Shell
+    module Action
+      # This action reads the state of the machine and puts it in the
+      # `:machine_state_id` key in the environment.
+      class ReadState
+        def initialize(app, env)
+          @app    = app
+          @logger = Log4r::Logger.new("vagrant_shell::action::read_state")
+        end
+
+        def call(env)
+          env[:machine_state_id] = read_state(env[:machine])
+
+          @app.call(env)
+        end
+
+        def read_state(machine)
+          return :not_created if machine.id.nil?
+
+          # Return the state
+          output = %x{ #{machine.provider_config.script} read-state #{machine.id} }
+          if $?.to_i > 0
+            raise Errors::ShellError, :message => "Failure: #{env[:machine].provider_config.script} read-state #{machine.id}"
+          end
+          output.strip
+        end
+      end
+    end
+  end
+end

data/lib/vagrant-shell/action/run_instance.rb

@@ -0,0 +1,110 @@
+require "log4r"
+require "pp"
+
+require 'vagrant/util/retryable'
+
+require 'vagrant-shell/util/timer'
+
+module VagrantPlugins
+  module Shell
+    module Action
+      # This runs the configured instance.
+      class RunInstance
+        include Vagrant::Util::Retryable
+
+        def initialize(app, env)
+          @app    = app
+          @logger = Log4r::Logger.new("vagrant_shell::action::run_instance")
+        end
+
+        def call(env)
+          # Initialize metrics if they haven't been
+          env[:metrics] ||= {}
+
+          # Get the configs
+          provider_config = env[:machine].provider_config
+          image              = provider_config.image
+          user_data          = provider_config.user_data
+          run_args           = provider_config.run_args
+
+          # Launch!
+          env[:ui].info(I18n.t("vagrant_shell.launching_instance"))
+          env[:ui].info(" -- Image: #{image}")
+
+          # Immediately save the ID since it is created at this point.
+          output = %x{ #{env[:machine].provider_config.script} run-instance #{image} #{run_args.join(" ")} }
+          if $?.to_i > 0
+            raise Errors::ShellError, :message => "Failure: #{env[:machine].provider_config.script} run-instance #{image} ..."
+          end
+          
+          env[:machine].id = output.split(/\s+/)[0]
+
+          # Wait for the instance to be ready first
+          env[:metrics]["instance_ready_time"] = Util::Timer.time do
+            tries = provider_config.instance_ready_timeout / 2
+
+            env[:ui].info(I18n.t("vagrant_shell.waiting_for_ready"))
+            begin
+              retryable(:on => Shell::Errors::TimeoutError, :tries => tries) do
+                # If we're interrupted don't worry about waiting
+                next if env[:interrupted]
+
+                # Wait for the server to be ready
+                true
+              end
+            rescue Shell::Errors::TimeoutError
+              # Delete the instance
+              terminate(env)
+
+              # Notify the user
+              raise Errors::InstanceReadyTimeout,
+                timeout: provider_config.instance_ready_timeout
+            end
+          end
+
+          @logger.info("Time to instance ready: #{env[:metrics]["instance_ready_time"]}")
+
+          if !env[:interrupted]
+            env[:metrics]["instance_ssh_time"] = Util::Timer.time do
+              # Wait for SSH to be ready.
+              env[:ui].info(I18n.t("vagrant_shell.waiting_for_ssh"))
+              while true
+                # If we're interrupted then just back out
+                break if env[:interrupted]
+                break if env[:machine].communicate.ready?
+                sleep 2
+              end
+            end
+
+            @logger.info("Time for SSH ready: #{env[:metrics]["instance_ssh_time"]}")
+
+            # Ready and booted!
+            env[:ui].info(I18n.t("vagrant_shell.ready"))
+          end
+
+          # Terminate the instance if we were interrupted
+          terminate(env) if env[:interrupted]
+
+          @app.call(env)
+        end
+
+        def recover(env)
+          return if env["vagrant.error"].is_a?(Vagrant::Errors::VagrantError)
+
+          if env[:machine].provider.state.id != :not_created
+            # Undo the import
+            terminate(env)
+          end
+        end
+
+        def terminate(env)
+          destroy_env = env.dup
+          destroy_env.delete(:interrupted)
+          destroy_env[:config_validate] = false
+          destroy_env[:force_confirm_destroy] = true
+          env[:action_runner].run(Action.action_destroy, destroy_env)
+        end
+      end
+    end
+  end
+end

data/lib/vagrant-shell/action/terminate_instance.rb

@@ -0,0 +1,30 @@
+require "log4r"
+
+module VagrantPlugins
+  module Shell
+    module Action
+      # This terminates the running instance.
+      class TerminateInstance
+        def initialize(app, env)
+          @app    = app
+          @logger = Log4r::Logger.new("vagrant_shell::action::terminate_instance")
+        end
+
+        def call(env)
+          # Destroy the server and remove the tracking ID
+          env[:ui].info(I18n.t("vagrant_shell.terminating"))
+          output = %x{ #{env[:machine].provider_config.script} terminate-instance #{env[:machine].id}}
+          if $?.to_i > 0
+            raise Errors::ShellError, :message => "Failure: #{env[:machine].provider_config.script} terminate-instance #{env[:machine].id}"
+          end
+
+          puts output
+
+          env[:machine].id = nil
+
+          @app.call(env)
+        end
+      end
+    end
+  end
+end

data/lib/vagrant-shell/action/timed_provision.rb

@@ -0,0 +1,21 @@
+require "vagrant-shell/util/timer"
+
+module VagrantPlugins
+  module Shell
+    module Action
+      # This is the same as the builtin provision except it times the
+      # provisioner runs.
+      class TimedProvision < Vagrant::Action::Builtin::Provision
+        def run_provisioner(env, name, p)
+          timer = Util::Timer.time do
+            super
+          end
+
+          env[:metrics] ||= {}
+          env[:metrics]["provisioner_times"] ||= []
+          env[:metrics]["provisioner_times"] << [name, timer]
+        end
+      end
+    end
+  end
+end

data/lib/vagrant-shell/config.rb

@@ -0,0 +1,95 @@
+require "vagrant"
+
+module VagrantPlugins
+  module Shell
+    class Config < Vagrant.plugin("2", :config)
+      # The ID of the Image to use.
+      #
+      # @return [String]
+      attr_accessor :image
+
+      # The timeout to wait for an instance to become ready.
+      #
+      # @return [Fixnum]
+      attr_accessor :instance_ready_timeout
+
+      # The user data string
+      #
+      # @return [String]
+      attr_accessor :user_data
+
+      # The shell script implementing some tech
+      # 
+      # @return [String]
+      attr_accessor :script
+
+      # The shell script run-instance args
+      # 
+      # @return [String]
+      attr_accessor :run_args
+
+      def initialize
+        @image                  = UNSET_VALUE
+        @instance_ready_timeout = UNSET_VALUE
+        @user_data              = UNSET_VALUE
+        @script                 = UNSET_VALUE
+        @run_args               = UNSET_VALUE
+
+        # Internal state (prefix with __ so they aren't automatically
+        # merged)
+        @__finalized = false
+      end
+
+      #-------------------------------------------------------------------
+      # Internal methods.
+      #-------------------------------------------------------------------
+
+      def merge(other)
+        super.tap do |result|
+        end
+      end
+
+      def finalize!
+        # Image must be nil, since we can't default that
+        @image = nil if @image == UNSET_VALUE
+
+        # Set the default timeout for waiting for an instance to be ready
+        @instance_ready_timeout = 120 if @instance_ready_timeout == UNSET_VALUE
+
+        # User Data is nil by default
+        @user_data = nil if @user_data == UNSET_VALUE
+
+        # No default shell script
+        @script = nil if @script == UNSET_VALUE
+
+        # No rub args by default
+        @run_args = [] if @run_args == UNSET_VALUE
+
+        # Mark that we finalized
+        @__finalized = true
+      end
+
+      def validate(machine)
+        { "Shell Provider" => [ ] } 
+      end
+
+      # utilities
+      def read_script pth_script
+        File.read(pth_script).split(/[ \t]*[\r\n]+/).join("; ")
+      end
+
+      def find_script name
+        try_path = ENV['PATH'].split(/:/).flatten.inject([]) { |acc, p| x = File.join(p,"shell-#{name.to_s}"); File.exists?(x) && acc << x; acc }.first
+        if try_path
+          return try_path
+        end
+
+        try_load = $:.inject([]) { |acc, p| x = File.expand_path("../libexec/shell-#{name.to_s}", p); File.exists?(x) && acc << x; acc }.first
+        if try_load
+          return try_load
+        end
+      end
+
+    end
+  end
+end

data/lib/vagrant-shell/errors.rb

@@ -0,0 +1,27 @@
+require "vagrant"
+
+module VagrantPlugins
+  module Shell
+    module Errors
+      class VagrantShellError < Vagrant::Errors::VagrantError
+        error_namespace("vagrant_shell.errors")
+      end
+
+      class ShellError < VagrantShellError
+        error_key(:shell_error)
+      end
+
+      class TimeoutError < VagrantShellError
+        error_key(:instance_ready_timeout)
+      end
+
+      class ComputeError < VagrantShellError
+        error_key(:instance_ready_timeout)
+      end
+
+      class InstanceReadyTimeout < VagrantShellError
+        error_key(:instance_ready_timeout)
+      end
+    end
+  end
+end

data/lib/vagrant-shell/plugin.rb

@@ -0,0 +1,77 @@
+begin
+  require "vagrant"
+rescue LoadError
+  raise "The Vagrant Shell plugin must be run within Vagrant."
+end
+
+# This is a sanity check to make sure no one is attempting to install
+# this into an early Vagrant version.
+if Vagrant::VERSION < "1.2.0"
+  raise "The Vagrant Shell plugin is only compatible with Vagrant 1.2+"
+end
+
+module VagrantPlugins
+  module Shell
+    class Plugin < Vagrant.plugin("2")
+      name "Shell"
+      description <<-DESC
+      This plugin installs a provider that allows Vagrant to manage
+      machines with shell scripts.
+      DESC
+
+      def self.make_provider nm_provider
+        config(nm_provider, :provider) do
+          require_relative "config"
+          Config
+        end
+
+        provider(nm_provider) do
+          # Setup logging and i18n
+          setup_logging
+          setup_i18n
+
+          # Return the provider
+          require_relative "provider"
+          Provider
+        end
+      end
+
+      make_provider(:shell)
+
+      # This initializes the internationalization strings.
+      def self.setup_i18n
+        I18n.load_path << File.expand_path("locales/en.yml", Shell.source_root)
+        I18n.reload!
+      end
+
+      # This sets up our log level to be whatever VAGRANT_LOG is.
+      def self.setup_logging
+        require "log4r"
+
+        level = nil
+        begin
+          level = Log4r.const_get(ENV["VAGRANT_LOG"].upcase)
+        rescue NameError
+          # This means that the logging constant wasn't found,
+          # which is fine. We just keep `level` as `nil`. But
+          # we tell the user.
+          level = nil
+        end
+
+        # Some constants, such as "true" resolve to booleans, so the
+        # above error checking doesn't catch it. This will check to make
+        # sure that the log level is an integer, as Log4r requires.
+        level = nil if !level.is_a?(Integer)
+
+        # Set the logging level on all "vagrant" namespaced
+        # logs as long as we have a valid level.
+        if level
+          logger = Log4r::Logger.new("vagrant_shell")
+          logger.outputters = Log4r::Outputter.stderr
+          logger.level = level
+          logger = nil
+        end
+      end
+    end
+  end
+end

data/lib/vagrant-shell/provider.rb

@@ -0,0 +1,50 @@
+require "log4r"
+require "vagrant"
+
+module VagrantPlugins
+  module Shell
+    class Provider < Vagrant.plugin("2", :provider)
+      def initialize(machine)
+        @machine = machine
+      end
+
+      def action(name)
+        # Attempt to get the action method from the Action class if it
+        # exists, otherwise return nil to show that we don't support the
+        # given action.
+        action_method = "action_#{name}"
+        return Action.send(action_method) if Action.respond_to?(action_method)
+        nil
+      end
+
+      def ssh_info
+        # Run a custom action called "read_ssh_info" which does what it
+        # says and puts the resulting SSH info into the `:machine_ssh_info`
+        # key in the environment.
+        env = @machine.action("read_ssh_info")
+        env[:machine_ssh_info]
+      end
+
+      def state
+        # Run a custom action we define called "read_state" which does
+        # what it says. It puts the state in the `:machine_state_id`
+        # key in the environment.
+        env = @machine.action("read_state")
+
+        state_id = env[:machine_state_id]
+
+        # Get the short and long description
+        short = I18n.t("vagrant_shell.states.short_#{state_id}")
+        long  = I18n.t("vagrant_shell.states.long_#{state_id}")
+
+        # Return the MachineState object
+        Vagrant::MachineState.new(state_id, short, long)
+      end
+
+      def to_s
+        id = @machine.id.nil? ? "new" : @machine.id
+        "Shell (#{id})"
+      end
+    end
+  end
+end

data/lib/vagrant-shell/ssh-agent.rb

@@ -0,0 +1,23 @@
+# fool vagrant into using ssh-agent keys instead of a fixed key on file
+module Vagrant
+  module Util
+    class Platform
+      def self.solaris?
+        true
+      end
+    end
+  end
+end
+
+require "net/ssh"
+
+module Net::SSH
+  class << self
+    alias_method :old_start, :start
+    
+    def start(host, username, opts)
+      opts[:keys_only] = false
+      self.old_start(host, username, opts)
+    end
+  end
+end 

data/lib/vagrant-shell/util/timer.rb

@@ -0,0 +1,17 @@
+module VagrantPlugins
+  module Shell
+    module Util
+      class Timer
+        # A basic utility method that times the execution of the given
+        # block and returns it.
+        def self.time
+          start_time = Time.now.to_f
+          yield
+          end_time = Time.now.to_f
+
+          end_time - start_time
+        end
+      end
+    end
+  end
+end

data/lib/vagrant-shell/version.rb

@@ -0,0 +1,5 @@
+module VagrantPlugins
+  module Shell
+    VERSION = File.read(File.expand_path("../../../VERSION", __FILE__)).strip
+  end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: vagrant-shell
 version: !ruby/object:Gem::Version
-  version: 0.2.11
+  version: 0.2.12
   prerelease: 
 platform: ruby
 authors:
@@ -20,6 +20,22 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
+- lib/vagrant-shell/action/is_created.rb
+- lib/vagrant-shell/action/message_already_created.rb
+- lib/vagrant-shell/action/message_not_created.rb
+- lib/vagrant-shell/action/read_ssh_info.rb
+- lib/vagrant-shell/action/read_state.rb
+- lib/vagrant-shell/action/run_instance.rb
+- lib/vagrant-shell/action/terminate_instance.rb
+- lib/vagrant-shell/action/timed_provision.rb
+- lib/vagrant-shell/action.rb
+- lib/vagrant-shell/config.rb
+- lib/vagrant-shell/errors.rb
+- lib/vagrant-shell/plugin.rb
+- lib/vagrant-shell/provider.rb
+- lib/vagrant-shell/ssh-agent.rb
+- lib/vagrant-shell/util/timer.rb
+- lib/vagrant-shell/version.rb
 - lib/vagrant-shell.rb
 - locales/en.yml
 - CHANGELOG.md