vagrant-skytap 0.1.11 → 0.2.0

data/_patches-20160118a/eng-12301

@@ -0,0 +1,50 @@
+# HG changeset patch
+# Parent 7bf28b483ba4495c173d9316aee2d8482d9705ab
+ENG-12301 release machine lock
+
+diff -r 7bf28b483ba4 lib/vagrant-skytap/action/mixin_machine_index.rb
+--- a/lib/vagrant-skytap/action/mixin_machine_index.rb	Thu Dec 03 19:36:57 2015 -0800
++++ b/lib/vagrant-skytap/action/mixin_machine_index.rb	Mon Dec 07 14:42:07 2015 -0800
+@@ -14,6 +14,7 @@
+         # NOTE: #get locks the machine. Make sure to #release(entry)
+         # when finished.
+         def machine_index_entry
++          @logger.debug("Locking machine #{index_uuid}") if @logger
+           entry = machine_index.get(env[:machine].index_uuid)
+         end
+       end
+diff -r 7bf28b483ba4 lib/vagrant-skytap/action/store_extra_data.rb
+--- a/lib/vagrant-skytap/action/store_extra_data.rb	Thu Dec 03 19:36:57 2015 -0800
++++ b/lib/vagrant-skytap/action/store_extra_data.rb	Mon Dec 07 14:42:07 2015 -0800
+@@ -17,6 +17,7 @@
+ 
+         def call(env)
+           entry = machine_index_entry
++          puts  "Machine locked. Pausing 5 seconds so you can kill me"
+           entry.extra_data.merge!(provider_extra_data)
+           entry = machine_index.set(entry)
+           machine_index.release(entry)
+diff -r 7bf28b483ba4 lib/vagrant-skytap/provider.rb
+--- a/lib/vagrant-skytap/provider.rb	Thu Dec 03 19:36:57 2015 -0800
++++ b/lib/vagrant-skytap/provider.rb	Mon Dec 07 14:42:07 2015 -0800
+@@ -6,6 +6,7 @@
+     class Provider < Vagrant.plugin("2", :provider)
+       def initialize(machine)
+         @machine = machine
++        @logger = Log4r::Logger.new("vagrant_skytap::plugin::provider")
+       end
+ 
+       def action(name)
+@@ -26,10 +27,11 @@
+       end
+ 
+       def state
++        @logger.debug("Entered Provider#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")
++        env = @machine.action("read_state", lock: false) # can't be this easy
+ 
+         state_id = env[:machine_state_id]
+ 

data/_patches-20160118a/eng-12720

