vagrant-terraform 0.1.3

data/lib/vagrant-terraform/action/setup_terraform.rb

@@ -0,0 +1,42 @@
+require "log4r"
+require "open3"
+
+module VagrantPlugins
+  module TerraformProvider
+    module Action
+      # This action reads the state of the machine and puts it in the
+      # `:machine_state_id` key in the environment.
+      class SetupTerraform
+        def initialize(app, env)
+          @app    = app
+          @logger = Log4r::Logger.new("vagrant_terraform::action::setup_terraform")
+        end
+
+        def call(env)
+          raise "env[:machine_tf_dir] not set" if env[:machine_tf_dir].nil?
+
+          terraform_dir = env[:machine_tf_dir]
+          if File.exist?(terraform_dir) && File.exist?("#{terraform_dir}/terraform.tfstate")
+            env[:ui].info("Already initialized.")
+          else
+            # dir_name = env[:root_path].basename.to_s.dup.gsub(/[^-a-z0-9_]/i, "")
+            begin
+              Dir.mkdir(File.dirname(terraform_dir)) unless File.exist?(File.dirname(terraform_dir))
+            rescue => e
+              retry if e.message =~ /File exists/
+              env[:ui].error("terraform init failed: #{e.message}")
+            end
+
+            begin
+              Dir.mkdir(terraform_dir) unless File.exist?(terraform_dir)
+            rescue => e
+              retry if e.message =~ /File exists/
+              env[:ui].error("terraform init failed: #{e.message}")
+            end
+          end
+          @app.call(env)
+        end
+      end
+    end
+  end
+end

data/lib/vagrant-terraform/action/start_vm.rb

@@ -0,0 +1,51 @@
+require 'log4r'
+require 'vagrant-terraform/errors'
+require 'vagrant-terraform/util/terraform_execute'
+require 'vagrant-terraform/util/update_vm_state'
+
+module VagrantPlugins
+  module TerraformProvider
+    module Action
+
+      # Just start the VM.
+      class StartVM
+        include Util::TerraformExecute
+        include Util::UpdateVmState
+
+        def initialize(app, env)
+          @logger = Log4r::Logger.new("vagrant_terraform::action::start_vm")
+          @app = app
+        end
+
+        def call(env)
+          config = env[:machine].provider_config
+
+          env[:ui].info(I18n.t("vagrant_terraform.starting_vm"))
+
+          begin
+            terraform_dir = env[:machine_tf_dir]
+            terraform_main_file = "#{terraform_dir}/main.tf"
+            update_vm_state(terraform_main_file, "running")
+            terraform_execute(env, 'terraform apply -auto-approve')
+          rescue Exception => e
+            fault_message = /Error was \"\[?(.+?)\]?\".*/.match(e.message)[1] rescue e.message
+            # TODO: retry in some case?
+            # retry if e.message =~ /something/
+
+            if e.message !~ /VM is running/
+              if config.debug
+                raise e
+              else
+                raise Errors::StartVMError,
+                  :error_message => fault_message
+              end
+            end
+
+          end
+
+          @app.call(env)
+        end
+      end
+    end
+  end
+end

data/lib/vagrant-terraform/action/wait_for_vm_up.rb

