vagrant-actionio 0.0.9

data/lib/vagrant-actionio/connection.rb

@@ -0,0 +1,70 @@
+require 'vagrant-actionio/util/env'
+require 'vagrant-actionio/errors'
+require 'vagrant-actionio/version'
+require 'oauth2'
+
+ENV['SSL_CERT_FILE'] = File.join(File.expand_path('../../../', __FILE__), '/data/cacert.pem')
+
+module VagrantPlugins
+  module ActionIO
+    class Connection
+      OAUTH_CLIENT_ID     = Util::Env.read_with_default('VAGRANT_ACTIONIO_OAUTH_ID', '414b8765a91db88e3d9d2a391eb19117a652b23ec7c1222fd61ddb59d0298072')
+      OAUTH_CLIENT_SECRET = Util::Env.read_with_default('VAGRANT_ACTIONIO_OAUTH_SECRET', 'd64a2c76e05126366d9627f165978a2a810c6b853c853df805e22f7390e59950')
+      VERIFY_SSL = ENV['VAGRANT_ACTIONIO_VERIFY_SSL'] != 'false'
+      HOST       = Util::Env.read_with_default('VAGRANT_ACTIONIO_HOST', 'https://www.action.io')
+      API_PATH_PREFIX = '/api/v0'
+      USER_AGENT = "Vagrant-ActionIO/#{VERSION} (Vagrant #{Vagrant::VERSION}; #{RUBY_DESCRIPTION})"
+
+      attr_accessor :client, :token
+
+      def initialize(access_token_string)
+        options = { site: HOST }
+        options[:ssl] = { verify_mode: OpenSSL::SSL::VERIFY_NONE } if !VERIFY_SSL
+        @client = OAuth2::Client.new(OAUTH_CLIENT_ID, OAUTH_CLIENT_SECRET, options)
+        @token = OAuth2::AccessToken.new(client, access_token_string)
+      end
+
+      def request(verb, path, options={})
+        options = { parse: :json }.merge options
+        options[:headers] ||= {}
+        options[:headers]['User-Agent'] = USER_AGENT
+
+        @token.request verb.to_sym, "#{API_PATH_PREFIX}#{path}", options
+      end
+
+      def verify_access_token
+        response = request(:get, '/scopes')
+      rescue => e
+        if e.response && e.response.status == 401
+          raise Errors::APIError, 'invalid_access_token'
+        else
+          raise e
+        end
+      else
+        if response.status == 200
+          json = JSON.parse(response.body)
+          if json.kind_of?(Hash) && json['scopes'].split.include?('boxes')
+            return
+          else
+            raise Errors::APIError, 'invalid_access_token_scope'
+          end
+        end
+      end
+
+      def fetch_box_state(box_id)
+        begin
+          response = request(:get, "/boxes/#{box_id}")
+        rescue => e
+          if e.respond_to?(:response) && e.response.status == 404
+            # The box can't be found
+            return nil
+          else
+            raise e
+          end
+        end
+
+        response.parsed['box']['state'].to_sym
+      end
+    end
+  end
+end

data/lib/vagrant-actionio/errors.rb

@@ -0,0 +1,35 @@
+require 'vagrant'
+
+module VagrantPlugins
+  module ActionIO
+    module Errors
+      class VagrantActionIOError < Vagrant::Errors::VagrantError
+        error_namespace('vagrant_actionio.errors')
+      end
+
+      class APIError < VagrantActionIOError
+        error_key(:api_error)
+      end
+
+      class BoxNotYetStartedError < VagrantActionIOError
+        error_key(:box_not_yet_started_error)
+      end
+
+      class BoxNotYetStoppedError < VagrantActionIOError
+        error_key(:box_not_yet_stopped_error)
+      end
+
+      class BoxNotYetTerminatedError < VagrantActionIOError
+        error_key(:box_not_yet_terminated_error)
+      end
+
+      class RsyncError < VagrantActionIOError
+        error_key(:rsync_error)
+      end
+
+      class TimeoutError < VagrantActionIOError
+        error_key(:timeout_error)
+      end
+    end
+  end
+end

data/lib/vagrant-actionio/plugin.rb

