vagrant-nitrousio 0.0.1

data/lib/vagrant-nitrousio/action/start.rb

@@ -0,0 +1,31 @@
+require 'log4r'
+require 'vagrant/util/retryable'
+require 'vagrant-nitrousio/errors'
+
+module VagrantPlugins
+  module NitrousIO
+    module Action
+      # This runs the configured instance.
+      class Start
+        include Vagrant::Util::Retryable
+
+        def initialize(app, env)
+          @app    = app
+          @logger = Log4r::Logger.new('vagrant_nitrousio::action::start_instance')
+        end
+
+        def call(env)
+          nitrousio = env[:nitrousio]
+          machine = env[:machine]
+          privileged = machine.provider_config.privileged
+
+          env[:ui].info(I18n.t('vagrant_nitrousio.starting_box'))
+          nitrousio.request(:post, "/containers/#{machine.id}/start", body: { privileged: privileged })
+          env[:ui].info(I18n.t('vagrant_nitrousio.box_ready'))
+
+          @app.call(env)
+        end
+      end
+    end
+  end
+end

data/lib/vagrant-nitrousio/action/stop.rb

@@ -0,0 +1,31 @@
+require 'log4r'
+require 'vagrant/util/retryable'
+require 'vagrant-nitrousio/errors'
+
+module VagrantPlugins
+  module NitrousIO
+    module Action
+      # This runs the configured instance.
+      class Stop
+        include Vagrant::Util::Retryable
+
+        def initialize(app, env)
+          @app    = app
+          @logger = Log4r::Logger.new('vagrant_nitrousio::action::stop_instance')
+        end
+
+        def call(env)
+          nitrousio = env[:nitrousio]
+          machine = env[:machine]
+
+          env[:ui].info(I18n.t('vagrant_nitrousio.stopping_box'))
+          nitrousio.request(:post, "/containers/#{machine.id}/stop")
+
+          env[:ui].info(I18n.t('vagrant_nitrousio.stopped'))
+
+          @app.call(env)
+        end
+      end
+    end
+  end
+end

data/lib/vagrant-nitrousio/action/sync_folders.rb

@@ -0,0 +1,57 @@
+require 'log4r'
+
+require 'vagrant/util/subprocess'
+
+module VagrantPlugins
+  module NitrousIO
+    module Action
+      # This middleware uses `rsync` to sync the folders over to the
+      # Nitrous.IO box.
+      class SyncFolders
+        def initialize(app, env)
+          @app    = app
+          @logger = Log4r::Logger.new("vagrant_nitrousio::action::sync_folders")
+        end
+
+        def call(env)
+          @app.call(env)
+
+          ssh_info = env[:machine].ssh_info
+
+          env[:machine].config.vm.synced_folders.each do |id, data|
+            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 !~ /\/$/
+
+            env[:ui].info(I18n.t("vagrant_nitrousio.rsync_folder",
+                                :hostpath => hostpath,
+                                :guestpath => guestpath))
+
+            # Create the guest path
+            env[:machine].communicate.sudo("mkdir -p '#{guestpath}'")
+            env[:machine].communicate.sudo(
+              "chown #{ssh_info[:username]} '#{guestpath}'")
+
+            # Rsync over to the guest path using the SSH info
+            command = [
+              "rsync", "--verbose", "--archive", "-z",
+              "-e", "ssh -p #{ssh_info[:port]} -i '#{ssh_info[:private_key_path]}' -o StrictHostKeyChecking=no -o UserKnownHostsFile=/dev/null -o LogLevel=FATAL",
+              hostpath,
+              "#{ssh_info[:username]}@#{ssh_info[:host]}:#{guestpath}"]
+
+            r = Vagrant::Util::Subprocess.execute(*command)
+            if r.exit_code != 0
+              raise Errors::RsyncError,
+                :guestpath => guestpath,
+                :hostpath => hostpath,
+                :stderr => r.stderr
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/vagrant-nitrousio/action/terminate.rb

