vagrant-softlayer 0.1.0

data/lib/vagrant-softlayer/errors.rb

@@ -0,0 +1,25 @@
+module VagrantPlugins
+  module SoftLayer
+    module Errors
+      class VagrantSoftLayerError < Vagrant::Errors::VagrantError
+        error_namespace("vagrant_softlayer.errors")
+      end
+
+      class SLApiError < VagrantSoftLayerError
+        error_key(:api_error)
+      end
+
+      class SLCertificateError < VagrantSoftLayerError
+        error_key(:certificate_error)
+      end
+
+      class SLDNSZoneNotFound < VagrantSoftLayerError
+        error_key(:dns_zone_not_found)
+      end
+
+      class SLSshKeyNotFound < VagrantSoftLayerError
+        error_key(:ssh_key_not_found)
+      end
+    end
+  end
+end

data/lib/vagrant-softlayer/plugin.rb

@@ -0,0 +1,77 @@
+begin
+  require "vagrant"
+rescue LoadError
+  raise "The Vagrant SoftLayer plugin must be run within Vagrant."
+end
+
+# This is a sanity check to make sure no one is attempting to install
+# this into an early Vagrant version.
+if Vagrant::VERSION < "1.3.0"
+  raise "The Vagrant SoftLayer plugin is only compatible with Vagrant 1.3+"
+end
+
+module VagrantPlugins
+  module SoftLayer
+    class Plugin < Vagrant.plugin("2")
+      name "SoftLayer"
+      description <<-DESC
+      This plugin installs a provider that allows Vagrant to manage
+      SoftLayer CCI.
+      DESC
+
+      command(:rebuild) do
+        require_relative 'command/rebuild'
+        Command::Rebuild
+      end
+
+      config(:softlayer, :provider) do
+        require_relative "config"
+        Config
+      end
+
+      provider(:softlayer) do
+        init_logging
+        init_i18n
+
+        require_relative "provider"
+        Provider
+      end
+
+      # This initializes the I18n load path so that the plugin specific
+      # transations work.
+      def self.init_i18n
+        I18n.load_path << File.expand_path("locales/en.yml", SoftLayer.source_root)
+        I18n.reload!
+      end
+
+      # This sets up our log level to be whatever VAGRANT_LOG is.
+      def self.init_logging
+        require "log4r"
+
+        level = nil
+        begin
+          level = Log4r.const_get(ENV["VAGRANT_LOG"].upcase)
+        rescue NameError
+          # This means that the logging constant wasn't found,
+          # which is fine. We just keep `level` as `nil`. But
+          # we tell the user.
+          level = nil
+        end
+
+        # Some constants, such as "true" resolve to booleans, so the
+        # above error checking doesn't catch it. This will check to make
+        # sure that the log level is an integer, as Log4r requires.
+        level = nil if !level.is_a?(Integer)
+
+        # Set the logging level on all "vagrant" namespaced
+        # logs as long as we have a valid level.
+        if level
+          logger = Log4r::Logger.new("vagrant_softlayer")
+          logger.outputters = Log4r::Outputter.stderr
+          logger.level = level
+          logger = nil
+        end
+      end
+    end
+  end
+end

data/lib/vagrant-softlayer/provider.rb

@@ -0,0 +1,47 @@
+module VagrantPlugins
+  module SoftLayer
+    class Provider < Vagrant.plugin("2", :provider)
+      def initialize(machine)
+        @machine = machine
+      end
+
+      def action(name)
+        # Attempt to get the action method from the Action class if it
+        # exists, otherwise return nil to show that we don't support the
+        # given action.
+        action_method = "action_#{name}"
+        return Action.send(action_method) if Action.respond_to?(action_method)
+        nil
+      end
+
+      def ssh_info
+        # Run a custom action called "read_ssh_info" which does what it
+        # says and puts the resulting SSH info into the `:machine_ssh_info`
+        # key in the environment.
+        env = @machine.action("read_ssh_info")
+        env[:machine_ssh_info]
+      end
+
+      def 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")
+
+        state_id = env[:machine_state_id]
+
+        # Get the short and long description
+        short = I18n.t("vagrant_softlayer.states.short_#{state_id}")
+        long  = I18n.t("vagrant_softlayer.states.long_#{state_id}")
+
+        # Return the MachineState object
+        Vagrant::MachineState.new(state_id, short, long)
+      end
+
+      def to_s
+        id = @machine.id || "new VM"
+        "SoftLayer (#{id})"
+      end
+    end
+  end
+end