@@ -0,0 +1,99 @@
+require 'log4r'
+require 'vagrant-terraform/util/timer'
+require 'vagrant-terraform/util/terraform_execute'
+require 'socket'
+require 'timeout'
+
+module VagrantPlugins
+  module TerraformProvider
+    module Action
+
+      # Wait till VM is started, till it obtains an IP address and is
+      # accessible via ssh.
+      class WaitForVmUp
+        include Util::TerraformExecute
+
+        def initialize(app, env)
+          @logger = Log4r::Logger.new("vagrant_terraform::action::wait_for_vm_up")
+          @app = app
+        end
+
+        def port_open?(ip, port, seconds=10)
+          # => checks if a port is open or not on a remote host
+          Timeout::timeout(seconds) do
+            begin
+              TCPSocket.new(ip, port).close
+              @logger.info("SSH Check OK for IP: #{ip}")
+              true
+            rescue Errno::ECONNREFUSED, Errno::EHOSTUNREACH, SocketError => e
+              @logger.info("SSH Connection Failed for IP #{ip}: #{e}")
+              false
+            end
+          end
+        rescue Timeout::Error
+          @logger.info("SSH Connection Failed: Timeout for IP: #{ip}" )
+          false
+        end
+
+        def call(env)
+          # Initialize metrics if they haven't been
+          env[:metrics] ||= {}
+
+          # Wait for VM to obtain an ip address.
+          env[:metrics]["instance_ip_time"] = Util::Timer.time do
+            env[:ui].info(I18n.t("vagrant_terraform.waiting_for_ip"))
+            for attempt in 1..300
+              # If we're interrupted don't worry about waiting
+              next if env[:interrupted]
+
+              output = terraform_execute(env, "terraform refresh")
+              ip_addr = output.match(/\b(?:\d{1,3}\.){3}\d{1,3}\b/)&.to_s
+              unless ip_addr.nil?
+                env[:ui].info("Got IP (attempt #{attempt}): #{ip_addr}")
+                # Check if SSH-Server is up
+                if port_open?(ip_addr, 22)
+                  env[:ip_address] = ip_addr
+                  @logger.debug("Got output #{env[:ip_address]}")
+                  break
+                end
+              end
+              sleep 2
+            end
+          end
+
+          terminate(env) if env[:interrupted]
+
+          if env[:ip_address].nil?
+            env[:ui].error("failed to get IP: #{env[:metrics]["instance_ip_time"]}")
+            raise Errors::NoIPError
+          else
+            @logger.info("Got IP address #{env[:ip_address]}")
+            @logger.info("Time for getting IP: #{env[:metrics]["instance_ip_time"]}")
+
+            # Booted and ready for use.
+            env[:ui].info(I18n.t("vagrant_terraform.ready"))
+
+            @app.call(env)
+          end
+        end
+
+        def recover(env)
+          return if env["vagrant.error"].is_a?(Vagrant::Errors::VagrantError)
+
+          if env[:machine].provider.state.id != :not_created
+            # Undo the import
+            terminate(env)
+          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-terraform/action.rb

