vagrant-softlayer 0.1.0

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

@@ -0,0 +1,99 @@
+require "log4r"
+
+require "vagrant/util/scoped_hash_override"
+require "vagrant/util/subprocess"
+require "vagrant/util/which"
+
+module VagrantPlugins
+  module SoftLayer
+    module Action
+      # This middleware uses `rsync` to sync the folders over to the
+      # SoftLayer instance.
+      class SyncFolders
+        include Vagrant::Util::ScopedHashOverride
+
+        def initialize(app, env)
+          @app    = app
+          @logger = Log4r::Logger.new("vagrant_softlayer::action::sync_folders")
+        end
+
+        def call(env)
+          @app.call(env)
+
+          ssh_info = env[:machine].ssh_info
+
+          unless Vagrant::Util::Which.which("rsync")
+            env[:ui].warn(I18n.t("vagrant_softlayer.sync_folders.rsync_not_found", :side => "host"))
+            return
+          end
+
+          if env[:machine].communicate.execute("which rsync", :error_check => false) != 0
+            env[:ui].warn(I18n.t("vagrant_softlayer.sync_folders.rsync_not_found", :side => "guest"))
+            return
+          end
+
+          env[:machine].config.vm.synced_folders.each do |id, data|
+            data = scoped_hash_override(data, :softlayer)
+
+            # Ignore disabled shared folders
+            next if data[:disabled]
+
+            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_softlayer.sync_folders.rsync_folder",
+                                :hostpath => hostpath,
+                                :guestpath => guestpath))
+
+            # Create the host path if it doesn't exist and option flag is set
+            if data[:create]
+              begin
+                FileUtils::mkdir_p(hostpath)
+              rescue => err
+                raise Errors::MkdirError,
+                  :hostpath => hostpath,
+                  :err => err
+              end
+            end
+
+            # 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/", "--exclude", "Vagrantfile",
+              "-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-softlayer/action/update_dns.rb

@@ -0,0 +1,96 @@
+module VagrantPlugins
+  module SoftLayer
+    module Action
+      # Look for the DNS zone relative to the configured domain and,
+      # on return path, perform an API call to add or remove the A
+      # resource record for the host.
+      class UpdateDNS
+        include Util::Network
+        include Util::Warden
+
+        def initialize(app, env)
+          @app    = app
+          @logger = Log4r::Logger.new("vagrant_softlayer::action::update_dns")
+        end
+
+        def call(env)
+          @env = env
+
+          @env[:dns_zone] = setup_dns
+
+          @app.call(@env)
+
+          update_dns
+        end
+
+        def dns_id
+          id = nil
+          id_file = @env[:machine].data_dir.join("dns_id")
+          id = id_file.read.chomp.to_i if id_file.file?
+          return id
+        end
+
+        def dns_id=(value)
+          @logger.info("New machine DNS ID: #{value.inspect}")
+
+          # The file that will store the id if we have one. This allows the
+          # ID to persist across Vagrant runs.
+          id_file = @env[:machine].data_dir.join("dns_id")
+
+          if value
+            # Write the "id" file with the id given.
+            id_file.open("w+") do |f|
+              f.write(value)
+            end
+          end
+        end
+
+        def setup_dns
+          unless @env[:machine].provider_config.manage_dns
+            @logger.debug("Not managing DNS. Going ahead.")
+            return
+          end
+
+          dns_zone = ::SoftLayer::Service.new("SoftLayer_Dns_Domain", @env[:sl_credentials])
+
+          domain = @env[:machine].provider_config.domain
+          @logger.debug("Looking for #{domain} zone into the SoftLayer zone list.")
+          dns_zone_obj = sl_warden { dns_zone.getByDomainName(domain).first }
+          raise Errors::SLDNSZoneNotFound, :zone => domain unless dns_zone_obj
+          @logger.debug("Found DNS zone: #{dns_zone_obj.inspect}")
+          return dns_zone_obj
+        end
+
+        def update_dns
+          unless @env[:machine].provider_config.manage_dns
+            @logger.debug("Not managing DNS. Going ahead.")
+            return
+          end
+
+          dns_resource = ::SoftLayer::Service.new("SoftLayer_Dns_Domain_ResourceRecord", @env[:sl_credentials])
+
+          case @env[:action_name]
+          when :machine_action_up
+            hostname          = @env[:machine].provider_config.hostname || @env[:machine].config.vm.hostname
+            @env[:sl_machine] = @env[:sl_connection].object_with_id(@env[:machine].id.to_i)
+            res_template      = {
+              "data"     => ip_address(@env),
+              "domainId" => @env[:dns_zone]["id"],
+              "host"     => hostname,
+              "ttl"      => 86400,
+              "type"     => "a"
+            }
+            @env[:ui].info I18n.t("vagrant_softlayer.vm.creating_dns_record")
+            @logger.debug("Creating DNS A record for #{hostname}.#{@env[:dns_zone][:name]} (IP address #{res_template['data']}).")
+            new_rr = sl_warden { dns_resource.createObject(res_template) }
+            self.dns_id = new_rr["id"]
+          when :machine_action_destroy
+            @env[:ui].info I18n.t("vagrant_softlayer.vm.deleting_dns_record")
+            @logger.debug("Deleting stored DNS A record (ID #{self.dns_id}).")
+            sl_warden { dns_resource.object_with_id(self.dns_id).deleteObject }
+          end
+        end
+      end
+    end
+  end
+end

