vagrant-actionio 0.0.9

data/lib/vagrant-actionio/action/read_state.rb

@@ -0,0 +1,36 @@
+require 'log4r'
+require 'vagrant-actionio/errors'
+
+module VagrantPlugins
+  module ActionIO
+    module Action
+      # This action reads the state of the machine and puts it in the
+      # `:machine_state_id` key in the environment.
+      class ReadState
+        def initialize(app, env)
+          @app    = app
+          @logger = Log4r::Logger.new("vagrant_actionio::action::read_state")
+        end
+
+        def call(env)
+          env[:machine_state_id] = read_state(env[:actionio], env[:machine])
+
+          @app.call(env)
+        end
+
+        def read_state(actionio, machine)
+          return :not_created if machine.id.nil?
+
+          # Find the box
+          state = actionio.fetch_box_state(machine.id)
+          if state.nil?
+            @logger.info("Box not found on Action.IO, assuming it got destroyed.")
+            machine.id = nil
+            return :not_created
+          end
+          state
+        end
+      end
+    end
+  end
+end

data/lib/vagrant-actionio/action/remove_machine_id.rb

@@ -0,0 +1,19 @@
+module VagrantPlugins
+  module ActionIO
+    module Action
+      # This can be used with "Call" built-in to check if the machine
+      # is terminated and branch in the middleware.
+      class RemoveMachineId
+        def initialize(app, env)
+          @app = app
+        end
+
+        def call(env)
+          env[:machine].id = nil
+
+          @app.call(env)
+        end
+      end
+    end
+  end
+end

data/lib/vagrant-actionio/action/run_instance.rb

@@ -0,0 +1,94 @@
+require 'log4r'
+require 'vagrant/util/retryable'
+require 'vagrant-actionio/util/timer'
+require 'vagrant-actionio/errors'
+require 'securerandom'
+
+module VagrantPlugins
+  module ActionIO
+    module Action
+      # This runs the configured instance.
+      class RunInstance
+        include Vagrant::Util::Retryable
+
+        def initialize(app, env)
+          @app    = app
+          @logger = Log4r::Logger.new('vagrant_actionio::action::run_instance')
+        end
+
+        def call(env)
+          # Initialize metrics if they haven't been
+          env[:metrics] ||= {}
+
+          actionio = env[:actionio]
+          machine = env[:machine]
+
+          # Get the configs
+          config = machine.provider_config
+          box_name = "vagrant-#{SecureRandom.hex 5}"
+          region = config.region
+          stack = config.stack
+
+          # Launch!
+          env[:ui].info I18n.t('vagrant_actionio.launching_box')
+          env[:ui].info " -- Box Name: #{box_name}"
+          env[:ui].info " -- Region: #{region}"
+          env[:ui].info " -- Stack: #{stack}"
+
+          create_box(actionio, machine, box_name, region, stack)
+
+          # Poll server to check whether the box is ready
+          env[:ui].info(I18n.t('vagrant_actionio.starting_box'))
+
+          # Wait 15 seconds first
+          sleep 15.0
+
+          wait_for_box_to_start(env)
+
+          if !env[:interrupted]
+            # Ready and booted!
+            env[:ui].info(I18n.t('vagrant_actionio.ready'))
+          end
+
+          # Terminate the instance if we were interrupted
+          #terminate(env) if env[:interrupted]
+
+          @logger.info("Time to instance ready: #{env[:metrics]["instance_ready_time"]}")
+
+          @app.call(env)
+        end
+
+        def create_box(actionio, machine, box_name, region, stack)
+          response = actionio.request(:post, '/boxes', params: { box: { name: box_name, region: region, box_template: stack } })
+
+          # save box id
+          machine.id = response.parsed['box']['id']
+        end
+
+        def wait_for_box_to_start(env)
+          actionio = env[:actionio]
+          machine = env[:machine]
+          env[:metrics]['instance_ready_time'] = Util::Timer.time do
+            retryable(on: Errors::BoxNotYetStartedError, tries: 10, sleep: 5.0) do
+              # If we're interrupted don't worry about waiting
+              next if env[:interrupted]
+
+              # check for the box's status
+              if actionio.fetch_box_state(machine.id) != :running
+                raise Errors::BoxNotYetStartedError
+              end
+            end
+          end
+        end
+
+        def terminate(env)
+          destroy_env = env.dup
+          destroy_env.delete(:interrupted)
+          destroy_env[:config_validate] = false
+          destroy_env[:force_confirm_destroy] = true
+          env[:action_runner].run(Action.action_destroy, destroy_env)
+        end
+      end
+    end
+  end
+end