@@ -0,0 +1,186 @@
+require 'fileutils'
+require 'vagrant/action/builder'
+
+module VagrantPlugins
+  module TerraformProvider
+    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 bring the box up from nothing.
+      def self.action_up
+        Vagrant::Action::Builder.new.tap do |b|
+          b.use HandleBox
+          b.use ConfigValidate
+
+          b.use Call, ReadState do |env, b2|
+            b2.use SetupTerraform
+            # synced_folders defaults to NFS on linux. Make it default to rsync.
+            env[:machine].config.nfs.functional = false
+            if env[:machine_state_id] == :running
+              b2.use Provision
+              b2.use SyncedFolderCleanup
+              require 'vagrant/action/builtin/synced_folders'
+              b2.use SyncedFolders
+              next
+            end
+
+            if env[:machine_state_id] == :not_created
+              b2.use CreateVM
+              b2.use Provision
+              b2.use SetHostname
+            end
+
+            b2.use StartVM
+            b2.use WaitForVmUp
+            b2.use SyncedFolderCleanup
+            require 'vagrant/action/builtin/synced_folders'
+            b2.use SyncedFolders
+          end
+
+        end
+      end
+
+      def self.action_destroy
+        Vagrant::Action::Builder.new.tap do |b|
+          b.use ConfigValidate
+          b.use Call, IsCreated do |env, b2|
+            if !env[:result]
+              unless env[:machine].id.nil?
+                dir = ".vagrant/terraform/#{env[:machine].id}"
+                env[:ui].info("Removing: " + dir)
+                FileUtils.rm_rf(dir)
+              end
+              env[:ui].info(I18n.t("vagrant_terraform.not_created"))
+              next
+            end
+
+            b2.use ProvisionerCleanup, :before if defined?(ProvisionerCleanup)
+            b2.use HaltVM unless env[:machine].state.id == :stopped
+            # b2.use WaitTillDown unless env[:machine].state.id == :stopped
+            b2.use DestroyVM
+          end
+        end
+      end
+
+      def self.action_provision
+        Vagrant::Action::Builder.new.tap do |b|
+          b.use ConfigValidate
+          b.use Call, IsCreated do |env, b2|
+            # synced_folders defaults to NFS on linux. Make it default to rsync.
+            env[:machine].config.nfs.functional = false
+            if !env[:result]
+              env[:ui].info(I18n.t("vagrant_terraform.not_created"))
+              next
+            end
+            b2.use Provision
+            b2.use SyncedFolderCleanup
+            require 'vagrant/action/builtin/synced_folders'
+            b2.use SyncedFolders
+          end
+        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 HandleBox
+          b.use ConfigValidate
+          b.use ReadState
+        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 Call, ReadState do |env, b2|
+            b2.use ReadSSHInfo
+          end
+        end
+      end
+
+      def self.action_halt
+        Vagrant::Action::Builder.new.tap do |b|
+          b.use Call, IsRunning do |env, b2|
+            if env[:machine_state_id] == :powering_up
+              env[:ui].info(I18n.t("vagrant_terraform.powering_up"))
+              next
+            end
+            if !env[:result]
+              env[:ui].info(I18n.t("vagrant_terraform.not_up"))
+              next
+            end
+            b2.use HaltVM
+          end
+        end
+      end
+
+      def self.action_reload
+        Vagrant::Action::Builder.new.tap do |b|
+          b.use action_halt
+          b.use action_up
+        end
+      end
+
+      def self.action_ssh
+        Vagrant::Action::Builder.new.tap do |b|
+          b.use ConfigValidate
+
+          b.use Call, ReadState do |env, b2|
+            if env[:machine_state_id] == :not_created
+              env[:ui].info(I18n.t("vagrant_terraform.not_created"))
+              next
+            end
+            if env[:machine_state_id] != :running
+              env[:ui].info(I18n.t("vagrant_terraform.not_up"))
+              next
+            end
+
+            raise Errors::NoIPError if env[:ip_address].nil?
+            b2.use SSHExec
+          end
+
+        end
+      end
+
+      def self.action_ssh_run
+        Vagrant::Action::Builder.new.tap do |b|
+          b.use ConfigValidate
+
+          b.use Call, ReadState do |env, b2|
+            if env[:machine_state_id] == :not_created
+              env[:ui].info(I18n.t("vagrant_terraform.not_created"))
+              next
+            end
+            if env[:machine_state_id] != :running
+              env[:ui].info(I18n.t("vagrant_terraform.not_up"))
+              next
+            end
+
+            raise Errors::NoIPError if env[:ip_address].nil?
+            b2.use SSHRun
+          end
+        end
+      end
+
+      action_root = Pathname.new(File.expand_path("../action", __FILE__))
+      autoload :SetupTerraform, action_root.join("setup_terraform")
+      autoload :CreateVM, action_root.join("create_vm")
+      autoload :DestroyVM, action_root.join("destroy_vm")
+      autoload :HaltVM, action_root.join("halt_vm")
+      autoload :IsCreated, action_root.join("is_created")
+      autoload :IsRunning, action_root.join("is_running")
+      autoload :ReadSSHInfo, action_root.join("read_ssh_info")
+      autoload :ReadState, action_root.join("read_state")
+      autoload :WaitForVmUp, action_root.join("wait_for_vm_up")
+
+      autoload :StartVM, action_root.join("start_vm")
+      # autoload :SyncedFolders, 'vagrant/action/builtin/synced_folders'
+      autoload :SyncedFolderCleanup, 'vagrant/action/builtin/synced_folder_cleanup'
+    end
+  end
+end

