vagrant-linode 0.1.0

checksums.yaml

@@ -0,0 +1,15 @@
+---
+!binary "U0hBMQ==":
+  metadata.gz: !binary |-
+    ZjE5MThiZTU0ODg3ZGVmZjA2OTI4MWEzZWIxYTc2YWRkNTYxZDllZA==
+  data.tar.gz: !binary |-
+    NTRmMjI5MzdkNDg5YjBkNzI5NjhjZTA0ODdlN2RkMGNmMDBlNTQ3OA==
+SHA512:
+  metadata.gz: !binary |-
+    YzBlMjc0ZGEyMDJmZTMwMDYzY2FlYTc4N2E0ZTBjMGVhOGFhNWJhMjhkZmYw
+    YzQ4NWYwZWNlY2FhYjBiMGU2YzUxNjQxYWI1OTM1ODk5NjEyMmVkMjgyNTQw
+    ZTU4OTIxODcwYzZjNzA1YjFhMTE3ODE4ODQxNjZmOGFiODBhNWE=
+  data.tar.gz: !binary |-
+    NjQwNmRjOTc3N2ZhZGI3MTcxM2RjM2YxYjExMmRhNGU3YzM4OWRjOTA2MTFm
+    NjM4Mzk3N2E0YmIyMjdhOWNjZTJiNTczZDU1MDI2ZDc2OWVjZjdmZDU1MzBi
+    NTQ5MGQ0ZjdhYWQ4YzNmMTdkM2E2ZGE4NTA5ODMwNDc2MDgxNTA=

data/.gitignore

@@ -0,0 +1,19 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+test/.vagrant
+tmp
+.vagrant

data/CHANGELOG.md

@@ -0,0 +1,4 @@
+Changelog
+=========
+
+

data/Gemfile

@@ -0,0 +1,11 @@
+source 'https://rubygems.org'
+
+gem 'vagrant', git: 'git://github.com/mitchellh/vagrant.git', tag: 'v1.6.3'
+gem 'vagrant-omnibus'
+gem 'rake'
+
+group :plugins do
+  gem 'vagrant-linode', path: '.'
+end
+
+gemspec

data/LICENSE.txt

