vagrant-terraform 0.1.3

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 2522d1ea4a52b4c972f6abf6a66f11f361ec801a26fb5bcb089d286a6cd292df
+  data.tar.gz: 703b30e9a3cb591a6022ad372ed5a1e9932bb319c170a07eda801659a14d734b
+SHA512:
+  metadata.gz: e361ce86c637c40b6b72510686a6cf9a77238f36fb7f8848965aeacac3acd95356d4928ddc6678d5a5c93108b8aaab38eb9d3eb6e74591706d461a6a0eeb356a
+  data.tar.gz: 448483359a5f6d30a4e95a5463edcb297504dae0ed4f42b65ede44a2834a1c9d9821c59bd123e9f2ae5132ce875e44fcf55754a085031ba72edcfae00442e1cb

data/.gitignore

@@ -0,0 +1,10 @@
+*.gem
+.bundle
+*.log
+/Vagrantfile*
+.vagrant
+/.idea
+*.gem
+/manifests
+vendor
+tmp

data/Gemfile

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+source "https://rubygems.org"
+
+git_source(:github) { |repo_name| "https://github.com/#{repo_name}" }
+
+# gem "rails"
+#group :plugins do
+#  gem 'vagrant-terraform', :path => '.'
+#end
+

data/Gemfile.lock

@@ -0,0 +1,11 @@
+GEM
+  remote: https://rubygems.org/
+  specs:
+
+PLATFORMS
+  x86_64-linux-musl
+
+DEPENDENCIES
+
+BUNDLED WITH
+   2.2.33