data/lib/vagrant-terraform/config.rb

@@ -0,0 +1,90 @@
+require 'vagrant'
+require 'filesize'
+
+module VagrantPlugins
+  module TerraformProvider
+    class Config < Vagrant.plugin('2', :config)
+      attr_reader :disks
+
+      attr_accessor :api_url
+      attr_accessor :api_token_id
+      attr_accessor :api_token_secret
+      attr_accessor :vga
+      attr_accessor :insecure
+      attr_accessor :debug
+      attr_accessor :vmname
+      attr_accessor :template
+      attr_accessor :disk_size
+      attr_accessor :storage_domain
+      attr_accessor :cpu_cores
+      attr_accessor :memory_size
+      attr_accessor :target_node
+      attr_accessor :onboot
+      attr_accessor :description
+      attr_accessor :nameserver
+      attr_accessor :searchdomain
+      attr_accessor :os_type
+      attr_accessor :full_clone
+
+      def initialize
+        @api_url           = UNSET_VALUE
+        @api_token_id      = UNSET_VALUE
+        @api_token_secret  = UNSET_VALUE
+        @vga           = UNSET_VALUE
+        @insecure          = UNSET_VALUE
+        @debug             = UNSET_VALUE
+        @vmname            = UNSET_VALUE
+        @template          = UNSET_VALUE
+        @disk_size         = UNSET_VALUE
+        @storage_domain    = UNSET_VALUE
+        @cpu_cores         = UNSET_VALUE
+        @memory_size       = UNSET_VALUE
+        @target_node       = UNSET_VALUE
+        @onboot            = UNSET_VALUE
+        @description       = UNSET_VALUE
+        @nameserver        = UNSET_VALUE
+        @searchdomain      = UNSET_VALUE
+        @os_type           = UNSET_VALUE
+        @full_clone        = UNSET_VALUE
+      end
+
+      def finalize!
+        @api_url = nil if @api_url == UNSET_VALUE
+        @api_token_id = nil if @api_token_id == UNSET_VALUE
+        @api_token_secret = nil if @api_token_secret == UNSET_VALUE
+        @vga = 'virtio' if @vga == UNSET_VALUE
+        @insecure = false if @insecure == UNSET_VALUE
+        @debug = false if @debug == UNSET_VALUE
+        @vmname = nil if @vmname == UNSET_VALUE
+        @template = nil if @template == UNSET_VALUE
+        @disk_size = nil if @disk_size == UNSET_VALUE
+        @storage_domain = nil if @storage_domain == UNSET_VALUE
+        @cpu_cores = 1 if @cpu_cores == UNSET_VALUE
+        @memory_size = '512 MiB' if @memory_size == UNSET_VALUE
+        @target_node = nil if @target_node == UNSET_VALUE
+        @onboot = false if @onboot == UNSET_VALUE
+        @description = '' if @description == UNSET_VALUE
+        @nameserver = '' if @nameserver == UNSET_VALUE
+        @searchdomain = '' if @searchdomain == UNSET_VALUE
+        @os_type = 'l26' if @os_type == UNSET_VALUE
+        @full_clone = true if @full_clone == UNSET_VALUE
+
+        unless disk_size.nil?
+          begin
+            @disk_size = Filesize.from(@disk_size).to_f('B').to_i
+          rescue ArgumentError
+            raise "Not able to parse 'disk_size' #{@disk_size}."
+          end
+        end
+
+        begin
+          @memory_size = Filesize.from(@memory_size).to_f('B').to_i
+        rescue ArgumentError
+          raise "Not able to parse `memory_size`."
+        end
+      end
+
+    end
+  end
+end
+

data/lib/vagrant-terraform/errors.rb

