vagrant-linode 0.1.3 → 0.2.0

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

@@ -8,26 +8,26 @@ include Vagrant::Util::Retryable
 module VagrantPlugins
   module Linode
     module Helpers
-      module Client
-        def client
-          def wait_for_event(env, id)
-            retryable(tries: 120, sleep: 10) do
-              # stop waiting if interrupted
-              next if env[:interrupted]
-              # check action status
-              result = @client.linode.job.list(jobid: id, linodeid: env[:machine].id)
-              result = result[0] if result.is_a?(Array)
-
-              yield result if block_given?
-              fail 'not ready' if result['host_finish_dt'] > ''
-            end
-          end
-          linodeapi = ::LinodeAPI::Raw.new(apikey: @machine.provider_config.token,
-				      endpoint: @machine.provider_config.api_url || nil)
-          # linodeapi.wait_for_event = wait_for_event
-          # linodeapi.extend wait_for_event
-        end
-      end
+#      module Client
+#        def client
+#          def wait_for_event(env, id)
+#            retryable(tries: 120, sleep: 10) do
+#              # stop waiting if interrupted
+#              next if env[:interrupted]
+#              # check action status
+#              result = @client.linode.job.list(jobid: id, linodeid: env[:machine].id)
+#              result = result[0] if result.is_a?(Array)
+#
+#              yield result if block_given?
+#              fail 'not ready' if result['host_finish_dt'] > ''
+#            end
+#          end
+#          linodeapi = ::LinodeAPI::Raw.new(apikey: @machine.provider_config.api_key,
+#                                           endpoint: @machine.provider_config.api_url || nil)
+#          # linodeapi.wait_for_event = wait_for_event
+#          # linodeapi.extend wait_for_event
+#        end
+#      end
 
       class ApiClient
         include Vagrant::Util::Retryable
@@ -35,69 +35,11 @@ module VagrantPlugins
         def initialize(machine)
           @logger = Log4r::Logger.new('vagrant::linode::apiclient')
           @config = machine.provider_config
-	  @client = ::LinodeAPI::Raw.new(apikey: @config.token, endpoint: @config.api_url || nil)
+          @client = ::LinodeAPI::Raw.new(apikey: @config.api_key, endpoint: @config.api_url || nil)
         end
 
         attr_reader :client
 
-        def delete(path, params = {}, _method = :delete)
-          @client.request :url_encoded
-          request(path, params, :delete)
-        end
-
-        def post(path, params = {}, _method = :post)
-          @client.headers['Content-Type'] = 'application/json'
-          request(path, params, :post)
-        end
-
-        def request(path, params = {}, method = :get)
-          begin
-            @logger.info "Request: #{path}"
-            result = @client.send(method) do |req|
-              req.url path, params
-              req.headers['Authorization'] = "Bearer #{@config.token}"
-            end
-          rescue Faraday::Error::ConnectionFailed => e
-            # TODO this is suspect but because farady wraps the exception
-            #      in something generic there doesn't appear to be another
-            #      way to distinguish different connection errors :(
-            if e.message =~ /certificate verify failed/
-              raise Errors::CertificateError
-            end
-
-            raise e
-          end
-
-          unless method == :delete
-            begin
-              body = JSON.parse(result.body)
-              @logger.info "Response: #{body}"
-              next_page = body['links']['pages']['next'] rescue nil
-              unless next_page.nil?
-                uri = URI.parse(next_page)
-                new_path = path.split('?')[0]
-                next_result = request("#{new_path}?#{uri.query}")
-                req_target = new_path.split('/')[-1]
-                body["#{req_target}"].concat(next_result["#{req_target}"])
-              end
-            rescue JSON::ParserError => e
-              raise(Errors::JSONError, message: e.message,
-                                       path: path,
-                                       params: params,
-                                       response: result.body)
-            end
-          end
-
-          unless /^2\d\d$/ =~ result.status.to_s
-            fail(Errors::APIStatusError, path: path,
-                                         params: params,
-                                         status: result.status,
-                                         response: body.inspect)
-          end
-
-          Result.new(body)
-        end
-
         def wait_for_event(env, id)
           retryable(tries: 120, sleep: 10) do
             # stop waiting if interrupted

data/lib/vagrant-linode/helpers/waiter.rb