data/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2013 <copyright holders>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1,120 @@
+# Vagrant Terraform Provider
+
+This is an experimental [Vagrant](http://www.vagrantup.com) plugin for Proxmox that uses
+Terraform under the hood to operate the virtual machines.
+
+Could be extended to support other Terraform providers in addition to Proxmox but at
+the moment I'm not planning to.
+
+Things I'm _not_ planning to do (due to lack of time and resources):
+* Put this in rubygems.org. If you want to use this, roll your own gem like instructed below.
+* Support other Terraform providers unless I have to move away from Proxmox to something else.
+* Add support for suspend / snapshots.
+* Support / test anything other than Ubuntu/Fedora
+* Support Ruby 2.x
+
+## Installation
+
+```
+$ gem build *.gemspec
+$ vagrant plugin install *.gem
+```
+
+## Usage
+
+### Prerequisites
+
+#### Requirements
+
+Tested on Ubuntu 22.04 and Fedora 40.
+
+[Terraform](https://developer.hashicorp.com/terraform/tutorials/aws-get-started/install-cli)
+
+#### Configuration
+
+Create API user
+https://registry.terraform.io/providers/Telmate/proxmox/latest/docs#creating-the-proxmox-user-and-role-for-terraform
+```
+pveum role add Terraform -privs "Datastore.AllocateSpace Datastore.AllocateTemplate Datastore.Audit Pool.Allocate Sys.Audit Sys.Console Sys.Modify VM.Allocate VM.Audit VM.Clone VM.Config.CDROM VM.Config.Cloudinit VM.Config.CPU VM.Config.Disk VM.Config.HWType VM.Config.Memory VM.Config.Network VM.Config.Options VM.Migrate VM.Monitor VM.PowerMgmt SDN.Use"
+
+pveum user add terraform@pve
+pveum aclmod / -user terraform@pve -role Terraform
+pveum user token add terraform@pve automation --privsep 0
+```
+The value on the last line is your API token secret you are going to need in your Vagrantfile.
+
+Privilege separation needs to be disabled from API key due to:
+https://github.com/Telmate/terraform-provider-proxmox/issues/784
+
+#### Prepare a VM template on your Proxmox PVE
+
+Download cloud image
+```
+wget https://cloud-images.ubuntu.com/noble/current/SHA256SUMS https://cloud-images.ubuntu.com/noble/current/SHA256SUMS.gpg https://cloud-images.ubuntu.com/noble/current/noble-server-cloudimg-amd64.img
+gpg --keyid-format long --verify SHA256SUMS.gpg SHA256SUMS  # Requires public key "UEC Image Automatic Signing Key <cdimage@ubuntu.com>"
+sha256sum -c --ignore-missing SHA256SUMS
+```
+
+Customize it the way you want with virt-customize
+```
+export LIBGUESTFS_BACKEND=direct; virt-customize -a noble-server-cloudimg-amd64.img --install qemu-guest-agent --run-command "truncate -s 0 /etc/machine-id /var/lib/dbus/machine-id"
+```
+
+Create a VM and convert it to template
+```
+qm create 9001 --memory 1024 --net0 virtio,bridge=vmbr0 --scsihw virtio-scsi-pci --name ubuntu-noble-template --machine q35,viommu=virtio --ostype l26 --rng0 /dev/urandom
+qm set 9001 --virtio0 [STORAGE_NAME]:0,import-from=/root/noble-server-cloudimg-amd64.img
+qm set 9001 --ide2 [STORAGE_NAME]:cloudinit --boot c --bootdisk virtio0
+qm template 9001
+```
+
+
+### Supported Commands
+
+1. `vagrant up`
+1. `vagrant destroy`
+1. `vagrant ssh [-c 'command']`
+1. `vagrant ssh-config`
+1. `vagrant halt`
+1. `vagrant reload`
+1. `vagrant status`
+
+### Simple configuration example with two network interfaces
+
+```
+Vagrant.configure("2") do |config|
+  config.vm.box = 'dummy'
+  config.vm.box_url = 'https://github.com/mika-b/vagrant-terraform/blob/main/example_box/dummy.box?raw=true'
+
+  config.vm.hostname = "example-vm.local"
+
+  config.vm.synced_folder './', '/vagrant', type: 'rsync', rsync__exclude: ["log/", ".git/"]  # , rsync__verbose: false
+  config.ssh.forward_agent = true
+
+  config.vm.network :private_network,
+    :terraform__network_name => 'testmgmt' # DHCP
+  config.vm.network :private_network,
+    :terraform__network_name => 'vmbr0', :terraform__ip => '192.168.0.51/24', :terraform__gateway => '192.168.0.1'
+
+  config.vm.provider :terraform do |terraform|
+    terraform.api_url = 'https://[PVE_ADDRESS]:8006/api2/json'
+    terraform.api_token_id = "terraform@pve!automation"
+    terraform.api_token_secret = "[API_TOKEN]"
+    terraform.insecure = true
+    terraform.debug = false
+    terraform.description = "Created by: #{ENV['USER']}"
+    terraform.template = 'ubuntu-noble-template'
+    terraform.cpu_cores = 2
+    terraform.memory_size = '4 GiB'
+    terraform.disk_size = '15 GB'
+    terraform.target_node = 'pve1'
+    terraform.storage_domain = '[STORAGE_NAME]'
+    terraform.nameserver = '1.1.1.1 1.0.0.1'
+    terraform.searchdomain = 'example.com'
+  end
+
+  config.vm.provision "shell", inline: <<-SHELL
+    ip a
+SHELL
+end
+```

data/example_box/README.md

@@ -0,0 +1,12 @@
+# Vagrant Terraform dummy box
+
+To turn this into a box:
+
+```
+$ tar cvzf dummy.box ./metadata.json ./Vagrantfile
+```
+
+Use it
+```
+vagrant --provider=terraform box add --name terraform dummy.box
+```

data/example_box/Vagrantfile

@@ -0,0 +1,14 @@
+# -*- mode: ruby -*-
+# vi: set ft=ruby :
+Vagrant.configure("2") do |config|
+  config.vm.box = 'terraform'
+  #config.vm.box_url = 'https://github.com/mika-b/vagrant-terraform/blob/master/example_box/dummy.box?raw=true'
+
+  config.vm.provider :terraform do |terraform|
+    terraform.api_url = 'https://server:8006/api2/json'
+    terraform.api_token_id = "terraform@pam!automation"
+    terraform.api_token_secret = "password"
+    terraform.insecure = true
+    terraform.debug = true
+  end
+end

data/example_box/metadata.json

@@ -0,0 +1,4 @@
+{
+    "provider": "terraform"
+}
+

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

@@ -0,0 +1,205 @@
+require 'log4r'
+require 'vagrant-terraform/util/machine_names'
+require 'vagrant-terraform/util/terraform_execute'
+require 'vagrant/util/retryable'
+
+module VagrantPlugins
+  module TerraformProvider
+    module Action
+      class CreateVM
+        include Util::TerraformExecute
+        include Util::MachineNames
+        include Vagrant::Util::Retryable
+
+        def initialize(app, env)
+          @logger = Log4r::Logger.new("vagrant_terraform::action::create_vm")
+          @app = app
+        end
+
+        def call(env)
+          # Get config.
+          config = env[:machine].provider_config
+          if config.target_node.nil?
+            raise "'target_node' must not be empty."
+          end
+
+          if config.storage_domain.nil?
+            raise "'storage_domain' must not be empty."
+          end
+
+          if config.disk_size.nil?
+            raise "'disk_size' must be set."
+          end
+
+          vmname = machine_vmname(env[:machine])
+
+          main_tf = <<-END
+provider "proxmox" {
+    pm_api_url   = "#{config.api_url}"
+    pm_api_token_id      = "#{config.api_token_id}"
+    pm_api_token_secret  = "#{config.api_token_secret}"
+    pm_tls_insecure = #{config.insecure.to_s}
+    pm_debug = #{config.debug}
+}
+
+resource "proxmox_vm_qemu" "#{vmname.gsub(/\./, '-')}" {
+    name       = "#{vmname}"
+    target_nodes = ["#{config.target_node}"]
+    desc = "#{config.description}"
+    vm_state   = "stopped"
+    clone      = "#{config.template}"
+    full_clone = "#{config.full_clone}"
+    cores      = #{config.cpu_cores.to_i}
+    memory     = #{Filesize.from("#{config.memory_size} B").to_f('MiB').to_i}
+    onboot = #{config.onboot}
+    agent      = 1
+    vga {
+        type   = "#{config.vga}"
+        # Between 4 and 512, ignored if type is defined to serial
+        memory = 64
+    }
+    scsihw     = "virtio-scsi-pci"
+    boot       = "order=virtio0"
+    bootdisk   = "virtio0"
+    os_type    = "#{config.os_type}"
+    disks {
+        virtio {
+            virtio0 {
+                disk {
+                    backup = false
+                    storage = "#{config.storage_domain}"
+                    size = "#{Filesize.from("#{config.disk_size} B").to_f('GB').to_i}G"
+                }
+            }
+        }
+        ide {
+            ide2 {
+                cloudinit {
+                    storage = "#{config.storage_domain}"
+                }
+            }
+        }
+    }
+    nameserver = "#{config.nameserver}"
+    searchdomain = "#{config.searchdomain}"
+%NETWORKS%
+    ciuser = "vagrant"
+    sshkeys = <<EOF
+    ssh-rsa AAAAB3NzaC1yc2EAAAABIwAAAQEA6NF8iallvQVp22WDkTkyrtvp9eWW6A8YVr+kz4TjGYe7gHzIw+niNltGEFHzD8+v1I2YJ6oXevct1YeS0o9HZyN1Q9qgCgzUFtdOKLv6IedplqoPkcmF0aYet2PkEDo3MlTBckFXPITAMzF8dJSIFo9D8HfdOV0IAdx4O7PtixWKn5y2hMNG0zQPyUecp4pzC6kivAIhyfHilFR61RGL+GPXQ2MWZWFYbAGjyiYJnAmCP3NOTd0jMZEnDkbUvxhMmBYSdETk1rRgm+R4LOzFUGaHqHDLKLX+FIPKcF96hrucXzcWyLbIbEgE98OHlnVYCzRdK8jlqm8tehUc9c9WhQ== vagrant insecure public key
+    EOF
+}
+
+# terraform output -raw public_ip
+output "public_ip" {
+  value = proxmox_vm_qemu.#{vmname.gsub(/\./, '-')}.default_ipv4_address
+}
+
+terraform {
+  required_version = ">= 1.8.0"
+  required_providers {
+    proxmox = {
+      source  = "telmate/proxmox"
+      version = "3.0.1-rc6"
+      #version = ">= 3.0.1-rc3"
+    }
+  }
+}
+ END
+          network_template = <<-END
+    network {
+        id = %IDX%
+        bridge    = "%BRIDGE%"
+        firewall  = false
+        link_down = false
+        model     = "virtio"
+    }
+    ipconfig%IDX% = "%IP%"
+END
+
+          vagrantfile_networks = []
+          env[:machine].id = vmname
+          env[:machine].config.vm.networks.each_with_index do |network, idx|
+            type, options = network
+
+            # Only private networks are supported
+            next unless type == :private_network
+            if ! options[:terraform__ip].nil?
+              if ! options[:terraform__ip].include? "/"
+                raise "IP must be given in CIDR form, for example 192.168.0.10/24"
+              end
+
+              if options[:terraform__gateway].nil?
+                network_str = network_template.gsub(/%IP%/, "ip=#{options[:terraform__ip]}")
+              else
+                network_str = network_template.gsub(/%IP%/, "ip=#{options[:terraform__ip]},gw=#{options[:terraform__gateway]}")
+              end
+            else
+              network_str = network_template.gsub(/%IP%/, "ip=dhcp")
+            end
+            network_str = network_str.gsub(/%BRIDGE%/, options[:terraform__network_name])
+            network_str = network_str.gsub(/%IDX%/, idx.to_s)
+            vagrantfile_networks << network_str
+          end
+          main_tf = main_tf.gsub(/%NETWORKS%/, vagrantfile_networks.join())
+
+          # Output the settings we're going to use to the user
+          env[:ui].info(I18n.t("vagrant_terraform.creating_vm"))
+          env[:ui].info(" -- Name:          #{vmname}")
+          env[:ui].info(" -- Template:      #{config.template}")
+          env[:ui].info(" -- Description:   #{config.description}")
+          env[:ui].info(" -- Target node:   #{config.target_node}")
+          env[:ui].info(" -- Storage domain: #{config.storage_domain}")
+          env[:ui].info(" -- CPU Cores:     #{config.cpu_cores}")
+          env[:ui].info(" -- Memory:        #{Filesize.from("#{config.memory_size} B").to_f('MiB').to_i} MB")
+          env[:ui].info(" -- Disk:          #{Filesize.from("#{config.disk_size} B").to_f('GiB').to_i} GB") unless config.disk_size.nil?
+
+          terraform_dir = env[:machine_tf_dir]
+          terraform_main_file = "#{terraform_dir}/main.tf"
+
+          File.write(terraform_main_file, main_tf)
+          terraform_execute(env, 'terraform init')
+
+          retryable(on: Errors::TerraformError, tries: 10, sleep: 1) do
+            begin
+              terraform_execute(env, "terraform apply -auto-approve")
+            rescue Errors::TerraformError => e
+              # ==> vm_one: terraform stderr: ╷
+              # ==> vm_one: │ Error: can't lock file '/var/lock/qemu-server/lock-100.conf' - got timeout
+              ansi_escape_regex = /\e\[(?:[0-9]{1,2}(?:;[0-9]{1,2})*)?[m|K]/
+              if e.message.gsub(ansi_escape_regex, '').include?("Error: can't lock file")
+                env[:ui].info("Proxmox unable to get lock, retrying")
+                raise e
+              end
+
+              if e.message.gsub(ansi_escape_regex, '') =~ /.*Error: [0-9 ]*unable to create VM [0-9]*: config file already exists/
+                env[:ui].info("Proxmox ID conflict, retrying")
+                raise e
+              end
+
+              if config.debug
+                raise e
+              else
+                fault_message = /Error: (.*)/.match(e.message.gsub(ansi_escape_regex, ''))[1] rescue e.message
+                raise Errors::CreateVMError,
+                  :error_message => fault_message
+              end
+            end
+          end
+
+          @app.call(env)
+        end
+
+        def recover(env)
+          # undo
+          return if env["vagrant.error"].is_a?(Vagrant::Errors::VagrantError)  # leaves main.tf in .vagrant/terraform/HOSTNAME/
+          env[:ui].info(I18n.t("vagrant_terraform.error_recovering"))
+          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/destroy_vm.rb

@@ -0,0 +1,39 @@
+require 'fileutils'
+require 'log4r'
+require 'vagrant-terraform/errors'
+require 'vagrant-terraform/util/terraform_execute'
+
+module VagrantPlugins
+  module TerraformProvider
+    module Action
+
+      class DestroyVM
+        include Util::TerraformExecute
+
+        def initialize(app, env)
+          @logger = Log4r::Logger.new("vagrant_terraform::action::destroy_vm")
+          @app = app
+        end
+
+        def call(env)
+          env[:ui].info(I18n.t("vagrant_terraform.destroy_vm"))
+
+          begin
+            # for some reason here the machine_tf_dir is not in env even though read_state has been called
+            # multiple times on 'vagrant halt' before we get here.
+            terraform_dir = ".vagrant/terraform/#{env[:machine].id}"
+
+            terraform_execute(env, 'terraform destroy -auto-approve')
+            FileUtils.rm_rf(terraform_dir)
+          rescue Exception => e
+            retry if e.message =~ /Please try again/
+
+            raise e
+          end
+
+          @app.call(env)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,39 @@
+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
+
+      class HaltVM
+        include Util::TerraformExecute
+        include Util::UpdateVmState
+
+        def initialize(app, env)
+          @logger = Log4r::Logger.new("vagrant_terraform::action::halt_vm")
+          @app = app
+        end
+
+        def call(env)
+
+          env[:ui].info(I18n.t("vagrant_terraform.halt_vm"))
+
+          begin
+            terraform_dir = ".vagrant/terraform/#{env[:machine].id}"
+            terraform_main_file = "#{terraform_dir}/main.tf"
+            update_vm_state(terraform_main_file, "stopped")
+            terraform_execute(env, 'terraform apply -auto-approve')
+          rescue Exception => e
+            # TODO: need to retry in some case?
+            # retry if e.message =~ /something/
+            raise e
+          end
+
+          @app.call(env)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,19 @@
+require "log4r"
+
+module VagrantPlugins
+  module TerraformProvider
+    module Action
+      class IsCreated
+        def initialize(app, env)
+          @app = app
+          @logger = Log4r::Logger.new("vagrant_terraform::action::is_created")
+        end
+
+        def call(env)
+          env[:result] = env[:machine].state.id != :not_created
+          @app.call(env)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,19 @@
+require "log4r"
+
+module VagrantPlugins
+  module TerraformProvider
+    module Action
+      class IsRunning
+        def initialize(app, env)
+          @app = app
+          @logger = Log4r::Logger.new("vagrant_terraform::action::is_created")
+        end
+
+        def call(env)
+          env[:result] = env[:machine].state.id == :running
+          @app.call(env)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,44 @@
+require "log4r"
+require 'vagrant-terraform/util/terraform_execute'
+
+module VagrantPlugins
+  module TerraformProvider
+    module Action
+      # This action reads the SSH info for the machine and puts it into the
+      # `:machine_ssh_info` key in the environment.
+      class ReadSSHInfo
+        include Util::TerraformExecute
+
+        def initialize(app, env)
+          @app    = app
+          @logger = Log4r::Logger.new("vagrant_terraform::action::read_ssh_info")
+        end
+
+        def call(env)
+          env[:machine_ssh_info] = read_ssh_info(env)
+
+          @app.call(env)
+        end
+
+        # Returns a hash of SSH connection information if and only if at least one IPv4
+        # address associated with the machine in question could be retrieved
+        # Otherwise, it returns nil.
+        def read_ssh_info(env)
+          machine = env[:machine]
+
+          ip_addr = terraform_execute(env, "terraform output -raw public_ip")
+          return nil if ip_addr.nil?
+
+          return {
+            :host             => ip_addr,
+            :port             => machine.config.ssh.guest_port,
+            :username         => machine.config.ssh.username,
+            :private_key_path => machine.config.ssh.private_key_path,
+            :forward_agent    => machine.config.ssh.forward_agent,
+            :forward_x11      => machine.config.ssh.forward_x11,
+          }
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,67 @@
+require "log4r"
+require 'vagrant-terraform/util/terraform_execute'
+require 'vagrant-terraform/util/machine_names'
+
+$terraform_refreshed = nil
+
+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 ReadState
+        include Util::TerraformExecute
+        include Util::MachineNames
+
+        def initialize(app, env)
+          @app    = app
+          @logger = Log4r::Logger.new("vagrant_terraform::action::read_state")
+        end
+
+        def call(env)
+          env[:machine_state_id] = read_state(env)
+          @app.call(env)
+        end
+
+        def read_state(env)
+          env[:machine_tf_dir] = ".vagrant/terraform/#{machine_vmname(env[:machine])}"
+          terraform_state_file = "#{env[:machine_tf_dir]}/terraform.tfstate"
+          if File.exist?(env[:machine_tf_dir]) && File.exist?(terraform_state_file)
+            # read_state might get called several times. Avoid refreshing 5 times in a row
+            # for example during "vagrant up" for no obvious reason.
+            if $terraform_refreshed.nil?
+              terraform_execute(env, 'terraform refresh')
+              $terraform_refreshed = true
+            end
+
+            json_data = File.read(terraform_state_file)
+            data = JSON.parse(json_data)
+
+            # Navigate to the "vm_state" value
+            resources = data["resources"]
+            return :not_created if resources.nil? || resources.empty?
+
+            first_resource = resources.first  # TODO: find by name
+            instances = first_resource["instances"]
+            return :not_created if instances.nil? || instances.empty?
+
+            attributes = instances.first["attributes"]
+            return :not_created if attributes.nil?
+
+            ip_addr = attributes["default_ipv4_address"]
+            unless ip_addr.nil?
+              env[:ip_address] = ip_addr
+            end
+
+            if attributes["vm_state"].nil?
+              return :not_created
+            end
+            return attributes["vm_state"].to_sym
+          else
+            return :not_created
+          end
+        end
+      end
+    end
+  end
+end