@@ -0,0 +1,32 @@
+require 'vagrant'
+
+module VagrantPlugins
+  module TerraformProvider
+    module Errors
+      class VagrantTerraformError < Vagrant::Errors::VagrantError
+        error_namespace("vagrant_terraform.errors")
+      end
+
+      class NoVMError < VagrantTerraformError
+        error_key(:no_vm_error)
+      end
+
+      class CreateVMError < VagrantTerraformError
+        error_key(:create_vm_error)
+      end
+
+      class StartVMError < VagrantTerraformError
+        error_key(:start_vm_error)
+      end
+
+      class NoIPError < VagrantTerraformError
+        error_key(:no_ip_error)
+      end
+
+      class TerraformError < VagrantTerraformError
+        error_key(:terraform_execution_error)
+      end
+
+    end
+  end
+end

data/lib/vagrant-terraform/plugin.rb

@@ -0,0 +1,75 @@
+# vim: ai ts=2 sts=2 et sw=2 ft=ruby
+begin
+  require 'vagrant'
+rescue LoadError
+  raise "The Vagrant Terraform 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 < '2.4.0'
+  raise "The Vagrant Terraform plugin is only compatible with Vagrant 2.4+"
+end
+
+module VagrantPlugins
+  module TerraformProvider
+    class Plugin < Vagrant.plugin('2')
+      name "terraform"
+      description <<-DESC
+      Vagrant plugin to manage virtual machines with terraform.
+      DESC
+
+      config("terraform", :provider) do
+        require_relative "config"
+        Config
+      end
+
+      provider("terraform", parallel: true) do
+        # Setup logging and i18n
+        setup_logging
+        setup_i18n
+
+        require_relative "provider"
+        Provider
+      end
+
+      # This initializes the internationalization strings.
+      def self.setup_i18n
+        I18n.load_path << File.expand_path("locales/en.yml",
+          TerraformProvider.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_terraform")
+          logger.outputters = Log4r::Outputter.stderr
+          logger.level = level
+          logger = nil
+        end
+      end
+    end
+  end
+end
+

data/lib/vagrant-terraform/provider.rb

@@ -0,0 +1,76 @@
+require 'vagrant'
+
+module VagrantPlugins
+  module TerraformProvider
+
+    # This is the base class for a provider for the V2 API. A provider
+    # is responsible for creating compute resources to match the
+    # needs of a Vagrant-configured system.
+    class Provider < Vagrant.plugin('2', :provider)
+      def initialize(machine)
+        @machine = machine
+      end
+
+      # This should return an action callable for the given name.
+      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
+
+      # This method is called if the underying machine ID changes. Providers
+      # can use this method to load in new data for the actual backing
+      # machine or to realize that the machine is now gone (the ID can
+      # become `nil`).
+      def machine_id_changed
+      end
+
+      # This should return a hash of information that explains how to
+      # SSH into the machine. If the machine is not at a point where
+      # SSH is even possible, then `nil` should be returned.
+      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.
+        #
+        # Ssh info has following format..
+        #
+        #{
+        #  :host => "1.2.3.4",
+        #  :port => "22",
+        #  :username => "mitchellh",
+        #  :private_key_path => "/path/to/my/key"
+        #}
+        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}.
+      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_terraform.states.short_#{state_id}")
+        long  = I18n.t("vagrant_terraform.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
+        "Terraform (#{id})"
+      end
+    end
+  end
+end
+

data/lib/vagrant-terraform/util/machine_names.rb

@@ -0,0 +1,23 @@
+module VagrantPlugins
+  module TerraformProvider
+    module Util
+      module MachineNames
+        DEFAULT_NAME = 'vagrant'.freeze
+
+      module_function
+
+        def machine_hostname(machine)
+          machine.config.vm.hostname || DEFAULT_NAME
+        end
+
+        def machine_vmname(machine)
+          if machine.id.nil?
+            machine.provider_config.vmname || machine_hostname(machine)
+          else
+            machine.id
+          end
+        end
+      end
+    end
+  end
+end