vagrant-softlayer 0.3.1 → 0.3.2

data/lib/vagrant-softlayer/errors.rb

@@ -1,29 +1,33 @@
-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 SLLoadBalancerNotFound < VagrantSoftLayerError
-        error_key(:load_balancer_not_found)
-      end
-
-      class SLSshKeyNotFound < VagrantSoftLayerError
-        error_key(:ssh_key_not_found)
-      end
-    end
-  end
-end
+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 SLLoadBalancerNotFound < VagrantSoftLayerError
+        error_key(:load_balancer_not_found)
+      end
+
+      class SLSshKeyNotFound < VagrantSoftLayerError
+        error_key(:ssh_key_not_found)
+      end
+
+      class SLVlanIdNotFound < VagrantSoftLayerError
+        error_key(:vlan_id_not_found)
+      end
+    end
+  end
+end

data/lib/vagrant-softlayer/plugin.rb

@@ -1,77 +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
+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/util/load_balancer.rb

@@ -1,103 +1,103 @@
-module VagrantPlugins
-  module SoftLayer
-    module Util
-      # This mixin contains utility methods for load balancer management.
-      module LoadBalancer
-        # Whether load balancer management is enabled or not.
-        def enabled?
-          if @env[:machine].provider_config.load_balancers.empty?
-            @logger.debug("No load balancer has been defined. Going ahead.")
-            return false
-          end
-
-          # Currently we don't do load balancing for private machines.
-          if @env[:machine].provider_config.private_only
-            @logger.info("Load balancing doesn't work for private machines. Going ahead.")
-            return false
-          end
-          true
-        end
-
-        # Get existing stuff.
-        def read_load_balancers
-          mask    = [
-            "id",
-            "ipAddress.ipAddress",
-            "virtualServers.serviceGroups.services.groupReferences",
-            "virtualServers.serviceGroups.services.healthChecks"
-          ]
-          @logger.debug("Looking for existing load balancers.")
-          @load_balancers = sl_warden { @services["Account"].object_mask(mask).getAdcLoadBalancers }
-          @logger.debug("Got load balancer configuration:")
-          @logger.debug("-- #{@load_balancers}")
-        end
-
-        # For each load balancer, check if total connections
-        # are less than 100% and, if so, rebalance the allocations.
-        def rebalance!
-          read_load_balancers
-          
-          @load_balancers.each do |load_balancer|
-            next if load_balancer["virtualServers"].empty?
-            next if 100 == load_balancer["virtualServers"].inject(0) { |sum, vs| sum += vs["allocation"] }
-
-            # Create allocation slots.
-            count      = load_balancer["virtualServers"].count
-            allocation = [100 / count] * count
-            (100 % count).times { |i| allocation[i] += 1 }
-
-            # Rebalance allocations.
-            load_balancer["virtualServers"].each do |vs|
-              vs["allocation"] = allocation.pop
-            end
-
-            # Update the VIP object.
-            @logger.debug("Rebalancing VIP #{load_balancer['id']}")
-            @logger.debug("-- #{load_balancer}")
-            @services["VirtualIpAddress"].object_with_id(load_balancer["id"]).editObject("virtualServers" => load_balancer["virtualServers"])
-          end
-        end
-
-        # Initial setup.
-        def setup
-          # A plethora of service objects is required for managing
-          # load balancers. We instanciate'em all here.
-          @services = {
-            "Account" => ::SoftLayer::Service.new("SoftLayer_Account", @env[:sl_credentials])
-          }
-          [
-            "Health_Check_Type",
-            "Routing_Method",
-            "Routing_Type",
-            "Service",
-            "Service_Group",
-            "VirtualIpAddress",
-            "VirtualServer"
-          ].each do |service|
-            @services[service] = ::SoftLayer::Service.new(
-              "SoftLayer_Network_Application_Delivery_Controller_LoadBalancer_#{service}",
-              @env[:sl_credentials]
-            )
-          end
-
-          # We create enumerations for the various configurables.
-          @enums = {}
-          [
-            "Health_Check_Type",
-            "Routing_Method",
-            "Routing_Type"
-          ].each do |service|
-            {}.tap do |enum|
-              sl_warden { @services[service].getAllObjects }.each do |record|
-                enum[record["name"].upcase] = record["id"]
-              end
-              @enums[service] = enum
-            end
-          end
-
-          read_load_balancers
-        end
-      end
-    end
-  end
-end
+module VagrantPlugins
+  module SoftLayer
+    module Util
+      # This mixin contains utility methods for load balancer management.
+      module LoadBalancer
+        # Whether load balancer management is enabled or not.
+        def enabled?
+          if @env[:machine].provider_config.load_balancers.empty?
+            @logger.debug("No load balancer has been defined. Going ahead.")
+            return false
+          end
+
+          # Currently we don't do load balancing for private machines.
+          if @env[:machine].provider_config.private_only
+            @logger.info("Load balancing doesn't work for private machines. Going ahead.")
+            return false
+          end
+          true
+        end
+
+        # Get existing stuff.
+        def read_load_balancers
+          mask    = [
+            "id",
+            "ipAddress.ipAddress",
+            "virtualServers.serviceGroups.services.groupReferences",
+            "virtualServers.serviceGroups.services.healthChecks"
+          ]
+          @logger.debug("Looking for existing load balancers.")
+          @load_balancers = sl_warden { @services["Account"].object_mask(mask).getAdcLoadBalancers }
+          @logger.debug("Got load balancer configuration:")
+          @logger.debug("-- #{@load_balancers}")
+        end
+
+        # For each load balancer, check if total connections
+        # are less than 100% and, if so, rebalance the allocations.
+        def rebalance!
+          read_load_balancers
+          
+          @load_balancers.each do |load_balancer|
+            next if load_balancer["virtualServers"].empty?
+            next if 100 == load_balancer["virtualServers"].inject(0) { |sum, vs| sum += vs["allocation"] }
+
+            # Create allocation slots.
+            count      = load_balancer["virtualServers"].count
+            allocation = [100 / count] * count
+            (100 % count).times { |i| allocation[i] += 1 }
+
+            # Rebalance allocations.
+            load_balancer["virtualServers"].each do |vs|
+              vs["allocation"] = allocation.pop
+            end
+
+            # Update the VIP object.
+            @logger.debug("Rebalancing VIP #{load_balancer['id']}")
+            @logger.debug("-- #{load_balancer}")
+            @services["VirtualIpAddress"].object_with_id(load_balancer["id"]).editObject("virtualServers" => load_balancer["virtualServers"])
+          end
+        end
+
+        # Initial setup.
+        def setup
+          # A plethora of service objects is required for managing
+          # load balancers. We instanciate'em all here.
+          @services = {
+            "Account" => ::SoftLayer::Service.new("SoftLayer_Account", @env[:sl_credentials])
+          }
+          [
+            "Health_Check_Type",
+            "Routing_Method",
+            "Routing_Type",
+            "Service",
+            "Service_Group",
+            "VirtualIpAddress",
+            "VirtualServer"
+          ].each do |service|
+            @services[service] = ::SoftLayer::Service.new(
+              "SoftLayer_Network_Application_Delivery_Controller_LoadBalancer_#{service}",
+              @env[:sl_credentials]
+            )
+          end
+
+          # We create enumerations for the various configurables.
+          @enums = {}
+          [
+            "Health_Check_Type",
+            "Routing_Method",
+            "Routing_Type"
+          ].each do |service|
+            {}.tap do |enum|
+              sl_warden { @services[service].getAllObjects }.each do |record|
+                enum[record["name"].upcase] = record["id"]
+              end
+              @enums[service] = enum
+            end
+          end
+
+          read_load_balancers
+        end
+      end
+    end
+  end
+end

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