@@ -0,0 +1,34 @@
+require 'log4r'
+require 'vagrant/util/retryable'
+require 'vagrant-nitrousio/errors'
+
+module VagrantPlugins
+  module NitrousIO
+    module Action
+      # This terminates the running instance.
+      class Terminate
+        include Vagrant::Util::Retryable
+
+        def initialize(app, env)
+          @app    = app
+          @logger = Log4r::Logger.new('vagrant_nitrousio::action::terminate_instance')
+        end
+
+        def call(env)
+          nitrousio = env[:nitrousio]
+          machine = env[:machine]
+
+          # Destroy the server and remove the tracking ID
+          env[:ui].info(I18n.t('vagrant_nitrousio.terminating_box'))
+          nitrousio.request(:delete, "/containers/#{machine.id}")
+
+          machine.id = nil
+
+          env[:ui].info(I18n.t('vagrant_nitrousio.terminated'))
+
+          @app.call(env)
+        end
+      end
+    end
+  end
+end

data/lib/vagrant-nitrousio/action/timed_provision.rb

@@ -0,0 +1,21 @@
+require 'vagrant-nitrousio/util/timer'
+
+module VagrantPlugins
+  module NitrousIO
+    module Action
+      # This is the same as the builtin provision except it times the
+      # provisioner runs.
+      class TimedProvision < Vagrant::Action::Builtin::Provision
+        def run_provisioner(env, prov)
+          timer = Util::Timer.time do
+            super
+          end
+
+          env[:metrics] ||= {}
+          env[:metrics]["provisioner_times"] ||= []
+          env[:metrics]["provisioner_times"] << [prov.class.to_s, timer]
+        end
+      end
+    end
+  end
+end

data/lib/vagrant-nitrousio/action/warn_networks.rb

@@ -0,0 +1,19 @@
+module VagrantPlugins
+  module NitrousIO
+    module Action
+      class WarnNetworks
+        def initialize(app, env)
+          @app = app
+        end
+
+        def call(env)
+          if env[:machine].config.vm.networks.length > 0
+            env[:ui].warn(I18n.t('vagrant_nitrousio.warn_networks'))
+          end
+
+          @app.call(env)
+        end
+      end
+    end
+  end
+end

data/lib/vagrant-nitrousio/action.rb

