vagrant-softlayer 0.1.0

data/.gitignore

@@ -0,0 +1,15 @@
+.DS_Store
+
+.bundle
+pkg/*
+Gemfile.lock
+
+.rspec
+
+.vagrant
+.vagrant.d/*
+Vagrantfile
+
+# Miscellaneous local stuff
+example_box/*.box
+scripts/*

data/Gemfile

@@ -0,0 +1,7 @@
+source 'https://rubygems.org'
+
+gemspec
+
+group :development do
+  gem "vagrant", :git => "git://github.com/mitchellh/vagrant.git"
+end

data/LICENSE

@@ -0,0 +1,20 @@
+The MIT License (MIT)
+
+Copyright (c) 2013 audiolize
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of
+this software and associated documentation files (the "Software"), to deal in
+the Software without restriction, including without limitation the rights to
+use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
+the Software, and to permit persons to whom the Software is furnished to do so,
+subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
+FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,233 @@
+# Vagrant SoftLayer Provider
+
+This is a [Vagrant](http://www.vagrantup.com) 1.3+ plugin that adds a [SoftLayer](http://www.softlayer.com)
+provider to Vagrant, allowing Vagrant to control and provision SoftLayer CCI instances.
+
+**NOTE:** This plugin requires Vagrant 1.3+
+
+## Features
+
+* Basic lifecycle (boot, halt, reboot) of SoftLayer CCI instances.
+* OS reload on a CCI (`vagrant rebuild`).
+* SSH into the instances.
+* Provision the instances with any built-in Vagrant provisioner.
+* Minimal synced folder support via `rsync`.
+
+## Installation
+
+### Set the `SSL_CERT_FILE` environment variable
+
+If you intend to use the public API endpoint, which is the default, you have to
+set the `SSL_CERT_FILE` environment variable.
+
+The *net/http* library of the Vagrant's embedded ruby does **not**
+check the validity of an SSL certificate during a TLS handshake. This breaks all
+the calls to the SoftLayer API, making the plugin unusable.
+
+For fixing this issue, you have to make ruby aware of a certificate authority
+bundle by setting `SSL_CERT_FILE`:
+
+**Linux**
+
+* To set this in your current command prompt session, type:
+
+  `export SSL_CERT_FILE=/opt/vagrant/embedded/cacert.pem`
+
+* To make this a permanent setting, add this in `.bashrc` or `.profile`.
+
+**Mac OS X**
+
+* To set this in your current command prompt session, type:
+
+  `export SSL_CERT_FILE=/Applications/Vagrant/embedded/cacert.pem`
+
+* To make this a permanent setting, add this in `/etc/launchd.conf`.
+
+**Windows**
+
+* To set this in your current command prompt session, type:
+
+  `set SSL_CERT_FILE=C:\HashiCorp\Vagrant\embedded\cacert.pem`
+
+* To make this a permanent setting, add this in your [control panel](http://www.microsoft.com/resources/documentation/windows/xp/all/proddocs/en-us/environment_variables.mspx?mfr=true).
+
+### Plugin installation
+
+Installation is performed in the prescribed manner for Vagrant 1.1+ plugins.
+After installing, `vagrant up` and specify the `softlayer` provider. An example is
+shown below.
+
+```
+$ vagrant plugin install vagrant-softlayer
+...
+$ vagrant up --provider=softlayer
+...
+```
+
+Of course prior to doing this, you'll need to obtain an SoftLayer-compatible
+box file for Vagrant.
+
+## Box File Format
+
+Every provider in Vagrant must introduce a custom box format. This
+provider introduces `softlayer` boxes. You can view an example box in
+the `example_box/` directory. That directory also contains instructions
+on how to build a box.
+
+The box format is basically just the required `metadata.json` file
+along with a `Vagrantfile` that does default settings for the
+provider-specific configuration for this provider.
+
+## Configuration
+
+This provider exposes quite a few provider-specific configuration options:
+
+### Authentication
+
+Parameter      | Description                          | Default                            | Required
+-------------- | ------------------------------------ | ---------------------------------- | --------
+`api_key`      | The API key for accessing SoftLayer  |                                    | yes
+`endpoint_url` | The endpoint SoftLayer API url       | SoftLayer::API_PUBLIC_ENDPOINT     | yes
+`username`     | The username for accessing SoftLayer |                                    | yes
+
+> **NOTE**
+>
+> In place of the API key and username you can use environment variables, respectively `SL_API_KEY` and `SL_USERNAME`.
+
+### DNS Management
+
+If the DNS zone of the configured domain is hosted by SoftLayer, you can automatically manage it.
+
+Parameter    | Description                           | Default | Required
+------------ | ------------------------------------- | ------- | --------
+`manage_dns` | Add/remove A record on create/destroy | false   | no
+
+### Instance Configuration
+
+Parameter          | Description                                 | Default                 | Required
+------------------ | ------------------------------------------- | ----------------------- | --------
+`datacenter`       | Datacenter shortname                        | First available         | no
+`dedicated`        | Allocate a dedicated CCI (non-shared host)  | false                   | no
+`domain`           | The domain of the instance                  |                         | yes
+`hostname`         | The hostname of the instance                |                         | yes *
+`hourly_billing`   | Hourly billing type (false for monthly)     | true                    | no
+`local_disk`       | Use a local disk (false for SAN)            | true                    | no
+`max_memory`       | The amount of RAM of the instance in Mb     | 1024                    | no
+`network_speed`    | Network port speed in Mbps                  | 10                      | no
+`operating_system` | The instance operating system identifier    | UBUNTU_LATEST           | no
+`post_install`     | URI of Post-install script to download      |                         | no
+`private_only`     | Only create access to the private network   | false                   | no
+`ssh_key`          | ID or label of the SSH key(s) to provision  |                         | yes
+`start_cpus`       | The number of processors of the instance    | 1                       | no
+`user_data`        | User defined metadata string                |                         | no
+`vlan_private`     | The ID of the private VLAN                  | Automatically generated | no
+`vlan_public`      | The ID of the public VLAN                   | Automatically generated | no
+
+\* The `hostname` could be specified either using `config.vm.hostname` or the provider parameter.
+
+These can be set like typical provider-specific configuration:
+
+```
+Vagrant.configure("2") do |config|
+  # ... other stuff
+
+  config.vm.provider :softlayer do |sl|
+    sl.api_key  = "foo"
+    sl.username = "bar"
+    sl.ssh_key  = "Vagrant insecure key"
+  end
+end
+```
+
+## OS Reload
+
+Reload of an instance's operating system is performed with the `vagrant rebuild` command.
+The primary disk of the instance will be formatted and a fresh copy of the underlying OS
+will be applied. Note that only `ssh_key` and `post_install` parameter will be read
+during rebuild, all the other parameters will be ignored. Provisioners will always run
+after rebuild.
+
+## Synced Folders
+
+There is minimal support for synced folders. Upon `vagrant up`,
+`vagrant reload`, and `vagrant provision`, the SoftLayer provider will use
+`rsync` (if available) to uni-directionally sync the folder to
+the remote machine over SSH.
+
+This is good enough for all built-in Vagrant provisioners (shell, ansible,
+chef, and puppet) to work!
+
+## Other Examples
+
+### Override SSH Username
+
+If you're running Vagrant with an user different from root, probably you need
+to override the username used for ssh connection. You can do it using the standard
+Vagrant syntax:
+
+```
+Vagrant.configure("2") do |config|
+  # ... other stuff
+
+  config.vm.provider :softlayer do |sl, override|
+    # ... other stuff
+    
+    override.ssh.username = "root"
+  end
+end
+```
+
+### Multiple SSH keys
+
+Multiple SSH keys to be provisioned could be specified using an array:
+
+```
+Vagrant.configure("2") do |config|
+  # ... other stuff
+
+  config.vm.provider :softlayer do |sl|
+    sl.api_key  = "foo"
+    sl.username = "bar"
+    # ssh_keys is just an alias of ssh_key
+    sl.ssh_keys = ["Vagrant insecure key", "My personal key"]
+  end
+end
+```
+
+Also, a bunch of aliases for the `ssh_key` parameter are provided for better semantic:
+
+* `ssh_keys`
+* `ssh_key_id`
+* `ssh_key_ids`
+* `ssh_key_name`
+* `ssh_key_names`
+
+## Development
+
+To work on the `vagrant-softlayer` plugin, clone this repository out, and use
+[Bundler](http://gembundler.com) to get the dependencies:
+
+```
+$ bundle
+```
+
+Once you have the dependencies, verify the unit tests pass with `rake`:
+
+```
+$ bundle exec rake
+```
+
+If those pass, you're ready to start developing the plugin. You can test
+the plugin without installing it into your Vagrant environment by just
+creating a `Vagrantfile` in the top level of this directory (it is gitignored)
+and add the following line to your `Vagrantfile`:
+
+```
+Vagrant.require_plugin "vagrant-softlayer"
+```
+
+Use bundler to execute Vagrant:
+
+```
+$ bundle exec vagrant up --provider=softlayer
+```

data/Rakefile

@@ -0,0 +1,6 @@
+require "bundler/gem_tasks"
+require 'rspec/core/rake_task'
+
+RSpec::Core::RakeTask.new
+
+task :default => "spec"

data/example_box/README.md

@@ -0,0 +1,13 @@
+# Vagrant SoftLayer Example Box
+
+Vagrant providers each require a custom provider-specific box format.
+This folder shows the example contents of a box for the `softlayer` provider.
+To turn this into a box:
+
+```
+$ tar cvzf softlayer.box ./metadata.json [./Vagrantfile]
+```
+
+A Vagrantfile with default configuration values for SoftLayer could be added. 
+These defaults can easily be overwritten by higher-level
+Vagrantfiles (such as project root Vagrantfiles).

data/example_box/metadata.json

@@ -0,0 +1,3 @@
+{
+    "provider": "softlayer"
+}

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

@@ -0,0 +1,54 @@
+module VagrantPlugins
+  module SoftLayer
+    module Action
+      # This creates a new instance.
+      class CreateInstance
+        include Util::Network
+        include Util::Warden
+
+        def initialize(app, env)
+          @app = app
+        end
+
+        def call(env)
+          @env = env
+          
+          @env[:ui].info I18n.t("vagrant_softlayer.vm.creating")
+          
+          result = sl_warden { env[:sl_connection].createObject(order_template) }
+          @env[:machine].id = result["id"].to_s
+
+          @app.call(@env)
+        end
+
+        def get_hostname
+          @env[:machine].provider_config.hostname || @env[:machine].config.vm.hostname
+        end
+
+        def order_template
+          template = {
+            "dedicatedAccountHostOnlyFlag" => @env[:machine].provider_config.dedicated,
+            "domain"                       => @env[:machine].provider_config.domain,
+            "hostname"                     => get_hostname,
+            "hourlyBillingFlag"            => @env[:machine].provider_config.hourly_billing,
+            "localDiskFlag"                => @env[:machine].provider_config.local_disk,
+            "maxMemory"                    => @env[:machine].provider_config.max_memory,
+            "networkComponents"            => [ { :maxSpeed => @env[:machine].provider_config.network_speed } ],
+            "operatingSystemReferenceCode" => @env[:machine].provider_config.operating_system,
+            "privateNetworkOnlyFlag"       => @env[:machine].provider_config.private_only,
+            "sshKeys"                      => ssh_keys(@env),
+            "startCpus"                    => @env[:machine].provider_config.start_cpus
+          }
+
+          template["datacenter"] = { :name => @env[:machine].provider_config.datacenter } if @env[:machine].provider_config.datacenter
+          template["postInstallScriptUri"] = @env[:machine].provider_config.post_install if @env[:machine].provider_config.post_install
+          template["primaryNetworkComponent"] = { :networkVlan => { :id => @env[:machine].provider_config.vlan_public } } if @env[:machine].provider_config.vlan_public
+          template["primaryBackendNetworkComponent"] = { :networkVlan => { :id => @env[:machine].provider_config.vlan_private } } if @env[:machine].provider_config.vlan_private
+          template["userData"] = [ { :value => @env[:machine].provider_config.user_data } ] if @env[:machine].provider_config.user_data
+
+          return template
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,23 @@
+module VagrantPlugins
+  module SoftLayer
+    module Action
+      # This deletes the running instance.
+      class DestroyInstance
+        include Util::Warden
+
+        def initialize(app, env)
+          @app = app
+        end
+
+        def call(env)
+          @app.call(env)
+
+          env[:ui].info I18n.t("vagrant_softlayer.vm.destroying")
+          
+          sl_warden { env[:sl_machine].deleteObject }
+          env[:machine].id = nil
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,21 @@
+module VagrantPlugins
+  module SoftLayer
+    module Action
+      # This can be used with "Call" built-in to check if the machine
+      # is in the given status.
+      class Is
+        def initialize(app, env, status)
+          @app    = app
+          @status = status
+        end
+
+        def call(env)
+          env[:result] = env[:machine].state.id == @status
+
+          # Carry on, just in case
+          @app.call(env)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,22 @@
+module VagrantPlugins
+  module SoftLayer
+    module Action
+      # This action sends a message to the UI,
+      # with given level and text.
+      class Message
+        def initialize(app, env, level, message)
+          @app     = app
+          @level   = level
+          @message = message
+        end
+
+        def call(env)
+          env[:ui].send(@level, I18n.t(@message))
+
+          # Carry on
+          @app.call(env)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,28 @@
+module VagrantPlugins
+  module SoftLayer
+    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
+        include Util::Network
+        include Util::Warden
+
+        def initialize(app, env)
+          @app = app
+        end
+
+        def call(env)
+          env[:machine_ssh_info] = read_ssh_info(env)
+
+          @app.call(env)
+        end
+
+        def read_ssh_info(env)
+          return nil unless env[:sl_machine]
+
+          return { :host => ip_address(env), :port => 22 }
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,42 @@
+require "log4r"
+
+module VagrantPlugins
+  module SoftLayer
+    module Action
+      # This action reads the state of the machine and puts it in the
+      # `:machine_state_id` key in the environment.
+      class ReadState
+        include Util::Warden
+
+        def initialize(app, env)
+          @app    = app
+          @logger = Log4r::Logger.new("vagrant_softlayer::action::read_state")
+        end
+
+        def call(env)
+          env[:machine_state_id] = read_state(env)
+
+          # Carry on
+          @app.call(env)
+        end
+
+        def read_state(env)
+          return :not_created unless env[:sl_machine]
+
+          wipe_id = lambda do
+            @logger.info("Machine not found, assuming it got destroyed.")
+            env[:machine].id = nil
+            next :not_created
+          end
+
+          state = sl_warden(wipe_id) { env[:sl_machine].getPowerState }
+          if state && ["Halted", "Paused", "Running"].include?(state["name"])
+            return state["name"].downcase.to_sym
+          else
+            return :unknown
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,35 @@
+module VagrantPlugins
+  module SoftLayer
+    module Action
+      # This rebuilds the running instance.
+      class RebuildInstance
+        include Util::Network
+        include Util::Warden
+
+        def initialize(app, env)
+          @app    = app
+          @logger = Log4r::Logger.new("vagrant_softlayer::action::rebuild_instance")
+        end
+
+        def call(env)
+          env[:ui].info I18n.t("vagrant_softlayer.vm.rebuilding")
+
+          # Wipe out provision sentinel file, we need to run provisioning after rebuild
+          @logger.debug("Looking for provision sentinel file.")
+          provision_file = env[:machine].data_dir.join("action_provision")
+          if provision_file.file?
+            @logger.debug("Removing provision sentinel file.")
+            provision_file.delete
+          end
+
+          template = { "sshKeyIds" => ssh_keys(env, true) }
+          template["customProvisionScriptUri"] = env[:machine].provider_config.post_install if env[:machine].provider_config.post_install
+          
+          sl_warden { env[:sl_machine].reloadOperatingSystem("FORCE", template) }
+          
+          @app.call(env)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,37 @@
+require "log4r"
+
+module VagrantPlugins
+  module SoftLayer
+    module Action
+      # This action creates the SoftLayer connection object and
+      # puts it into the `:sl_connection` key in the environment.
+      # Also, if a machine id is found, another key called
+      # `:sl_machine` and containing the masked object is created.
+      class SetupSoftLayer
+        def initialize(app, env)
+          @app    = app
+          @logger = Log4r::Logger.new("vagrant_softlayer::action::connect_softlayer")
+        end
+
+        def call(env)
+          @logger.info("Creating the SoftLayer connection object...")
+
+          env[:sl_credentials] = {
+            :api_key      => env[:machine].provider_config.api_key,
+            :endpoint_url => env[:machine].provider_config.endpoint_url,
+            :username     => env[:machine].provider_config.username
+          }
+
+          env[:sl_connection] = ::SoftLayer::Service.new("SoftLayer_Virtual_Guest", env[:sl_credentials])
+
+          unless env[:machine].id.nil? || env[:machine].id.empty?
+            env[:sl_machine] = env[:sl_connection].object_with_id(env[:machine].id.to_i)
+          end
+
+          # Carry on
+          @app.call(env)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,21 @@
+module VagrantPlugins
+  module SoftLayer
+    module Action
+      # This starts a stopped instance.
+      class StartInstance
+        include Util::Warden
+
+        def initialize(app, env)
+          @app    = app
+        end
+
+        def call(env)
+          env[:ui].info I18n.t("vagrant_softlayer.vm.starting")
+          sl_warden { env[:sl_machine].powerOn }
+          
+          @app.call(env)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,30 @@
+module VagrantPlugins
+  module SoftLayer
+    module Action
+      # This stops the running instance.
+      class StopInstance
+        include Util::Warden
+
+        def initialize(app, env)
+          @app    = app
+        end
+
+        def call(env)
+          if env[:machine].state.id == :halted
+            env[:ui].info I18n.t("vagrant_softlayer.vm.already_stopped")
+          else
+            if env[:force_halt]
+              env[:ui].info I18n.t("vagrant_softlayer.vm.stopping_force")
+              sl_warden { env[:sl_machine].powerOff }
+            else
+              env[:ui].info I18n.t("vagrant_softlayer.vm.stopping")
+              sl_warden { env[:sl_machine].powerOffSoft }
+            end
+          end
+
+          @app.call(env)
+        end
+      end
+    end
+  end
+end