@@ -0,0 +1,21 @@
+module VagrantPlugins
+  module Linode
+    module Helpers
+      module Waiter
+        include Vagrant::Util::Retryable
+        def wait_for_event(env, id)
+          retryable(tries: 120, sleep: 10) do
+            # stop waiting if interrupted
+            next if env[:interrupted]
+            # check action status
+            result = env[:linode_api].linode.job.list(jobid: id, linodeid: env[:machine].id)
+            result = result[0] if result.is_a?(Array)
+
+            yield result if block_given?
+            fail 'not ready' if result['host_finish_dt'] > ''
+          end
+        end
+      end
+    end
+  end
+end

data/lib/vagrant-linode/plugin.rb

@@ -1,3 +1,15 @@
+begin
+  require 'vagrant'
+rescue LoadError
+  raise 'The Linode provider 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.1.0'
+  fail 'Linode provider is only compatible with Vagrant 1.1+'
+end
+
 module VagrantPlugins
   module Linode
     class Plugin < Vagrant.plugin('2')
@@ -13,10 +25,18 @@ module VagrantPlugins
       end
 
       provider(:linode, parallel: true) do
+        Linode.init_i18n
+        Linode.init_logging
+
         require_relative 'provider'
         Provider
       end
 
+      command(:linode) do
+        require_relative 'commands/root'
+        Commands::Root
+      end
+
       command(:rebuild) do
         require_relative 'commands/rebuild'
         Commands::Rebuild

data/lib/vagrant-linode/provider.rb

@@ -1,13 +1,22 @@
+require 'vagrant-linode/helpers/client'
 require 'vagrant-linode/actions'
 
 module VagrantPlugins
   module Linode
     class Provider < Vagrant.plugin('2', :provider)
+      def initialize(machine)
+        @machine = machine
+      end
+
       # This class method caches status for all linodes within
       # the Linode account. A specific linode's status
       # may be refreshed by passing :refresh => true as an option.
       def self.linode(machine, opts = {})
-        client = Helpers::ApiClient.new(machine).client
+	client = Helpers::ApiClient.new(machine).client
+
+        # @todo how do I reuse VagrantPlugins::Linode::Actions::ConnectLinode ?
+        # ..and nuke the helper
+        # client = env[:linode_api]
 
         # load status of linodes if it has not been done before
         unless @linodes
@@ -20,7 +29,7 @@ module VagrantPlugins
           linode = client.linode.list(linodeid: machine.id).first
           linode.network = client.linode.ip.list linodeid: linode['linodeid']
           @linodes << linode
-        else
+	elsif machine.id
           # lookup linode status for the given machine
           linode = @linodes.find { |d| d['linodeid'].to_s == machine.id }
         end
@@ -37,15 +46,12 @@ module VagrantPlugins
         linode ||= { status: :not_created }
       end
 
-      def initialize(machine)
-        @machine = machine
-      end
-
       # Attempt to get the action method from the Action class if it
       # exists, otherwise return nil to show that we don't support the
       # given action.
       def action(name)
-        return Actions.send(name) if Actions.respond_to?(name)
+        action_method = "action_#{name}"
+        return Actions.send(action_method) if Actions.respond_to?(action_method)
         nil
       end
 
@@ -56,6 +62,9 @@ module VagrantPlugins
       # is simply the machine instance given to this object. And no
       # return value is necessary.
       def machine_id_changed
+        if @machine.id
+          Provider.linode(@machine, refresh: true)
+	end
       end
 
       # This should return a hash of information that explains how to
@@ -77,40 +86,26 @@ module VagrantPlugins
       # `ssh` prompt with a password, whereas we can pass a private key
       # via commandline.
       def ssh_info
-        linode = Provider.linode(@machine, refresh: true)
-
-        return nil if self.state.id != :active
-
-        public_network = linode.network.find { |network| network['ispublic'] == 1 }
-
-        {
-          host: public_network['ipaddress'],
-          port: '22',
-          username: 'root',
-          private_key_path: @machine.config.ssh.private_key_path
-        }
+        env = @machine.action('read_ssh_info')
+        env[:machine_ssh_info]
       end
 
       # This should return the state of the machine within this provider.
       # The state must be an instance of {MachineState}. Please read the
       # documentation of that class for more information.
       def state
