vagrant-openstack-plugin-tom 0.12.0

data/lib/vagrant-openstack-plugin/action/delete_server.rb

@@ -0,0 +1,84 @@
+require 'vagrant/util/retryable'
+require 'timeout'
+
+require "log4r"
+
+module VagrantPlugins
+  module OpenStack
+    module Action
+      # This deletes the running server, if there is one.
+      class DeleteServer
+        include Vagrant::Util::Retryable
+
+        def initialize(app, env)
+          @app    = app
+          @logger = Log4r::Logger.new("vagrant_openstack::action::delete_server")
+        end
+
+        def call(env)
+          machine = env[:machine]
+          id = machine.id || (env[:openstack_compute].servers.all( :name => machine.name ).length == 1 and
+                              env[:openstack_compute].servers.all( :name => machine.name ).first.id)
+
+          if id
+            env[:ui].info(I18n.t("vagrant_openstack.deleting_server"))
+
+            # TODO: Validate the fact that we get a server back from the API.
+            server = env[:openstack_compute].servers.get(id)
+            if server
+              # get volumes before destroying server
+              volumes = server.volume_attachments
+
+              ip = server.floating_ip_address
+
+              retryable(:on => Timeout::Error, :tries => 20) do
+                # If we're interrupted don't worry about waiting
+                next if env[:interrupted]
+
+                begin
+                  server.destroy if server
+                  status = Timeout::timeout(10) {
+                    while server.reload
+                      sleep(1)
+                    end
+                  }
+                rescue RuntimeError => e
+                  # If we don't have an error about a state transition, then
+                  # we just move on.
+                  raise if e.message !~ /should have transitioned/
+                  raise Errors::ServerNotDestroyed
+                rescue Fog::Compute::OpenStack::NotFound
+                  # If we don't have a server anymore we should be done here just continue on
+                end
+              end
+
+              if machine.provider_config.floating_ip_pool && machine.provider_config.floating_ip == ":auto"
+                address = env[:openstack_compute].list_all_addresses.body["floating_ips"].find{|i| i["ip"] == ip}
+                if address
+                  env[:openstack_compute].release_address(address["id"])
+                end
+              end
+
+              env[:ui].info(I18n.t("vagrant_openstack.deleting_volumes"))
+              volumes.each do |compute_volume|
+                volume = env[:openstack_volume].volumes.get(compute_volume["id"])
+                if volume
+                  env[:ui].info("Deleting volume: #{volume.display_name}")
+                  begin
+                    volume.destroy
+                  rescue Excon::Errors::Error => e
+                    raise Errors::VolumeBadState, :volume => volume.display_name, :state => e.message
+                  end
+                end
+              end
+            end
+          else
+            env[:ui].info(I18n.t("vagrant_openstack.not_created"))
+          end
+
+          @app.call(env)
+        end
+      end
+    end
+  end
+end

data/lib/vagrant-openstack-plugin/action/hard_reboot_server.rb

@@ -0,0 +1,27 @@
+require "log4r"
+
+module VagrantPlugins
+  module OpenStack
+    module Action
+      # This hard reboots a running server, if there is one.
+      class HardRebootServer
+        def initialize(app, env)
+          @app    = app
+          @logger = Log4r::Logger.new("vagrant_openstack::action::hard_reboot_server")
+        end
+
+        def call(env)
+          if env[:machine].id
+            env[:ui].info(I18n.t("vagrant_openstack.hard_rebooting_server"))
+
+            # TODO: Validate the fact that we get a server back from the API.
+            server = env[:openstack_compute].servers.get(env[:machine].id)
+            server.reboot('HARD')
+          end
+
+          @app.call(env)
+        end
+      end
+    end
+  end
+end

data/lib/vagrant-openstack-plugin/action/is_created.rb

@@ -0,0 +1,16 @@
+module VagrantPlugins
+  module OpenStack
+    module Action
+      class IsCreated
+        def initialize(app, env)
+          @app = app
+        end
+
+        def call(env)
+          env[:result] = env[:machine].state.id == :active
+          @app.call(env)
+        end
+      end
+    end
+  end
+end

data/lib/vagrant-openstack-plugin/action/is_paused.rb

@@ -0,0 +1,16 @@
+module VagrantPlugins
+  module OpenStack
+    module Action
+      class IsPaused
+        def initialize(app, env)
+          @app = app
+        end
+
+        def call(env)
+          env[:result] = env[:machine].state.id == :paused
+          @app.call(env)
+        end
+      end
+    end
+  end
+end

data/lib/vagrant-openstack-plugin/action/is_snapshoting.rb

