vagrant-skytap 0.1.6 → 0.1.7

data/eng-10269.diff.1

@@ -0,0 +1,455 @@
+# HG changeset patch
+# Parent 586410d23ff4907e87ce5ee2c7eee574f0749ab0
+ENG-10269 add parallelization support for `vagrant up`. This appears to work for the no-parallel case.
+
+diff -r 586410d23ff4 lib/vagrant-skytap/action.rb
+--- a/lib/vagrant-skytap/action.rb	Thu Nov 19 21:24:21 2015 -0800
++++ b/lib/vagrant-skytap/action.rb	Thu Nov 19 21:24:32 2015 -0800
+@@ -187,6 +187,30 @@
+       # This action is called to bring the box up from nothing.
+       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
++        end
++      end
++
++      # Pulled out of action_up to allow
++      def self.action_create
++        Vagrant::Action::Builder.new.tap do |b|
+           b.use HandleBox
+           b.use ConfigValidate
+           b.use InitializeAPIClient
+@@ -204,26 +228,23 @@
+             b1.use StoreExtraData
+             b1.use SetUpVm
+           end
+-          b.use Call, IsRunning do |env, b1|
++          b.use Call, IsStopped do |env, b1|
+             if env[:result]
+-              b1.use MessageAlreadyRunning
+-              next
+-            end
+-
+-            b1.use Call, IsStopped do |env2, b2|
+-              if env2[:result]
+-                b2.use UpdateHardware
+-                b2.use SetHostname
+-                b2.use action_prepare_boot
+-              end
+-
+-              b2.use RunVm
+-              b2.use WaitForCommunicator
++              b1.use UpdateHardware
++              b1.use SetHostname
+             end
+           end
+         end
+       end
+ 
++      def self.action_run_environment
++        Vagrant::Action::Builder.new.tap do |b|
++          b.use InitializeAPIClient
++          b.use FetchEnvironment
++          b.use RunEnvironment
++        end
++      end
++
+       def self.action_reload
+         Vagrant::Action::Builder.new.tap do |b|
+           b.use ConfigValidate
+diff -r 586410d23ff4 lib/vagrant-skytap/action/initialize_api_client.rb
+--- a/lib/vagrant-skytap/action/initialize_api_client.rb	Thu Nov 19 21:24:21 2015 -0800
++++ b/lib/vagrant-skytap/action/initialize_api_client.rb	Thu Nov 19 21:24:32 2015 -0800
+@@ -15,7 +15,14 @@
+         def call(env)
+           @logger.info("Connecting to Skytap...")
+ 
+-          client = API::Client.new(env[:machine].provider_config)
++          # This can be called outside the context of a machine
++          config = env[:machine].try(:provider_config) || {
++            base_url:  env[:base_url],
++            username:  env[:username],
++            api_token: env[:api_token],
++          }
++
++          client = API::Client.new(config)
+           if client.get('/configurations').code == '200'
+             env[:api_client] = client
+           end
+diff -r 586410d23ff4 lib/vagrant-skytap/action/run_environment.rb
+--- a/lib/vagrant-skytap/action/run_environment.rb	Thu Nov 19 21:24:21 2015 -0800
++++ b/lib/vagrant-skytap/action/run_environment.rb	Thu Nov 19 21:24:32 2015 -0800
+@@ -16,8 +16,10 @@
+         end
+ 
+         def call(env)
+-          env[:ui].info(I18n.t("vagrant_skytap.launching_instance"))
+-          environment.run!
++          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)
+ 
+           @app.call(env)
+         end
+diff -r 586410d23ff4 lib/vagrant-skytap/api/environment.rb
+--- a/lib/vagrant-skytap/api/environment.rb	Thu Nov 19 21:24:21 2015 -0800
++++ b/lib/vagrant-skytap/api/environment.rb	Thu Nov 19 21:24:32 2015 -0800
+@@ -28,7 +28,9 @@
+           end
+ 
+           def properties(env)
+-            EnvironmentProperties.read(env[:machine].env.local_data_path)
++            # This can be called outside the context of a particular machine
++            path = env[:local_data_path] || env[:machine].env.local_data_path
++            EnvironmentProperties.read(path)
+           end
+ 
+           def check_vm_before_adding(env, vm)
+@@ -78,6 +80,10 @@
+           super
+         end
+ 
++        def run!(vm_ids = nil)
++          set_runstate :running, vm_ids: vm_ids
++        end
++
+         def delete
+           retry_while_resource_busy do
+             api_client.delete(url)
+diff -r 586410d23ff4 lib/vagrant-skytap/api/runstate_operations.rb
+--- a/lib/vagrant-skytap/api/runstate_operations.rb	Thu Nov 19 21:24:21 2015 -0800
++++ b/lib/vagrant-skytap/api/runstate_operations.rb	Thu Nov 19 21:24:32 2015 -0800
+@@ -20,12 +20,17 @@
+         end
+ 
+         def poweroff!
+-          set_runstate :halted, :stopped
++          set_runstate :halted, completed_runstate: :stopped
+         end
+ 
+-        def set_runstate(new_runstate, completed_runstate = nil)
+-          completed_runstate ||= new_runstate
+-          update_with_retry(runstate: new_runstate)
++        def set_runstate(new_runstate, opts = {})
++          completed_runstate = opts.delete(:completed_runstate) || new_runstate
++
++          params = {runstate: new_runstate}.tap do |ret|
++            ret[:multiselect] = opts[:vm_ids] if opts[:vm_ids]
++          end
++          update_with_retry(params)
++
+           wait_for_runstate(completed_runstate) unless runstate == completed_runstate
+         end
+ 
+diff -r 586410d23ff4 lib/vagrant-skytap/command/start_mixins.rb
+--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
++++ b/lib/vagrant-skytap/command/start_mixins.rb	Thu Nov 19 21:24:32 2015 -0800
+@@ -0,0 +1,47 @@
++module VagrantPlugins
++  module Skytap
++    module Command
++      module StartMixins
++
++        # Would be nice to just extend this, then alias #build_start_options
++        # and add default options flag.
++        #include VagrantPlugins::CommandUp::StartMixins
++
++        # This adds the standard `start` command line flags to the given
++        # OptionParser, storing the result in the `options` dictionary.
++        #
++        # @param [OptionParser] parser
++        # @param [Hash] options
++        def build_start_options(parser, options)
++          # Setup the defaults
++          options[:provision_types] = nil
++
++          # Add the options
++          parser.on("--[no-]provision", "Enable or disable provisioning") do |p|
++            options[:provision_enabled] = p
++            options[:provision_ignore_sentinel] = true
++          end
++
++          parser.on("--provision-with x,y,z", Array,
++                  "Enable only certain provisioners, by type.") do |list|
++            options[:provision_types] = list.map { |type| type.to_sym }
++            options[:provision_enabled] = true
++            options[:provision_ignore_sentinel] = true
++          end
++        end
++
++        # This validates the provisioner flags and raises an exception
++        # if there are invalid ones.
++        def validate_provisioner_flags!(options)
++          (options[:provision_types] || []).each do |type|
++              klass = Vagrant.plugin("2").manager.provisioners[type]
++              if !klass
++                raise Vagrant::Errors::ProvisionerFlagInvalid,
++                  name: type.to_s
++              end
++          end
++        end
++      end
++    end
++  end
++end
+diff -r 586410d23ff4 lib/vagrant-skytap/command/up.rb
+--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
++++ b/lib/vagrant-skytap/command/up.rb	Thu Nov 19 21:24:32 2015 -0800
+@@ -0,0 +1,139 @@
++require 'optparse'
++
++require "vagrant"
++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.
++
++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)"
++        end
++
++        def execute
++          options = {}
++          options[:destroy_on_error] = true
++          options[:parallel] = true
++          options[:provision_ignore_sentinel] = false
++
++          opts = OptionParser.new do |o|
++            o.banner = "Usage: vagrant up [options] [name]"
++            o.separator ""
++            o.separator "Options:"
++            o.separator ""
++
++            build_start_options(o, options)
++
++            o.on("--[no-]destroy-on-error",
++                 "Destroy machine if any fatal error happens (default to true)") do |destroy|
++              options[:destroy_on_error] = destroy
++            end
++
++            o.on("--[no-]parallel",
++                 "Enable or disable parallelism if provider supports it") do |parallel|
++              options[:parallel] = parallel
++            end
++
++            o.on("--provider PROVIDER", String,
++                 "Back the machine with a specific provider") do |provider|
++              options[:provider] = provider
++            end
++          end
++
++          # Parse the options
++          argv = parse_options(opts)
++          return if !argv
++
++          # Validate the provisioners
++          validate_provisioner_flags!(options)
++
++          # Go over each VM and bring it up
++          @logger.debug("'Up' each target VM...")
++
++
++          # Begin modified section
++
++          machines = []
++          names = argv
++          if names.empty?
++            autostart = false
++            @env.vagrantfile.machine_names_and_options.each do |n, o|
++              autostart = true if o.key?(:autostart)
++              o[:autostart] = true if !o.key?(:autostart)
++              names << n.to_s if o[:autostart]
++            end
++
++            # If we have an autostart key but no names, it means that
++            # all machines are autostart: false and we don't start anything.
++            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))
++
++            machines << machine
++
++            if options[:parallel]
++              machine.action(:create, options)
++            else
++              machine.action(:up, options)
++            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
++          machines.each do |m|
++            next if !m.config.vm.post_up_message
++            next if m.config.vm.post_up_message == ""
++
++            # Add a newline to separate things.
++            @env.ui.info("", prefix: false)
++
++            m.ui.success(I18n.t(
++              "vagrant.post_up_message",
++              name: m.name.to_s,
++              message: m.config.vm.post_up_message))
++          end
++
++          # Success, exit status 0
++          0
++        end
++      end
++    end
++  end
++end
+diff -r 586410d23ff4 lib/vagrant-skytap/plugin.rb
+--- a/lib/vagrant-skytap/plugin.rb	Thu Nov 19 21:24:21 2015 -0800
++++ b/lib/vagrant-skytap/plugin.rb	Thu Nov 19 21:24:32 2015 -0800
+@@ -24,7 +24,7 @@
+         Config
+       end
+ 
+-      provider(:skytap, parallel: false) do
++      provider(:skytap, parallel: true) do
+         # Setup logging and i18n
+         setup_logging
+         setup_i18n
+@@ -34,6 +34,11 @@
+         Provider
+       end
+ 
++      command("up", primary: true) do
++        require_relative "command/up"
++        Command::Up
++      end
++
+       # This initializes the internationalization strings.
+       def self.setup_i18n
+         I18n.load_path << File.expand_path("locales/en.yml", Skytap.source_root)
+diff -r 586410d23ff4 locales/en.yml
+--- a/locales/en.yml	Thu Nov 19 21:24:21 2015 -0800
++++ b/locales/en.yml	Thu Nov 19 21:24:32 2015 -0800
+@@ -3,8 +3,8 @@
+     already_status: |-
+       The machine is already %{status}.
+ 
+-    launching_instance: |-
+-      Launching an instance with the following settings...
++    running_environment: |-
++      Starting VMs ...
+     launching_vm: |-
+       Launching a VM with the following settings...
+     not_created: |-
+diff -r 586410d23ff4 spec/acceptance/provider/up_spec.rb
+--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
++++ b/spec/acceptance/provider/up_spec.rb	Thu Nov 19 21:24:32 2015 -0800
+@@ -0,0 +1,33 @@
++# This tests that an instance can be halted correctly
++shared_examples 'provider/up' do |provider, options|
++  if !options[:box]
++    raise ArgumentError,
++          "box option must be specified for provider: #{provider}"
++  end
++
++  include_context 'acceptance'
++
++  before do
++    environment.skeleton('generic')
++    #assert_execute('vagrant', 'box', 'add', 'basic', options[:box])
++  end
++
++  after do
++    assert_execute('vagrant', 'destroy', '--force')
++  end
++
++  it 'should bring up the machine and halt it' do
++    status("Test: machine can be brought up")
++    up_result = execute("vagrant", "up")
++    expect(up_result).to exit_with(0)
++
++    status("Test: machine is running after up")
++    echo_result = execute("vagrant", "ssh", "-c", "echo foo")
++    expect(echo_result).to exit_with(0)
++    expect(echo_result.stdout).to match(/foo\n$/)
++
++    status("Test: machine can be halted")
++    halt_result = execute("vagrant", "halt")
++    expect(halt_result).to exit_with(0)
++  end
++end
+diff -r 586410d23ff4 spec/acceptance/skeletons/generic/Vagrantfile
+--- a/spec/acceptance/skeletons/generic/Vagrantfile	Thu Nov 19 21:24:21 2015 -0800
++++ b/spec/acceptance/skeletons/generic/Vagrantfile	Thu Nov 19 21:24:32 2015 -0800
+@@ -1,15 +1,14 @@
+ Vagrant.configure("2") do |config|
+-  config.vm.box = "skytap-dummy"
++  config.vm.box = "skytap/empty"
+ 
+   config.vm.provider :skytap do |skytap, override|
+-    skytap.username = "user"
+-    skytap.api_token = "9999999999999999999999"
+-    skytap.base_url = "https://example.com/"
++    skytap.vm_url  = "/vms/7285844"
++    skytap.vpn_url = "/vpns/vpn-711360"
++#    skytap.vpn_url = "/vpns/vpn-3195669"
+   end
+ 
+   config.vm.define "vm1" do |ubuntu|
+-    ubuntu.vm.provider :skytap do |box|
+-      box.vm_url = "https://example.com/vms/1"
+-    end
++    ubuntu.ssh.username = "skytap"
++    ubuntu.ssh.password = "ChangeMe!"
+   end
+ end