@@ -0,0 +1,73 @@
+begin
+  require 'vagrant'
+rescue LoadError
+  raise 'The Vagrant Action.IO plugin 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'
+  raise 'The Vagrant Action.IO plugin is only compatible with Vagrant 1.1+'
+end
+
+module VagrantPlugins
+  module ActionIO
+    class Plugin < Vagrant.plugin('2')
+      name 'Action.IO'
+      description <<-DESC
+      This plugin installs a provider that allows Vagrant to manage
+      boxes in Action.IO.
+      DESC
+
+      config(:actionio, :provider) do
+        require_relative 'config'
+        Config
+      end
+
+      provider(:actionio) do
+        # Setup logging and i18n
+        setup_logging
+        setup_i18n
+
+        # Return the provider
+        require_relative 'provider'
+        Provider
+      end
+
+      # This initializes the internationalization strings.
+      def self.setup_i18n
+        I18n.load_path << File.expand_path('locales/en.yml', ActionIO.source_root)
+        I18n.reload!
+      end
+
+      # This sets up our log level to be whatever VAGRANT_LOG is.
+      def self.setup_logging
+        require 'log4r'
+
+        level = nil
+        begin
+          level = Log4r.const_get(ENV['VAGRANT_LOG'].upcase)
+        rescue NameError
+          # This means that the logging constant wasn't found,
+          # which is fine. We just keep `level` as `nil`. But
+          # we tell the user.
+          level = nil
+        end
+
+        # Some constants, such as "true" resolve to booleans, so the
+        # above error checking doesn't catch it. This will check to make
+        # sure that the log level is an integer, as Log4r requires.
+        level = nil if !level.is_a?(Integer)
+
+        # Set the logging level on all "vagrant" namespaced
+        # logs as long as we have a valid level.
+        if level
+          logger = Log4r::Logger.new('vagrant_actionio')
+          logger.outputters = Log4r::Outputter.stderr
+          logger.level = level
+          logger = nil
+        end
+      end
+    end
+  end
+end

data/lib/vagrant-actionio/provider.rb

@@ -0,0 +1,50 @@
+require 'log4r'
+require 'vagrant'
+
+module VagrantPlugins
+  module ActionIO
+    class Provider < Vagrant.plugin('2', :provider)
+      def initialize(machine)
+        @machine = machine
+      end
+
+      def action(name)
+        # 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.
+        action_method = "action_#{name}"
+        return Action.send(action_method) if Action.respond_to?(action_method)
+        nil
+      end
+
+      def ssh_info
+        # Run a custom action called 'read_ssh_info' which does what it
+        # says and puts the resulting SSH info into the `:machine_ssh_info`
+        # key in the environment.
+        env = @machine.action('read_ssh_info')
+        env[:machine_ssh_info]
+      end
+
+      def state
+        # Run a custom action we define called 'read_state' which does
+        # what it says. It puts the state in the `:machine_state_id`
+        # key in the environment.
+        env = @machine.action('read_state')
+
+        state_id = env[:machine_state_id]
+
+        # Get the short and long description
+        short = I18n.t("vagrant_actionio.states.short_#{state_id}")
+        long  = I18n.t("vagrant_actionio.states.long_#{state_id}")
+
+        # Return the MachineState object
+        Vagrant::MachineState.new(state_id, short, long)
+      end
+
+      def to_s
+        id = @machine.id.nil? ? 'new' : @machine.id
+        "Action.IO (#{id})"
+      end
+    end
+  end
+end

data/lib/vagrant-actionio/util/env.rb

@@ -0,0 +1,12 @@
+module VagrantPlugins
+  module ActionIO
+    module Util
+      class Env
+        def self.read_with_default(env_var, default)
+          value = ENV[env_var]
+          value.nil? ? default : value
+        end
+      end
+    end
+  end
+end

data/lib/vagrant-actionio/util/timer.rb

@@ -0,0 +1,17 @@
+module VagrantPlugins
+  module ActionIO
+    module Util
+      class Timer
+        # A basic utility method that times the execution of the given
+        # block and returns it.
+        def self.time
+          start_time = Time.now.to_f
+          yield
+          end_time = Time.now.to_f
+
+          end_time - start_time
+        end
+      end
+    end
+  end
+end

data/lib/vagrant-actionio/version.rb

@@ -0,0 +1,5 @@
+module VagrantPlugins
+  module ActionIO
+    VERSION = '0.0.9'
+  end
+end

data/locales/en.yml