@@ -0,0 +1,24 @@
+module VagrantPlugins
+  module OpenStack
+    module Action
+      class IsSnapshoting
+        def initialize(app, env)
+          @app = app
+        end
+
+        def call(env)
+          if env[:machine].id
+            infos = env[:openstack_compute].get_server_details(env[:machine].id)
+            task = infos.body['server']['OS-EXT-STS:task_state']
+            if task == 'image_snapshot' || task == 'image_pending_upload'
+              env[:result] = true
+            else
+              env[:result] = false
+            end
+          end
+          @app.call(env)
+        end
+      end
+    end
+  end
+end

data/lib/vagrant-openstack-plugin/action/is_suspended.rb

@@ -0,0 +1,16 @@
+module VagrantPlugins
+  module OpenStack
+    module Action
+      class IsSuspended
+        def initialize(app, env)
+          @app = app
+        end
+
+        def call(env)
+          env[:result] = env[:machine].state.id == :suspended
+          @app.call(env)
+        end
+      end
+    end
+  end
+end

data/lib/vagrant-openstack-plugin/action/message_already_created.rb

@@ -0,0 +1,16 @@
+module VagrantPlugins
+module OpenStack
+    module Action
+      class MessageAlreadyCreated
+        def initialize(app, env)
+          @app = app
+        end
+
+        def call(env)
+          env[:ui].info(I18n.t("vagrant_openstack.already_created"))
+          @app.call(env)
+        end
+      end
+    end
+  end
+end

data/lib/vagrant-openstack-plugin/action/message_already_paused.rb

@@ -0,0 +1,16 @@
+module VagrantPlugins
+  module OpenStack
+    module Action
+      class MessageAlreadyPaused
+        def initialize(app, env)
+          @app = app
+        end
+
+        def call(env)
+          env[:ui].info(I18n.t("vagrant_openstack.already_paused"))
+          @app.call(env)
+        end
+      end
+    end
+  end
+end

data/lib/vagrant-openstack-plugin/action/message_already_suspended.rb

@@ -0,0 +1,16 @@
+module VagrantPlugins
+  module OpenStack
+    module Action
+      class MessageAlreadySuspended
+        def initialize(app, env)
+          @app = app
+        end
+
+        def call(env)
+          env[:ui].info(I18n.t("vagrant_openstack.already_suspended"))
+          @app.call(env)
+        end
+      end
+    end
+  end
+end

data/lib/vagrant-openstack-plugin/action/message_not_created.rb

@@ -0,0 +1,16 @@
+module VagrantPlugins
+  module OpenStack
+    module Action
+      class MessageNotCreated
+        def initialize(app, env)
+          @app = app
+        end
+
+        def call(env)
+          env[:ui].info(I18n.t("vagrant_openstack.not_created"))
+          @app.call(env)
+        end
+      end
+    end
+  end
+end

data/lib/vagrant-openstack-plugin/action/message_server_running.rb

@@ -0,0 +1,16 @@
+module VagrantPlugins
+  module OpenStack
+    module Action
+      class MessageServerRunning
+        def initialize(app, env)
+          @app = app
+        end
+
+        def call(env)
+          env[:ui].info(I18n.t("vagrant_openstack.server_running", name: env[:machine].name))
+          @app.call(env)
+        end
+      end
+    end
+  end
+end

data/lib/vagrant-openstack-plugin/action/message_snapshot_done.rb

@@ -0,0 +1,16 @@
+module VagrantPlugins
+module OpenStack
+    module Action
+      class MessageSnapshotDone
+        def initialize(app, env)
+          @app = app
+        end
+
+        def call(env)
+          env[:ui].info(I18n.t("vagrant_openstack.snapshot_done"))
+          @app.call(env)
+        end
+      end
+    end
+  end
+end

data/lib/vagrant-openstack-plugin/action/message_snapshot_in_progress.rb

@@ -0,0 +1,16 @@
+module VagrantPlugins
+module OpenStack
+    module Action
+      class MessageSnapshotInProgress
+        def initialize(app, env)
+          @app = app
+        end
+
+        def call(env)
+          env[:ui].info(I18n.t("vagrant_openstack.snapshot_in_progress"))
+          @app.call(env)
+        end
+      end
+    end
+  end
+end

data/lib/vagrant-openstack-plugin/action/message_will_not_destroy.rb

