vagrant-vultr_pro 0.2.1

data/lib/vagrant-vultr/config.rb

@@ -0,0 +1,76 @@
+module VagrantPlugins
+  module Vultr
+    class Config < Vagrant.plugin(2, :config)
+      attr_accessor :token
+      attr_accessor :region
+      attr_accessor :os
+      attr_accessor :snapshot
+      attr_accessor :plan
+      attr_accessor :enable_ipv6
+      attr_accessor :enable_private_network
+      attr_accessor :label
+      attr_accessor :tag
+      attr_accessor :hostname
+      attr_accessor :timeout
+      attr_accessor :ssh_key
+      attr_accessor :startup_script
+
+      def initialize
+        @token = UNSET_VALUE
+        @region = UNSET_VALUE
+        @os = UNSET_VALUE
+        @snapshot = UNSET_VALUE
+        @plan = UNSET_VALUE
+        @enable_ipv6 = UNSET_VALUE
+        @enable_private_network = UNSET_VALUE
+        @label    = UNSET_VALUE
+        @tag      = UNSET_VALUE
+        @hostname = UNSET_VALUE
+        @timeout  = UNSET_VALUE
+        @ssh_key = UNSET_VALUE
+        @startup_script = UNSET_VALUE
+      end
+
+      def finalize!
+        @token = ENV['VULTR_TOKEN'] if @token == UNSET_VALUE
+        @region = 'Seattle' if @region == UNSET_VALUE
+        @os = 'Ubuntu 14.04 x64' if @os == UNSET_VALUE && @snapshot == UNSET_VALUE
+        @plan = '768 MB RAM,15 GB SSD,1.00 TB BW' if @plan == UNSET_VALUE
+        @snapshot = nil if @snapshot == UNSET_VALUE
+        @enable_ipv6 = 'no' if @enable_ipv6 == UNSET_VALUE
+        @enable_private_network = 'no' if @enable_private_network == UNSET_VALUE
+        @label    = ''  if @label    == UNSET_VALUE
+        @tag      = ''  if @tag      == UNSET_VALUE
+        @hostname = ''  if @hostname == UNSET_VALUE
+        @script   = ''  if @script   == UNSET_VALUE
+        @timeout  = 300 if @timeout  == UNSET_VALUE
+        @ssh_key = 'vagrant' if @ssh_key == UNSET_VALUE
+        @startup_script = '' if @startup_script == UNSET_VALUE
+      end
+
+      def validate(machine)
+        errors = []
+
+        key = machine.config.ssh.private_key_path
+        key = key.first if key.is_a?(Array)
+        if !key
+          errors << 'You have to specify config.ssh.private_key_path.'
+        elsif !File.file?(File.expand_path("#{key}.pub", machine.env.root_path))
+          errors << "Cannot find SSH public key: #{key}.pub."
+        end
+
+        if both_os_and_snapshot_provided?
+          errors << 'You have to specify one of provider.os or provider.snapshot.'
+        end
+
+        {'vultr' => errors}
+      end
+
+      private
+
+      def both_os_and_snapshot_provided?
+        @os != UNSET_VALUE && @snapshot
+      end
+    end
+  end
+end

data/lib/vagrant-vultr/helpers/client.rb