@@ -0,0 +1,121 @@
+en:
+  vagrant_actionio:
+    already_created: |-
+      The box already exists on Action.IO.
+    already_terminated: |-
+      The box is already terminated on Action.IO.
+    cannot_terminate: |-
+      The box needs to be in either "running" or "stopped" state to be terminatable.
+    launching_box: |-
+      Launching a box on Action.IO with the following settings...
+    not_created: |-
+      Your box on Action.IO is not created. Please create your box by running `vagrant up` first.
+    not_running: |-
+      Your box on Action.IO is not running. Please start your box by running `vagrant up` first.
+    provisioning_not_yet_supported: |-
+      Vagrant provisioning is coming soon, but not yet supported. Please check https://github.com/action-io/vagrant-actionio for updates.
+    ready: |-
+      Your box on Action.IO is running and ready for use!
+    rsync_folder: |-
+      Rsyncing folder: %{hostpath} => %{guestpath}
+    starting_box: |-
+      Starting the box on Action.IO...
+    stopped: |-
+      Your box on Action.IO is stopped.
+    stopping_box: |-
+      Stopping the box on Action.IO...
+    terminated: |-
+      Your box on Action.IO is terminated.
+    terminating_box: |-
+      Terminating the box on Action.IO...
+    warn_networks: |-
+      Warning! The Action.IO provider doesn't support any of the Vagrant
+      high-level network configurations (`config.vm.network`). They
+      will be silently ignored.
+
+    config:
+      access_token_required: |-
+        An access token must be specified via "access_token"
+
+      private_key_missing: |-
+        The specified SSH private key could not be found
+
+      region_required: |-
+        A region must be specified via "region"
+
+      ssh_private_key_path_required: |-
+        A path to an ssh private key must be specified via "ssh_private_key_path"
+
+    errors:
+      api_error: |-
+        There was an error talking to Action.IO. The error message is shown below:
+
+        %{message}
+
+      box_not_yet_started_error: |-
+        Box is not yet started.
+
+      box_not_yet_stopped_error: |-
+        Box is not yet stopped.
+
+      box_not_yet_terminated_error: |-
+        Box is not yet terminated.
+
+      invalid_access_token: |-
+        Access token is invalid.
+
+      invalid_access_token_scope: |-
+        Access token does not have "boxes" scope.
+
+      rsync_error: |-
+        There was an error when attemping to rsync a shared folder.
+        Please inspect the error message below for more info.
+
+        Host path: %{hostpath}
+        Guest path: %{guestpath}
+        Error: %{stderr}
+
+      timeout_error: |-
+        Box creation timed out.
+
+    states:
+      short_not_created: |-
+        not created
+      long_not_created: |-
+        The Action.IO box is not created. Run `vagrant up` to create it.
+
+      short_provisioning: |-
+        provisioning
+      long_provisioning: |-
+        The Action.IO box is being created.
+
+      short_running: |-
+        running
+      long_running: |-
+        The Action.IO box is running. To stop this machine, you can run
+        `vagrant halt`. To destroy the machine, you can run `vagrant destroy`.
+
+      short_starting: |-
+        starting
+      long_starting: |-
+        The Action.IO box is starting.
+
+      short_stopped: |-
+        stopped
+      long_stopped: |-
+        The Action.IO box is stopped. Run `vagrant up` to start it.
+
+      short_stopping: |-
+        stopping
+      long_stopping: |-
+        The Action.IO box is stopping.
+
+      short_terminated: |-
+        terminated
+      long_terminated: |-
+        The Action.IO box is terminated.
+
+      short_terminating: |-
+        terminating
+      long_terminating: |-
+        The Action.IO box is terminating.

data/spec/vagrant-actionio/action/read_ssh_info_spec.rb

@@ -0,0 +1,58 @@
+require 'vagrant-actionio/action/read_ssh_info'
+require 'ostruct'
+
+describe VagrantPlugins::ActionIO::Action::ReadSSHInfo do
+  let(:app) { double 'app', call: nil }
+  let(:instance) { VagrantPlugins::ActionIO::Action::ReadSSHInfo.new(app, env) }
+
+  context 'when machine id is nil' do
+    let(:machine) { double 'machine', id: nil }
+    let(:env) { { actionio: nil, machine: machine } }
+
+    it 'returns nil' do
+      instance.call(env)
+      expect(env[:machine_ssh_info]).to be_nil
+    end
+  end
+
+  context 'when machine id is not nil' do
+    let(:machine) { OpenStruct.new(id: 123) }
+    let!(:actionio) { double 'connection', request: nil }
+    let(:env) { { actionio: actionio, machine: machine } }
+
+    context 'when request is successful' do
+      before do
+        json = '{"box":{"id":123,"host":"foo-box-123.usw1.actionbox.io","port":12345}}'
+        response = double 'response', status: 200, body: json, parsed: JSON.parse(json)
+        actionio.should_receive(:request).with(:get, '/boxes/123').and_return response
+        machine.stub_chain(:provider_config, :ssh_private_key_path).and_return '/home/action/.ssh/id_rsa'
+      end
+
+      it 'makes a get request to /boxes/:id and returns a hash containing the ssh info' do
+        instance.call(env)
+        expect(env[:machine_ssh_info]).to eq({
+          host: 'foo-box-123.usw1.actionbox.io',
+          port: '12345',
+          private_key_path: '/home/action/.ssh/id_rsa',
+          username: 'action'
+        })
+      end
+    end
+
+    context 'when request returns 404' do
+      before do
+        response = double 'response', status: 404
+        error = StandardError.new('request error')
+        error.stub(:response) { response }
+        actionio.should_receive(:request).with(:get, '/boxes/123').and_raise error
+      end
+
+      it 'sets machine id to be nil and returns nil' do
+        instance.call(env)
+        expect(env[:machine].id).to be_nil
+        expect(env[:machine_ssh_info]).to be_nil
+      end
+    end
+  end
+end
+