vagrant-skytap 0.1.6 → 0.1.7

data/eng-10269.diff

@@ -0,0 +1,577 @@
+# HG changeset patch
+# Parent 586410d23ff4907e87ce5ee2c7eee574f0749ab0
+# Parent  586410d23ff4907e87ce5ee2c7eee574f0749ab0
+ENG-10269 add parallelization support for `vagrant up`.
+
+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:50:44 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
+@@ -187,6 +192,14 @@
+       # 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 action_run_vm
++        end
++      end
++
++      # This action is called by our modified "up" command.
++      def self.action_create
++        Vagrant::Action::Builder.new.tap do |b|
+           b.use HandleBox
+           b.use ConfigValidate
+           b.use InitializeAPIClient
+@@ -204,23 +217,58 @@
+             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 UpdateHardware
++              b1.use SetHostname
++            end
++          end
++        end
++      end
++
++#      # 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 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, 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
++                b2.use RunEnvironment
++              else
++                b2.use RunVm
+               end
+-
+-              b2.use RunVm
+-              b2.use WaitForCommunicator
+             end
+           end
++          b.use WaitForCommunicator
+         end
+       end
+ 
+@@ -251,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")
+@@ -263,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 586410d23ff4 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:50:44 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 586410d23ff4 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:50:44 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 586410d23ff4 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:50:44 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 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:50:44 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,8 +17,14 @@
+         end
+ 
+         def call(env)
+-          env[:ui].info(I18n.t("vagrant_skytap.launching_instance"))
+-          environment.run!
++          # 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 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:50:44 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:50:44 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:50:44 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:50:44 2015 -0800
+@@ -0,0 +1,138 @@
++require 'optparse'
++
++require "vagrant"
++require "byebug"
++
++require_relative 'start_mixins'
++
++# 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 < Vagrant.plugin("2", :command)
++        include StartMixins
++
++        def self.synopsis
++          "starts and provisions the vagrant environment"
++        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...")
++
++          # Create the VMs, then pass all the machines to the run action
++          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
++
++          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
++              machine.action(:create, options)
++            end
++
++            # 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 machines.empty?
++            @env.ui.info(I18n.t("vagrant.up_no_machines"))
++            return 0
++          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:50:44 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:50:44 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: |-
+@@ -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
+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:50:44 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:50:44 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