@@ -0,0 +1,166 @@
+require 'pathname'
+
+require 'vagrant/action/builder'
+
+module VagrantPlugins
+  module NitrousIO
+    module Action
+      # Include the built-in modules so we can use them as top-level things.
+      include Vagrant::Action::Builtin
+
+      # This action is called to halt the remote machine.
+      def self.action_halt
+        Vagrant::Action::Builder.new.tap do |b|
+          b.use ConfigValidate
+          b.use ConnectNitrousIO
+          b.use Call, IsRunning do |env, b2|
+            if !env[:result]
+              b2.use MessageNotRunning
+              next
+            end
+
+            b2.use Stop
+          end
+        end
+      end
+
+      # This action is called to terminate the remote machine.
+      def self.action_destroy
+        Vagrant::Action::Builder.new.tap do |b|
+          b.use ConfigValidate
+          b.use ConnectNitrousIO
+          b.use Call, IsTerminated do |env, b2|
+            if env[:result]
+              b2.use MessageAlreadyTerminated
+              b2.use RemoveMachineId
+              next
+            end
+
+            b2.use Call, IsRunning do |env, b3|
+              if env[:result]
+                b3.use Stop
+              end
+
+              b3.use Call, IsStopped do |env, b4|
+                if !env[:result]
+                  b4.use MessageCannotTerminate
+                  next
+                end
+                b4.use Terminate
+              end
+            end
+          end
+        end
+      end
+
+      # This action is called when `vagrant provision` is called.
+      def self.action_provision
+        Vagrant::Action::Builder.new.tap do |b|
+          b.use ConfigValidate
+          b.use Call, IsCreated do |env, b2|
+            if !env[:result]
+              b2.use MessageNotCreated
+              next
+            end
+
+            b2.use Provision
+            b2.use SyncFolders
+          end
+        end
+      end
+
+      # This action is called to read the SSH info of the machine. The
+      # resulting state is expected to be put into the `:machine_ssh_info`
+      # key.
+      def self.action_read_ssh_info
+        Vagrant::Action::Builder.new.tap do |b|
+          b.use ConfigValidate
+          b.use ConnectNitrousIO
+          b.use ReadSSHInfo
+        end
+      end
+
+      # This action is called to read the state of the machine. The
+      # resulting state is expected to be put into the `:machine_state_id`
+      # key.
+      def self.action_read_state
+        Vagrant::Action::Builder.new.tap do |b|
+          b.use ConfigValidate
+          b.use ConnectNitrousIO
+          b.use ReadState
+        end
+      end
+
+      # This action is called to SSH into the machine.
+      def self.action_ssh
+        Vagrant::Action::Builder.new.tap do |b|
+          b.use ConfigValidate
+          b.use Call, IsCreated do |env, b2|
+            if !env[:result]
+              b2.use MessageNotCreated
+              next
+            end
+
+            b2.use Call, IsRunning do |env, b3|
+              if !env[:result]
+                b3.use MessageNotRunning
+                next
+              end
+
+              b3.use SSHExec
+            end
+          end
+        end
+      end
+
+      # This action is called to bring the box up from nothing.
+      def self.action_up
+        Vagrant::Action::Builder.new.tap do |b|
+          b.use ConfigValidate
+          b.use ConnectNitrousIO
+
+          b.use Call, IsCreated do |env, b2|
+            if env[:result]
+              b2.use MessageAlreadyCreated
+              b2.use Call, IsStopped do |env, b3|
+                if env[:result]
+                  b3.use Start
+                end
+              end
+              next
+            end
+
+            b2.use Create
+            b2.use AddPubKey
+            b2.use action_provision
+          end
+        end
+      end
+
+      # The autoload farm
+      action_root = Pathname.new(File.expand_path('../action', __FILE__))
+      autoload :AddPubKey,                action_root.join('add_pub_key')
+      autoload :ConnectNitrousIO,         action_root.join('connect_nitrousio')
+      autoload :Create,                   action_root.join('create')
+      autoload :IsCreated,                action_root.join('is_created')
+      autoload :IsRunning,                action_root.join('is_running')
+      autoload :IsStopped,                action_root.join('is_stopped')
+      autoload :IsTerminated,             action_root.join('is_terminated')
+      autoload :MessageAlreadyCreated,    action_root.join('message_already_created')
+      autoload :MessageAlreadyTerminated, action_root.join('message_already_terminated')
+      autoload :MessageCannotTerminate,   action_root.join('message_cannot_terminate')
+      autoload :MessageNotCreated,        action_root.join('message_not_created')
+      autoload :MessageNotRunning,        action_root.join('message_not_running')
+      autoload :MessageProvisioningNotYetSupported, action_root.join('message_provisioning_not_yet_supported')
+      autoload :ReadSSHInfo,              action_root.join('read_ssh_info')
+      autoload :ReadState,                action_root.join('read_state')
+      autoload :RemoveMachineId,          action_root.join('remove_machine_id')
+      autoload :Start,                    action_root.join('start')
+      autoload :Stop,                     action_root.join('stop')
+      autoload :SyncFolders,              action_root.join('sync_folders')
+      autoload :Terminate,                action_root.join("terminate")
+      autoload :TimedProvision,           action_root.join('timed_provision')
+      autoload :WarnNetworks,             action_root.join('warn_networks')
+    end
+  end
+end

data/lib/vagrant-nitrousio/client.rb