@@ -0,0 +1,74 @@
+# HG changeset patch
+# Parent cc2ef994b16e0e695ce23413086a3eb891955849
+ENG-12720 add forwarded_ports provider cap for "port" command
+
+diff -r cc2ef994b16e lib/vagrant-skytap/action/forward_ports.rb
+--- a/lib/vagrant-skytap/action/forward_ports.rb	Wed Jan 13 13:32:23 2016 -0800
++++ b/lib/vagrant-skytap/action/forward_ports.rb	Wed Jan 13 13:33:15 2016 -0800
+@@ -29,6 +29,9 @@
+ 
+           env[:ui].output(I18n.t("vagrant.actions.vm.forward_ports.forwarding"))
+           forward_ports
++          # these ports have already been remapped
++          # Write a file forwarded_ports, analogous to synced_folders, which maps the
++          # pidsfiles/ids to host ip, guest ip, host port, guest port
+ 
+           @app.call(env)
+         end
+diff -r cc2ef994b16e lib/vagrant-skytap/cap/forwarded_ports.rb
+--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
++++ b/lib/vagrant-skytap/cap/forwarded_ports.rb	Wed Jan 13 13:33:15 2016 -0800
+@@ -0,0 +1,26 @@
++module VagrantPlugins
++  module Skytap
++    module Cap
++      module ForwardedPorts
++        # Reads the forwarded ports that currently exist on the machine
++        # itself. This raises an exception if the machine isn't running.
++        #
++        # This also may not match up with configured forwarded ports, because
++        # Vagrant auto port collision fixing may have taken place.
++        #
++        # @return [Hash<Integer, Integer>] Host => Guest port mappings.
++        def self.forwarded_ports(machine)
++          return nil if machine.state.id != :running
++
++          {}.tap do |result|
++            # Since we can't access the host to call host capabilities, we need a
++            # redundant method here which reads from a forwarded_ports file.
++            #env[:host].capability(:read_forwarded_ports, nil, machine).each do |name, hostport, guestport|
++            #  result[hostport] = guestport
++            #end
++          end
++        end
++      end
++    end
++  end
++end
+diff -r cc2ef994b16e lib/vagrant-skytap/hosts/common/cap/ssh_tunnel.rb
+--- a/lib/vagrant-skytap/hosts/common/cap/ssh_tunnel.rb	Wed Jan 13 13:32:23 2016 -0800
++++ b/lib/vagrant-skytap/hosts/common/cap/ssh_tunnel.rb	Wed Jan 13 13:33:15 2016 -0800
+@@ -53,6 +53,8 @@
+ 
+             def read_forwarded_ports(env, env_hash, machine = nil)
+               machine ||= env_hash[:machine]
++              # this doesn't get enough info (need to return protocol, hostport, guestport, ?).
++              # Read from the forwarded_ports file that we create when forwarding the ports.
+               get_pidfiles_for_machine(machine).collect do |pidfile|
+                 read_pid(machine.data_dir.join(pidfile))
+               end
+diff -r cc2ef994b16e lib/vagrant-skytap/plugin.rb
+--- a/lib/vagrant-skytap/plugin.rb	Wed Jan 13 13:32:23 2016 -0800
++++ b/lib/vagrant-skytap/plugin.rb	Wed Jan 13 13:33:15 2016 -0800
+@@ -49,6 +49,11 @@
+         Cap::PublicAddress
+       end
+ 
++      provider_capability(:skytap, :forwarded_ports) do
++        require_relative "cap/forwarded_ports"
++        Cap::ForwardedPorts
++      end
++
+       %w[start_ssh_tunnel kill_ssh_tunnel kill_forwarded_ports read_used_ports read_forwarded_ports].each do |cap|
+         host_capability("bsd", cap) do
+           require_relative "hosts/bsd/cap/ssh_tunnel"

data/_patches-20160118a/eng-12843