data/lib/vagrant-skytap/action/initial_state.rb

@@ -0,0 +1,20 @@
+module VagrantPlugins
+  module Skytap
+    module Action
+      # Our modified "up" command captures the VM states in the initial_states hash
+      # before running them, potentially in parallel.
+      class InitialState
+        def initialize(app, env)
+          @app = app
+          @logger = Log4r::Logger.new("vagrant_skytap::action::initial_state")
+        end
+
+        def call(env)
+          # if initial_states is absent, result is nil
+          env[:result] = env[:initial_states].try(:[], env[:machine].id)
+          @app.call(env)
+        end
+      end
+    end
+  end
+end

data/lib/vagrant-skytap/action/is_parallelized.rb

@@ -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

data/lib/vagrant-skytap/action/message_resuming.rb

@@ -0,0 +1,16 @@
+module VagrantPlugins
+  module Skytap
+    module Action
+      class MessageResuming
+        def initialize(app, env)
+          @app = app
+        end
+
+        def call(env)
+          env[:ui].info(I18n.t("vagrant_skytap.resuming"))
+          @app.call(env)
+        end
+      end
+    end
+  end
+end

data/lib/vagrant-skytap/action/run_environment.rb

@@ -3,7 +3,9 @@ require "log4r"
 module VagrantPlugins
   module Skytap
     module Action