data/lib/vagrant-softlayer/action/wait_for_provision.rb

@@ -0,0 +1,40 @@
+require "log4r"
+
+module VagrantPlugins
+  module SoftLayer
+    module Action
+      # Waits until the new machine has been provisioned.
+      class WaitForProvision
+        include Util::Warden
+
+        def initialize(app, env)
+          @app    = app
+          @logger = Log4r::Logger.new("vagrant_softlayer::action::wait_for_provision")
+        end
+
+        def call(env)
+          env[:ui].info I18n.t("vagrant_softlayer.vm.wait_for_provision")
+
+          env[:sl_machine] = env[:sl_connection].object_with_id(env[:machine].id.to_i)
+
+          retry_msg = lambda { @logger.debug("Object not found, retrying in 10 seconds.") }
+
+          # 20 minutes timeout
+          Timeout::timeout(1200) do
+            @logger.debug("Checking if the newly ordered machine has been provisioned.")
+            sl_warden(retry_msg, 10) do
+              while env[:sl_machine].getPowerState["name"] != "Running" || env[:sl_machine].object_mask( { "provisionDate" => "" } ).getObject == {}
+                @logger.debug("The machine is still provisioning. Retrying in 10 seconds.")
+                sleep 10
+              end
+            end
+          end
+
+          env[:ui].info I18n.t("vagrant_softlayer.vm.provisioned")
+          
+          @app.call(env)
+        end
+      end
+    end
+  end
+end

data/lib/vagrant-softlayer/action/wait_for_rebuild.rb

@@ -0,0 +1,36 @@
+require "log4r"
+
+module VagrantPlugins
+  module SoftLayer
+    module Action
+      # Waits until the new machine has been rebuilt.
+      class WaitForRebuild
+        include Util::Warden
+
+        def initialize(app, env)
+          @app    = app
+          @logger = Log4r::Logger.new("vagrant_softlayer::action::wait_for_rebuild")
+        end
+
+        def call(env)
+          env[:ui].info I18n.t("vagrant_softlayer.vm.wait_for_rebuild")
+
+          # 20 minutes timeout
+          Timeout::timeout(1200) do
+            @logger.debug("Checking if the instance has been rebuilt.")
+            sl_warden do
+              while env[:sl_machine].object_mask("activeTransactionCount").getObject["activeTransactionCount"] > 0
+                @logger.debug("The machine is still being rebuilt. Retrying in 10 seconds.")
+                sleep 10
+              end
+            end
+          end
+
+          env[:ui].info I18n.t("vagrant_softlayer.vm.rebuilt")
+          
+          @app.call(env)
+        end
+      end
+    end
+  end
+end

data/lib/vagrant-softlayer/action.rb

