vagrant-cloudstack 0.0.5

data/lib/vagrant-cloudstack/action/connect_cloudstack.rb

@@ -0,0 +1,47 @@
+require "fog"
+require "log4r"
+
+module VagrantPlugins
+  module Cloudstack
+    module Action
+      # This action connects to Cloudstack, verifies credentials work, and
+      # puts the Cloudstack connection object into the
+      # `:cloudstack_compute` key in the environment.
+      class ConnectCloudstack
+        def initialize(app, env)
+          @app    = app
+          @logger = Log4r::Logger.new("vagrant_cloudstack::action::connect_cloudstack")
+        end
+
+        def call(env)
+          # Get the domain we're going to booting up in
+          domain = env[:machine].provider_config.domain
+
+          # Get the configs
+          domain_config = env[:machine].provider_config.get_domain_config(domain)
+
+          # Build the fog config
+          fog_config = {
+            :provider      => :cloudstack
+            #:domain        => domain_config
+          }
+
+          if domain_config.api_key
+            fog_config[:cloudstack_api_key] = domain_config.api_key
+            fog_config[:cloudstack_secret_access_key] = domain_config.secret_key
+          end
+
+          fog_config[:cloudstack_host] = domain_config.host if domain_config.host
+          fog_config[:cloudstack_path] = domain_config.path if domain_config.path
+          fog_config[:cloudstack_port] = domain_config.port if domain_config.port
+          fog_config[:cloudstack_scheme] = domain_config.scheme if domain_config.scheme
+
+          @logger.info("Connecting to Cloudstack...")
+          env[:cloudstack_compute] = Fog::Compute.new(fog_config)
+
+          @app.call(env)
+        end
+      end
+    end
+  end
+end

data/lib/vagrant-cloudstack/action/is_created.rb

@@ -0,0 +1,18 @@
+module VagrantPlugins
+  module Cloudstack
+    module Action
+      # This can be used with "Call" built-in to check if the machine
+      # is created and branch in the middleware.
+      class IsCreated
+        def initialize(app, env)
+          @app = app
+        end
+
+        def call(env)
+          env[:result] = env[:machine].state.id != :not_created
+          @app.call(env)
+        end
+      end
+    end
+  end
+end

data/lib/vagrant-cloudstack/action/message_already_created.rb

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

data/lib/vagrant-cloudstack/action/message_not_created.rb

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

data/lib/vagrant-cloudstack/action/read_ssh_info.rb