@@ -0,0 +1,57 @@
+require 'vagrant-nitrousio/util/env'
+require 'vagrant-nitrousio/errors'
+require 'vagrant-nitrousio/version'
+require 'oauth2'
+
+module VagrantPlugins
+  module NitrousIO
+    class Client
+      HOST       = Util::Env.read_with_default('VAGRANT_NITROUSIO_HOST', 'https://pro.nitrous.io')
+      API_PATH_PREFIX = '/api/v0'
+      USER_AGENT = "Vagrant-NitrousIO/#{VERSION} (Vagrant #{Vagrant::VERSION}; #{RUBY_DESCRIPTION})"
+
+      attr_reader :connection, :access
+
+      def initialize
+        @connection = OAuth2::Client.new('', '', site: HOST, token_url: "#{API_PATH_PREFIX}/oauth/token")
+      end
+
+      def authorize(username, password)
+        @access = @connection.password.get_token(username, password)
+      rescue => e
+        if e.code == "invalid_grant"
+          raise Errors::AuthenticationFailedError, description: e.description
+        end
+        raise Errors::APIError, message: e.description
+      end
+
+      def request(verb, path, options={})
+        options = { parse: :json }.merge options
+        options[:headers] ||= {}
+        options[:headers]['User-Agent'] = USER_AGENT
+
+        @access.request verb.to_sym, "#{API_PATH_PREFIX}#{path}", options
+      rescue => e
+        case e.code
+        when "host_not_found"
+          raise Errors::HostNotFoundError
+        when "container_not_found"
+          raise Errors::ContainerNotFoundError
+        when "image_not_found"
+          raise Errors::ImageNotFoundError
+        else
+          raise Errors::APIError, message: e.description
+        end
+      end
+
+      def fetch_box_state(box_id)
+        response = request(:get, "/containers/#{box_id}")
+        response.parsed['container']['state'].to_sym
+      rescue Errors::ContainerNotFoundError => e
+        return nil
+      rescue => e
+        raise e
+      end
+    end
+  end
+end

data/lib/vagrant-nitrousio/config.rb

@@ -0,0 +1,94 @@
+require 'vagrant'
+
+module VagrantPlugins
+  module NitrousIO
+    class Config < Vagrant.plugin('2', :config)
+      # The username for accessing Nitrous.IO API.
+      #
+      # @return [String]
+      attr_accessor :username
+
+      # The password for accessing Nitrous.IO API.
+      #
+      # @return [String]
+      attr_accessor :password
+
+      # The slug of the Nitrous.IO host yout want to provision the box.
+      #
+      # @return [String]
+      attr_accessor :host
+
+      # The image repository to be used as the base when creating the box.
+      #
+      # @return [String]
+      attr_accessor :image
+
+      # Whether the container is privileged or not
+      #
+      # @return [Boolean]
+      attr_accessor :privileged
+
+      # The path to the SSH private key to use with the Nitrous.IO box.
+      # This overrides the `config.ssh.private_key_path` variable.
+      #
+      # @return [String]
+      attr_accessor :ssh_private_key_path
+
+      def initialize
+        @username             = UNSET_VALUE
+        @password             = UNSET_VALUE
+        @host                 = UNSET_VALUE
+        @image                = UNSET_VALUE
+        @ssh_private_key_path = UNSET_VALUE
+        @privileged           = UNSET_VALUE
+
+        # Internal state (prefix with __ so they aren't automatically
+        # merged)
+        @__finalized = false
+      end
+
+      #-------------------------------------------------------------------
+      # Internal methods.
+      #-------------------------------------------------------------------
+
+      def finalize!
+        # The username default to nil
+        @username = nil if @username == UNSET_VALUE
+
+        # The password default to nil
+        @password = nil if @password == UNSET_VALUE
+
+        # The host default to nil
+        @host = nil if @host == UNSET_VALUE
+
+        # The image default to nitrousio/vagrant-base
+        @image = 'nitrousio/vagrant:latest' if @image == UNSET_VALUE
+
+        # The SSH values by default are nil, and the top-level config
+        # `config.ssh` values are used.
+        @ssh_private_key_path = nil if @ssh_private_key_path == UNSET_VALUE
+
+        # The privileged flag is set to false by default
+        @privileged = false if @privileged == UNSET_VALUE
+
+        # Mark that we finalized
+        @__finalized = true
+      end
+
+      def validate(machine)
+        errors = []
+
+        errors << I18n.t('vagrant_nitrousio.config.username_required') if @username.nil?
+        errors << I18n.t('vagrant_nitrousio.config.password_required') if @password.nil?
+        errors << I18n.t('vagrant_nitrousio.config.host_required') if @host.nil?
+        errors << I18n.t('vagrant_nitrousio.config.ssh_private_key_path_required') if @ssh_private_key_path.nil?
+
+        if @ssh_private_key_path && !File.file?(File.expand_path(@ssh_private_key_path, machine.env.root_path))
+          errors << I18n.t('vagrant_nitrousio.config.private_key_missing')
+        end
+
+        { 'Nitrous.IO Provider' => errors }
+      end
+    end
+  end
+end