-      # Runs the Skytap environment.
+      # Runs multiple VMs in parallel. This middleware will be invoked for
+      # each machine, so we set the :first_machine flag to prevent redundant
+      # REST calls.
       class RunEnvironment
         include Vagrant::Util::Retryable
 
@@ -16,8 +18,12 @@ module VagrantPlugins
         end
 
         def call(env)
-          env[:ui].info(I18n.t("vagrant_skytap.launching_instance"))
-          environment.run!
+          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

data/lib/vagrant-skytap/action/wait_for_communicator.rb

@@ -40,7 +40,7 @@ module VagrantPlugins
               end
             end
           rescue Timeout::Error
-            raise Errors::VMBootTimeout
+            raise Vagrant::Errors::VMBootTimeout
           end
         end
       end

data/lib/vagrant-skytap/action.rb

@@ -168,6 +168,11 @@ module VagrantPlugins
         end
       end
 
+      # Note: Provision and SyncedFolders perform actions before and after
+      # calling the next middleware in the sequence. Both require that
+      # the machine be booted before those calls return. This requirement
+      # can be satisfied by putting the WaitForCommunicator middleware
+      # later in the sequence.
       def self.action_prepare_boot
         Vagrant::Action::Builder.new.tap do |b|
           b.use PrepareNFSSettings