-        status = Provider.linode(@machine)['status']
-        states = {
-		    ""  => :not_created,
-		    '-2' => :boot_failed,
-		    '-1' => :being_created,
-	            '0' => :brand_new, # brand new
-	            '1' => :active, # running
-	            '2' => :off, # powered off
-		    '3' => :shutting_down
-                 }
-        id = long = short = states[status.to_s]
-        Vagrant::MachineState.new(id, short, long)
+        env = @machine.action('read_state')
+        state_id = env[:machine_state]
+
+        short = I18n.t("vagrant_linode.states.short_#{state_id}")
+        long = I18n.t("vagrant_linode.states.long_#{state_id}")
+
+        Vagrant::MachineState.new(state_id, short, long)
       end
 
       def to_s
-	"Linode"
+        id = @machine.id.nil? ? 'new' : @machine.id
+        "Linode (#{id})"
       end
     end
   end

data/lib/vagrant-linode/version.rb

@@ -1,5 +1,5 @@
 module VagrantPlugins
   module Linode
-    VERSION = '0.1.3'
+    VERSION = '0.2.0'
   end
 end

data/locales/en.yml

@@ -23,8 +23,24 @@ en:
       trying_rsync_install: "Rsync not found, attempting to install with yum..."
       rsyncing: "Rsyncing folder: %{hostpath} => %{guestpath}..."
       rsync_missing: "The rsync executable was not found in the current path."
+    states:
+      short_not_created: "Not Created"
+      short_boot_failed: "Boot Failed"
+      short_being_created: "Being Created"
+      short_brand_new: "Brand New"
+      short_active: "Active"
+      short_off: "Powered Off"
+      short_shutting_down: "Shutting Down"
+      long_not_created: "Linode has not been created"
+      long_boot_failed: "Linode boot failed"
+      long_being_created: "Linode is created"
+      long_brand_new: "Linode is brand new"
+      long_active: "Linode is active"
+      long_off: "Linode is powered off"
+      long_shutting_down: "Linode is shutting down"
     config:
-      token: "Token is required"
+      api_key: "API Key is required"
+      token: "Config option token is deprecated. Use api_key."
       private_key: "SSH private key path is required"
       public_key: "SSH public key not found: %{key}"
       disk_too_large: "Disk Images use more drive space than plan allocates"

data/spec/spec_helper.rb

@@ -0,0 +1,20 @@
+if ENV['COVERAGE'] != 'false'
+  require 'simplecov'
+  require 'coveralls'
+  SimpleCov.formatter = SimpleCov::Formatter::MultiFormatter[
+    SimpleCov::Formatter::HTMLFormatter,
+    Coveralls::SimpleCov::Formatter
+  ]
+  SimpleCov.start
+
+  # Normally classes are lazily loaded, so any class without a test
+  # is missing from the report.  This ensures they show up so we can
+  # see uncovered methods.
+  require 'vagrant'
+  Dir['lib/**/*.rb'].each do|file|
+    require_string = file.match(/lib\/(.*)\.rb/)[1]
+    require require_string
+  end
+end
+
+require 'linode'

data/spec/vagrant-linode/actions/list_distributions_spec.rb

@@ -0,0 +1,47 @@
+require 'spec_helper'
+require 'vagrant-linode/actions/list_distributions'
+
+describe VagrantPlugins::Linode::Actions::ListImages do
+  let(:app) { lambda { |_env| } }
+  let(:ui) { Vagrant::UI::Silent.new }
+  let(:distributions) do
+    Fog.mock!
+    Fog::Compute.new(provider: :linode,
+                     linode_region: :dfw,
+                     linode_api_key: 'anything',
+                     linode_username: 'anything').distributions
+  end
+  let(:compute_connection) { double('fog connection') }
+  let(:env) do
+    {
+      linode_compute: compute_connection,
+      ui: ui
+    }
+  end
+
+  subject(:action) { described_class.new(app, env) }
+
+  before do
+    allow(compute_connection).to receive(:distributions).and_return distributions
+  end
+
+  it 'get distributions from Fog' do
+    expect(compute_connection).to receive(:distributions).and_return distributions
+    action.call(env)
+  end
+
+  it 'writes a sorted, formatted image table to Vagrant::UI' do
+    header_line = '%-36s %s' % ['Image ID', 'Image Name']
+    expect(ui).to receive(:info).with(header_line)
+    distributions.sort_by(&:name).each do |image|
+      formatted_line = '%-36s %s' % [image.id.to_s, image.name]
+      expect(ui).to receive(:info).with formatted_line
+    end
+    action.call(env)
+  end
+
+  it 'continues the middleware chain' do
+    expect(app).to receive(:call).with(env)
+    action.call(env)
+  end
+end