data/lib/vagrant-softlayer/util/network.rb

@@ -0,0 +1,42 @@
+module VagrantPlugins
+  module SoftLayer
+    module Util
+      module Network
+        # Gets instance's IP address.
+        #
+        # Returns the private IP address if the instance has been
+        # defined as private only, the public IP address otherwise.
+        def ip_address(env)
+          service = env[:machine].provider_config.private_only ? :getPrimaryBackendIpAddress : :getPrimaryIpAddress
+          return sl_warden { env[:sl_machine].send(service) }
+        end
+
+        # Returns SSH keys starting from the configuration parameter.
+        #
+        # In the configuration, each key could be passed either as an
+        # id or as a label. The routine will detect this and lookup
+        # the id if needed.
+        #
+        # The first parameter is the current environment.
+        #
+        # The second parameter is useful for returning: if it is set
+        # the routine will return just the array of ids (this is needed,
+        # as an example, for reloading OS), otherwise an hash is
+        # returned (this latter case is needed instead for creating
+        # an instance).
+        def ssh_keys(env, ids_only = false)
+          account  = ::SoftLayer::Service.new("SoftLayer_Account", env[:sl_credentials])
+          acc_keys = sl_warden { account.object_mask("id", "label").getSshKeys }
+          key_ids  = []
+          Array(env[:machine].provider_config.ssh_key).each do |key|
+            pattern = key.is_a?(String) ? "label" : "id"
+            key_hash = acc_keys.find { |acc_key| acc_key[pattern] == key }
+            raise Errors::SLSshKeyNotFound, :key => key unless key_hash
+            key_ids << key_hash["id"]
+          end
+          return (ids_only ? key_ids : key_ids.map { |key_id| { :id => key_id } })
+        end
+      end
+    end
+  end
+end

data/lib/vagrant-softlayer/util/warden.rb

@@ -0,0 +1,38 @@
+module VagrantPlugins
+  module SoftLayer
+    module Util
+      module Warden
+        # Handles gracefully SoftLayer API calls.
+        #
+        # The block code is executed, catching both common
+        # connection errors and API exceptions.
+        #
+        # Optionally, in the not-so-uncommon case when
+        # the object (e.g. the SoftLayer instance) is not
+        # found, executes a proc and/or retry the API call
+        # after some seconds.
+        #
+        # A future version of the method will add a retry timeout.
+        def sl_warden(rescue_proc = nil, retry_interval = 0, &block)
+          begin
+            yield
+          rescue ::OpenSSL::SSL::SSLError
+            raise Errors::SLCertificateError
+          rescue SocketError, ::SoftLayer::SoftLayerAPIException => e
+            if e.class == ::SoftLayer::SoftLayerAPIException && e.message.start_with?("Unable to find object with id")
+              out = rescue_proc.call if rescue_proc
+              if retry_interval > 0
+                sleep retry_interval
+                retry
+              else
+                return out
+              end
+            else
+              raise Errors::SLApiError, :class => e.class, :message => e.message
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/vagrant-softlayer/version.rb

@@ -0,0 +1,5 @@
+module VagrantPlugins
+  module SoftLayer
+    VERSION = "0.1.0"
+  end
+end

data/lib/vagrant-softlayer.rb

@@ -0,0 +1,22 @@
+require "pathname"
+require "softlayer_api"
+require "vagrant-softlayer/plugin"
+
+module VagrantPlugins
+  module SoftLayer
+    API_PRIVATE_ENDPOINT = ::SoftLayer::API_PRIVATE_ENDPOINT
+    API_PUBLIC_ENDPOINT  = ::SoftLayer::API_PUBLIC_ENDPOINT
+
+    lib_path = Pathname.new(File.expand_path("../vagrant-softlayer", __FILE__))
+    autoload :Action, lib_path.join("action")
+    autoload :Config, lib_path.join("config")
+    autoload :Errors, lib_path.join("errors")
+
+    # This returns the path to the source of this plugin.
+    #
+    # @return [Pathname]
+    def self.source_root
+      @source_root ||= Pathname.new(File.expand_path("../../", __FILE__))
+    end
+  end
+end

data/locales/en.yml

