vagrant-hetznercloud 0.0.1

data/lib/vagrant-hetznercloud/action/connect_hetznercloud.rb

@@ -0,0 +1,33 @@
+require 'fog/hetznercloud'
+
+module VagrantPlugins
+  module Hetznercloud
+    module Action
+      # This action connects to Hetznercloud, verifies credentials work, and
+      # puts the Hetznercloud connection object into the `:hetznercloud_compute` key
+      # in the environment.
+      class ConnectHetznercloud
+        def initialize(app, _env)
+          @app    = app
+          @logger = Log4r::Logger.new('vagrant_hetznercloud::action::connect_hetznercloud')
+        end
+
+        def call(env)
+          # Get the configs
+          provider_config = env[:machine].provider_config
+
+          # Build the fog config
+          fog_config = {
+            provider:                  :hetznercloud,
+            hetznercloud_token:        provider_config.token
+          }
+
+          @logger.info('Connecting to Hetznercloud...')
+          env[:hetznercloud_compute] = Fog::Compute.new(fog_config)
+
+          @app.call(env)
+        end
+      end
+    end
+  end
+end

data/lib/vagrant-hetznercloud/action/create_server.rb

@@ -0,0 +1,92 @@
+require 'vagrant/util/retryable'
+require 'vagrant-hetznercloud/util/timer'
+
+module VagrantPlugins
+  module Hetznercloud
+    module Action
+      # This creates the configured server.
+      class CreateServer
+        include Vagrant::Util::Retryable
+
+        def initialize(app, _env)
+          @app    = app
+          @logger = Log4r::Logger.new('vagrant_hetznercloud::action::create_server')
+        end
+
+        def call(env)
+          # Initialize metrics if they haven't been
+          env[:metrics] ||= {}
+
+          config = env[:machine].provider_config
+
+          server_type     = config.server_type
+          image           = config.image
+          name            = config.name
+          ssh_keys        = config.ssh_keys
+          location        = config.location
+          datacenter      = config.datacenter
+          user_data       = config.user_data
+
+          env[:ui].info(I18n.t('vagrant_hetznercloud.creating_server'))
+          env[:ui].info(" -- Type: #{server_type}")
+          env[:ui].info(" -- Image: #{image}")
+          env[:ui].info(" -- Name: #{name}")
+          env[:ui].info(" -- SSH Keys: #{ssh_keys}")
+          env[:ui].info(" -- location: #{location}")
+          env[:ui].info(" -- datacenter: #{datacenter}")
+          env[:ui].info(" -- user_data: #{user_data}")
+
+          options = {
+            name:            name,
+            image:           image,
+            server_type:     server_type,
+            ssh_keys:        ssh_keys
+          }
+
+          option[:location] = location unless location.nil?
+          option[:datacenter] = datacenter unless datacenter.nil?
+          option[:user_data] = user_data unless user_data.nil?
+
+          begin
+            server = env[:hetznercloud_compute].servers.create(options)
+          rescue Fog::Hetznercloud::Compute::Error => e
+            raise Errors::FogError, message: e.message
+          rescue Excon::Errors::HTTPStatusError => e
+            raise Errors::InternalFogError,
+                  error: e.message,
+                  response: e.response.body
+          end
+
+          env[:ui].info(" -- Server IP: #{server.public_ip_address}")
+
+          @logger.info("Machine '#{name}' created.")
+
+          # Immediately save the ID since it is created at this point.
+          env[:machine].id = server.id
+
+          # destroy the server if we were interrupted
+          destroy(env) if env[:interrupted]
+
+          @logger.info("Waiting for Machine '#{name}' with IP #{server.public_ip_address} to be ready.")
+          server.wait_for { ready? }
+
+          @app.call(env)
+        end
+
+        def recover(env)
+          return if env['vagrant.error'].is_a?(Vagrant::Errors::VagrantError)
+
+          destroy(env) if env[:machine].provider.state.id != :not_created
+        end
+
+        def destroy(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-hetznercloud/action/destroy_server.rb

@@ -0,0 +1,33 @@
+module VagrantPlugins
+  module Hetznercloud
+    module Action
+      # This destroys the running server.
+      class DestroyServer
+        def initialize(app, _env)
+          @app = app
+        end
+
+        def call(env)
+          server = env[:hetznercloud_compute].servers.get(env[:machine].id)
+
+          # Destroy the server and remove the tracking ID
+          env[:ui].info(I18n.t('vagrant_hetznercloud.destroying'))
+
+          begin
+            server.destroy
+          rescue Fog::Hetznercloud::Compute::InvalidRequestError => e
+            if e.message =~ /server should be stopped/
+              server.terminate(async: false)
+            else
+              raise
+            end
+          end
+
+          env[:machine].id = nil
+
+          @app.call(env)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,18 @@
+module VagrantPlugins
+  module Hetznercloud
+    module Action
+      # This can be used with "Call" built-in to check if the machine
+      # is created and branch in the middleware.
+      class IsCreated
+        def initialize(app, _env)
+          @app = app
+        end
+
+        def call(env)
+          env[:result] = env[:machine].state.id != :not_created
+          @app.call(env)
+        end
+      end
+    end
+  end
+end

data/lib/vagrant-hetznercloud/action/is_stopped.rb

@@ -0,0 +1,18 @@
+module VagrantPlugins
+  module Hetznercloud
+    module Action
+      # This can be used with "Call" built-in to check if the machine
+      # is stopped and branch in the middleware.
+      class IsStopped
+        def initialize(app, _env)
+          @app = app
+        end
+
+        def call(env)
+          env[:result] = env[:machine].state.id == :off
+          @app.call(env)
+        end
+      end
+    end
+  end
+end

data/lib/vagrant-hetznercloud/action/list_images.rb

@@ -0,0 +1,23 @@
+module VagrantPlugins
+  module Hetznercloud
+    module Action
+      class ListImages
+        def initialize(app, _env)
+          @app = app
+        end
+
+        def call(env)
+          compute = env[:hetznercloud_compute]
+
+          env[:ui].info(format('%-37s %-26s %-7s %-36s %s', 'Image ID', 'Created At', 'Type', 'Description', 'Image Name'), prefix: false)
+          compute.images.sort_by(&:name).each do |image|
+            created_at = Time.parse(image.created)
+            env[:ui].info(format('%-37s %-26s %-7s %-36s %s', image.identity, created_at, image.type, image.description, image.name), prefix: false)
+          end
+
+          @app.call(env)
+        end
+      end
+    end
+  end
+end

data/lib/vagrant-hetznercloud/action/message_already_created.rb

@@ -0,0 +1,16 @@
+module VagrantPlugins
+  module Hetznercloud
+    module Action
+      class MessageAlreadyCreated
+        def initialize(app, _env)
+          @app = app
+        end
+
+        def call(env)
+          env[:ui].info(I18n.t('vagrant_hetznercloud.already_status', status: 'created'))
+          @app.call(env)
+        end
+      end
+    end
+  end
+end

data/lib/vagrant-hetznercloud/action/message_not_created.rb

@@ -0,0 +1,16 @@
+module VagrantPlugins
+  module Hetznercloud
+    module Action
+      class MessageNotCreated
+        def initialize(app, _env)
+          @app = app
+        end
+
+        def call(env)
+          env[:ui].info(I18n.t('vagrant_hetznercloud.not_created'))
+          @app.call(env)
+        end
+      end
+    end
+  end
+end

data/lib/vagrant-hetznercloud/action/message_will_not_destroy.rb

@@ -0,0 +1,16 @@
+module VagrantPlugins
+  module Hetznercloud
+    module Action
+      class MessageWillNotDestroy
+        def initialize(app, _env)
+          @app = app
+        end
+
+        def call(env)
+          env[:ui].info(I18n.t('vagrant_hetznercloud.will_not_destroy', name: env[:machine].name))
+          @app.call(env)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,51 @@
+module VagrantPlugins
+  module Hetznercloud
+    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
+        def initialize(app, _env)
+          @app    = app
+          @logger = Log4r::Logger.new('vagrant_hetznercloud::action::read_ssh_info')
+        end
+
+        def call(env)
+          env[:machine_ssh_info] = read_ssh_info(env[:hetznercloud_compute], env[:machine])
+
+          @app.call(env)
+        end
+
+        def read_ssh_info(hetznercloud, machine)
+          return nil if machine.id.nil?
+
+          # Find the machine
+          server = hetznercloud.servers.get(machine.id)
+          if server.nil?
+            # The machine can't be found
+            @logger.info("Machine couldn't be found, assuming it got destroyed.")
+            machine.id = nil
+            return nil
+          end
+
+          # read attribute override
+          ssh_host_attribute = machine.provider_config.ssh_host_attribute
+          # default host attributes to try. NOTE: Order matters!
+          ssh_attrs = %i[public_ip_address]
+          ssh_attrs = (Array(ssh_host_attribute) + ssh_attrs).uniq if ssh_host_attribute
+          # try each attribute, get out on first value
+          host = nil
+          while !host && (attr = ssh_attrs.shift)
+            begin
+              host = server.send(attr)
+            rescue NoMethodError
+              @logger.info("SSH host attribute not found #{attr}")
+            end
+          end
+
+          { host: host, port: 22, username: 'root' }
+
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,36 @@
+module VagrantPlugins
+  module Hetznercloud
+    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_hetznercloud::action::read_state')
+        end
+
+        def call(env)
+          env[:machine_state_id] = read_state(env[:hetznercloud_compute], env[:machine])
+
+          @app.call(env)
+        end
+
+        def read_state(hetznercloud, machine)
+          return :not_created if machine.id.nil?
+
+          # Find the machine
+          server = hetznercloud.servers.get(machine.id)
+          if server.nil?
+            # The machine can't be found
+            @logger.info('Machine not found, assuming it got destroyed.')
+            machine.id = nil
+            return :not_created
+          end
+
+          # Return the state
+          server.status.to_sym
+        end
+      end
+    end
+  end
+end

data/lib/vagrant-hetznercloud/action/start_server.rb

@@ -0,0 +1,90 @@
+require 'vagrant/util/retryable'
+require 'vagrant-hetznercloud/util/timer'
+
+module VagrantPlugins
+  module Hetznercloud
+    module Action
+      # This starts a stopped server.
+      class StartServer
+        include Vagrant::Util::Retryable
+
+        def initialize(app, _env)
+          @app    = app
+          @logger = Log4r::Logger.new('vagrant_hetznercloud::action::start_server')
+        end
+
+        def call(env)
+          # Initialize metrics if they haven't been
+          env[:metrics] ||= {}
+
+          config = env[:machine].provider_config
+
+          server = env[:hetznercloud_compute].servers.get(env[:machine].id)
+
+          env[:ui].info(I18n.t('vagrant_hetznercloud.starting'))
+
+          begin
+            server.poweron
+          rescue Fog::Hetznercloud::Compute::Error => e
+            raise Errors::FogError, message: e.message
+          end
+
+          # Wait for the server to be ready first
+          env[:metrics]['server_ready_time'] = Util::Timer.time do
+            tries = config.server_ready_timeout / 2
+
+            env[:ui].info(I18n.t('vagrant_hetznercloud.waiting_for_ready'))
+            begin
+              retryable(on: Fog::Errors::TimeoutError, tries: tries) do
+                # If we're interrupted don't worry about waiting
+                next if env[:interrupted]
+
+                # Wait for the server to be ready
+                server.wait_for(2, config.server_check_interval) { ready? }
+              end
+            rescue Fog::Errors::TimeoutError
+              # Notify the user
+              raise Errors::ServerReadyTimeout,
+                    timeout: config.server_ready_timeout
+            end
+          end
+
+          @logger.info("Time to server ready: #{env[:metrics]['server_ready_time']}")
+
+          unless env[:interrupted]
+            env[:metrics]['server_ssh_time'] = Util::Timer.time do
+              # Wait for SSH to be ready.
+              env[:ui].info(I18n.t('vagrant_hetznercloud.waiting_for_ssh'))
+              network_ready_retries = 0
+              network_ready_retries_max = 10
+              loop do
+                # If we're interrupted then just back out
+                break if env[:interrupted]
+                # When a server comes up, it's networking may not be ready by
+                # the time we connect.
+                begin
+                  break if env[:machine].communicate.ready?
+                rescue
+                  if network_ready_retries < network_ready_retries_max
+                    network_ready_retries += 1
+                    @logger.warn(I18n.t('vagrant_hetznercloud.waiting_for_ssh, retrying'))
+                  else
+                    raise
+                  end
+                end
+                sleep 2
+              end
+            end
+
+            @logger.info("Time for SSH ready: #{env[:metrics]['server_ssh_time']}")
+
+            # Ready and booted!
+            env[:ui].info(I18n.t('vagrant_hetznercloud.ready'))
+          end
+
+          @app.call(env)
+        end
+      end
+    end
+  end
+end