@@ -180,12 +185,28 @@ module VagrantPlugins
 
       def self.action_resume
         Vagrant::Action::Builder.new.tap do |b|
-          b.use action_up
+          Vagrant::Action::Builder.new.tap do |b|
+            b.use InitializeAPIClient
+            b.use FetchEnvironment
+            b.use Call, IsSuspended do |env, b1|
+              if env[:result]
+                b1.use MessageResuming
+                b1.use RunVm
+                b1.use WaitForCommunicator
+              end
+            end
+          end
         end
       end
 
-      # This action is called to bring the box up from nothing.
-      def self.action_up
+      # The Skytap provider has a modified "vagrant up" command which
+      # takes advantage of parallel runstate operations on Skytap
+      # environments. The create and update_hardware actions are
+      # separated from the run_vm action, so we can pass in the ids
+      # and initial states for all machines to be run, potentially
+      # with a single REST call.
+
+      def self.action_create
         Vagrant::Action::Builder.new.tap do |b|
           b.use HandleBox
           b.use ConfigValidate
@@ -204,23 +225,53 @@ module VagrantPlugins
             b1.use StoreExtraData
             b1.use SetUpVm
           end
-          b.use Call, IsRunning do |env, b1|
+        end
+      end
+
+      def self.action_update_hardware
+        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
+
+      def self.action_run_vm
+        Vagrant::Action::Builder.new.tap do |b|
+          b.use InitializeAPIClient
+          b.use FetchEnvironment
+
+          # The "up" command stores the pre-run states to
+          # avoid a race condition when running multiple
+          # VMs in parallel -- we need to know which VMs
+          # are actually being powered on and need to
+          # have folders synced and provisioning run.
+          b.use Call, InitialState do |env, b1|
+            case env[:result]
+            when :running
               b1.use MessageAlreadyRunning
               next