@@ -0,0 +1,146 @@
+en:
+  vagrant_softlayer:
+    config:
+      api_key_required: |-
+        The SoftLayer API key is required. Please specify it
+        using the SL_API_KEY environment variable or in the provider
+        section of the Vagrantfile:
+
+        config.vm.provider :softlayer do |sl|
+          sl.api_key = "my_API_key"
+        end
+      domain_required: |-
+        The domain of the SoftLayer instance is required.
+        Please specify it in the provider section of the Vagrantfile:
+
+        config.vm.provider :softlayer do |sl|
+          sl.domain = "example.com"
+        end
+      hostname_required: |-
+        The hostname of the SoftLayer instance is required.
+        Please specify it either with `config.vm.hostname` or
+        in the provider section of the Vagrantfile:
+
+        config.vm.hostname = "vagrant"
+
+        config.vm.provider :softlayer do |sl|
+          sl.hostname = "vagrant"
+        end
+      ssh_key_required: |-
+        At least an SSH key for the instance is required.
+        Please specify it, either using name or id, in the
+        provider section of the Vagrantfile:
+
+        config.vm.provider :softlayer do |sl|
+          sl.ssh_key = 1
+        end
+      username_required: |-
+        The SoftLayer username is required. Please specify it
+        using the SL_USERNAME environment variable or in the provider
+        section of the Vagrantfile:
+
+        config.vm.provider :softlayer do |sl|
+          sl.username = "my_username"
+        end
+    errors:
+      api_error: |-
+        Vagrant returned an exception while calling the SoftLayer API.
+
+        Exception class: %{class}
+        Exception message: %{message}
+      certificate_error: |-
+        The secure connection to the SoftLayer API has failed. This is 
+        generally caused by the OpenSSL configuration associated with
+        the Ruby install being unaware of the system specific CA certs.
+        
+        Please ensure that the SSL_CERT_FILE environment variable is set
+        with a path to a certificate authority.
+        
+        Linux example:
+
+        export SSL_CERT_FILE=/opt/vagrant/embedded/cacert.pem
+
+        Mac OS X example:
+
+        export SSL_CERT_FILE=/Applications/Vagrant/embedded/cacert.pem
+
+        Windows example:
+
+        set SSL_CERT_FILE=C:\HashiCorp\Vagrant\embedded\cacert.pem
+      dns_zone_not_found: |-
+        The DNS zone you're trying to manage (%{zone}) has not been
+        found in the zone list.
+      ssh_key_not_found: |-
+        The SSH key you're trying to set (%{key}) does not exists in the
+        SoftLayer account's keychain.
+    states:
+      short_not_created: |-
+        not created
+      long_not_created: |-
+        The SoftLayer instance is not created. Run `vagrant up` to create it.
+      short_halted: |-
+        stopped
+      long_halted: |-
+        The SoftLayer instance is stopped. Run `vagrant up` to start it.
+      short_paused: |-
+        paused
+      long_paused: |-
+        The SoftLayer instance is paused. You need to resume it using another
+        SoftLayer client tool (e.g. `sl` command line utility).
+      short_running: |-
+        running
+      long_running: |-
+        The SoftLayer instance is running. To stop this machine, you can run
+        `vagrant halt`. To destroy the machine, you can run `vagrant destroy`.
+      short_unknown: |-
+        unknown
+      long_unknown: |-
+        The SoftLayer instance is in an unknown state. You need to check it
+        out using SoftLayer administrative interface.
+    sync_folders:
+      rsync_folder: |-
+        Rsyncing folder: %{hostpath} => %{guestpath}
+      rsync_not_found: |-
+        Warning! Folder sync disabled because the rsync binary is missing in the %{side}.
+        Make sure rsync is installed and the binary can be found in the PATH.
+    vm:
+      already_running: |-
+        The SoftLayer instance is already running.
+      already_stopped: |-
+        The SoftLayer instance is already stopped.
+      creating: |-
+        Creating a new SoftLayer instance...
+      creating_dns_record: |-
+        Creating DNS record for the instance...
+      deleting_dns_record: |-
+        Deleting DNS record for the instance...
+      destroying: |-
+        Destroying the SoftLayer instance...
+      not_destroying: |-
+        The SoftLayer instance will not be destroyed, since the confirmation
+        was declined.
+      not_created: |-
+        The SoftLayer instance does not exists.
+      not_rebuilding: |-
+        The SoftLayer instance will not be rebuilded, since the confirmation
+        was declined.
+      not_running: |-
+        The SoftLayer instance is not running. Please run `vagrant up` first.
+      provisioned: |-
+        SoftLayer instance successfully provisioned!
+      rebuilding: |-
+        Rebuilding the SoftLayer instance...
+      rebuild_confirmation: |-
+        Are you sure you want to rebuild the current VM? [y/N] 
+      rebuilt: |-
+        SoftLayer instance successfully rebuilt!
+      starting: |-
+        Starting the SoftLayer instance...
+      stopping: |-
+        Stopping the SoftLayer instance gracefully...
+      stopping_force: |-
+        Stopping the SoftLayer instance forcibly...
+      wait_for_provision: |-
+        Waiting for instance provisioning. This may take a few minutes...
+      wait_for_rebuild: |-
+        Waiting for instance rebuilding. This may take a few minutes...