@@ -1,73 +1,75 @@
-module VagrantPlugins
-  module SoftLayer
-    module Util
-      module Network
-        # Gets hostname of the instance starting from the environment.
-        def hostname(env)
-          env[:machine].provider_config.hostname || env[:machine].config.vm.hostname
-        end
-
-        # Gets IP address of the instance starting from the environment.
-        #
-        # Returns the private IP address if the instance has been
-        # defined as private only, the public IP address otherwise.
-        def ip_address(env)
-          ip_address_record(env)[:address]
-        end
-
-        # Gets IP address ID of the instance starting from the environment.
-        #
-        # Returns the private IP address ID if the instance has been
-        # defined as private only, the public IP address ID otherwise.
-        def ip_address_id(env)
-          ip_address_record(env)[:id]
-        end
-
-        # Gets IP address record of the instance starting from the environment.
-        #
-        # Returns an hash with the following structure:
-        #
-        # :address
-        # :id
-        #
-        # Returns the private IP address record if the instance has been
-        # defined as private only, the public IP address record otherwise.
-        def ip_address_record(env)
-          data_type = env[:machine].provider_config.private_only ? "primaryBackendNetworkComponent" : "primaryNetworkComponent"
-          mask      = { data_type => { "primaryIpAddressRecord" => ["id", "ipAddress"] } }
-          record    = sl_warden { env[:sl_machine].object_mask(mask).getObject }
-          return {
-            :address => record[data_type]["primaryIpAddressRecord"]["ipAddress"],
-            :id      => record[data_type]["primaryIpAddressRecord"]["id"]
-          }
-        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
+module VagrantPlugins
+  module SoftLayer
+    module Util
+      module Network
+        # Gets hostname of the instance starting from the environment.
+        def hostname(env)
+          env[:machine].provider_config.hostname || env[:machine].config.vm.hostname
+        end
+
+        # Gets IP address of the instance starting from the environment.
+        #
+        # Returns the private IP address if the instance has been
+        # defined as private only, the public IP address otherwise.
+        def ip_address(env)
+          ip_address_record(env)[:address]
+        end
+
+        # Gets IP address ID of the instance starting from the environment.
+        #
+        # Returns the private IP address ID if the instance has been
+        # defined as private only, the public IP address ID otherwise.
+        def ip_address_id(env)
+          ip_address_record(env)[:id]
+        end
+
+        # Gets IP address record of the instance starting from the environment.
+        #
+        # Returns an hash with the following structure:
+        #
+        # :address
+        # :id
+        #
+        # Returns the private IP address record if the instance has been
+        # defined as private only, the public IP address record otherwise
+        # unless the force_private_ip override is true.
+        def ip_address_record(env)
+          data_type = env[:machine].provider_config.private_only ? "primaryBackendNetworkComponent" : "primaryNetworkComponent"
+          data_type = "primaryBackendNetworkComponent" if env[:machine].provider_config.force_private_ip
+          mask      = { data_type => { "primaryIpAddressRecord" => ["id", "ipAddress"] } }
+          record    = sl_warden { env[:sl_machine].object_mask(mask).getObject }
+          return {
+            :address => record[data_type]["primaryIpAddressRecord"]["ipAddress"],
+            :id      => record[data_type]["primaryIpAddressRecord"]["id"]
+          }
+        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