@@ -0,0 +1,95 @@
+# HG changeset patch
+# Parent d12ff92a5f45243523ff63f49b559dd3793fe41e
+ENG-12843 make Up command work without hacking a copy of the command
+
+diff -r d12ff92a5f45 -r 52e7dd5125d7 lib/vagrant-skytap/action.rb
+--- a/lib/vagrant-skytap/action.rb	Mon Dec 28 10:54:14 2015 -0800
++++ b/lib/vagrant-skytap/action.rb	Tue Jan 05 13:21:52 2016 -0800
+@@ -190,6 +190,16 @@
+       # and initial states for all machines to be run, potentially
+       # with a single REST call.
+ 
++      def self.action_up
++        Vagrant::Action::Builder.new.tap do |b|
++          b.use HandleBox
++          #b.use action_fetch_environment
++          b.use ConfigValidate
++#          b.use InitializeAPIClient
++#          b.use FetchEnvironment
++        end
++      end
++
+       def self.action_create
+         Vagrant::Action::Builder.new.tap do |b|
+           b.use HandleBox
+@@ -320,6 +330,7 @@
+       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 :PostActionUp, action_root.join("post_action_up")
+       autoload :PrepareForwardedPortCollisionParams, action_root.join("prepare_forwarded_port_collision_params")
+       autoload :PrepareNFSSettings, action_root.join("prepare_nfs_settings")
+       autoload :PrepareNFSValidIds, action_root.join("prepare_nfs_valid_ids")
+diff -r d12ff92a5f45 -r 52e7dd5125d7 lib/vagrant-skytap/action/post_action_up.rb
+--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
++++ b/lib/vagrant-skytap/action/post_action_up.rb	Tue Jan 05 13:21:52 2016 -0800
+@@ -0,0 +1,26 @@
++require 'byebug'
++require_relative "mixin_machine_index"
++
++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 PostActionUp
++        include MixinMachineIndex
++        def initialize(app, env)
++          @app = app
++          @logger = Log4r::Logger.new("vagrant_skytap::action::post_action_up")
++        end
++
++        def call(env)
++          @logger.info env[:action_name]
++          @logger.info env[:machine].try(:name)
++          debugger
++
++          @app.call(env)
++        end
++      end
++    end
++  end
++end
+diff -r d12ff92a5f45 -r 52e7dd5125d7 lib/vagrant-skytap/plugin.rb
+--- a/lib/vagrant-skytap/plugin.rb	Mon Dec 28 10:54:14 2015 -0800
++++ b/lib/vagrant-skytap/plugin.rb	Tue Jan 05 13:21:52 2016 -0800
+@@ -3,7 +3,7 @@
+ rescue LoadError
+   raise "The Vagrant Skytap plugin must be run within Vagrant."
+ end
+-
++require 'byebug'
+ # 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"
+@@ -34,9 +34,17 @@
+         Provider
+       end
+ 
+-      command("up", primary: true) do
+-        require_relative "command/up"
+-        Skytap::Command::Up
++#      command("up", primary: true) do
++#        require_relative "command/up"
++#        Skytap::Command::Up
++#      end
++
++      action_hook(:post_up_behavior1, :environment_unload) do |hook|
++        hook.prepend(VagrantPlugins::Skytap::Action::PostActionUp)
++      end
++
++      action_hook(:post_up_behavior4, :machine_action_up) do |hook|
++        hook.append(VagrantPlugins::Skytap::Action::PostActionUp)
+       end
+ 
+       command("publish-url", primary: true) do

data/_patches-20160118a/eng-13040