data/lib/vagrant-actionio/action/start_instance.rb

@@ -0,0 +1,56 @@
+require 'log4r'
+require 'vagrant/util/retryable'
+require 'vagrant-actionio/errors'
+
+module VagrantPlugins
+  module ActionIO
+    module Action
+      # This runs the configured instance.
+      class StartInstance
+        include Vagrant::Util::Retryable
+
+        def initialize(app, env)
+          @app    = app
+          @logger = Log4r::Logger.new('vagrant_actionio::action::start_instance')
+        end
+
+        def call(env)
+          actionio = env[:actionio]
+          machine = env[:machine]
+
+          start_box(actionio, machine)
+
+          # Poll server to check whether the box is ready
+          env[:ui].info(I18n.t('vagrant_actionio.starting_box'))
+
+          # Wait 10 seconds first
+          sleep 10.0
+
+          wait_for_box_to_start(env)
+
+          env[:ui].info(I18n.t('vagrant_actionio.ready'))
+
+          @app.call(env)
+        end
+
+        def start_box(actionio, machine)
+          actionio.request(:put, "/boxes/#{machine.id}/start")
+        end
+
+        def wait_for_box_to_start(env)
+          actionio = env[:actionio]
+          machine = env[:machine]
+          retryable(on: Errors::BoxNotYetStartedError, tries: 10, sleep: 3.0) do
+            # If we're interrupted don't worry about waiting
+            next if env[:interrupted]
+
+            # check for the box's status
+            if actionio.fetch_box_state(machine.id) != :running
+              raise Errors::BoxNotYetStartedError
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/vagrant-actionio/action/stop_instance.rb