@@ -0,0 +1,23 @@
+Copyright (c) 2013 John Bender
+Copyright (c) 2013 Shawn Dahlen
+
+MIT License
+
+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,201 @@
+Linode Vagrant Provider
+==============================
+`vagrant-linode` is a provider plugin for Vagrant that supports the
+management of [Linode](https://www.linode.com/) linodes
+(instances).
+
+**NOTE:** The Chef provisioner is no longer supported by default (as of 0.2.0).
+Please use the `vagrant-omnibus` plugin to install Chef on Vagrant-managed
+machines. This plugin provides control over the specific version of Chef
+to install.
+
+Current features include:
+- create and destroy linodes
+- power on and off linodes
+- rebuild a linode
+- provision a linode with the shell or Chef provisioners
+- setup a SSH public key for authentication
+- create a new user account during linode creation
+
+The provider has been tested with Vagrant 1.1.5+ using Ubuntu 14.04 LTS and
+Debian 7.5 guest operating systems.
+
+Install
+-------
+Installation of the provider requires two steps:
+
+1. Install the provider plugin using the Vagrant command-line interface:
+
+        $ vagrant plugin install vagrant-linode
+
+
+**NOTE:** If you are using a Mac, and this plugin would not work caused by SSL certificate problem,
+You may need to specify certificate path explicitly.
+You can verify actual certificate path by running:
+
+```bash
+ruby -ropenssl -e "p OpenSSL::X509::DEFAULT_CERT_FILE"
+```
+
+Then, add the following environment variable to your
+`.bash_profile` script and `source` it:
+
+```bash
+export SSL_CERT_FILE=/usr/local/etc/openssl/cert.pem
+```
+
+Configure
+---------
+Once the provider has been installed, you will need to configure your project
+to use it. The most basic `Vagrantfile` to create a linode on Linode
+is shown below:
+
+```ruby
+Vagrant.configure('2') do |config|
+
+  config.vm.provider :linode do |provider, override|
+    override.ssh.private_key_path = '~/.ssh/id_rsa'
+    override.vm.box = 'linode'
+    override.vm.box_url = "https://github.com/displague/vagrant-linode/raw/master/box/linode.box"
+
+    provider.token = 'API_KEY'
+    provider.distribution = 'Ubuntu 14.04 LTS'
+    provider.datacenter = 'newark'
+    provider.plan = 'Linode 1024'
+    # provider.planid = <int>
+    # provider.paymentterm = <*1*,12,24>
+    # provider.datacenterid = <int>
+    # provider.image = <string>
+    # provider.imageid = <int>
+    # provider.private_networking = <boolean>
+    # provider.stackscript = <string>
+    # provider.stackscriptid = <int>
+    # provider.distributionid = <int>
+  end
+end
+```
+
+Please note the following:
+- You *must* specify the `override.ssh.private_key_path` to enable authentication
+  with the linode. The provider will create a new Linode SSH key using
+  your public key which is assumed to be the `private_key_path` with a *.pub*
+  extension.
+- You *must* specify your Linode Personal Access Token. This may be
+  found on the control panel within the *Apps &amp; API* section.
+
+**Supported Configuration Attributes**
+
+The following attributes are available to further configure the provider:
+- `provider.image` - A string representing the image to use when creating a
+   new linode (e.g. `Debian 7.5`). The available options may
+   be found on Linode's new linode [form](https://www.linode.com/distributions).
+   It defaults to `Ubuntu 14.04 LTS`.
+- `provider.datacenter` - A string representing the region to create the new
+   linode in. It defaults to `newark`.
+- `provider.plan` - A string representing the size to use when creating a
+  new linode (e.g. `Linode 2048`). It defaults to `Linode 1024`.
+- `provider.private_networking` - A boolean flag indicating whether to enable
+  a private network interface (if the region supports private networking). It
+  defaults to `false`.
+- `provider.ssh_key_name` - A string representing the name to use when creating
+  a Linode SSH key for linode authentication. It defaults to `Vagrant`.
+- `provider.setup` - A boolean flag indicating whether to setup a new user
+  account and modify sudo to disable tty requirement. It defaults to `true`.
+  If you are using a tool like [packer](https://packer.io) to create
+  reusable snapshots with user accounts already provisioned, set to `false`.
+
+The provider will create a new user account with the specified SSH key for
+authorization if `config.ssh.username` is set and the `provider.setup`
+attribute is `true`.
+
+### provider.plan
+
+Each Linode Tier has been assigned a Plan Identifcation Number.
+Current Plan-ID table follows:
+
+| PlanID  | Plan                      |
+|:------- |:------------------------- |
+|    1    |  1GB Plan (Linode 1024)   |
+|    2    |  2GB Plan (Linode 2048)   |
+|    4    |  4GB Plan (Linode 4096)   |
+|    6    |  8GB Plan (Linode 8192)   |
+|    7    | 16GB Plan (Linode 16384)  |
+|    8    | 32GB Plan (Linode 32768)  |
+|    9    | 48GB Plan (Linode 49152)  |
+|   10    | 64GB Plan (Linode 65536)  |
+|   12    | 96GB Plan (Linode 98304)  |
+
+```
+curl -X POST "https://api.linode.com/?api_action=avail.plans" \
+     --data-ascii api_key="$LINODE_API_KEY" \
+     2>/dev/null | jq '.DATA [] | .PLANID,.LABEL'
+```
+
+More detail: [Linode API - Plans](https://www.linode.com/api/utility/avail.plans)
+
+### provider.datacenter
+
+Each region has been specified with a Data Center ID.
+Current Region-ID table is:
+
+| DatacenterID | Datacenter | Location            |
+|:-------      |:------     |:--------------------|
+|   4          | atlanta    | Atlanta, GA, USA    |
+|   2          | dallas     | Dallas, TX, USA     |
+|   3          | fremont    | Fremont, CA, USA    |
+|   7          | london     | London, England, UK |
+|   6          | newark     | Newark, NJ, USA     |
+|   8          | tokyo      | Tokyo, JP           |
+
+You can find latest datacenter ID number using Linode API call.
+
+- example call.
+
+```
+curl -X POST "https://api.linode.com/?api_action=avail.datacenters" \
+     --data-ascii api_key="$LINODE_API_KEY" \
+     2>/dev/null | jq '.DATA [] | .DATACENTERID,.ABBR,.LOCATION'
+```
+
+More detail: [Linode API - Datacenters](https://www.linode.com/api/utility/avail.datacenters)
+
+Run
+---
+After creating your project's `Vagrantfile` with the required configuration
+attributes described above, you may create a new linode with the following
+command:
+
+    $ vagrant up --provider=linode
+
+This command will create a new linode, setup your SSH key for authentication,
+create a new user account, and run the provisioners you have configured.
+
+**Supported Commands**
+
+The provider supports the following Vagrant sub-commands:
+- `vagrant destroy` - Destroys the linode instance.
+- `vagrant ssh` - Logs into the linode instance using the configured user
+  account.
+- `vagrant halt` - Powers off the linode instance.
+- `vagrant provision` - Runs the configured provisioners and rsyncs any
+  specified `config.vm.synced_folder`.
+- `vagrant reload` - Reboots the linode instance.
+- `vagrant rebuild` - Destroys the linode instance and recreates it with the
+  same IP address which was previously assigned.
+- `vagrant status` - Outputs the status (active, off, not created) for the
+  linode instance.
+
+Contribute
+----------
+To contribute, clone the repository, and use [Bundler](http://gembundler.com)
+to install dependencies:
+
+    $ bundle
+
+To run the provider's tests:
+
+    $ bundle exec rake test
+
+You can now make modifications. Running `vagrant` within the Bundler
+environment will ensure that plugins installed in your Vagrant
+environment are not loaded.

data/Rakefile

@@ -0,0 +1,22 @@
+require 'bundler/gem_helper'
+
+namespace :gem do
+  Bundler::GemHelper.install_tasks
+end
+
+task :test do
+  result = sh 'bash test/test.sh'
+
+  if result
+    puts 'Success!'
+  else
+    puts 'Failure!'
+    exit 1
+  end
+end
+
+def env
+  %w(LINODE_CLIENT_ID LINODE_API_KEY VAGRANT_LOG).reduce('') do |acc, key|
+    acc += "#{key}=#{ENV[key] || 'error'} "
+  end
+end

data/box/README.md

@@ -0,0 +1,13 @@
+# Vagrant Linode Cloud Example Box
+
+Vagrant providers each require a custom provider-specific box format.
+This folder shows the example contents of a box for the `linode` provider.
+To turn this into a box:
+
+```
+$ tar cvzf linode.box ./metadata.json ./Vagrantfile
+```
+
+This box works by using Vagrant's built-in Vagrantfile merging to setup
+defaults for Linode. These defaults can easily be overwritten by higher-level
+Vagrantfiles (such as project root Vagrantfiles).

data/box/metadata.json

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

data/lib/vagrant-linode/actions/check_state.rb

@@ -0,0 +1,19 @@
+module VagrantPlugins
+  module Linode
+    module Actions
+      class CheckState
+        def initialize(app, env)
+          @app = app
+          @machine = env[:machine]
+          @logger = Log4r::Logger.new('vagrant::linode::check_state')
+        end
+
+        def call(env)
+          env[:machine_state] = @machine.state.id
+          @logger.info "Machine state is '#{@machine.state.id}'"
+          @app.call(env)
+        end
+      end
+    end
+  end
+end

data/lib/vagrant-linode/actions/create.rb

@@ -0,0 +1,191 @@
+require 'vagrant-linode/helpers/client'
+require 'vagrant-linode/errors'
+
+module VagrantPlugins
+  module Linode
+    module Actions
+      class Create
+        include Helpers::Client
+        include Vagrant::Util::Retryable
+
+        def initialize(app, env)
+          @app = app
+          @machine = env[:machine]
+          @client = client
+          @logger = Log4r::Logger.new('vagrant::linode::create')
+        end
+
+        def call(env)
+          ssh_key_id = env[:machine].config.ssh.private_key_path
+          ssh_key_id = ssh_key_id[0] if ssh_key_id.is_a?(Array)
+
+          if ssh_key_id
+            pubkey = File.read(File.expand_path("#{ssh_key_id}.pub"))
+          end
+
+          if @machine.provider_config.root_pass
+            root_pass = @machine.provider_config.root_pass
+          else
+            root_pass = Digest::SHA2.new.update(@machine.provider_config.api_key).to_s
+          end
+
+          if @machine.provider_config.distribution
+            distributions = @client.avail.distributions
+            distribution = distributions.find { |d| d.label.downcase.include? @machine.provider_config.distribution.downcase }
+            raise( Errors::DistroMatch, distro: @machine.provider_config.distribution.to_s ) if distribution == nil
+            distribution_id = distribution.distributionid || nil
+          else
+            distribution_id = @machine.provider_config.distributionid
+          end
+
+          if @machine.provider_config.datacenter
+            datacenters = @client.avail.datacenters
+            datacenter = datacenters.find { |d| d.abbr == @machine.provider_config.datacenter }
+            datacenter_id = datacenter.datacenterid || nil # @todo throw if not found
+          else
+            datacenter_id = @machine.provider_config.datacenterid
+          end
+
+          if @machine.provider_config.plan
+            plans = @client.avail.linodeplans
+            plan = plans.find { |p| p.label.include? @machine.provider_config.plan }
+            raise Errors::PlanID, plan: @machine.provider_config.plan if plan == nil
+            plan_id = plan.planid || nil 
+          else
+            plan_id = @machine.provider_config.planid
+          end
+
+          ### Disk Images
+          xvda_size, swap_size, disk_sanity = @machine.provider_config.xvda_size, @machine.provider_config.swap_size, true
+
+          # Sanity checks for disk size
+          if xvda_size != true
+            disk_sanity = false if ( xvda_size.to_i + swap_size.to_i ) > ( plan['disk'].to_i * 1024 )
+          end
+
+          # throw if disk sizes are too large
+          if xvda_size == true
+            xvda_size = ( ( plan['disk'].to_i * 1024 ) - swap_size.to_i )
+          elsif disk_sanity == false
+            raise Errors::DiskSize, current: (xvda_size.to_i + swap_size.to_i), max: ( plan['disk'].to_i * 1024 )
+          end
+
+          env[:ui].info I18n.t('vagrant_linode.info.creating')
+
+          # submit new linode request
+          result = @client.linode.create(
+            planid: plan_id,
+            datacenterid: datacenter_id,
+            paymentterm: @machine.provider_config.paymentterm || 1
+          )
+          env[:ui].info I18n.t('vagrant_linode.info.created', linodeid: result['linodeid'])
+
+          # @client.linode.job.list(:linodeid => result['linodeid'], :pendingonly => 1)
+          # assign the machine id for reference in other commands
+          @machine.id = result['linodeid'].to_s
+
+          if distribution_id
+            swap = @client.linode.disk.create(
+              linodeid: result['linodeid'],
+              label: 'Vagrant swap',
+              type: 'swap',
+              size: swap_size
+            )
+
+            disk = @client.linode.disk.createfromdistribution(
+              linodeid: result['linodeid'],
+              distributionid: distribution_id,
+              label: 'Vagrant Disk Distribution ' + distribution_id.to_s + ' Linode ' + result['linodeid'].to_s,
+              type: 'ext4',
+              size: xvda_size,
+              rootSSHKey: pubkey,
+              rootPass: root_pass
+            )
+          elsif image_id
+            disk = @client.linode.disk.createfromimage(
+              linodeid: result['linodeid'],
+              imageid: image_id,
+              size: xvda_size,
+              rootSSHKey: pubkey,
+              rootPass: root_pass
+            )
+
+            swap = @client.linode.disk.create(
+              linodeid: result['linodeid'],
+              label: 'Vagrant swap',
+              type: 'swap',
+              size: swap_size
+            )
+          end
+
+          config = @client.linode.config.create(
+            linodeid: result['linodeid'],
+            label: 'Vagrant Config',
+            disklist: "#{disk['diskid']},#{swap['diskid']}",
+            kernelid: 138 # default - newest @todo make this part of config..
+          )
+
+          # @todo: allow provisioning to set static configuration for networking
+          if @machine.provider_config.private_networking
+            private_network = @client.linode.ip.addprivate linodeid: result['linodeid']
+          end
+
+          result = @client.linode.update(
+            linodeid: result['linodeid'],
+            label: @machine.config.vm.hostname || @machine.name
+          )
+
+          env[:ui].info I18n.t('vagrant_linode.info.booting', linodeid: result['linodeid'])
+
+          bootjob = @client.linode.boot linodeid: result['linodeid']
+          # sleep 1 until ! @client.linode.job.list(:linodeid => result['linodeid'], :jobid => bootjob['jobid'], :pendingonly => 1).length
+          wait_for_event(env, bootjob['jobid'])
+
+          # refresh linode state with provider and output ip address
+          linode = Provider.linode(@machine, refresh: true)
+          public_network = linode.network.find { |network| network['ispublic'] == 1 }
+          env[:ui].info I18n.t('vagrant_linode.info.linode_ip', ip: public_network['ipaddress'])
+
+          if private_network
+            env[:ui].info I18n.t('vagrant_linode.info.linode_private_ip', ip: private_network['ipaddress'])
+          end
+
+          # wait for ssh to be ready
+          switch_user = @machine.provider_config.setup?
+          user = @machine.config.ssh.username
+          if switch_user
+            @machine.config.ssh.username = 'root'
+            @machine.config.ssh.password = root_pass
+          end
+
+          retryable(tries: 25, sleep: 10) do # @todo bump tries when this is solid
+            next if env[:interrupted]
+            fail 'not ready' unless @machine.communicate.ready?
+          end
+
+          @machine.config.ssh.username = user
+
+          @app.call(env)
+        end
+
+        # Both the recover and terminate are stolen almost verbatim from
+        # the Vagrant AWS provider up action
+        # def recover(env)
+        #  print YAML::dump env['vagrant_error']
+        #  return if env['vagrant.error'].is_a?(Vagrant::Errors::VagrantError)
+        #  if @machine.state.id != -1
+        #    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(Actions.destroy, destroy_env)
+        end
+      end
+    end
+  end
+end

data/lib/vagrant-linode/actions/destroy.rb

@@ -0,0 +1,30 @@
+require 'vagrant-linode/helpers/client'
+
+module VagrantPlugins
+  module Linode
+    module Actions
+      class Destroy
+        include Helpers::Client
+
+        def initialize(app, env)
+          @app = app
+          @machine = env[:machine]
+          @client = client
+          @logger = Log4r::Logger.new('vagrant::linode::destroy')
+        end
+
+        def call(env)
+          # submit destroy linode request
+          @client.linode.delete(linodeid: @machine.id, skipchecks: true)
+
+          env[:ui].info I18n.t('vagrant_linode.info.destroying')
+
+          # set the machine id to nil to cleanup local vagrant state
+          @machine.id = nil
+
+          @app.call(env)
+        end
+      end
+    end
+  end
+end

data/lib/vagrant-linode/actions/modify_provision_path.rb

@@ -0,0 +1,38 @@
+module VagrantPlugins
+  module Linode
+    module Actions
+      class ModifyProvisionPath
+        def initialize(app, env)
+          @app = app
+          @machine = env[:machine]
+          @logger =
+            Log4r::Logger.new('vagrant::linode::modify_provision_path')
+        end
+
+        def call(env)
+          # check if provisioning is enabled
+          enabled = true
+          enabled = env[:provision_enabled] if env.key?(:provision_enabled)
+          return @app.call(env) unless enabled
+
+          username = @machine.ssh_info[:username]
+
+          # change ownership of the provisioning path recursively to the
+          # ssh user
+          #
+          # TODO submit patch to vagrant to set appropriate permissions
+          # based on ssh username
+          @machine.config.vm.provisioners.each do |provisioner|
+            cfg = provisioner.config
+            path = cfg.upload_path if cfg.respond_to? :upload_path
+            path = cfg.provisioning_path if cfg.respond_to? :provisioning_path
+            @machine.communicate.sudo("chown -R #{username} #{path}",
+                                      error_check: false)
+          end
+
+          @app.call(env)
+        end
+      end
+    end
+  end
+end

data/lib/vagrant-linode/actions/power_off.rb

@@ -0,0 +1,32 @@
+require 'vagrant-linode/helpers/client'
+# TODO: --force
+module VagrantPlugins
+  module Linode
+    module Actions
+      class PowerOff
+        include Helpers::Client
+
+        def initialize(app, env)
+          @app = app
+          @machine = env[:machine]
+          @client = client
+          @logger = Log4r::Logger.new('vagrant::linode::power_off')
+        end
+
+        def call(env)
+          # submit power off linode request
+          result = @client.linode.shutdown(linodeid: @machine.id)
+
+          # wait for request to complete
+          env[:ui].info I18n.t('vagrant_linode.info.powering_off')
+          wait_for_event(env, result['jobid'])
+
+          # refresh linode state with provider
+          Provider.linode(@machine, refresh: true)
+
+          @app.call(env)
+        end
+      end
+    end
+  end
+end

data/lib/vagrant-linode/actions/power_on.rb

@@ -0,0 +1,32 @@
+require 'vagrant-linode/helpers/client'
+
+module VagrantPlugins
+  module Linode
+    module Actions
+      class PowerOn
+        include Helpers::Client
+
+        def initialize(app, env)
+          @app = app
+          @machine = env[:machine]
+          @client = client
+          @logger = Log4r::Logger.new('vagrant::linode::power_on')
+        end
+
+        def call(env)
+          # submit power on linode request
+          result = @client.linode.boot(linodeid: @machine.id)
+
+          # wait for request to complete
+          env[:ui].info I18n.t('vagrant_linode.info.powering_on')
+          wait_for_event(env, result['jobid'])
+
+          # refresh linode state with provider
+          Provider.linode(@machine, refresh: true)
+
+          @app.call(env)
+        end
+      end
+    end
+  end
+end