vagrant-linode 0.1.0

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

@@ -0,0 +1,53 @@
+require 'vagrant-linode/helpers/client'
+
+module VagrantPlugins
+  module Linode
+    module Actions
+      class Rebuild
+        include Helpers::Client
+        include Vagrant::Util::Retryable
+
+        def initialize(app, env)
+          @app = app
+          @machine = env[:machine]
+          @client = client
+          @logger = Log4r::Logger.new('vagrant::linode::rebuild')
+        end
+
+        def call(env)
+          # @todo find a convenient way to send provider_config back to the create action, reusing the diskid or configid
+          fail 'not implemented'
+          # look up image id
+          image_id = @client
+            .request('/v2/images')
+            .find_id(:images, name: @machine.provider_config.image)
+
+          # submit rebuild request
+          result = @client.post("/v2/linodes/#{@machine.id}/actions", type: 'rebuild',
+                                                                      image: image_id)
+
+          # wait for request to complete
+          env[:ui].info I18n.t('vagrant_linode.info.rebuilding')
+          wait_for_event(env, result['jobid'])
+
+          # refresh linode state with provider
+          Provider.linode(@machine, refresh: true)
+
+          # wait for ssh to be ready
+          switch_user = @machine.provider_config.setup?
+          user = @machine.config.ssh.username
+          @machine.config.ssh.username = 'root' if switch_user
+
+          retryable(tries: 120, sleep: 10) do
+            next if env[:interrupted]
+            fail 'not ready' unless @machine.communicate.ready?
+          end
+
+          @machine.config.ssh.username = user
+
+          @app.call(env)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,28 @@
+require 'vagrant-linode/helpers/client'
+
+module VagrantPlugins
+  module Linode
+    module Actions
+      class Reload
+        include Helpers::Client
+
+        def initialize(app, env)
+          @app = app
+          @machine = env[:machine]
+          @client = client
+          @logger = Log4r::Logger.new('vagrant::linode::reload')
+        end
+
+        def call(env)
+          # submit reboot linode request
+          result = @client.linode.reboot(linodeid: @machine.id)
+
+          # wait for request to complete
+          env[:ui].info I18n.t('vagrant_linode.info.reloading')
+          wait_for_event(env, result['jobid'])
+          @app.call(env)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,52 @@
+require 'vagrant-linode/helpers/client'
+
+module VagrantPlugins
+  module Linode
+    module Actions
+      class SetupKey
+        include Helpers::Client
+
+        def initialize(app, env)
+          @app = app
+          @machine = env[:machine]
+          @client = client
+          @logger = Log4r::Logger.new('vagrant::linode::setup_key')
+        end
+
+        # TODO check the content of the key to see if it has changed
+        def call(env)
+          ssh_key_name = @machine.provider_config.ssh_key_name
+
+          begin
+            # assigns existing ssh key id to env for use by other commands
+            env[:ssh_key_id] = @client
+              .request('/v2/account/keys')
+              .find_id(:ssh_keys, name: ssh_key_name)
+
+            env[:ui].info I18n.t('vagrant_linode.info.using_key', name: ssh_key_name)
+          rescue Errors::ResultMatchError
+            env[:ssh_key_id] = create_ssh_key(ssh_key_name, env)
+          end
+
+          @app.call(env)
+        end
+
+        private
+
+        def create_ssh_key(name, env)
+          # assumes public key exists on the same path as private key with .pub ext
+          path = @machine.config.ssh.private_key_path
+          path = path[0] if path.is_a?(Array)
+          path = File.expand_path(path, @machine.env.root_path)
+          pub_key = Linode.public_key(path)
+
+          env[:ui].info I18n.t('vagrant_linode.info.creating_key', name: name)
+
+          result = @client.post('/v2/account/keys', name: name,
+                                                    public_key: pub_key)
+          result['ssh_key']['id']
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,41 @@
+module VagrantPlugins
+  module Linode
+    module Actions
+      class SetupSudo
+        def initialize(app, env)
+          @app = app
+          @machine = env[:machine]
+          @logger = Log4r::Logger.new('vagrant::linode::setup_sudo')
+        end
+
+        def call(env)
+          # check if setup is enabled
+          return @app.call(env) unless @machine.provider_config.setup?
+
+          # override ssh username to root
+          user = @machine.config.ssh.username
+          @machine.config.ssh.username = 'root'
+
+          # check for guest name available in Vagrant 1.2 first
+          guest_name = @machine.guest.name if @machine.guest.respond_to?(:name)
+          guest_name ||= @machine.guest.to_s.downcase
+
+          case guest_name
+          when /redhat/
+            env[:ui].info I18n.t('vagrant_linode.info.modifying_sudo')
+
+            # disable tty requirement for sudo
+            @machine.communicate.execute(<<-'BASH')
+              sed -i'.bk' -e 's/\(Defaults\s\+requiretty\)/# \1/' /etc/sudoers
+            BASH
+          end
+
+          # reset ssh username
+          @machine.config.ssh.username = user
+
+          @app.call(env)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,62 @@
+module VagrantPlugins
+  module Linode
+    module Actions
+      class SetupUser
+        def initialize(app, env)
+          @app = app
+          @machine = env[:machine]
+          @logger = Log4r::Logger.new('vagrant::linode::setup_user')
+        end
+
+        def call(env)
+          # check if setup is enabled
+          return @app.call(env) unless @machine.provider_config.setup?
+
+          # check if a username has been specified
+          return @app.call(env) unless @machine.config.ssh.username
+
+          # override ssh username to root temporarily
+          user = @machine.config.ssh.username
+          @machine.config.ssh.username = 'root'
+
+          env[:ui].info I18n.t('vagrant_linode.info.creating_user', user: user)
+
+          # create user account
+          @machine.communicate.execute(<<-BASH)
+            if ! (grep ^#{user}: /etc/passwd); then
+              useradd -m -s /bin/bash #{user};
+            fi
+          BASH
+
+          # grant user sudo access with no password requirement
+          @machine.communicate.execute(<<-BASH)
+            if ! (grep #{user} /etc/sudoers); then
+              echo "#{user} ALL=(ALL:ALL) NOPASSWD: ALL" >> /etc/sudoers;
+            else
+              sed -i -e "/#{user}/ s/=.*/=(ALL:ALL) NOPASSWD: ALL/" /etc/sudoers;
+            fi
+          BASH
+
+          # create the .ssh directory in the users home
+          @machine.communicate.execute("su #{user} -c 'mkdir -p ~/.ssh'")
+
+          # add the specified key to the authorized keys file
+          path = @machine.config.ssh.private_key_path
+          path = path[0] if path.is_a?(Array)
+          path = File.expand_path(path, @machine.env.root_path)
+          pub_key = Linode.public_key(path)
+          @machine.communicate.execute(<<-BASH)
+            if ! grep '#{pub_key}' /home/#{user}/.ssh/authorized_keys; then
+              echo '#{pub_key}' >> /home/#{user}/.ssh/authorized_keys;
+            fi
+          BASH
+
+          # reset username
+          @machine.config.ssh.username = user
+
+          @app.call(env)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,80 @@
+require 'vagrant/util/subprocess'
+require 'vagrant/util/which'
+
+module VagrantPlugins
+  module Linode
+    module Actions
+      class SyncFolders
+        def initialize(app, env)
+          @app = app
+          @machine = env[:machine]
+          @logger = Log4r::Logger.new('vagrant::linode::sync_folders')
+        end
+
+        def call(env)
+          ssh_info = @machine.ssh_info
+
+          @machine.config.vm.synced_folders.each do |_id, data|
+            next if data[:disabled]
+
+            if @machine.guest.capability?(:rsync_installed)
+              installed = @machine.guest.capability(:rsync_installed)
+              unless installed
+                can_install = @machine.guest.capability?(:rsync_install)
+                fail Vagrant::Errors::RSyncNotInstalledInGuest unless can_install
+                @machine.ui.info I18n.t('vagrant.rsync_installing')
+                @machine.guest.capability(:rsync_install)
+              end
+            end
+
+            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/#{Regexp.last_match[1]}" }
+            end
+
+            env[:ui].info I18n.t('vagrant_linode.info.rsyncing', hostpath: hostpath,
+                                                                 guestpath: guestpath)
+
+            # create the guest path
+            @machine.communicate.sudo("mkdir -p #{guestpath}")
+            @machine.communicate.sudo(
+              "chown -R #{ssh_info[:username]} #{guestpath}")
+
+            key = ssh_info[:private_key_path]
+            key = key[0] if key.is_a?(Array)
+
+            # rsync over to the guest path using the ssh info
+            command = [
+              'rsync', '--verbose', '--archive', '-z', '--delete',
+              '-e', "ssh -p #{ssh_info[:port]} -o StrictHostKeyChecking=no -i '#{key}'",
+              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
+              fail Errors::RsyncError,
+                   guestpath: guestpath,
+                   hostpath: hostpath,
+                   stderr: r.stderr
+            end
+          end
+
+          @app.call(env)
+        end
+      end
+    end
+  end
+end

data/lib/vagrant-linode/actions.rb

@@ -0,0 +1,160 @@
+require 'vagrant-linode/actions/check_state'
+require 'vagrant-linode/actions/create'
+require 'vagrant-linode/actions/destroy'
+require 'vagrant-linode/actions/power_off'
+require 'vagrant-linode/actions/power_on'
+require 'vagrant-linode/actions/rebuild'
+require 'vagrant-linode/actions/reload'
+require 'vagrant-linode/actions/setup_user'
+require 'vagrant-linode/actions/setup_sudo'
+require 'vagrant-linode/actions/setup_key'
+require 'vagrant-linode/actions/sync_folders'
+require 'vagrant-linode/actions/modify_provision_path'
+
+module VagrantPlugins
+  module Linode
+    module Actions
+      include Vagrant::Action::Builtin
+
+      def self.destroy
+        Vagrant::Action::Builder.new.tap do |builder|
+          builder.use ConfigValidate
+          builder.use Call, CheckState do |env, b|
+            case env[:machine_state]
+            when :not_created
+              env[:ui].info I18n.t('vagrant_linode.info.not_created')
+            else
+              b.use Call, DestroyConfirm do |env2, b2|
+                if env2[:result]
+                  b2.use Destroy
+                  b2.use ProvisionerCleanup if defined?(ProvisionerCleanup)
+                end
+              end
+            end
+          end
+        end
+      end
+
+      def self.ssh
+        Vagrant::Action::Builder.new.tap do |builder|
+          builder.use ConfigValidate
+          builder.use Call, CheckState do |env, b|
+            case env[:machine_state]
+            when :active
+              b.use SSHExec
+            when :off
+              env[:ui].info I18n.t('vagrant_linode.info.off')
+            when :not_created
+              env[:ui].info I18n.t('vagrant_linode.info.not_created')
+            end
+          end
+        end
+      end
+
+      def self.ssh_run
+        Vagrant::Action::Builder.new.tap do |builder|
+          builder.use ConfigValidate
+          builder.use Call, CheckState do |env, b|
+            case env[:machine_state]
+            when :active
+              b.use SSHRun
+            when :off
+              env[:ui].info I18n.t('vagrant_linode.info.off')
+            when :not_created
+              env[:ui].info I18n.t('vagrant_linode.info.not_created')
+            end
+          end
+        end
+      end
+
+      def self.provision
+        Vagrant::Action::Builder.new.tap do |builder|
+          builder.use ConfigValidate
+          builder.use Call, CheckState do |env, b|
+            case env[:machine_state]
+            when :active
+              b.use Provision
+              b.use ModifyProvisionPath
+              b.use SyncFolders
+            when :off
+              env[:ui].info I18n.t('vagrant_linode.info.off')
+            when :not_created
+              env[:ui].info I18n.t('vagrant_linode.info.not_created')
+            end
+          end
+        end
+      end
+
+      def self.up
+        Vagrant::Action::Builder.new.tap do |builder|
+          builder.use ConfigValidate
+          builder.use Call, CheckState do |env, b|
+            case env[:machine_state]
+            when :active
+              env[:ui].info I18n.t('vagrant_linode.info.already_active')
+            when :off
+              b.use PowerOn
+              b.use provision
+            when :not_created
+              # b.use SetupKey # no access to ssh keys in linode api
+              b.use Create
+              b.use SetupSudo
+              b.use SetupUser
+              b.use provision
+            end
+          end
+        end
+      end
+
+      def self.halt
+        Vagrant::Action::Builder.new.tap do |builder|
+          builder.use ConfigValidate
+          builder.use Call, CheckState do |env, b|
+            case env[:machine_state]
+            when :active
+              b.use PowerOff
+            when :off
+              env[:ui].info I18n.t('vagrant_linode.info.already_off')
+            when :not_created
+              env[:ui].info I18n.t('vagrant_linode.info.not_created')
+            end
+          end
+        end
+      end
+
+      def self.reload
+        Vagrant::Action::Builder.new.tap do |builder|
+          builder.use ConfigValidate
+          builder.use Call, CheckState do |env, b|
+            case env[:machine_state]
+            when :active
+              b.use Reload
+              b.use provision
+            when :off
+              env[:ui].info I18n.t('vagrant_linode.info.off')
+            when :not_created
+              env[:ui].info I18n.t('vagrant_linode.info.not_created')
+            end
+          end
+        end
+      end
+
+      def self.rebuild
+        Vagrant::Action::Builder.new.tap do |builder|
+          builder.use ConfigValidate
+          builder.use Call, CheckState do |env, b|
+            case env[:machine_state]
+            when :active, :off
+              b.use Rebuild
+              b.use SetupSudo
+              b.use SetupUser
+              b.use provision
+            when :not_created
+              env[:ui].info I18n.t('vagrant_linode.info.not_created')
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/vagrant-linode/commands/rebuild.rb

@@ -0,0 +1,23 @@
+require 'optparse'
+
+module VagrantPlugins
+  module Linode
+    module Commands
+      class Rebuild < Vagrant.plugin('2', :command)
+        def execute
+          opts = OptionParser.new do |o|
+            o.banner = 'Usage: vagrant rebuild [vm-name]'
+          end
+
+          argv = parse_options(opts)
+
+          with_target_vms(argv) do |machine|
+            machine.action(:rebuild)
+          end
+
+          0
+        end
+      end
+    end
+  end
+end

data/lib/vagrant-linode/config.rb

@@ -0,0 +1,65 @@
+module VagrantPlugins
+  module Linode
+    class Config < Vagrant.plugin('2', :config)
+      attr_accessor :token
+      attr_accessor :api_url
+      attr_accessor :distribution
+      attr_accessor :datacenter
+      attr_accessor :plan
+      attr_accessor :paymentterm
+      attr_accessor :private_networking
+      attr_accessor :ca_path
+      attr_accessor :ssh_key_name
+      attr_accessor :setup
+      attr_accessor :xvda_size
+      attr_accessor :swap_size
+
+      alias_method :setup?, :setup
+
+      def initialize
+        @token              = UNSET_VALUE
+        @api_url            = UNSET_VALUE
+        @distribution       = UNSET_VALUE
+        @datacenter         = UNSET_VALUE
+        @plan               = UNSET_VALUE
+        @paymentterm        = UNSET_VALUE
+        @private_networking = UNSET_VALUE
+        @ca_path            = UNSET_VALUE
+        @ssh_key_name       = UNSET_VALUE
+        @setup              = UNSET_VALUE
+        @xvda_size          = UNSET_VALUE
+        @swap_size          = UNSET_VALUE
+      end
+
+      def finalize!
+        @token              = ENV['LINODE_TOKEN'] if @token == UNSET_VALUE
+        @api_url            = ENV['LINODE_URL'] if @api_url == UNSET_VALUE
+        @distribution       = 'Ubuntu 14.04 LTS' if @distribution == UNSET_VALUE
+        @datacenter         = 'dallas' if @datacenter == UNSET_VALUE
+        @plan               = 'Linode 1024' if @plan == UNSET_VALUE
+        @paymentterm        = '1' if @paymentterm == UNSET_VALUE
+        @private_networking = false if @private_networking == UNSET_VALUE
+        @ca_path            = nil if @ca_path == UNSET_VALUE
+        @ssh_key_name       = 'Vagrant' if @ssh_key_name == UNSET_VALUE
+        @setup              = true if @setup == UNSET_VALUE
+        @xvda_size          = true if @xvda_size == UNSET_VALUE
+        @swap_size          = '256' if @swap_size == UNSET_VALUE
+      end
+
+      def validate(machine)
+        errors = []
+        errors << I18n.t('vagrant_linode.config.token') unless @token
+
+        key = machine.config.ssh.private_key_path
+        key = key[0] if key.is_a?(Array)
+        if !key
+          errors << I18n.t('vagrant_linode.config.private_key')
+        elsif !File.file?(File.expand_path("#{key}.pub", machine.env.root_path))
+          errors << I18n.t('vagrant_linode.config.public_key', key: "#{key}.pub")
+        end
+
+        { 'Linode Provider' => errors }
+      end
+    end
+  end
+end

data/lib/vagrant-linode/errors.rb

@@ -0,0 +1,49 @@
+module VagrantPlugins
+  module Linode
+    module Errors
+      class LinodeError < Vagrant::Errors::VagrantError
+        error_namespace('vagrant_linode.errors')
+      end
+
+      class APIStatusError < LinodeError
+        error_key(:api_status)
+      end
+
+      class DiskSize < LinodeError
+        error_key(:disk_size)
+      end
+
+      class DistroMatch < LinodeError
+        error_key(:distro_match)
+      end
+
+      class JSONError < LinodeError
+        error_key(:json)
+      end
+
+      class ResultMatchError < LinodeError
+        error_key(:result_match)
+      end
+
+      class CertificateError < LinodeError
+        error_key(:certificate)
+      end
+
+      class LocalIPError < LinodeError
+        error_key(:local_ip)
+      end
+
+      class PlanID < LinodeError
+        error_key(:plan_id)
+      end
+
+      class PublicKeyError < LinodeError
+        error_key(:public_key)
+      end
+
+      class RsyncError < LinodeError
+        error_key(:rsync)
+      end
+    end
+  end
+end