@@ -0,0 +1,56 @@
+require 'log4r'
+require 'vagrant/util/retryable'
+require 'vagrant-actionio/errors'
+
+module VagrantPlugins
+  module ActionIO
+    module Action
+      # This runs the configured instance.
+      class StopInstance
+        include Vagrant::Util::Retryable
+
+        def initialize(app, env)
+          @app    = app
+          @logger = Log4r::Logger.new('vagrant_actionio::action::stop_instance')
+        end
+
+        def call(env)
+          actionio = env[:actionio]
+          machine = env[:machine]
+
+          stop_box(actionio, machine)
+
+          # Poll server to check whether the box is ready
+          env[:ui].info(I18n.t('vagrant_actionio.stopping_box'))
+
+          # Wait 10 seconds first
+          sleep 10.0
+
+          wait_for_box_to_stop(env)
+
+          env[:ui].info(I18n.t('vagrant_actionio.stopped'))
+
+          @app.call(env)
+        end
+
+        def stop_box(actionio, machine)
+          actionio.request(:put, "/boxes/#{machine.id}/stop")
+        end
+
+        def wait_for_box_to_stop(env)
+          actionio = env[:actionio]
+          machine = env[:machine]
+          retryable(on: Errors::BoxNotYetStoppedError, tries: 10, sleep: 3.0) do
+            # If we're interrupted don't worry about waiting
+            next if env[:interrupted]
+
+            # check for the box's status
+            if actionio.fetch_box_state(machine.id) != :stopped
+              raise Errors::BoxNotYetStoppedError
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,57 @@
+require 'log4r'
+
+require 'vagrant/util/subprocess'
+
+module VagrantPlugins
+  module ActionIO
+    module Action
+      # This middleware uses `rsync` to sync the folders over to the
+      # Action.IO box.
+      class SyncFolders
+        def initialize(app, env)
+          @app    = app
+          @logger = Log4r::Logger.new("vagrant_actionio::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 = File.join('/home/action', 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_actionio.rsync_folder",
+                                :hostpath => hostpath,
+                                :guestpath => guestpath))
+
+            # Create the guest path
+            env[:machine].communicate.execute("mkdir -p '#{guestpath}'")
+            env[:machine].communicate.execute(
+              "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-actionio/action/terminate_instance.rb

@@ -0,0 +1,57 @@
+require 'log4r'
+require 'vagrant/util/retryable'
+require 'vagrant-actionio/errors'
+
+module VagrantPlugins
+  module ActionIO
+    module Action
+      # This terminates the running instance.
+      class TerminateInstance
+        include Vagrant::Util::Retryable
+
+        def initialize(app, env)
+          @app    = app
+          @logger = Log4r::Logger.new('vagrant_actionio::action::terminate_instance')
+        end
+
+        def call(env)
+          actionio = env[:actionio]
+          machine = env[:machine]
+
+          # Destroy the server and remove the tracking ID
+          env[:ui].info(I18n.t('vagrant_actionio.terminating_box'))
+          terminate_box(actionio, machine)
+
+          # Wait 15 seconds first
+          sleep 15.0
+
+          wait_for_box_to_terminate(env)
+
+          machine.id = nil
+
+          env[:ui].info(I18n.t('vagrant_actionio.terminated'))
+
+          @app.call(env)
+        end
+
+        def terminate_box(actionio, machine)
+          actionio.request(:delete, "/boxes/#{machine.id}")
+        end
+
+        def wait_for_box_to_terminate(env)
+          actionio = env[:actionio]
+          machine = env[:machine]
+          retryable(on: Errors::BoxNotYetTerminatedError, tries: 10, sleep: 3.0) do
+            # If we're interrupted don't worry about waiting
+            next if env[:interrupted]
+
+            # check for the box's status
+            if actionio.fetch_box_state(machine.id) != :terminated
+              raise Errors::BoxNotYetTerminatedError
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,21 @@
+require 'vagrant-actionio/util/timer'
+
+module VagrantPlugins
+  module ActionIO
+    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-actionio/action/warn_networks.rb

@@ -0,0 +1,19 @@
+module VagrantPlugins
+  module ActionIO
+    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_actionio.warn_networks'))
+          end
+
+          @app.call(env)
+        end
+      end
+    end
+  end
+end

data/lib/vagrant-actionio/config.rb

@@ -0,0 +1,75 @@
+require 'vagrant'
+
+module VagrantPlugins
+  module ActionIO
+    class Config < Vagrant.plugin('2', :config)
+      # The access token for accessing Action.IO API.
+      #
+      # @return [String]
+      attr_accessor :access_token
+
+      # The name of the Action.IO region in which to create the box.
+      #
+      # @return [String]
+      attr_accessor :region
+
+      # The name of the Action.IO base stack (box template) to create the box.
+      #
+      # @return [String]
+      attr_accessor :stack
+
+      # The path to the SSH private key to use with the Action.IO box.
+      # This overrides the `config.ssh.private_key_path` variable.
+      #
+      # @return [String]
+      attr_accessor :ssh_private_key_path
+
+      def initialize(region_specific=false)
+        @access_token         = UNSET_VALUE
+        @region               = UNSET_VALUE
+        @stack                = UNSET_VALUE
+        @ssh_private_key_path = UNSET_VALUE
+
+        # Internal state (prefix with __ so they aren't automatically
+        # merged)
+        @__finalized = false
+      end
+
+      #-------------------------------------------------------------------
+      # Internal methods.
+      #-------------------------------------------------------------------
+
+      def finalize!
+        # The access token default to nil
+        @access_token = nil if @access_token == UNSET_VALUE
+
+        # Default region is usw-1
+        @region = 'us-west-1' if @region == UNSET_VALUE
+
+        # Box base stack defaults to rails
+        @stack = 'rails' if @stack == 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
+
+        # Mark that we finalized
+        @__finalized = true
+      end
+
+      def validate(machine)
+        errors = []
+
+        errors << I18n.t('vagrant_actionio.config.access_token_required') if @access_token.nil?
+        errors << I18n.t('vagrant_actionio.config.region_required') if @region.nil?
+        errors << I18n.t('vagrant_actionio.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_actionio.config.private_key_missing')
+        end
+
+        { 'Action.IO Provider' => errors }
+      end
+    end
+  end
+end