@@ -0,0 +1,200 @@
+require "pathname"
+require "vagrant-softlayer/util/network"
+require "vagrant-softlayer/util/warden"
+
+module VagrantPlugins
+  module SoftLayer
+    module Action
+      # Include the built-in modules so we can use them as top-level things.
+      include Vagrant::Action::Builtin
+
+      # This action is called to terminate the remote machine.
+      def self.action_destroy
+        Vagrant::Action::Builder.new.tap do |b|
+          b.use Call, DestroyConfirm do |env, b2|
+            if env[:result]
+              b2.use ConfigValidate
+              b.use Call, Is, :not_created do |env2, b3|
+                if env2[:result]
+                  b3.use Message, :error, "vagrant_softlayer.vm.not_created"
+                  next
+                end
+              end
+              b2.use SetupSoftLayer
+              b2.use DestroyInstance
+              b2.use UpdateDNS
+            else
+              b2.use Message, :warn, "vagrant_softlayer.vm.not_destroying"
+            end
+          end
+        end
+      end
+
+      # This action is called to halt the remote machine.
+      def self.action_halt
+        Vagrant::Action::Builder.new.tap do |b|
+          b.use ConfigValidate
+          b.use Call, Is, :running do |env, b2|
+            if !env[:result]
+              b2.use Message, :error, "vagrant_softlayer.vm.not_running"
+              next
+            end
+
+            b2.use SetupSoftLayer
+            b2.use StopInstance
+          end
+        end
+      end
+
+      # This action is called to run provisioners on the machine.
+      def self.action_provision
+        Vagrant::Action::Builder.new.tap do |b|
+          b.use ConfigValidate
+          b.use Call, Is, :running do |env, b2|
+            if !env[:result]
+              b2.use Message, :error, "vagrant_softlayer.vm.not_running"
+              next
+            end
+
+            b2.use Provision
+            b2.use SyncFolders
+          end
+        end
+      end
+
+      # This action is called to read the SSH info of the machine. The
+      # resulting state is expected to be put into the `:machine_ssh_info`
+      # key.
+      def self.action_read_ssh_info
+        Vagrant::Action::Builder.new.tap do |b|
+          b.use ConfigValidate
+          b.use SetupSoftLayer
+          b.use ReadSSHInfo
+        end
+      end
+
+      # This action is called to read the state of the machine. The
+      # resulting state is expected to be put into the `:machine_state_id`
+      # key.
+      def self.action_read_state
+        Vagrant::Action::Builder.new.tap do |b|
+          b.use ConfigValidate
+          b.use SetupSoftLayer
+          b.use ReadState
+        end
+      end
+
+      # This action is called to rebuild the machine OS from scratch.
+      def self.action_rebuild
+        Vagrant::Action::Builder.new.tap do |b|
+          b.use Call, Confirm, I18n.t("vagrant_softlayer.vm.rebuild_confirmation"), :force_rebuild do |env, b2|
+            if env[:result]
+              b2.use ConfigValidate
+              b.use Call, Is, :not_created do |env2, b3|
+                if env2[:result]
+                  b3.use Message, :error, "vagrant_softlayer.vm.not_created"
+                  next
+                end
+              end
+              b2.use SetupSoftLayer
+              b2.use RebuildInstance
+              b2.use Provision
+              b2.use SyncFolders
+              b2.use WaitForRebuild
+              b2.use WaitForCommunicator
+            else
+              b2.use Message, :warn, "vagrant_softlayer.vm.not_rebuilding"
+            end
+          end
+        end
+      end
+
+      # This action is called to reload the machine.
+      def self.action_reload
+        Vagrant::Action::Builder.new.tap do |b|
+          b.use action_halt
+          b.use action_up
+        end
+      end
+
+      # This action is called to SSH into the machine.
+      def self.action_ssh
+        Vagrant::Action::Builder.new.tap do |b|
+          b.use ConfigValidate
+          b.use Call, Is, :running do |env, b2|
+            if !env[:result]
+              b2.use Message, :error, "vagrant_softlayer.vm.not_running"
+              next
+            end
+
+            b2.use SSHExec
+          end
+        end
+      end
+
+      def self.action_ssh_run
+        Vagrant::Action::Builder.new.tap do |b|
+          b.use ConfigValidate
+          b.use Call, Is, :running do |env, b2|
+            if !env[:result]
+              b2.use Message, :error, "vagrant_softlayer.vm.not_running"
+              next
+            end
+
+            b2.use SSHRun
+          end
+        end
+      end
+
+      # This action is called to bring the box up from nothing.
+      def self.action_up
+        Vagrant::Action::Builder.new.tap do |b|
+          b.use HandleBoxUrl
+          b.use ConfigValidate
+          b.use SetupSoftLayer
+          b.use Call, Is, :not_created do |env1, b1|
+            if env1[:result]
+              b1.use SetupSoftLayer
+              b1.use Provision
+              b1.use SyncFolders
+              b1.use UpdateDNS
+              b1.use CreateInstance
+              b1.use WaitForProvision
+              b1.use WaitForCommunicator
+            else
+              b1.use Call, Is, :halted do |env2, b2|
+                if env2[:result]
+                  b2.use SetupSoftLayer
+                  b2.use Provision
+                  b2.use SyncFolders
+                  b2.use StartInstance
+                  b2.use WaitForCommunicator
+                else
+                  b2.use Message, :warn, "vagrant_softlayer.vm.already_running"
+                end
+              end
+            end
+          end
+        end
+      end
+
+      # The autoload farm
+      action_root = Pathname.new(File.expand_path("../action", __FILE__))
+
+      autoload :CreateInstance,   action_root.join("create_instance")
+      autoload :DestroyInstance,  action_root.join("destroy_instance")
+      autoload :Is,               action_root.join("is")
+      autoload :Message,          action_root.join("message")
+      autoload :ReadSSHInfo,      action_root.join("read_ssh_info")
+      autoload :ReadState,        action_root.join("read_state")
+      autoload :RebuildInstance,  action_root.join("rebuild_instance")
+      autoload :SetupSoftLayer,   action_root.join("setup_softlayer")
+      autoload :StartInstance,    action_root.join("start_instance")
+      autoload :StopInstance,     action_root.join("stop_instance")
+      autoload :SyncFolders,      action_root.join("sync_folders")
+      autoload :UpdateDNS,        action_root.join("update_dns")
+      autoload :WaitForProvision, action_root.join("wait_for_provision")
+      autoload :WaitForRebuild,   action_root.join("wait_for_rebuild")
+    end
+  end
+end