@@ -0,0 +1,156 @@
+require 'vultr/vultr'
+require 'vagrant/util/retryable'
+
+module VagrantPlugins
+  module Vultr
+    module Helpers
+      module Client
+        def client
+          @client ||= ApiClient.new(@machine.provider_config.token, @machine.provider_config.timeout)
+        end
+      end
+
+
+      class ApiClient
+        include Vagrant::Util::Retryable
+
+        TimeoutError = Class.new(StandardError)
+
+        def initialize(token, timeout)
+          ::Vultr.api_key = token
+          @timeout = timeout || 300
+        end
+
+        def servers
+          servers = request { ::Vultr::Server.list }
+          servers = servers.values if servers.any?
+
+          servers
+        end
+
+        def server(sub_id)
+          servers.find { |server| server['SUBID'] == sub_id }
+        end
+
+        def create_server(attributes)
+          params = {
+            DCID: region_id(attributes[:region]),
+            VPSPLANID: vps_plan_id(attributes[:plan]),
+            SSHKEYID: ssh_key_id(attributes[:ssh_key_name]),
+            SCRIPTID: startup_script_id(attributes[:startup_script_name]),
+            enable_ipv6: attributes[:enable_ipv6],
+            enable_private_network: attributes[:enable_private_network],
+            label:    attributes[:label],
+            tag:      attributes[:tag],
+            hostname: attributes[:hostname]
+          }
+
+          if attributes[:snapshot]
+            params.merge!(OSID: os_id('Snapshot'), SNAPSHOTID: attributes[:snapshot])
+          else
+            params.merge!(OSID: os_id(attributes[:os]))
+          end
+
+          request { ::Vultr::Server.create(params) }['SUBID']
+        end
+
+        def start_server(sub_id)
+          request { ::Vultr::Server.start(SUBID: sub_id) }
+        end
+
+        def reboot_server(sub_id)
+          request { ::Vultr::Server.reboot(SUBID: sub_id) }
+        end
+
+        def stop_server(sub_id)
+          request { ::Vultr::Server.halt(SUBID: sub_id) }
+        end
+
+        def destroy_server(sub_id)
+          request { ::Vultr::Server.destroy(SUBID: sub_id) }
+        end
+
+        def os_id(os)
+          oses = request { ::Vultr::OS.list }
+          oses.values.find { |o| o['name'] == os }['OSID']
+        end
+
+        def region_id(region)
+          regions = request { ::Vultr::Regions.list }
+          regions.values.find { |r| r['name'] == region }['DCID']
+        end
+
+        def vps_plan_id(plan)
+          plans = request { ::Vultr::Plans.list }
+          plans.values.find { |p| p['name'] == plan }['VPSPLANID']
+        end
+
+        def startup_script_id(startup_script_name)
+          scripts = request { ::Vultr::StartupScript.list }
+          script = scripts.values.find { |s| s['name'] == startup_script_name }
+          script['SCRIPTID'] if script
+        end
+
+        def ssh_key_id(ssh_key_name)
+          ssh_keys = request { ::Vultr::SSHKey.list }
+          ssh_key = ssh_keys.values.find { |s| s['name'] == ssh_key_name }
+          ssh_key['SSHKEYID'] if ssh_key
+        end
+
+        def create_ssh_key(name, key)
+          request { ::Vultr::SSHKey.create(name: name, ssh_key: key) }['SSHKEYID']
+        end
+
+        def wait_to_activate(sub_id)
+          wait_until do
+            # it might be not shown in API for some reason
+            server = server(sub_id)
+            server && server['status'] == 'active'
+          end
+        end
+
+        def wait_to_power_on(sub_id)
+          wait_until do
+            # it might be not shown in API for some reason
+            server = server(sub_id)
+            server && server['status'] == 'active' && server['power_status'] == 'running' && server['server_state'] == 'ok'
+          end
+        end
+
+        def wait_to_destroy(sub_id)
+          wait_until { !server(sub_id) }
+        end
+
+        # @todo Fix the case when SSH key is not ready so it asks for password
+        # @todo Extract away from client?
+        def wait_for_ssh(machine)
+          # SSH may be unreachable after server is started
+          wait_until(Errno::ENETUNREACH) do
+            machine.communicate.wait_for_ready(@timeout)
+          end
+        end
+
+        private
+
+        def request
+          if interval = ENV['VULTR_RATE_LIMIT_INTERVAL_MS']
+            sleep interval.to_f / 1000
+          end
+
+          response = yield
+          if response[:status] != 200
+            raise "API request failed: #{response[:result]}."
+          else
+            response[:result]
+          end
+        end
+
+        def wait_until(exception = TimeoutError)
+          retryable(tries: @timeout, sleep: 1, on: exception) do
+            yield or raise exception
+          end
+        end
+      end
+    end
+  end
+end

data/lib/vagrant-vultr/plugin.rb

@@ -0,0 +1,18 @@
+module VagrantPlugins
+  module Vultr
+    class Plugin < Vagrant.plugin(2)
+      name 'vagrant-vultr_pro'
+      description 'Plugin allows to use Vultr as provider'
+
+      config(:vultr, :provider) do
+        require_relative 'config'
+        Config
+      end
+
+      provider(:vultr) do
+        require_relative 'provider'
+        Provider
+      end
+    end
+  end
+end

data/lib/vagrant-vultr/provider.rb

@@ -0,0 +1,48 @@
+require 'vagrant-vultr/helpers/client'
+
+module VagrantPlugins
+  module Vultr
+    class Provider < Vagrant.plugin(2, :provider)
+      include Helpers::Client
+
+      def initialize(machine)
+        @machine = machine
+        @client = client
+      end
+
+      def action(name)
+        return unless Action.respond_to?(name)
+        Action.__send__(name)
+      end
+
+      def state
+        server = @client.server(@machine.id)
+
+        if server
+          if server['status'] == 'active' && server['power_status'] == 'running'
+            state = :active
+          else
+            state = :off
+          end
+        else
+          state = :not_created
+        end
+
+        long = short = state.to_s
+        Vagrant::MachineState.new(state, short, long)
+      end
+
+      def ssh_info
+        server = @client.server(@machine.id)
+        return if server['status'] != 'active' && server['power_status'] != 'running'
+
+        {
+          host: server['main_ip'],
+          port: '22',
+          username: 'root',
+          PasswordAuthentication: 'no'
+        }
+      end
+    end
+  end
+end

data/lib/vagrant-vultr_pro.rb

@@ -0,0 +1,12 @@
+require 'vagrant'
+
+require 'vagrant-vultr/action'
+require 'vagrant-vultr/plugin'
+
+module VagrantPlugins
+  module Vultr
+    def self.source_root
+      @source_root ||= Pathname.new(File.expand_path('../../', __FILE__))
+    end
+  end
+end

data/lib/vultr/version.rb

@@ -0,0 +1,10 @@
+module Vultr
+  module VERSION
+    MAJOR = 0
+    MINOR = 4
+    TINY  = 3
+    PRE   = nil
+
+    STRING = [MAJOR, MINOR, TINY, PRE].compact.join('.')
+  end
+end