@@ -0,0 +1,16 @@
+module VagrantPlugins
+  module OpenStack
+    module Action
+      class MessageWillNotDestroy
+        def initialize(app, env)
+          @app = app
+        end
+
+        def call(env)
+          env[:ui].info(I18n.t("vagrant_openstack.will_not_destroy", name: env[:machine].name))
+          @app.call(env)
+        end
+      end
+    end
+  end
+end

data/lib/vagrant-openstack-plugin/action/pause_server.rb

@@ -0,0 +1,27 @@
+require "log4r"
+
+module VagrantPlugins
+  module OpenStack
+    module Action
+      # This pauses a running server, if there is one.
+      class PauseServer
+        def initialize(app, env)
+          @app    = app
+          @logger = Log4r::Logger.new("vagrant_openstack::action::pause_server")
+        end
+
+        def call(env)
+          if env[:machine].id
+            env[:ui].info(I18n.t("vagrant_openstack.pausing_server"))
+
+            # TODO: Validate the fact that we get a server back from the API.
+            server = env[:openstack_compute].servers.get(env[:machine].id)
+            env[:openstack_compute].pause_server(server.id)
+          end
+
+          @app.call(env)
+        end
+      end
+    end
+  end
+end

data/lib/vagrant-openstack-plugin/action/read_ssh_info.rb

@@ -0,0 +1,103 @@
+require "log4r"
+require "ipaddr"
+
+module VagrantPlugins
+  module OpenStack
+    module Action
+      # This action reads the SSH info for the machine and puts it into the
+      # `:machine_ssh_info` key in the environment.
+      class ReadSSHInfo
+        def initialize(app, env)
+          @app    = app
+          @logger = Log4r::Logger.new("vagrant_openstack::action::read_ssh_info")
+        end
+
+        def call(env)
+          env[:machine_ssh_info] = read_ssh_info(env[:openstack_compute], env[:machine], env[:floating_ip])
+
+          @app.call(env)
+        end
+
+        def read_ssh_info(openstack, machine, floating_ip)
+            id = machine.id || openstack.servers.all( :name => machine.name ).first.id rescue nil
+          return nil if id.nil?
+          server = openstack.servers.get(id)
+          if server.nil?
+            # The machine can't be found
+            @logger.info("Machine couldn't be found, assuming it got destroyed.")
+            machine.id = nil
+            return nil
+          end
+
+          config = machine.provider_config
+
+          # Print a list of the available networks
+          server.addresses.each do |network_name, network_info|
+            @logger.debug("OpenStack Network Name: #{network_name}")
+          end
+
+          if config.network
+            host = server.addresses[config.network].last['addr'] rescue nil
+          else
+            if config.address_id.to_sym == :floating_ip
+              host = floating_ip
+            else
+              host = server.addresses[config.address_id].last['addr'] rescue nil
+            end
+          end
+
+          # If host is still nil, try to find the IP address another way
+          if host.nil?
+            @logger.debug("Was unable to determine what network to use. Trying to find a valid IP to use.")
+            if server.public_ip_addresses.length > 0
+              @logger.debug("Public IP addresses available: #{server.public_ip_addresses}")
+              if floating_ip
+                if server.public_ip_addresses.include?(floating_ip)
+                  @logger.debug("Using the floating IP defined in Vagrantfile.")
+                  host = machine.floating_ip
+                else
+                  @logger.debug("The floating IP that was specified is not available to this instance.")
+                  raise Errors::FloatingIPNotValid
+                end
+              else
+                host = server.public_ip_address
+                @logger.debug("Using the first available public IP address: #{host}.")
+              end
+            elsif server.private_ip_addresses.length > 0
+              @logger.debug("Private IP addresses available: #{server.private_ip_addresses}")
+              if config.ssh_ip_family.nil?
+                host = server.private_ip_address
+                @logger.debug("Using the first available private IP address: #{host}.")
+              else
+                for ip in server.private_ip_addresses
+                  addr = IPAddr.new ip
+                  if addr.send("#{config.ssh_ip_family}?".to_sym)
+                    host = ip.to_s
+                    @logger.debug("Using the first available #{config.ssh_ip_family} IP address: #{host}.")
+                    break
+                  end
+                end
+              end
+            end
+          end
+
+          # If host got this far and is still nil/empty, raise an error or
+          # else vagrant will try connecting to localhost which will never
+          # make sense in this scenario
+          if host.nil? or host.empty?
+            @logger.debug("No valid SSH host could be found.")
+            raise Errors::SSHNoValidHost
+          end
+
+          # Read the DNS info
+          return {
+            # Usually there should only be one public IP
+            :host => host,
+            :port => 22,
+            :username => config.ssh_username
+          }
+        end
+      end
+    end
+  end
+end