data/lib/vagrant-softlayer/command/rebuild.rb

@@ -0,0 +1,34 @@
+require 'optparse'
+
+module VagrantPlugins
+  module SoftLayer
+    module Command
+      class Rebuild < Vagrant.plugin('2', :command)
+        def execute
+          options = {}
+          options[:force] = false
+
+          opts = OptionParser.new do |o|
+            o.banner = "Usage: vagrant rebuild [vm-name]"
+            o.separator ""
+
+            o.on("-f", "--force", "Rebuild without confirmation.") do |f|
+              options[:force] = f
+            end
+          end
+
+          argv = parse_options(opts)
+          return if !argv
+
+          declined = false
+          with_target_vms(argv) do |vm|
+            action_env = vm.action(:rebuild, :force_rebuild => options[:force], :provision_ignore_sentinel => false)
+            declined = true if action_env.has_key?(:force_rebuild_result) && action_env[:force_rebuild_result] == false
+          end
+
+          declined ? 1 : 0
+        end
+      end
+    end
+  end
+end

data/lib/vagrant-softlayer/config.rb

@@ -0,0 +1,178 @@
+module VagrantPlugins
+  module SoftLayer
+    class Config < Vagrant.plugin("2", :config)
+      # The API key to access SoftLayer.
+      attr_accessor :api_key
+
+      # The endpoint SoftLayer API url.
+      attr_accessor :endpoint_url
+
+      # The username to access SoftLayer.
+      attr_accessor :username
+
+      # The datacenter shortname.
+      attr_accessor :datacenter
+
+      # Whether to allocate a dedicated instance.
+      attr_accessor :dedicated
+
+      # The domain of the instance.
+      attr_accessor :domain
+
+      # The hostname of the instance.
+      attr_accessor :hostname
+
+      # The billing type of the instance (true for hourly, false for monthly).
+      attr_accessor :hourly_billing
+
+      # The disk type of the instance (true for local, false for SAN).
+      attr_accessor :local_disk
+
+      # The amount of RAM of the instance.
+      attr_accessor :max_memory
+
+      # Network port speed in Mbps.
+      attr_accessor :network_speed
+
+      # The instance operating system identifier.
+      attr_accessor :operating_system
+
+      # URI of post-install script to download.
+      attr_accessor :post_install
+
+      # Whether or not the instance only has access to the private network.
+      attr_accessor :private_only
+
+      # The id or name of the ssh key to be provisioned.
+      attr_accessor :ssh_key
+
+      # The number of processors of the instance.
+      attr_accessor :start_cpus
+
+      # User defined metadata string.
+      attr_accessor :user_data
+
+      # The ID of the private VLAN.
+      attr_accessor :vlan_private
+
+      # The ID of the public VLAN.
+      attr_accessor :vlan_public
+
+      # Automatically update DNS on create and destroy.
+      attr_accessor :manage_dns
+
+      def initialize
+        @api_key      = UNSET_VALUE
+        @endpoint_url = UNSET_VALUE
+        @username     = UNSET_VALUE
+
+        @datacenter       = UNSET_VALUE
+        @dedicated        = UNSET_VALUE
+        @domain           = UNSET_VALUE
+        @hostname         = UNSET_VALUE
+        @hourly_billing   = UNSET_VALUE
+        @local_disk       = UNSET_VALUE
+        @max_memory       = UNSET_VALUE
+        @network_speed    = UNSET_VALUE
+        @operating_system = UNSET_VALUE
+        @post_install     = UNSET_VALUE
+        @private_only     = UNSET_VALUE
+        @ssh_key          = UNSET_VALUE
+        @start_cpus       = UNSET_VALUE
+        @user_data        = UNSET_VALUE
+        @vlan_private     = UNSET_VALUE
+        @vlan_public      = UNSET_VALUE
+
+        @manage_dns = UNSET_VALUE
+      end
+
+      def finalize!
+        # Try to get username and api key from environment variables.
+        # They will default to nil if the environment variables are not present.
+        @api_key  = ENV["SL_API_KEY"] if @api_key == UNSET_VALUE
+        @username = ENV["SL_USERNAME"] if @username == UNSET_VALUE
+
+        # Endpoint url defaults to public SoftLayer API url.
+        @endpoint_url = API_PUBLIC_ENDPOINT if @endpoint_url == UNSET_VALUE
+
+        # No default datacenter.
+        @datacenter = nil if @datacenter == UNSET_VALUE
+
+        # Shared instance by default.
+        @dedicated = false if @dedicated == UNSET_VALUE
+
+        # Domain should be specified in Vagrantfile, so we set default to nil.
+        @domain = nil if @domain == UNSET_VALUE
+
+        # Hostname should be specified in Vagrantfile, either using `config.vm.hostname`
+        # or the provider specific configuration entry.
+        @hostname = nil if @hostname == UNSET_VALUE
+
+        # Bill hourly by default.
+        @hourly_billing = true if @hourly_billing == UNSET_VALUE
+
+        # Use local disk by default.
+        @local_disk = true if @local_disk == UNSET_VALUE
+
+        # 1Gb of RAM by default.
+        @max_memory = 1024 if @max_memory == UNSET_VALUE
+
+        # 10Mbps by default.
+        @network_speed = 10 if @network_speed == UNSET_VALUE
+
+        # Provision with the latest Ubuntu by default.
+        @operating_system = "UBUNTU_LATEST" if @operating_system == UNSET_VALUE
+
+        # No post install script by default.
+        @post_install = nil if @post_install == UNSET_VALUE
+
+        # Private-network only is false by default.
+        @private_only = false if @private_only == UNSET_VALUE
+
+        # SSH key should be specified in Vagrantfile, so we set default to nil.
+        @ssh_key = nil if @ssh_key == UNSET_VALUE
+
+        # One processor by default.
+        @start_cpus = 1 if @start_cpus == UNSET_VALUE
+
+        # No user metadata by default.
+        @user_data = nil if @user_data == UNSET_VALUE
+
+        # No specific private VLAN by default.
+        @vlan_private = nil if @vlan_private == UNSET_VALUE
+
+        # No specific public VLAN by default.
+        @vlan_public = nil if @vlan_public == UNSET_VALUE
+
+        # DNS management off by default
+        @manage_dns = false if @manage_dns == UNSET_VALUE
+      end
+
+      # Aliases for ssh_key for beautiful semantic
+      def ssh_keys=(value)
+        @ssh_key = value
+      end
+      alias_method :ssh_key_id=, :ssh_keys=
+      alias_method :ssh_key_ids=, :ssh_keys=
+      alias_method :ssh_key_name=, :ssh_keys=
+      alias_method :ssh_key_names=, :ssh_keys=
+
+      def validate(machine)
+        errors = []
+
+        errors << I18n.t("vagrant_softlayer.config.api_key_required") if !@api_key
+        errors << I18n.t("vagrant_softlayer.config.username_required") if !@username
+
+        errors << I18n.t("vagrant_softlayer.config.domain_required") if !@domain
+        errors << I18n.t("vagrant_softlayer.config.ssh_key_required") if !@ssh_key
+
+        #  Fail if both `vm.hostname` and `provider.hostname` are nil.
+        if !@hostname && !machine.config.vm.hostname
+          errors << I18n.t("vagrant_softlayer.config.hostname_required")
+        end
+
+        { "SoftLayer" => errors }
+      end
+    end
+  end
+end