data/spec/vagrant-linode/actions/list_plans_spec.rb

@@ -0,0 +1,47 @@
+require 'spec_helper'
+require 'vagrant-linode/actions/list_plans'
+
+describe VagrantPlugins::Linode::Actions::ListPlans do
+  let(:app) { lambda { |_env| } }
+  let(:ui) { Vagrant::UI::Silent.new }
+  let(:plans) do
+    Fog.mock!
+    Fog::Compute.new(provider: :linode,
+                     linode_datacenter: :dallas,
+                     linode_api_key: 'anything',
+                     linode_username: 'anything').plans
+  end
+  let(:compute_connection) { double('fog connection') }
+  let(:env) do
+    {
+      linode_compute: compute_connection,
+      ui: ui
+    }
+  end
+
+  subject(:action) { described_class.new(app, env) }
+
+  before do
+    allow(compute_connection).to receive(:plans).and_return plans
+  end
+
+  it 'get plans from Fog' do
+    expect(compute_connection).to receive(:plans).and_return plans
+    action.call(env)
+  end
+
+  it 'writes a sorted, formatted plan table to Vagrant::UI' do
+    header_line = '%-36s %s' % ['Plan ID', 'Plan Name']
+    expect(ui).to receive(:info).with(header_line)
+    plans.sort_by(&:id).each do |plan|
+      formatted_line = '%-36s %s' % [plan.id, plan.name]
+      expect(ui).to receive(:info).with formatted_line
+    end
+    action.call(env)
+  end
+
+  it 'continues the middleware chain' do
+    expect(app).to receive(:call).with(env)
+    action.call(env)
+  end
+end

data/spec/vagrant-linode/config_spec.rb

