vagrant-triggers 0.1.0 → 0.2.0

data/CHANGELOG.md

@@ -0,0 +1,14 @@
+## 0.2.0 (October 19, 2013)
+
+NEW FEATURES:
+
+  - New option: ```:append_to_path```.
+
+IMPROVEMENTS:
+
+  - Triggers won't run if ```VAGRANT_NO_TRIGGERS``` environment variable is set.
+  - Command argument could also be an array.
+
+## 0.1.0 (August 19, 2013)
+
+  - Initial release.

data/README.md

@@ -18,19 +18,26 @@ Installation is performed in the prescribed manner for Vagrant 1.1+ plugins.
 The following ```Vagrantfile``` configuration options are added:
 
 ```
-config.trigger.before :command, :execute => "script"
+trigger.before :command, { :option => "value", ... }
 ```
 
 ```
-config.trigger.after :command, :execute => "script"
+trigger.after :command, { :option => "value", ... }
 ```
 
+The first argument is the command in which the trigger will be tied. It could be an array (e.g. ```[:up, :resume]```) in case of multiple commands.
+
 ### Options
 
 * ```:execute => "script"```: the script to execute
+* ```:append_to_path => ["dir", "dir"]```: additional places where looking for the script. See [this wiki page](https://github.com/emyl/vagrant-triggers/wiki/The-:append_to_path-option) for details.
 * ```:force => true```: continue even if the script fails (exits with non-zero code)
 * ```:stdout => true```: display script output
 
+### Skipping execution
+
+Triggers won't run if ```VAGRANT_NO_TRIGGERS``` environment variable is set.
+
 ## Example
 
 In the following example a VirtualBox VM (not managed by Vagrant) will be tied to the machine defined in ```Vagrantfile```, to make so that it follows its lifecycle:
@@ -40,10 +47,9 @@ In the following example a VirtualBox VM (not managed by Vagrant) will be tied t
 Vagrant.configure("2") do |config|
 
   {
-    :halt => "controlvm 22aed8b3-d246-40d5-8ad4-176c17552c43 acpipowerbutton",
-    :resume => "startvm 22aed8b3-d246-40d5-8ad4-176c17552c43 --type headless",
-    :suspend => "controlvm 22aed8b3-d246-40d5-8ad4-176c17552c43 savestate",
-    :up => "startvm 22aed8b3-d246-40d5-8ad4-176c17552c43 --type headless"
+    [:up, :resume] => "startvm 22aed8b3-d246-40d5-8ad4-176c17552c43 --type headless",
+    :suspend       => "controlvm 22aed8b3-d246-40d5-8ad4-176c17552c43 savestate",
+    :halt          => "controlvm 22aed8b3-d246-40d5-8ad4-176c17552c43 acpipowerbutton",
   }.each do |command, trigger|
     config.trigger.before command, :execute => "vboxmanage #{trigger}", :stdout => true
   end

data/lib/vagrant-triggers/action/trigger.rb

@@ -20,6 +20,37 @@ module VagrantPlugins
           @app.call(env)
         end
 
+        def execute(raw_command)
+          @env[:ui].info 'Executing command "' + raw_command + '"...'
+          command     = Shellwords.shellsplit(raw_command)
+          env_backup  = ENV.to_hash
+          begin
+            result = Vagrant::Util::Subprocess.execute(command[0], *command[1..-1])
+          rescue Vagrant::Errors::CommandUnavailable, Vagrant::Errors::CommandUnavailableWindows
+            @logger.debug("Command not found in the path.")
+            @logger.debug("Current PATH: #{ENV["PATH"]}")
+            new_path = Array(@options[:append_to_path]).join(File::PATH_SEPARATOR)
+            @logger.debug("Temporary replacing the system PATH with #{new_path}.")
+            unless new_path.empty?
+              new_env = env_backup.dup
+              new_env.delete("PATH")
+              new_env["PATH"] = new_path
+              ENV.replace(new_env)
+              @options[:append_to_path] = nil
+              retry
+            end
+            raise Errors::CommandUnavailable, :command => command[0]
+          ensure
+            ENV.replace(env_backup)
+          end
+          if result.exit_code != 0 && !@options[:force]
+            raise Errors::CommandFailed, :command => raw_command, :stderr => result.stderr
+          end
+          if @options[:stdout]
+            @env[:ui].info "Command output:\n\n#{result.stdout}\n"
+          end
+        end
+
         def fire_triggers
           # Triggers don't fire on environment load and unload.
           return if [:environment_load, :environment_unload].include?(@env[:action_name])
@@ -31,18 +62,9 @@ module VagrantPlugins
           unless triggers_to_fire.empty?
             @env[:ui].info "Running triggers #{@condition} action..."
             triggers_to_fire.each do |trigger|
-              options = trigger[:options]
-              if options[:execute]
-                raw_command = options[:execute]
-                @env[:ui].info 'Executing command "' + raw_command + '"...'
-                command     = Shellwords.shellsplit(raw_command)
-                result      = Vagrant::Util::Subprocess.execute(command[0], *command[1..-1])
-                if result.exit_code != 0 && !options[:force]
-                  raise Errors::CommandFailed, :command => raw_command, :stderr => result.stderr
-                end
-                if options[:stdout]
-                  @env[:ui].info "Command output:\n\n#{result.stdout}\n"
-                end
+              @options = trigger[:options]
+              if @options[:execute]
+                execute(@options[:execute])
               else
                 @logger.debug("Trigger command not found.")
               end

data/lib/vagrant-triggers/config.rb

@@ -7,12 +7,12 @@ module VagrantPlugins
         @triggers = []
       end
 
-      def after(action, options = {})
-        @triggers << { :action => action, :condition => :after, :options => options }
+      def after(actions, options = {})
+        add_trigger(actions, :after, options)
       end
 
-      def before(action, options = {})
-        @triggers << { :action => action, :condition => :before, :options => options }
+      def before(actions, options = {})
+        add_trigger(actions, :before, options)
       end      
 
       def validate(machine)
@@ -24,6 +24,14 @@ module VagrantPlugins
 
         { "triggers" => errors }
       end
+
+      private
+
+      def add_trigger(actions, condition, options)
+        Array(actions).each do |action|
+          @triggers << { :action => action, :condition => :before, :options => options }
+        end
+      end
     end
   end
 end

data/lib/vagrant-triggers/errors.rb

@@ -8,6 +8,10 @@ module VagrantPlugins
       class CommandFailed < VagrantTriggerError
         error_key(:command_failed)
       end
+
+      class CommandUnavailable < VagrantTriggerError
+        error_key(:command_unavailable)
+      end
     end
   end
 end

data/lib/vagrant-triggers/plugin.rb

@@ -23,8 +23,10 @@ module VagrantPlugins
 
       action_hook(:trigger, Plugin::ALL_ACTIONS) do |hook|
         require_relative "action"
-        hook.prepend(Action.action_trigger(:before))
-        hook.append(Action.action_trigger(:after))
+        unless ENV["VAGRANT_NO_TRIGGERS"]
+          hook.prepend(Action.action_trigger(:before))
+          hook.append(Action.action_trigger(:after))
+        end
       end
       
       config(:trigger) do

data/lib/vagrant-triggers/version.rb

@@ -1,5 +1,5 @@
 module VagrantPlugins
   module Triggers
-    VERSION = "0.1.0"
+    VERSION = "0.2.0"
   end
 end

data/locales/en.yml

@@ -5,4 +5,8 @@ en:
         The command "%{command}" returned a failed exit code. The
         error output is shown below:
 
-        %{stderr}
+        %{stderr}
+      command_unavailable: |-
+        The executable "%{command}" Vagrant is trying to trigger
+        was not found. If you know it is not in the PATH, please
+        specify its absolute path using the :append_to_path option.

data/spec/vagrant-triggers/action/trigger_spec.rb

@@ -1,4 +1,5 @@
 require "spec_helper"
+require "vagrant/util/platform"
 require "vagrant/util/subprocess"
 
 describe VagrantPlugins::Triggers::Action::Trigger do
@@ -14,65 +15,104 @@ describe VagrantPlugins::Triggers::Action::Trigger do
 
   let(:result)         { double("result", :exit_code => 0, :stderr => stderr) }
   let(:stderr)         { double("stderr") }
-  
+
   before do
     @triggers = [ { :action => machine_action, :condition => condition, :options => { :execute => "foo" } } ]
     machine.stub_chain(:config, :trigger, :triggers).and_return(@triggers)
-    Vagrant::Util::Subprocess.stub(:execute => result)
   end
 
-  it "should skip :environment_load and :environment_unload actions" do
-    [:environment_load, :environment_unload].each do |action|
-      env.stub(:[]).with(:action_name).and_return(action)
-      env.should_not_receive(:[]).with(:machine_action)
+  context "with a regular command" do
+    before do
+      Vagrant::Util::Subprocess.stub(:execute => result)
+    end
+
+    it "should skip :environment_load and :environment_unload actions" do
+      [:environment_load, :environment_unload].each do |action|
+        env.stub(:[]).with(:action_name).and_return(action)
+        env.should_not_receive(:[]).with(:machine_action)
+        described_class.new(app, env, condition).call(env)
+      end
+    end
+
+    it "shouldn't fire if machine action is not defined" do
+      env.stub(:[]).with(:action_name)
+      env.stub(:[]).with(:machine_action).and_return(nil)
+      env.should_not_receive(:[]).with(:machine)
       described_class.new(app, env, condition).call(env)
     end
-  end
 
-  it "shouldn't fire if machine action is not defined" do
-    env.stub(:[]).with(:action_name)
-    env.stub(:[]).with(:machine_action).and_return(nil)
-    env.should_not_receive(:[]).with(:machine)
-    described_class.new(app, env, condition).call(env)
-  end
+    it "should fire trigger when all conditions are satisfied" do
+      Vagrant::Util::Subprocess.should_receive(:execute).with("foo")
+      described_class.new(app, env, condition).call(env)
+    end
 
-  it "should fire trigger when all conditions are satisfied" do
-    Vagrant::Util::Subprocess.should_receive(:execute).with("foo")
-    described_class.new(app, env, condition).call(env)
-  end
+    it "should fire all defined triggers" do
+      @triggers << { :action => machine_action, :condition => condition, :options => { :execute => "bar" } }
+      Vagrant::Util::Subprocess.should_receive(:execute).twice
+      described_class.new(app, env, condition).call(env)
+    end
 
-  it "should fire all defined triggers" do
-    @triggers << { :action => machine_action, :condition => condition, :options => { :execute => "bar" } }
-    Vagrant::Util::Subprocess.should_receive(:execute).twice
-    described_class.new(app, env, condition).call(env)
-  end
+    it "shouldn't execute trigger with no command" do
+      @triggers[0][:options] = {}
+      Vagrant::Util::Subprocess.should_not_receive(:execute)
+      described_class.new(app, env, condition).call(env)
+    end
 
-  it "shouldn't execute trigger with no command" do
-    @triggers[0][:options] = {}
-    Vagrant::Util::Subprocess.should_not_receive(:execute)
-    described_class.new(app, env, condition).call(env)
-  end
+    it "shouldn't fire trigger when condition doesn't match" do
+      @triggers[0][:condition] = "blah"
+      Vagrant::Util::Subprocess.should_not_receive(:execute)
+      described_class.new(app, env, condition).call(env)
+    end
 
-  it "shouldn't fire trigger when condition doesn't match" do
-    @triggers[0][:condition] = "blah"
-    Vagrant::Util::Subprocess.should_not_receive(:execute)
-    described_class.new(app, env, condition).call(env)
-  end
+    it "shouldn't fire trigger when action doesn't match" do
+      @triggers[0][:action] = "blah"
+      Vagrant::Util::Subprocess.should_not_receive(:execute)
+      described_class.new(app, env, condition).call(env)
+    end
 
-  it "shouldn't fire trigger when action doesn't match" do
-    @triggers[0][:action] = "blah"
-    Vagrant::Util::Subprocess.should_not_receive(:execute)
-    described_class.new(app, env, condition).call(env)
-  end
+    it "should raise an error if executed command exits with non-zero code" do
+      result.stub(:exit_code => 1)
+      expect { described_class.new(app, env, condition).call(env) }.to raise_error(VagrantPlugins::Triggers::Errors::CommandFailed)
+    end
 
-  it "should raise an error if executed command exits with non-zero code" do
-    result.stub(:exit_code => 1)
-    expect { described_class.new(app, env, condition).call(env) }.to raise_error(VagrantPlugins::Triggers::Errors::CommandFailed)
+    it "shouldn't raise an error if executed command exits with non-zero code but :force option was specified" do
+      @triggers[0][:options][:force] = true
+      result.stub(:exit_code => 1)
+      expect { described_class.new(app, env, condition).call(env) }.not_to raise_error()
+    end
   end
 
-  it "shouldn't raise an error if executed command exits with non-zero code but :force option was specified" do
-    @triggers[0][:options][:force] = true
-    result.stub(:exit_code => 1)
-    expect { described_class.new(app, env, condition).call(env) }.to_not raise_error()
+  context "with a command not in the PATH" do
+    before do
+      @tmp_dir = Vagrant::Util::Platform.windows? ? ENV["USERPROFILE"] : ENV["HOME"]
+      File.open("#{@tmp_dir}/foo", "w+", 0700) { |file| }
+      File.stub(:executable? => false)
+      File.stub(:executable?).with("#{@tmp_dir}/foo").and_return(true)
+    end
+
+    after do
+      File.delete("#{@tmp_dir}/foo")
+    end
+
+    it "should raise a CommandUnavailable error by default" do
+      expect { described_class.new(app, env, condition).call(env) }.to raise_error(VagrantPlugins::Triggers::Errors::CommandUnavailable)
+    end
+
+    it "should raise a CommandUnavailable error on Windows" do
+      Vagrant::Util::Platform.stub(:windows? => true)
+      expect { described_class.new(app, env, condition).call(env) }.to raise_error(VagrantPlugins::Triggers::Errors::CommandUnavailable)
+    end
+
+    it "should honor the :append_to_path option and restore original path after execution" do
+      @triggers[0][:options][:append_to_path] = @tmp_dir
+      original_path = ENV["PATH"]
+      described_class.new(app, env, condition).call(env)
+      expect(ENV["PATH"]).to eq(original_path)
+    end
+
+    it "should accept an array for the :append_to_path option" do
+      @triggers[0][:options][:append_to_path] = [@tmp_dir, @tmp_dir]
+      expect { described_class.new(app, env, condition).call(env) }.not_to raise_error()
+    end
   end
 end

data/spec/vagrant-triggers/config_spec.rb

@@ -20,6 +20,11 @@ describe VagrantPlugins::Triggers::Config do
       config.after :up, :exec => "echo ls"
       expect(config.triggers).to have(2).items
     end
+
+    it "should record multiple entries if the action is an array" do
+      config.before [:up, :halt], :exec => "echo ls"
+      expect(config.triggers).to have(2).items
+    end
   end
 
   describe "validation" do

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: vagrant-triggers
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.2.0
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-08-19 00:00:00.000000000 Z
+date: 2013-10-19 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -66,6 +66,7 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
+- CHANGELOG.md
 - Gemfile
 - lib/vagrant-triggers/action/trigger.rb
 - lib/vagrant-triggers/action.rb
@@ -97,7 +98,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '0'
       segments:
       - 0
-      hash: -3600971872626738108
+      hash: -1012364614977122118
 required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
   requirements:
@@ -106,7 +107,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
       segments:
       - 0
-      hash: -3600971872626738108
+      hash: -1012364614977122118
 requirements: []
 rubyforge_project: 
 rubygems_version: 1.8.23