vagrant-shell 0.2.3

data/.gitignore

@@ -0,0 +1,14 @@
+# OS-specific
+.DS_Store
+
+# Bundler/Rubygems
+*.gem
+.bundle
+pkg/*
+tags
+Gemfile.lock
+
+# Vagrant
+.vagrant
+Vagrantfile
+!example_box/Vagrantfile

data/CHANGELOG.md

@@ -0,0 +1,39 @@
+# 0.2.2 (April 18, 2013)
+
+* Fix crashing bug with incorrect provisioner arguments.
+
+# 0.2.1 (April 16, 2013)
+
+* Got rid of extranneous references to old SSH settings.
+
+# 0.2.0 (April 16, 2013)
+
+* Add support for `vagrant ssh -c` [GH-42]
+* Ability to specify a timeout for waiting for instances to become ready. [GH-44]
+* Better error message if instance didn't become ready in time.
+* Connection can now be done using IAM profiles. [GH-41]
+
+# 0.1.3 (April 9, 2013)
+
+* The `AWS_ACCESS_KEY` and `AWS_SECRET_KEY` will be used if available
+  and no specific keys are set in the Vagrantfile. [GH-33]
+* Fix issues with SSH on VPCs, the correct IP is used. [GH-30]
+* Exclude the ".vagrant" directory from rsync.
+* Implement `:disabled` flag support for shared folders. [GH-29]
+* `aws.user_data` to specify user data on the instance. [GH-26]
+
+# 0.1.2 (March 22, 2013)
+
+* Choose the proper region when connecting to AWS. [GH-9]
+* Configurable SSH port. [GH-13]
+* Support other AWS-compatible API endpoints with `config.endpoint`
+  and `config.version`. [GH-6]
+* Disable strict host key checking on rsync so known hosts aren't an issue. [GH-7]
+
+# 0.1.1 (March 18, 2013)
+
+* Up fog dependency for Vagrant 1.1.1
+
+# 0.1.0 (March 14, 2013)
+
+* Initial release.

data/Gemfile

@@ -0,0 +1,3 @@
+source "https://rubygems.org"
+
+gemspec

data/LICENSE

@@ -0,0 +1,8 @@
+The MIT License (MIT)
+Copyright (c) 2013 Mitchell Hashimoto
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,12 @@
+# Vagrant Shell Provider
+
+This is a [Vagrant](http://www.vagrantup.com) 1.2+ plugin that adds a
+shell provider to Vagrant, allowing Vagrant to control and provision
+machines using shell scripts.  It's meant to be customized with scripts
+for Xen, Docker, etc.
+
+**NOTE:** This plugin requires Vagrant 1.2+,
+
+## Usage
+
+TODO - this gem is a work in progress

data/Rakefile

@@ -0,0 +1,21 @@
+require 'rubygems'
+require 'bundler/setup'
+require 'rspec/core/rake_task'
+
+# Immediately sync all stdout so that tools like buildbot can
+# immediately load in the output.
+$stdout.sync = true
+$stderr.sync = true
+
+# Change to the directory of this file.
+Dir.chdir(File.expand_path("../", __FILE__))
+
+# This installs the tasks that help with gem creation and
+# publishing.
+Bundler::GemHelper.install_tasks
+
+# Install the `spec` task so that we can run tests.
+RSpec::Core::RakeTask.new
+
+# Default task is to run the unit tests
+task :default => "spec"

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,33 @@
+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
+          host,port = `#{machine.provider_config.script} ssh-info #{machine.id}`.split(/\s+/)[0,2]
+          return {
+            :host => host,
+            :port => port
+          }
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,29 @@
+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
+          `#{machine.provider_config.script} read-state #{machine.id}`
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,109 @@
+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
+          ami                = provider_config.ami
+          user_data          = provider_config.user_data
+
+          # Launch!
+          env[:ui].info(I18n.t("vagrant_shell.launching_instance"))
+          env[:ui].info(" -- AMI: #{ami}")
+
+          begin
+            # Immediately save the ID since it is created at this point.
+            env[:machine].id = `#{env[:machine].provider_config.script} run-instance #{ami}`.split(/\s+/)[0]
+          rescue Errors::ComputeError => e
+            raise Errors::ShellError, :message => e.message
+          end
+
+
+          # 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/sync_folders.rb

@@ -0,0 +1,67 @@
+require "log4r"
+
+require "vagrant/util/subprocess"
+
+require "vagrant/util/scoped_hash_override"
+
+module VagrantPlugins
+  module Shell
+    module Action
+      # This middleware uses `rsync` to sync the folders over to the
+      # Shell instance.
+      class SyncFolders
+        include Vagrant::Util::ScopedHashOverride
+
+        def initialize(app, env)
+          @app    = app
+          @logger = Log4r::Logger.new("vagrant_shell::action::sync_folders")
+        end
+
+        def call(env)
+          @app.call(env)
+
+          ssh_info = env[:machine].ssh_info
+
+          env[:machine].config.vm.synced_folders.each do |id, data|
+            data = scoped_hash_override(data, :shell)
+
+            # Ignore disabled shared folders
+            next if data[:disabled]
+
+            hostpath  = File.expand_path(data[:hostpath], env[:root_path])
+            guestpath = data[:guestpath]
+
+            # Make sure there is a trailing slash on the host path to
+            # avoid creating an additional directory with rsync
+            hostpath = "#{hostpath}/" if hostpath !~ /\/$/
+
+            env[:ui].info(I18n.t("vagrant_shell.rsync_folder",
+                                :hostpath => hostpath,
+                                :guestpath => guestpath))
+
+            # Create the guest path
+            env[:machine].communicate.sudo("mkdir -p '#{guestpath}'")
+            env[:machine].communicate.sudo(
+              "chown #{ssh_info[:username]} '#{guestpath}'")
+
+            # Rsync over to the guest path using the SSH info
+            command = [
+              "rsync", "--verbose", "--archive", "-z",
+              "--exclude", ".vagrant/",
+              "-e", "ssh -p #{ssh_info[:port]} -o StrictHostKeyChecking=no -i '#{ssh_info[:private_key_path]}'",
+              hostpath,
+              "#{ssh_info[:username]}@#{ssh_info[:host]}:#{guestpath}"]
+
+            r = Vagrant::Util::Subprocess.execute(*command)
+            if r.exit_code != 0
+              raise Errors::RsyncError,
+                :guestpath => guestpath,
+                :hostpath => hostpath,
+                :stderr => r.stderr
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,24 @@
+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"))
+          `#{env[:machine].provider_config.script} terminate-instance #{env[:machine].id}`
+          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/action/warn_networks.rb

@@ -0,0 +1,19 @@
+module VagrantPlugins
+  module Shell
+    module Action
+      class WarnNetworks
+        def initialize(app, env)
+          @app = app
+        end
+
+        def call(env)
+          if env[:machine].config.vm.networks.length > 0
+            env[:ui].warn(I18n.t("vagrant_shell.warn_networks"))
+          end
+
+          @app.call(env)
+        end
+      end
+    end
+  end
+end

data/lib/vagrant-shell/action.rb

@@ -0,0 +1,116 @@
+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
+            b2.use SyncFolders
+          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 SyncFolders
+            b2.use WarnNetworks
+            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 :SyncFolders, action_root.join("sync_folders")
+      autoload :TimedProvision, action_root.join("timed_provision")
+      autoload :WarnNetworks, action_root.join("warn_networks")
+      autoload :TerminateInstance, action_root.join("terminate_instance")
+    end
+  end
+end

data/lib/vagrant-shell/config.rb

@@ -0,0 +1,68 @@
+require "vagrant"
+
+module VagrantPlugins
+  module Shell
+    class Config < Vagrant.plugin("2", :config)
+      # The ID of the AMI to use.
+      #
+      # @return [String]
+      attr_accessor :ami
+
+      # 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
+
+      def initialize
+        @ami                    = UNSET_VALUE
+        @instance_ready_timeout = UNSET_VALUE
+        @user_data              = UNSET_VALUE
+        @script                 = 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!
+        # AMI must be nil, since we can't default that
+        @ami = nil if @ami == 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
+
+        # Mark that we finalized
+        @__finalized = true
+      end
+
+      def validate(machine)
+        { "Shell Provider" => [ ] } 
+      end
+    end
+  end
+end

data/lib/vagrant-shell/errors.rb

@@ -0,0 +1,31 @@
+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
+
+      class RsyncError < VagrantShellError
+        error_key(:rsync_error)
+      end
+    end
+  end
+end

data/lib/vagrant-shell/plugin.rb

@@ -0,0 +1,73 @@
+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
+
+      config(:shell, :provider) do
+        require_relative "config"
+        Config
+      end
+
+      provider(:shell) do
+        # Setup logging and i18n
+        setup_logging
+        setup_i18n
+
+        # Return the provider
+        require_relative "provider"
+        Provider
+      end
+
+      # 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/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 = "0.2.3"
+  end
+end

data/lib/vagrant-shell.rb

@@ -0,0 +1,18 @@
+require "pathname"
+
+require "vagrant-shell/plugin"
+
+module VagrantPlugins
+  module Shell
+    lib_path = Pathname.new(File.expand_path("../vagrant-shell", __FILE__))
+    autoload :Action, lib_path.join("action")
+    autoload :Errors, lib_path.join("errors")
+
+    # This returns the path to the source of this plugin.
+    #
+    # @return [Pathname]
+    def self.source_root
+      @source_root ||= Pathname.new(File.expand_path("../../", __FILE__))
+    end
+  end
+end

data/locales/en.yml

@@ -0,0 +1,59 @@
+en:
+  vagrant_shell:
+    already_created: |-
+      The machine is already created.
+    launching_instance: |-
+      Launching an instance with the following settings...
+    not_created: |-
+      Instance is not created. Please run `vagrant up` first.
+    ready: |-
+      Machine is booted and ready for use!
+    rsync_folder: |-
+      Rsyncing folder: %{hostpath} => %{guestpath}
+    terminating: |-
+      Terminating the instance...
+    waiting_for_ready: |-
+      Waiting for instance to become "ready"...
+    waiting_for_ssh: |-
+      Waiting for SSH to become available...
+    warn_networks: |-
+      Warning! The Shell provider doesn't support any of the Vagrant
+      high-level network configurations (`config.vm.network`). They
+      will be silently ignored.
+
+    config:
+      ami_required: |-
+        An AMI must be configured via "ami"
+      private_key_missing: |-
+        The specified private key for Shell could not be found
+
+    errors:
+      shell_error: |-
+        There was an error talking to Shell. The error message is shown
+        below:
+
+        %{message}
+      instance_ready_timeout: |-
+        The instance never became "ready" in Shell. The timeout currently
+        set waiting for the instance to become ready is %{timeout} seconds.
+        Please verify that the machine properly boots. If you need more time
+        set the `instance_ready_timeout` configuration on the Shell provider.
+      rsync_error: |-
+        There was an error when attemping to rsync a share folder.
+        Please inspect the error message below for more info.
+
+        Host path: %{hostpath}
+        Guest path: %{guestpath}
+        Error: %{stderr}
+
+    states:
+      short_not_created: |-
+        not created
+      long_not_created: |-
+        The Shell instance is not created. Run `vagrant up` to create it.
+
+      short_running: |-
+        running
+      long_running: |-
+        The Shell instance is running. To stop this machine, you can run
+        `vagrant halt`. To destroy the machine, you can run `vagrant destroy`.

data/vagrant-shell.gemspec

@@ -0,0 +1,51 @@
+$:.unshift File.expand_path("../lib", __FILE__)
+require "vagrant-shell/version"
+
+Gem::Specification.new do |s|
+  s.name          = "vagrant-shell"
+  s.version       = VagrantPlugins::Shell::VERSION
+  s.platform      = Gem::Platform::RUBY
+  s.authors       = [ "Tom Bombadil", "Mitchell Hashimoto" ]
+  s.email         = [ "amanibhavam@destructuring.org", "mitchell@hashicorp.com" ]
+  s.homepage      = "http://destructuring.org/vagrant-shell"
+  s.summary       = "Enables Vagrant to manage machines using shell scripts"
+  s.description   = "Enables Vagrant to manage machines using shell scripts"
+
+  s.required_rubygems_version = ">= 1.3.6"
+  s.rubyforge_project         = "vagrant-shell"
+
+  # The following block of code determines the files that should be included
+  # in the gem. It does this by reading all the files in the directory where
+  # this gemspec is, and parsing out the ignored files from the gitignore.
+  # Note that the entire gitignore(5) syntax is not supported, specifically
+  # the "!" syntax, but it should mostly work correctly.
+  root_path      = File.dirname(__FILE__)
+  all_files      = Dir.chdir(root_path) { Dir.glob("**/{*,.*}") }
+  all_files.reject! { |file| [".", ".."].include?(File.basename(file)) }
+  gitignore_path = File.join(root_path, ".gitignore")
+  gitignore      = File.readlines(gitignore_path)
+  gitignore.map!    { |line| line.chomp.strip }
+  gitignore.reject! { |line| line.empty? || line =~ /^(#|!)/ }
+
+  unignored_files = all_files.reject do |file|
+    # Ignore any directories, the gemspec only cares about files
+    next true if File.directory?(file)
+
+    # Ignore any paths that match anything in the gitignore. We do
+    # two tests here:
+    #
+    #   - First, test to see if the entire path matches the gitignore.
+    #   - Second, match if the basename does, this makes it so that things
+    #     like '.DS_Store' will match sub-directories too (same behavior
+    #     as git).
+    #
+    gitignore.any? do |ignore|
+      File.fnmatch(ignore, file, File::FNM_PATHNAME) ||
+        File.fnmatch(ignore, File.basename(file), File::FNM_PATHNAME)
+    end
+  end
+
+  s.files         = unignored_files
+  s.executables   = unignored_files.map { |f| f[/^bin\/(.*)/, 1] }.compact
+  s.require_path  = 'lib'
+end

metadata

@@ -0,0 +1,73 @@
+--- !ruby/object:Gem::Specification
+name: vagrant-shell
+version: !ruby/object:Gem::Version
+  version: 0.2.3
+  prerelease: 
+platform: ruby
+authors:
+- Tom Bombadil
+- Mitchell Hashimoto
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-05-01 00:00:00.000000000 Z
+dependencies: []
+description: Enables Vagrant to manage machines using shell scripts
+email:
+- amanibhavam@destructuring.org
+- mitchell@hashicorp.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- CHANGELOG.md
+- Gemfile
+- 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/sync_folders.rb
+- lib/vagrant-shell/action/terminate_instance.rb
+- lib/vagrant-shell/action/timed_provision.rb
+- lib/vagrant-shell/action/warn_networks.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/util/timer.rb
+- lib/vagrant-shell/version.rb
+- lib/vagrant-shell.rb
+- LICENSE
+- locales/en.yml
+- Rakefile
+- README.md
+- vagrant-shell.gemspec
+- .gitignore
+homepage: http://destructuring.org/vagrant-shell
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: 1.3.6
+requirements: []
+rubyforge_project: vagrant-shell
+rubygems_version: 1.8.25
+signing_key: 
+specification_version: 3
+summary: Enables Vagrant to manage machines using shell scripts
+test_files: []