data/spec/spec_helper.rb

@@ -0,0 +1 @@
+require_relative "../lib/vagrant-softlayer"

data/spec/vagrant-softlayer/config_spec.rb

@@ -0,0 +1,156 @@
+require "spec_helper"
+
+describe VagrantPlugins::SoftLayer::Config do
+  let(:config)  { described_class.new }
+  let(:machine) { double("machine") }
+
+  describe "defaults" do
+    subject do
+      config.tap do |o|
+        o.finalize!
+      end
+    end
+
+    its("api_key")      { should be_nil }
+    its("endpoint_url") { should eq VagrantPlugins::SoftLayer::API_PUBLIC_ENDPOINT }
+    its("username")     { should be_nil }
+
+    its("datacenter")       { should be_nil }
+    its("dedicated")        { should be_false }
+    its("domain")           { should be_nil }
+    its("hostname")         { should be_nil }
+    its("hourly_billing")   { should be_true }
+    its("local_disk")       { should be_true }
+    its("max_memory")       { should eq 1024 }
+    its("network_speed")    { should eq 10 }
+    its("operating_system") { should eq "UBUNTU_LATEST" }
+    its("post_install")     { should be_nil }
+    its("private_only")     { should be_false }
+    its("ssh_key")          { should be_nil }
+    its("start_cpus")       { should eq 1 }
+    its("user_data")        { should be_nil }
+    its("vlan_private")     { should be_nil }
+    its("vlan_public")      { should be_nil }
+
+    its("manage_dns") { should be_false }
+  end
+
+  describe "overriding defaults" do
+    context "booleans" do
+      [true, false].each do |bool|
+        [:dedicated, :hourly_billing, :local_disk, :manage_dns, :private_only].each do |attribute|
+          it "should accept both true and false for #{attribute}" do
+            config.send("#{attribute}=".to_sym, bool)
+            config.finalize!
+            expect(config.send(attribute)).to eq bool
+          end
+        end
+      end
+    end
+
+    context "integers" do
+      [:max_memory, :network_speed, :ssh_key, :start_cpus, :vlan_private, :vlan_public].each do |attribute|
+        it "should not default #{attribute} if overridden" do
+          config.send("#{attribute}=".to_sym, 999)
+          config.finalize!
+          expect(config.send(attribute)).to eq 999
+        end
+      end
+    end
+
+    context "strings" do
+      [:api_key, :datacenter, :endpoint_url, :username, :domain, :hostname, :operating_system, :post_install, :ssh_key, :user_data].each do |attribute|
+        it "should not default #{attribute} if overridden" do
+          config.send("#{attribute}=".to_sym, "foo")
+          config.finalize!
+          expect(config.send(attribute)).to eq "foo"
+        end
+      end
+    end
+  end
+
+  describe "using SL_ environment variables" do
+    before :each do
+      ENV.stub(:[]).with("SL_API_KEY").and_return("env_api_key")
+      ENV.stub(:[]).with("SL_USERNAME").and_return("env_username")
+    end
+
+    subject do
+      config.tap do |o|
+        o.finalize!
+      end
+    end
+
+    its("api_key")  { should eq "env_api_key" }
+    its("username") { should eq "env_username" }
+  end
+
+  describe "validation" do
+    before :each do
+      # Setup some good configuration values
+      config.api_key  = "An API key"
+      config.username = "An username"
+
+      config.datacenter       = "ams01"
+      config.dedicated        = false
+      config.domain           = "example.com"
+      config.hostname         = "vagrant"
+      config.hourly_billing   = true
+      config.local_disk       = true
+      config.max_memory       = 1024
+      config.network_speed    = 10
+      config.operating_system = "UBUNTU_LATEST"
+      config.post_install     = "http://example.com/foo"
+      config.ssh_key          = ["First key", "Second key"]
+      config.start_cpus       = 1
+      config.user_data        = "some metadata"
+      config.vlan_private     = 111
+      config.vlan_public      = 222
+
+      config.manage_dns       = false
+
+      machine.stub_chain(:config, :vm, :hostname).and_return(nil)
+    end
+
+    it "should validate" do
+      config.finalize!
+      expect(config.validate(machine)["SoftLayer"]).to have(:no).item
+    end
+
+    it "should fail if API key is not given" do
+      config.api_key = nil
+      config.finalize!
+      expect(config.validate(machine)["SoftLayer"]).to have(1).item
+    end
+
+    it "should fail if username is not given" do
+      config.username = nil
+      config.finalize!
+      expect(config.validate(machine)["SoftLayer"]).to have(1).item
+    end
+
+    it "should fail if domain is not given" do
+      config.domain = nil
+      config.finalize!
+      expect(config.validate(machine)["SoftLayer"]).to have(1).item
+    end
+
+    it "should fail if hostname is not given" do
+      config.hostname = nil
+      config.finalize!
+      expect(config.validate(machine)["SoftLayer"]).to have(1).item
+    end
+
+    it "should validate if hostname is not given but config.vm.hostname is set" do
+      config.hostname = nil
+      machine.stub_chain(:config, :vm, :hostname).and_return("vagrant")
+      expect(config.validate(machine)["SoftLayer"]).to have(:no).item
+    end
+
+    it "should fail if ssh key is not given" do
+      config.ssh_key = nil
+      config.finalize!
+      expect(config.validate(machine)["SoftLayer"]).to have(1).item
+    end
+  end
+end