data/lib/vagrant-nitrousio/errors.rb

@@ -0,0 +1,55 @@
+require 'vagrant'
+
+module VagrantPlugins
+  module NitrousIO
+    module Errors
+      class VagrantNitrousIOError < Vagrant::Errors::VagrantError
+        error_namespace('vagrant_nitrousio.errors')
+      end
+
+      class APIError < VagrantNitrousIOError
+        error_key(:api_error)
+      end
+
+      class AuthenticationFailedError < VagrantNitrousIOError
+        error_key(:authentication_failed_error)
+      end
+
+      class HostNotFoundError < VagrantNitrousIOError
+        error_key(:host_not_found_error)
+      end
+
+      class ContainerNotFoundError < VagrantNitrousIOError
+        error_key(:container_not_found_error)
+      end
+
+      class ImageNotFoundError < VagrantNitrousIOError
+        error_key(:image_not_found_error)
+      end
+
+      class PublicKeyError < VagrantNitrousIOError
+        error_key(:public_key_error)
+      end
+
+      class BoxNotYetStartedError < VagrantNitrousIOError
+        error_key(:box_not_yet_started_error)
+      end
+
+      class BoxNotYetStoppedError < VagrantNitrousIOError
+        error_key(:box_not_yet_stopped_error)
+      end
+
+      class BoxNotYetTerminatedError < VagrantNitrousIOError
+        error_key(:box_not_yet_terminated_error)
+      end
+
+      class RsyncError < VagrantNitrousIOError
+        error_key(:rsync_error)
+      end
+
+      class TimeoutError < VagrantNitrousIOError
+        error_key(:timeout_error)
+      end
+    end
+  end
+end

data/lib/vagrant-nitrousio/plugin.rb

@@ -0,0 +1,73 @@
+begin
+  require 'vagrant'
+rescue LoadError
+  raise 'The Vagrant Nitrous.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.6.0'
+  raise 'The Vagrant Nitrous.IO plugin is only compatible with Vagrant 1.6+'
+end
+
+module VagrantPlugins
+  module NitrousIO
+    class Plugin < Vagrant.plugin('2')
+      name 'Nitrous.IO'
+      description <<-DESC
+      This plugin installs a provider that allows Vagrant to manage
+      boxes in Nitrous.IO.
+      DESC
+
+      config(:nitrousio, :provider) do
+        require_relative 'config'
+        Config
+      end
+
+      provider(:nitrousio, parallel: true) 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', NitrousIO.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_nitrousio')
+          logger.outputters = Log4r::Outputter.stderr
+          logger.level = level
+          logger = nil
+        end
+      end
+    end
+  end
+end

data/lib/vagrant-nitrousio/provider.rb

@@ -0,0 +1,50 @@
+require 'log4r'
+require 'vagrant'
+
+module VagrantPlugins
+  module NitrousIO
+    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_nitrousio.states.short_#{state_id}")
+        long  = I18n.t("vagrant_nitrousio.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
+        "Nitrous.IO (#{id})"
+      end
+    end
+  end
+end