@@ -0,0 +1,291 @@
+# HG changeset patch
+# Parent 3e63d0cb1ef6e5757f785da86648be335dc967f5
+ENG-13040 port forwarding collision detection & repair
+
+diff -r 3e63d0cb1ef6 Vagrantfile
+--- a/Vagrantfile	Wed Jan 13 14:42:59 2016 -0800
++++ b/Vagrantfile	Wed Jan 13 16:48:17 2016 -0800
+@@ -88,7 +88,7 @@
+ settings_key = :etrue_prod
+ vm1_key = :golden
+ vm2_key = :windows_winrm_configured
+-vm3_key = :ubuntu2
++vm3_key = :golden
+ #############################
+ 
+ 
+@@ -125,8 +125,8 @@
+     box.vm.provision "shell", path: "provisioning/apache.sh"
+     box.vm.provision "shell", path: "provisioning/vagrant.sh"
+ 
+-    box.vm.network :forwarded_port, guest: 80, host: 9000
+-    #box.vm.network :forwarded_port, guest: 21, host: 9001
++    box.vm.network :forwarded_port, guest: 80, host: 9000, auto_correct: true
++    box.vm.network :forwarded_port, guest: 21, host: 9001, auto_correct: true
+   end
+ 
+ #  config.vm.define "vm2" do |box|
+@@ -140,17 +140,20 @@
+ #    box.vm.synced_folder "vm2", "/synced", type: :nfs
+ #  end
+ #
+-#  config.vm.define "vm3" do |box|
+-#    box.vm.hostname = "vm3"
+-#    box.vm.provider :skytap do |box|
+-#      box.vm_url = vms[vm3_key][:vm_url]
+-#    end
+-#    box.ssh.username    = vms[vm3_key][:username]
+-#    box.ssh.password    = vms[vm3_key][:password]
+-#    box.vm.communicator = vms[vm3_key][:communicator]
+-#    box.vm.synced_folder "vm3", "/synced", type: :nfs
+-#    box.vm.provision "shell", path: "provisioning/trivial.sh"
+-#  end
++  config.vm.define "vm3" do |box|
++    #box.vm.hostname = "vm3"
++    box.vm.provider :skytap do |box|
++      box.vm_url = vms[vm3_key][:vm_url]
++    end
++    box.ssh.username    = vms[vm3_key][:username]
++    box.ssh.password    = vms[vm3_key][:password]
++    box.vm.communicator = vms[vm3_key][:communicator]
++    #box.vm.synced_folder "vm3", "/synced", type: :nfs
++    box.vm.provision "shell", path: "provisioning/trivial.sh"
++
++    box.vm.network :forwarded_port, guest: 80, host: 9000, auto_correct: true
++    box.vm.network :forwarded_port, guest: 21, host: 9001, auto_correct: true
++  end
+ end
+ 
+ #ubuntu.vm.synced_folder "vm1", "/home/skytap/app", type: :nfs, :mount_options => ['actimeo=1']
+diff -r 3e63d0cb1ef6 lib/vagrant-skytap/action.rb
+--- a/lib/vagrant-skytap/action.rb	Wed Jan 13 14:42:59 2016 -0800
++++ b/lib/vagrant-skytap/action.rb	Wed Jan 13 16:48:17 2016 -0800
+@@ -289,6 +289,9 @@
+         Vagrant::Action::Builder.new.tap do |b|
+           b.use ClearForwardedPorts
+           b.use ReadSSHInfo
++          b.use EnvSet, port_collision_repair: true
++          b.use PrepareForwardedPortCollisionParams
++          b.use HandleForwardedPortCollisions
+           b.use ForwardPorts
+         end
+       end
+@@ -316,6 +319,7 @@
+       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 :PrepareForwardedPortCollisionParams, action_root.join("prepare_forwarded_port_collision_params")
+       autoload :PrepareNFSSettings, action_root.join("prepare_nfs_settings")
+       autoload :PrepareNFSValidIds, action_root.join("prepare_nfs_valid_ids")
+       autoload :ReadSSHInfo, action_root.join("read_ssh_info")
+diff -r 3e63d0cb1ef6 lib/vagrant-skytap/action/prepare_forwarded_port_collision_params.rb
+--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
++++ b/lib/vagrant-skytap/action/prepare_forwarded_port_collision_params.rb	Wed Jan 13 16:48:17 2016 -0800
+@@ -0,0 +1,35 @@
++module VagrantPlugins
++  module Skytap
++    module Action
++      class PrepareForwardedPortCollisionParams
++        def initialize(app, env)
++          @app = app
++        end
++
++        def call(env)
++          # Get the forwarded ports used by other virtual machines and
++          # consider those in use as well.
++          env[:port_collision_extra_in_use] = env[:host].capability(:read_used_ports, env)
++
++          # Build the remap for any existing collision detections
++          remap = {}
++          env[:port_collision_remap] = remap
++          env[:host].capability(:read_forwarded_ports, env).each do |name, hostport, guestport|
++            env[:machine].config.vm.networks.each do |type, options|
++              next if type != :forwarded_port
++
++              # If the ID matches the name of the forwarded port, then
++              # remap.
++              if options[:id] == name
++                remap[options[:host]] = hostport
++                break
++              end
++            end
++          end
++
++          @app.call(env)
++        end
++      end
++    end
++  end
++end
+diff -r 3e63d0cb1ef6 lib/vagrant-skytap/hosts/common/cap/ssh_tunnel.rb
+--- a/lib/vagrant-skytap/hosts/common/cap/ssh_tunnel.rb	Wed Jan 13 14:42:59 2016 -0800
++++ b/lib/vagrant-skytap/hosts/common/cap/ssh_tunnel.rb	Wed Jan 13 16:48:17 2016 -0800
+@@ -18,21 +18,21 @@
+             def start_ssh_tunnel(env, fp, env_hash)
+               logger = create_logger
+               machine = env_hash[:machine]
+-              pidfile = pidfile_name(fp)
+-              pid = read_pid(machine.data_dir.join(pidfile))
++              pid = read_pid(machine.data_dir.join(fp.pidfile))
+ 
+               if pid && autossh_pid?(pid)
+                 logger.info("An autossh process already exists with pid #{pid}.")
+               else
+-                args = ssh_args(fp, pidfile, env_hash)
+-                vars = autossh_environment_variables(pidfile, env_hash)
++                args = ssh_args(fp, machine, env_hash)
++                vars = autossh_environment_variables(fp, machine)
+                 args << {env: vars}
+                 Vagrant::Util::Subprocess.execute("autossh", "-f", *args)
+               end
+             end
+ 
+             def kill_forwarded_ports(env, env_hash)
+-              get_pidfiles_for_machine(env_hash[:machine]).each do |pidfile|
++              machine = env_hash[:machine]
++              pidfiles_for_directory(machine.data_dir).each do |pidfile|
+                 kill_ssh_tunnel(env, pidfile, env_hash)
+               end
+             end
+@@ -49,49 +49,82 @@
+               end
+             end
+ 
+-
+-            def pidfile_name(fp)
+-              "#{fp.protocol}#{fp.host_port}.pid"
+-            end
+-
+             def read_pid(pidfile_path)
+               File.read(pidfile_path).presence.try(:to_i) if File.exist?(pidfile_path)
+             end
+ 
+-            def get_pidfiles_for_machine(machine)
++            # Returns fpinfo for this machine's forwarded ports.
++            def read_forwarded_ports(env, env_hash)
++              machine = env_hash[:machine]
++              fpinfos_for_directory(machine.data_dir)
++            end
++
++            # Returns fpinfo for the forwarded ports of all *other* machines
++            def read_used_ports(env, env_hash)
++              machine = env_hash[:machine]
++              paths = machine_paths(env).reject!{|k,v| k == machine.name.to_s}
++              paths.values.collect{|path| fpinfos_for_directory(path)}.flatten
++            end
++
++            # fpinfo (my terminology) is an array of:
++            # [adapter, name, hostport, guestport]
++            # Currently all the info we have is the pid itself,
++            # so guestport is nil. Adapter is unused.
++            def fpinfos_for_directory(dir)
++              pidfiles_for_directory(dir).collect do |pidfile|
++                pidfile =~ /(\w+)(\d+)\.pid/
++                protocol, hostport, guestport = $1, $2, nil
++                [nil, "#{protocol}#{hostport}", hostport, guestport]
++              end
++            end
++
++            def pidfiles_for_directory(dir)
+               pidfiles = []
+-              Vagrant::Util::SafeChdir.safe_chdir(machine.data_dir) do
++              Vagrant::Util::SafeChdir.safe_chdir(dir) do
+                 pidfiles = Dir.glob("*.pid")
+               end
+               pidfiles
+             end
+ 
++            # Map of machine names to absolute data_dirs, including
++            # only Skytap machines.
++            def machine_paths(env)
++              h = {}
++              env_path = env.local_data_path
++              Vagrant::Util::SafeChdir.safe_chdir(env.local_data_path) do
++                Dir.foreach("machines") do |machine_name|
++                  data_dir = "machines/#{machine_name}/skytap"
++                  if Dir.exist?(data_dir)
++                    h[machine_name] = env_path.join(data_dir)
++                  end
++                end
++              end
++              h
++            end
++
+             # Checks that the pid is actually an autossh process (and not
+             # something else using a recycled pid).
+             def autossh_pid?(pid)
+-              # get_comm_for_pid(pid) == 'autossh'
+-              true
++              get_comm_for_pid(pid) == 'autossh'
+             end
+ 
+             # Get the command, minus any arguments, for the given
+-            # pid. This probably needs to be overridden per host cap
++            # pid. These arguments give the desired results
++            # on MacOS, Ubuntu
+             def get_comm_for_pid(pid)
+               result = Vagrant::Util::Subprocess.execute("ps", "-p", pid.to_s, "-o", "comm")
+               result.stdout.split("\n").last
+             end
+ 
+-
+-            # these args seem to work on MacOS and Ubuntu ...
+-            # untested on other implementations
+-            def ssh_args(fp, pidfile, env_hash)
+-              machine = env_hash[:machine]
++            # These arguments give the desired results
++            # on MacOS, Ubuntu
++            def ssh_args(fp, machine, env_hash)
+               ssh_info = env_hash[:machine_ssh_info]
+               ssh_options = {
+                 "ServerAliveInterval" => 10,
+                 "ServerAliveCountMax" => 3,
+                 "StrictHostKeyChecking" => "no",
+               }
+-
+               args = []
+               args << "-q" # quiet
+               args << "-N" # no remote command
+@@ -104,10 +137,9 @@
+               args << "#{ssh_info[:username]}@#{ssh_info[:host]}"
+             end
+ 
+-            def autossh_environment_variables(pidfile, env_hash, monitoring_port = 0)
+-              machine = env_hash[:machine]
++            def autossh_environment_variables(fp, machine, monitoring_port = 0)
+               {
+-                "AUTOSSH_PIDFILE" => machine.data_dir.join(pidfile),
++                "AUTOSSH_PIDFILE" => machine.data_dir.join(fp.pidfile),
+                 "AUTOSSH_PORT" => monitoring_port,
+                 "AUTOSSH_LOGFILE" => "/tmp/#{pidfile}_#{machine.id}_autossh.log",
+               }
+diff -r 3e63d0cb1ef6 lib/vagrant-skytap/model/forwarded_port.rb
+--- a/lib/vagrant-skytap/model/forwarded_port.rb	Wed Jan 13 14:42:59 2016 -0800
++++ b/lib/vagrant-skytap/model/forwarded_port.rb	Wed Jan 13 16:48:17 2016 -0800
+@@ -64,6 +64,14 @@
+         def correct_host_port(new_port)
+           @host_port = new_port
+         end
++
++        # This generates a filename which can be used to
++        # store the pid of an ssh tunnel.
++        #
++        # @return [String]
++        def pidfile
++          "#{protocol}#{host_port}.pid"
++        end
+       end
+     end
+   end
+diff -r 3e63d0cb1ef6 lib/vagrant-skytap/plugin.rb
+--- a/lib/vagrant-skytap/plugin.rb	Wed Jan 13 14:42:59 2016 -0800
++++ b/lib/vagrant-skytap/plugin.rb	Wed Jan 13 16:48:17 2016 -0800
+@@ -49,7 +49,7 @@
+         Cap::PublicAddress
+       end
+ 
+-      %w[start_ssh_tunnel kill_ssh_tunnel kill_forwarded_ports].each do |cap|
++      %w[start_ssh_tunnel kill_ssh_tunnel kill_forwarded_ports read_used_ports read_forwarded_ports].each do |cap|
+         host_capability("bsd", cap) do
+           require_relative "hosts/bsd/cap/ssh_tunnel"
+           HostBSD::Cap::SSHTunnel