+            when :suspended
+              b1.use MessageResuming
+            else
+              b1.use action_prepare_boot
             end
-
-            b1.use Call, IsStopped do |env2, b2|
+            b1.use Call, IsParallelized do |env2, b2|
               if env2[:result]
-                b2.use UpdateHardware
-                b2.use SetHostname
-                b2.use action_prepare_boot
+                # Note: RunEnvironment is a no-op after
+                # the first invocation.
+                b2.use RunEnvironment
+              else
+                b2.use RunVm
               end
-
-              b2.use RunVm
-              b2.use WaitForCommunicator
             end
           end
+          b.use WaitForCommunicator
         end
       end
 
@@ -229,13 +280,17 @@ module VagrantPlugins
           b.use ConfigValidate
           b.use InitializeAPIClient
           b.use FetchEnvironment
-          b.use Call, ExistenceCheck do |env, b2|
+          b.use Call, ExistenceCheck do |env, b1|
             case env[:result]
             when :missing_environment, :missing_vm, :no_vms
-              b2.use MessageNotCreated
+              b1.use MessageNotCreated
             else
-              b2.use action_halt
-              b2.use action_up
+              b1.use action_halt
+              b1.use action_update_hardware
+              # We don't need to store the initial states
+              # before calling run_vm, because the default
+              # behavior is to treat the VMs as powered off.
+              b1.use action_run_vm
             end
           end
         end
@@ -251,6 +306,8 @@ module VagrantPlugins
       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")
@@ -258,6 +315,7 @@ module VagrantPlugins
       autoload :MessageAlreadyRunning, action_root.join("message_already_running")
       autoload :MessageNotCreated, action_root.join("message_not_created")
       autoload :MessageEnvironmentUrl, action_root.join("message_environment_url")
+      autoload :MessageResuming, action_root.join("message_resuming")
       autoload :MessageWillNotDestroy, action_root.join("message_will_not_destroy")
       autoload :PrepareNFSSettings, action_root.join("prepare_nfs_settings")
       autoload :PrepareNFSValidIds, action_root.join("prepare_nfs_valid_ids")