@@ -0,0 +1,41 @@
+require "log4r"
+
+module VagrantPlugins
+  module Cloudstack
+    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_cloudstack::action::read_ssh_info")
+        end
+
+        def call(env)
+          env[:machine_ssh_info] = read_ssh_info(env[:cloudstack_compute], env[:machine])
+
+          @app.call(env)
+        end
+
+        def read_ssh_info(cloudstack, machine)
+          return nil if machine.id.nil?
+
+          # Find the machine
+          server = cloudstack.servers.get(machine.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
+
+          # Read the DNS info
+          return {
+            :host => server.nics[0]['ipaddress'],
+            :port => 22
+          }
+        end
+      end
+    end
+  end
+end

data/lib/vagrant-cloudstack/action/read_state.rb

@@ -0,0 +1,38 @@
+require "log4r"
+
+module VagrantPlugins
+  module Cloudstack
+    module Action
+      # This action reads the state of the machine and puts it in the
+      # `:machine_state_id` key in the environment.
+      class ReadState
+        def initialize(app, env)
+          @app    = app
+          @logger = Log4r::Logger.new("vagrant_cloudstack::action::read_state")
+        end
+
+        def call(env)
+          env[:machine_state_id] = read_state(env[:cloudstack_compute], env[:machine])
+
+          @app.call(env)
+        end
+
+        def read_state(cloudstack, machine)
+          return :not_created if machine.id.nil?
+
+          # Find the machine
+          server = cloudstack.servers.get(machine.id)
+          if server.nil? || [:"shutting-down", :terminated].include?(server.state.to_sym)
+            # The machine can't be found
+            @logger.info("Machine not found or terminated, assuming it got destroyed.")
+            machine.id = nil
+            return :not_created
+          end
+
+          # Return the state
+          return server.state.to_sym
+        end
+      end
+    end
+  end
+end

data/lib/vagrant-cloudstack/action/run_instance.rb

@@ -0,0 +1,148 @@
+require "log4r"
+require 'pp'   # XXX FIXME REMOVE WHEN NOT NEEDED
+
+require 'vagrant/util/retryable'
+
+require 'vagrant-cloudstack/util/timer'
+
+module VagrantPlugins
+  module Cloudstack
+    module Action
+      # This runs the configured instance.
+      class RunInstance
+        include Vagrant::Util::Retryable
+
+        def initialize(app, env)
+          @app    = app
+          @logger = Log4r::Logger.new("vagrant_cloudstack::action::run_instance")
+        end
+
+        def call(env)
+          # Initialize metrics if they haven't been
+          env[:metrics] ||= {}
+
+          # Get the domain we're going to booting up in
+          domain = env[:machine].provider_config.domain
+
+          # Get the configs
+          domain_config       = env[:machine].provider_config.get_domain_config(domain)
+          zone_id             = domain_config.zone_id
+          network_id          = domain_config.network_id
+          project_id          = domain_config.project_id
+          service_offering_id = domain_config.service_offering_id
+          template_id         = domain_config.template_id
+
+          # Launch!
+          env[:ui].info(I18n.t("vagrant_cloudstack.launching_instance"))
+          env[:ui].info(" -- Service offering UUID: #{service_offering_id}")
+          env[:ui].info(" -- Template UUID: #{template_id}")
+          env[:ui].info(" -- Project UUID: #{project_id}") if project_id != nil
+          env[:ui].info(" -- Zone UUID: #{zone_id}")
+          env[:ui].info(" -- Network UUID: #{network_id}") if network_id
+
+          local_user = ENV['USER'].dup
+          local_user.gsub!(/[^-a-z0-9_]/i, "")
+          prefix = env[:root_path].basename.to_s
+          prefix.gsub!(/[^-a-z0-9_]/i, "")
+          display_name = local_user + "_" + prefix + "_#{Time.now.to_i}"
+
+          begin
+            options = {
+              :display_name       => display_name,
+              :zone_id            => zone_id,
+              :flavor_id          => service_offering_id,
+              :image_id           => template_id,
+              :network_ids        => [network_id]
+            }
+
+            options['project_id'] = project_id if project_id != nil
+
+            server = env[:cloudstack_compute].servers.create(options)
+          rescue Fog::Compute::Cloudstack::NotFound => e
+            # Invalid subnet doesn't have its own error so we catch and
+            # check the error message here.
+            # XXX FIXME vpc?
+            if e.message =~ /subnet ID/
+              raise Errors::FogError,
+                :message => "Subnet ID not found: #{network_id}"
+            end
+
+            raise
+          rescue Fog::Compute::Cloudstack::Error => e
+            raise Errors::FogError, :message => e.message
+          end
+
+          # Immediately save the ID since it is created at this point.
+          # XXX FIXME does cloudstack+fog return the job id rather than
+          # server id?
+          env[:machine].id = server.id
+
+          # Wait for the instance to be ready first
+          env[:metrics]["instance_ready_time"] = Util::Timer.time do
+            tries = domain_config.instance_ready_timeout / 2
+
+            env[:ui].info(I18n.t("vagrant_cloudstack.waiting_for_ready"))
+            begin
+              retryable(:on => Fog::Errors::TimeoutError, :tries => tries) do
+                # If we're interrupted don't worry about waiting
+                next if env[:interrupted]
+
+                # Wait for the server to be ready
+                server.wait_for(2) { ready? }
+              end
+            rescue Fog::Errors::TimeoutError
+              # Delete the instance
+              terminate(env)
+
+              # Notify the user
+              raise Errors::InstanceReadyTimeout,
+                timeout: domain_config.instance_ready_timeout
+            end
+          end
+
+          @logger.info("Time to instance ready: #{env[:metrics]["instance_ready_time"]}")
+
+          if !env[:interrupted]
+            env[:metrics]["instance_ssh_time"] = Util::Timer.time do
+              # Wait for SSH to be ready.
+              env[:ui].info(I18n.t("vagrant_cloudstack.waiting_for_ssh"))
+              while true
+                # If we're interrupted then just back out
+                break if env[:interrupted]
+                break if env[:machine].communicate.ready?
+                sleep 2
+              end
+            end
+
+            @logger.info("Time for SSH ready: #{env[:metrics]["instance_ssh_time"]}")
+
+            # Ready and booted!
+            env[:ui].info(I18n.t("vagrant_cloudstack.ready"))
+          end
+
+          # Terminate the instance if we were interrupted
+          terminate(env) if env[:interrupted]
+
+          @app.call(env)
+        end
+
+        def recover(env)
+          return if env["vagrant.error"].is_a?(Vagrant::Errors::VagrantError)
+
+          if env[:machine].provider.state.id != :not_created
+            # Undo the import
+            terminate(env)
+          end
+        end
+
+        def terminate(env)
+          destroy_env = env.dup
+          destroy_env.delete(:interrupted)
+          destroy_env[:config_validate] = false
+          destroy_env[:force_confirm_destroy] = true
+          env[:action_runner].run(Action.action_destroy, destroy_env)
+        end
+      end
+    end
+  end
+end

data/lib/vagrant-cloudstack/action/sync_folders.rb

@@ -0,0 +1,85 @@
+require "log4r"
+
+require "vagrant/util/subprocess"
+
+require "vagrant/util/scoped_hash_override"
+
+require "vagrant/util/which"
+
+module VagrantPlugins
+  module Cloudstack
+    module Action
+      # This middleware uses `rsync` to sync the folders over to the
+      # Cloudstack instance.
+      class SyncFolders
+        include Vagrant::Util::ScopedHashOverride
+
+        def initialize(app, env)
+          @app    = app
+          @logger = Log4r::Logger.new("vagrant_cloudstack::action::sync_folders")
+        end
+
+        def call(env)
+          @app.call(env)
+
+          ssh_info = env[:machine].ssh_info
+
+          env[:machine].config.vm.synced_folders.each do |id, data|
+            data = scoped_hash_override(data, :cloudstack)
+
+            # Ignore disabled shared folders
+            next if data[:disabled]
+
+            unless Vagrant::Util::Which.which('rsync')
+              env[:ui].warn(I18n.t('vagrant_cloudstack.rsync_not_found_warning'))
+              break
+            end
+
+            hostpath  = File.expand_path(data[:hostpath], env[:root_path])
+            guestpath = data[:guestpath]
+
+            # Make sure there is a trailing slash on the host path to
+            # avoid creating an additional directory with rsync
+            hostpath = "#{hostpath}/" if hostpath !~ /\/$/
+
+            # on windows rsync.exe requires cygdrive-style paths
+            if Vagrant::Util::Platform.windows?
+              hostpath = hostpath.gsub(/^(\w):/) { "/cygdrive/#{$1}" }
+            end
+
+            env[:ui].info(I18n.t("vagrant_cloudstack.rsync_folder",
+                                :hostpath => hostpath,
+                                :guestpath => guestpath))
+
+            # Create the guest path
+            env[:machine].communicate.sudo("mkdir -p '#{guestpath}'")
+            env[:machine].communicate.sudo(
+              "chown #{ssh_info[:username]} '#{guestpath}'")
+
+            # Rsync over to the guest path using the SSH info
+            command = [
+              "rsync", "--verbose", "--archive", "-z",
+              "--exclude", ".vagrant/",
+              "-e", "ssh -p #{ssh_info[:port]} -o StrictHostKeyChecking=no -i '#{ssh_info[:private_key_path]}'",
+              hostpath,
+              "#{ssh_info[:username]}@#{ssh_info[:host]}:#{guestpath}"]
+
+            # we need to fix permissions when using rsync.exe on windows, see
+            # http://stackoverflow.com/questions/5798807/rsync-permission-denied-created-directories-have-no-permissions
+            if Vagrant::Util::Platform.windows?
+              command.insert(1, "--chmod", "ugo=rwX")
+            end
+
+            r = Vagrant::Util::Subprocess.execute(*command)
+            if r.exit_code != 0
+              raise Errors::RsyncError,
+                :guestpath => guestpath,
+                :hostpath => hostpath,
+                :stderr => r.stderr
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/vagrant-cloudstack/action/terminate_instance.rb

@@ -0,0 +1,26 @@
+require "log4r"
+
+module VagrantPlugins
+  module Cloudstack
+    module Action
+      # This terminates the running instance.
+      class TerminateInstance
+        def initialize(app, env)
+          @app    = app
+          @logger = Log4r::Logger.new("vagrant_cloudstack::action::terminate_instance")
+        end
+
+        def call(env)
+          server = env[:cloudstack_compute].servers.get(env[:machine].id)
+
+          # Destroy the server and remove the tracking ID
+          env[:ui].info(I18n.t("vagrant_cloudstack.terminating"))
+          server.destroy
+          env[:machine].id = nil
+
+          @app.call(env)
+        end
+      end
+    end
+  end
+end