data/_patches-20160118a/env-source

@@ -0,0 +1,112 @@
+# HG changeset patch
+# Parent 2d0352ab9e88823add32c339d95d9782c00fba51
+ENG-11604 support using environment vms (this is impossible without an API change)
+
+diff -r 2d0352ab9e88 Vagrantfile
+--- a/Vagrantfile	Wed Nov 04 16:26:46 2015 -0800
++++ b/Vagrantfile	Wed Nov 04 16:28:24 2015 -0800
+@@ -39,7 +39,7 @@
+   config.vm.define "vm1" do |ubuntu|
+     ubuntu.vm.hostname = "vm1"
+     ubuntu.vm.provider :skytap do |box|
+-      box.vm_url = UBUNTU1#GENERIC_UBUNTU
++      box.vm_url = UBUNTU_STOPPED_ENVIRONMENT_SOURCE_VM_A#GENERIC_UBUNTU
+       #box.cpus = 1
+       #box.cpuspersocket = 1
+       #box.ram = 1024
+@@ -64,7 +64,7 @@
+   config.vm.define "vm3" do |ubuntu|
+     ubuntu.vm.hostname = "vm3"
+     ubuntu.vm.provider :skytap do |box|
+-      box.vm_url = UBUNTU2#GENERIC_UBUNTU
++      box.vm_url = UBUNTU_STOPPED_ENVIRONMENT_SOURCE_VM_B#GENERIC_UBUNTU
+     end
+     ubuntu.vm.communicator = :ssh
+     ubuntu.ssh.username = "skytap"
+diff -r 2d0352ab9e88 lib/vagrant-skytap/api/environment.rb
+--- a/lib/vagrant-skytap/api/environment.rb	Wed Nov 04 16:26:46 2015 -0800
++++ b/lib/vagrant-skytap/api/environment.rb	Wed Nov 04 16:28:24 2015 -0800
+@@ -18,8 +18,27 @@
+             vm = Vm.fetch(env, vm_url)
+             check_vm_before_adding(env, vm)
+ 
+-            resp = env[:api_client].post(RESOURCE_ROOT, JSON.dump(template_id: vm.template_id, vm_ids: [vm.id]))
+-            fetch(env, resp['Location'])
++            params = {
++              vm_ids: [vm.id]
++            }.tap do |params|
++              if vm.from_template?
++                params[:template_id] = vm.template_id
++              else
++                params[:configuration_id] = vm.environment_id
++              end
++            end
++
++            puts params
++            debugger
++
++            resp = env[:api_client].post(RESOURCE_ROOT, JSON.dump(params))#_for_add(vm)))
++            if resp['Location']
++              puts "Redirected to #{resp['Location']}"
++              fetch(env, resp['Location'])
++            else
++              puts "call returned #{resp.body}"
++              new(JSON.load(resp.body), env)
++            end
+           end
+ 
+           def fetch(env, url)
+@@ -31,6 +50,16 @@
+             EnvironmentProperties.read(env[:machine].env.local_data_path)
+           end
+ 
++          def params_for_add(vm)
++            {
++              vm_ids: [vm.id]
++            }.tap do |params|
++              unless params[:merge_configuration] = vm.environment_id
++                params[:template_id] = vm.template_id
++              end
++            end
++          end
++
+           def check_vm_before_adding(env, vm)
+             raise Errors::NotTemplateVm, url: vm.url unless vm.from_template?
+             raise Errors::SourceVmNotStopped, name: env[:machine].name, url: vm.url unless vm.stopped?
+@@ -90,7 +119,20 @@
+           check_vm_before_adding(env, vm)
+           vm_ids = vms.collect(&:id)
+ 
+-          update_with_retry(template_id: vm.template_id, vm_ids: [vm.id])
++          params = {
++            vm_ids: [vm.id]
++          }.tap do |params|
++            if vm.from_template?
++              params[:template_id] = vm.template_id
++            else
++              params[:merge_configuration] = vm.environment_id
++            end
++          end
++
++
++          puts params
++          debugger
++          update_with_retry(params)#self.class.params_for_add(vm))
+           new_vm_ids = vms.collect(&:id) - vm_ids
+           get_vm_by_id(new_vm_ids.last)
+         end
+diff -r 2d0352ab9e88 lib/vagrant-skytap/api/vm.rb
+--- a/lib/vagrant-skytap/api/vm.rb	Wed Nov 04 16:26:46 2015 -0800
++++ b/lib/vagrant-skytap/api/vm.rb	Wed Nov 04 16:28:24 2015 -0800
+@@ -60,6 +60,11 @@
+           !!get_api_attribute('template_url')
+         end
+ 
++        def environment_id
++          get_api_attribute('configuration_url') =~ /configurations\/(\d+)/
++          $1
++        end
++
+         def template_id
+           get_api_attribute('template_url') =~ /templates\/(\d+)/
+           $1