data/vagrant-softlayer.gemspec

@@ -0,0 +1,53 @@
+$:.unshift File.expand_path("../lib", __FILE__)
+require "vagrant-softlayer/version"
+
+Gem::Specification.new do |spec|
+  spec.name          = "vagrant-softlayer"
+  spec.version       = VagrantPlugins::SoftLayer::VERSION
+  spec.authors       = "Audiolize GmbH"
+  spec.email         = ""
+  spec.description   = "Enables Vagrant to manages SoftLayer CCI."
+  spec.summary       = "Enables Vagrant to manages SoftLayer CCI."
+  
+  # The following block of code determines the files that should be included
+  # in the gem. It does this by reading all the files in the directory where
+  # this gemspec is, and parsing out the ignored files from the gitignore.
+  # Note that the entire gitignore(5) syntax is not supported, specifically
+  # the "!" syntax, but it should mostly work correctly.
+  root_path      = File.dirname(__FILE__)
+  all_files      = Dir.chdir(root_path) { Dir.glob("**/{*,.*}") }
+  all_files.reject! { |file| [".", ".."].include?(File.basename(file)) }
+  gitignore_path = File.join(root_path, ".gitignore")
+  gitignore      = File.readlines(gitignore_path)
+  gitignore.map!    { |line| line.chomp.strip }
+  gitignore.reject! { |line| line.empty? || line =~ /^(#|!)/ }
+
+  unignored_files = all_files.reject do |file|
+    # Ignore any directories, the gemspec only cares about files
+    next true if File.directory?(file)
+
+    # Ignore any paths that match anything in the gitignore. We do
+    # two tests here:
+    #
+    #   - First, test to see if the entire path matches the gitignore.
+    #   - Second, match if the basename does, this makes it so that things
+    #     like '.DS_Store' will match sub-directories too (same behavior
+    #     as git).
+    #
+    gitignore.any? do |ignore|
+      File.fnmatch(ignore, file, File::FNM_PATHNAME) ||
+        File.fnmatch(ignore, File.basename(file), File::FNM_PATHNAME)
+    end
+  end
+
+  spec.files        = unignored_files
+  spec.executables  = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files   = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_path = "lib"
+
+  spec.add_dependency "softlayer_api"
+
+  spec.add_development_dependency "bundler", "~> 1.3"
+  spec.add_development_dependency "rake"
+  spec.add_development_dependency "rspec"
+end