@@ -0,0 +1,189 @@
+require 'spec_helper'
+require 'vagrant-linode/config'
+
+describe VagrantPlugins::Linode::Config do
+  describe 'defaults' do
+    let(:vagrant_public_key) { Vagrant.source_root.join('keys/vagrant.pub') }
+
+    subject do
+      super().tap(&:finalize!)
+    end
+
+    its(:api_key)  { should be_nil }
+    its(:api_url)  { should be_nil }
+    its(:distribution) { should eq(/Ubuntu/) }
+    its(:datacenter) { should eq(/dallas/) }
+    its(:plan) { should eq(/1024/) }
+    its(:paymentterm)   { should eq(/1/) }
+    its(:private_networking)    { should eq(/Ubuntu/) }
+    its(:ca_path) { should eql(vagrant_public_key) }
+    its(:ssh_key_name) { should eq(/Vagrant/) }
+    its(:setup) { should eq(true) }
+    its(:xvda_size) { should eq(true) }
+    its(:swap_size) { should eq(256) }
+  end
+
+  describe 'overriding defaults' do
+    [:api_key,
+     :api_url,
+     :distribution,
+     :plan,
+     :paymentterm,
+     :private_networking,
+     :ca_path,
+     :ssh_key_name,
+     :setup,
+     :xvda_size,
+     :swap_size].each do |attribute|
+      it "should not default #{attribute} if overridden" do
+        subject.send("#{attribute}=".to_sym, 'foo')
+        subject.finalize!
+        subject.send(attribute).should == 'foo'
+      end
+    end
+
+    it 'should not default plan if overridden' do
+      plan = 'Linode 2048'
+      subject.send(:plan, plan)
+      subject.finalize!
+      subject.send(:plan).should include(plan)
+    end
+
+  end
+
+  describe 'validation' do
+    let(:machine) { double('machine') }
+    let(:validation_errors) { subject.validate(machine)['Linode Provider'] }
+    let(:error_message) { double('error message') }
+
+    before(:each) do
+      machine.stub_chain(:env, :root_path).and_return '/'
+      subject.api_key = 'bar'
+    end
+
+    subject do
+      super().tap(&:finalize!)
+    end
+
+    context 'with invalid key' do
+      it 'should raise an error' do
+        subject.nonsense1 = true
+        subject.nonsense2 = false
+        I18n.should_receive(:t).with('vagrant.config.common.bad_field',
+                                     fields: 'nonsense1, nonsense2')
+        .and_return error_message
+        validation_errors.first.should == error_message
+      end
+    end
+    context 'with good values' do
+      it 'should validate' do
+        validation_errors.should be_empty
+      end
+    end
+
+    context 'the API key' do
+      it 'should error if not given' do
+        subject.api_key = nil
+        I18n.should_receive(:t).with('vagrant_linode.config.api_key').and_return error_message
+        validation_errors.first.should == error_message
+      end
+    end
+
+    context 'the public key path' do
+      it "should have errors if the key doesn't exist" do
+        subject.public_key_path = 'missing'
+        I18n.should_receive(:t).with('vagrant_linode.config.public_key_not_found').and_return error_message
+        validation_errors.first.should == error_message
+      end
+      it 'should not have errors if the key exists with an absolute path' do
+        subject.public_key_path = File.expand_path 'locales/en.yml', Dir.pwd
+        validation_errors.should be_empty
+      end
+      it 'should not have errors if the key exists with a relative path' do
+        machine.stub_chain(:env, :root_path).and_return '.'
+        subject.public_key_path = 'locales/en.yml'
+        validation_errors.should be_empty
+      end
+    end
+
+    context 'the username' do
+      it 'should error if not given' do
+        subject.username = nil
+        I18n.should_receive(:t).with('vagrant_linode.config.username_required').and_return error_message
+        validation_errors.first.should == error_message
+      end
+    end
+
+    [:linode_compute_url, :linode_auth_url].each do |url|
+      context "the #{url}" do
+        it 'should not validate if the URL is invalid' do
+          subject.send "#{url}=", 'baz'
+          I18n.should_receive(:t).with('vagrant_linode.config.invalid_uri', key: url, uri: 'baz').and_return error_message
+          validation_errors.first.should == error_message
+        end
+      end
+    end
+  end
+
+  describe 'linode_auth_url' do
+    it 'should return UNSET_VALUE if linode_auth_url and linode_region are UNSET' do
+      subject.linode_auth_url.should == VagrantPlugins::Linode::Config::UNSET_VALUE
+    end
+    it 'should return UNSET_VALUE if linode_auth_url is UNSET and linode_region is :ord' do
+      subject.linode_region = :ord
+      subject.linode_auth_url.should == VagrantPlugins::Linode::Config::UNSET_VALUE
+    end
+    it 'should return UK Authentication endpoint if linode_auth_url is UNSET and linode_region is :lon' do
+      subject.linode_region = :lon
+      subject.linode_auth_url.should == Fog::Linode::UK_AUTH_ENDPOINT
+    end
+    it 'should return custom endpoint if supplied and linode_region is :lon' do
+      my_endpoint = 'http://custom-endpoint.com'
+      subject.linode_region = :lon
+      subject.linode_auth_url = my_endpoint
+      subject.linode_auth_url.should == my_endpoint
+    end
+    it 'should return custom endpoint if supplied and linode_region is UNSET' do
+      my_endpoint = 'http://custom-endpoint.com'
+      subject.linode_auth_url = my_endpoint
+      subject.linode_auth_url.should == my_endpoint
+    end
+  end
+
+  describe 'lon_region?' do
+    it 'should return false if linode_region is UNSET_VALUE' do
+      subject.linode_region = VagrantPlugins::Linode::Config::UNSET_VALUE
+      subject.send(:lon_region?).should be_false
+    end
+    it 'should return false if linode_region is nil' do
+      subject.linode_region = nil
+      subject.send(:lon_region?).should be_false
+    end
+    it 'should return false if linode_region is :ord' do
+      subject.linode_region = :ord
+      subject.send(:lon_region?).should be_false
+    end
+    it "should return true if linode_region is 'lon'" do
+      subject.linode_region = 'lon'
+      subject.send(:lon_region?).should be_true
+    end
+    it 'should return true if linode_Region is :lon' do
+      subject.linode_region = :lon
+      subject.send(:lon_region?).should be_true
+    end
+  end
+
+  describe 'network' do
+    it 'should remove SERVICE_NET_ID if :service_net is detached' do
+      subject.send(:network, :service_net, attached: false)
+      subject.send(:networks).should_not include(VagrantPlugins::Linode::Config::SERVICE_NET_ID)
+    end
+
+    it 'should not allow duplicate networks' do
+      net_id = 'deadbeef-0000-0000-0000-000000000000'
+      subject.send(:network, net_id)
+      subject.send(:network, net_id)
+      subject.send(:networks).count(net_id).should == 1
+    end
+  end
+end