vagrant-skytap 0.1.6 → 0.1.7

data/eng-10269-tmp.diff

@@ -0,0 +1,361 @@
+# HG changeset patch
+# Parent 3713c076cd219f51dd1ec0e9bc6409b8bedae26f
+# Parent  3c74e38a2da6d728e18975b99f87943a20209c10
+[mq]: tmp
+* * *
+[mq]: 2015-11-19_20-26-00_r88+.diff
+
+diff -r 3713c076cd21 lib/vagrant-skytap/action.rb
+--- a/lib/vagrant-skytap/action.rb	Thu Nov 19 21:24:32 2015 -0800
++++ b/lib/vagrant-skytap/action.rb	Thu Nov 19 21:25:06 2015 -0800
+@@ -168,6 +168,11 @@
+         end
+       end
+ 
++      # Some middlewares perform further actions after the succeeding
++      # middleware returns. Provision and SyncedFolders, specifically,
++      # both require the machine to be booted. This requirement can be
++      # satisfied by putting the WaitForCommunicator middleware further
++      # down in the sequence.
+       def self.action_prepare_boot
+         Vagrant::Action::Builder.new.tap do |b|
+           b.use PrepareNFSSettings
+@@ -188,27 +193,11 @@
+       def self.action_up
+         Vagrant::Action::Builder.new.tap do |b|
+           b.use action_create
+-
+-          b.use Call, IsStopped do |env, b1|
+-            if env[:result]
+-              # this has some kind of hook that executes
+-              # when #action returns
+-              b1.use action_prepare_boot
+-            end
+-          end
+-
+-          b.use Call, IsRunning do |env, b1|
+-            if env[:result]
+-              b1.use MessageAlreadyRunning
+-              next
+-            end
+-            b1.use RunVm
+-            b1.use WaitForCommunicator
+-          end
++          b.use action_run_vm
+         end
+       end
+ 
+-      # Pulled out of action_up to allow
++      # This action is called by our modified "up" command.
+       def self.action_create
+         Vagrant::Action::Builder.new.tap do |b|
+           b.use HandleBox
+@@ -237,11 +226,49 @@
+         end
+       end
+ 
+-      def self.action_run_environment
++#      # This action is called by our modified "up" command.
++#      def self.action_update_properties
++#        Vagrant::Action::Builder.new.tap do |b|
++#          b.use InitializeAPIClient
++#          b.use FetchEnvironment
++#          b.use Call, IsStopped do |env, b1|
++#            if env[:result]
++#              b1.use UpdateHardware
++#              b1.use SetHostname
++#            end
++#          end
++#        end
++#      end
++
++      # This action is called by our modified "up" command after
++      # all the VMs have been created. The action is called once
++      # for each machine, but by default, the RunEnvironment
++      # middleware will run all the machines in parallel; after
++      # the first invocation, RunEnvironment is a no-op.
++      def self.action_run_vm
+         Vagrant::Action::Builder.new.tap do |b|
+           b.use InitializeAPIClient
+           b.use FetchEnvironment
+-          b.use RunEnvironment
++          b.use Call, InitialState do |env, b1|
++            case env[:result]
++            when :running
++              b1.use MessageAlreadyRunning
++              next
++            when :suspended
++              b1.use Message, "The machine will be resumed"
++            when :stopped
++              b1.use action_prepare_boot
++            end
++
++            b1.use Call, IsParallelized do |env2, b2|
++              if env2[:result]
++                b2.use RunEnvironment
++              else
++                b2.use RunVm
++              end
++            end
++          end
++          b.use WaitForCommunicator
+         end
+       end
+ 
+@@ -272,6 +299,8 @@
+       autoload :ExistenceCheck, action_root.join("existence_check")
+       autoload :FetchEnvironment, action_root.join("fetch_environment")
+       autoload :InitializeAPIClient, action_root.join("initialize_api_client")
++      autoload :InitialState, action_root.join("initial_state")
++      autoload :IsParallelized, action_root.join("is_parallelized")
+       autoload :IsRunning, action_root.join("is_running")
+       autoload :IsStopped, action_root.join("is_stopped")
+       autoload :IsSuspended, action_root.join("is_suspended")
+@@ -284,6 +313,7 @@
+       autoload :PrepareNFSValidIds, action_root.join("prepare_nfs_valid_ids")
+       autoload :ReadSSHInfo, action_root.join("read_ssh_info")
+       autoload :ReadState, action_root.join("read_state")
++      autoload :RequiresBoot, action_root.join("requires_boot")
+       autoload :RunEnvironment, action_root.join("run_environment")
+       autoload :RunVm, action_root.join("run_vm")
+       autoload :SetHostname, action_root.join("set_hostname")
+diff -r 3713c076cd21 lib/vagrant-skytap/action/initial_state.rb
+--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
++++ b/lib/vagrant-skytap/action/initial_state.rb	Thu Nov 19 21:25:06 2015 -0800
+@@ -0,0 +1,20 @@
++module VagrantPlugins
++  module Skytap
++    module Action
++      # This is specifically for the "up" action. When we run in parallel, we have
++      # to know which machines were initially powered off so we can set up operations
++      # which will happen after the machine is ready
++      class InitialState
++        def initialize(app, env)
++          @app = app
++          @logger = Log4r::Logger.new("vagrant_skytap::action::initial_state")
++        end
++
++        def call(env)
++          env[:result] = env[:initial_states][env[:machine].id]
++          @app.call(env)
++        end
++      end
++    end
++  end
++end
+diff -r 3713c076cd21 lib/vagrant-skytap/action/is_parallelized.rb
+--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
++++ b/lib/vagrant-skytap/action/is_parallelized.rb	Thu Nov 19 21:25:06 2015 -0800
+@@ -0,0 +1,21 @@
++module VagrantPlugins
++  module Skytap
++    module Action
++      # This can be used with "Call" built-in to check if the action
++      # is being performed as part of a parallel operation.
++      class IsParallelized
++        def initialize(app, env)
++          @app = app
++          @logger = Log4r::Logger.new("vagrant_skytap::action::is_parallelized")
++        end
++
++        def call(env)
++          env[:result] = env[:parallel]
++          @logger.info("Parallelization is #{env[:result] ? 'on' : 'off'}")
++
++          @app.call(env)
++        end
++      end
++    end
++  end
++end
+diff -r 3713c076cd21 lib/vagrant-skytap/action/requires_boot.rb
+--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
++++ b/lib/vagrant-skytap/action/requires_boot.rb	Thu Nov 19 21:25:06 2015 -0800
+@@ -0,0 +1,20 @@
++module VagrantPlugins
++  module Skytap
++    module Action
++      # This can be used with "Call" built-in to check if the machine
++      # was stopped at the beginning of the command and needs the prepare_boot
++      # action. If this information is not captured,
++      class RequiresBoot
++        def initialize(app, env)
++          @app = app
++          @logger = Log4r::Logger.new("vagrant_skytap::action::requires_boot")
++        end
++
++        def call(env)
++          env[:result] = env[:require_boot].collect(&:id).include?(env[:machine].id)
++          @app.call(env)
++        end
++      end
++    end
++  end
++end
+diff -r 3713c076cd21 lib/vagrant-skytap/action/run_environment.rb
+--- a/lib/vagrant-skytap/action/run_environment.rb	Thu Nov 19 21:24:32 2015 -0800
++++ b/lib/vagrant-skytap/action/run_environment.rb	Thu Nov 19 21:25:06 2015 -0800
+@@ -3,7 +3,8 @@
+ module VagrantPlugins
+   module Skytap
+     module Action
+-      # Runs the Skytap environment.
++      # Runs multiple VMs in parallel. The :first_machine flag is used to prevent
++      # redundant REST calls on subsequent invocations.
+       class RunEnvironment
+         include Vagrant::Util::Retryable
+ 
+@@ -16,10 +17,14 @@
+         end
+ 
+         def call(env)
+-          env[:ui].info(I18n.t("vagrant_skytap.running_environment"))
+-          vm_ids = env[:machines].try(:collect, &:id)
+-          @logger.info("Running VMs: #{vm_ids}")
+-          env[:environment].run!(vm_ids)
++          # Since the middleware sequence is called for each machine, use a
++          # flag to ensure that we only make the request once.
++          if env[:first_machine]
++            env[:ui].info(I18n.t("vagrant_skytap.running_environment"))
++            vm_ids = env[:machines].try(:collect, &:id)
++            @logger.info("Running VMs: #{vm_ids}")
++            env[:environment].run!(vm_ids)
++          end
+ 
+           @app.call(env)
+         end
+diff -r 3713c076cd21 lib/vagrant-skytap/command/up.rb
+--- a/lib/vagrant-skytap/command/up.rb	Thu Nov 19 21:24:32 2015 -0800
++++ b/lib/vagrant-skytap/command/up.rb	Thu Nov 19 21:25:06 2015 -0800
+@@ -1,24 +1,23 @@
+ require 'optparse'
+ 
+ require "vagrant"
+-require 'byebug'
++require "byebug"
+ 
+ require_relative 'start_mixins'
+ 
+-# This is a copy of Vagrant's built-in "up" command which handles
+-# parallel runstate changes by invoking the run_environment action
+-# once for all machines: runstate operations lock the environment,
+-# and are therefore not thread-safe.
++# This is a modified copy of the built-in "up" command, which alters how
++# parallelization is implemented. Instead of making concurrent requests to run
++# individual VMs, we make a single REST call to update the runstates of
++# multiple VMs within the containing Skytap environment.
+ 
+ module VagrantPlugins
+   module Skytap
+     module Command
+-      #class Up < VagrantPlugins::CommandUp::Command
+       class Up < Vagrant.plugin("2", :command)
+         include StartMixins
+ 
+         def self.synopsis
+-          "starts and provisions the vagrant environment (with parallel runstate support)"
++          "starts and provisions the vagrant environment"
+         end
+ 
+         def execute
+@@ -61,9 +60,7 @@
+           # Go over each VM and bring it up
+           @logger.debug("'Up' each target VM...")
+ 
+-
+-          # Begin modified section
+-
++          # Create the VMs, then pass all the machines to the run action
+           machines = []
+           names = argv
+           if names.empty?
+@@ -79,41 +76,42 @@
+             names = nil if autostart && names.empty?
+           end
+ 
+-          with_target_vms(names, provider: options[:provider]) do |machine|
+-            @env.ui.info(I18n.t(
+-              "vagrant.commands.up.upping",
+-              name: machine.name,
+-              provider: machine.provider_name))
++          if names
++            with_target_vms(names, provider: options[:provider]) do |machine|
++              @env.ui.info(I18n.t(
++                "vagrant.commands.up.upping",
++                name: machine.name,
++                provider: machine.provider_name))
+ 
+-            machines << machine
++              machines << machine
++              machine.action(:create, options)
++            end
+ 
+-            if options[:parallel]
+-              machine.action(:create, options)
+-            else
+-              machine.action(:up, options)
++            # Capture states before the parallel runstate operation.
++            # Checking state is relatively expensive. we should be smarter
++            # about what information to capture. For example, we can
++            # determine which machines were newly created, and put them in
++            # the :stopped collection. Or call them :created? No, that
++            # would likely be confusing
++            #require_boot = machines.select{|m| m.state.id == :stopped}
++            initial_states = machines.inject({}) do |acc, m|
++              acc[m.id] = m.state.id
++              acc
++            end
++
++            machines.each_with_index do |machine, i|
++              machine.action(:run_vm, options.merge(
++                first_machine:  i == 0,
++                machines:       machines,
++                #require_boot:   require_boot,
++                initial_states: initial_states
++              ))
+             end
+           end
+ 
+-          if options[:parallel]
+-            @env.action_runner.run(VagrantPlugins::Skytap::Action.action_run_environment,
+-              local_data_path: @env.local_data_path,
+-              machines:        machines,
+-              machine:         machines.first,
+-              base_url:        nil,
+-              username:        nil,
+-              api_token:       nil,
+-              ui:              @env.ui
+-            )
+-          end
+-
+-          # End modified section
+-
+-
+           if machines.empty?
+             @env.ui.info(I18n.t("vagrant.up_no_machines"))
+             return 0
+-          else
+-
+           end
+ 
+           # Output the post-up messages that we have, if any
+@@ -137,3 +135,4 @@
+     end
+   end
+ end
++
+diff -r 3713c076cd21 locales/en.yml
+--- a/locales/en.yml	Thu Nov 19 21:24:32 2015 -0800
++++ b/locales/en.yml	Thu Nov 19 21:25:06 2015 -0800
+@@ -53,6 +53,11 @@
+       vm_url_required:
+         The URL of a Skytap VM must be specified via "vm_url"
+ 
++    commands:
++      up:
++        creating: |-
++          Creating machine '%{name}' with '%{provider}' provider...
++
+     errors:
+       instance_ready_timeout: |-
+         The instance never became "ready" in Skytap. The timeout currently