vagrant-hetznercloud 0.0.1

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

@@ -0,0 +1,25 @@
+module VagrantPlugins
+  module Hetznercloud
+    module Action
+      # This stops the running server.
+      class StopServer
+        def initialize(app, _env)
+          @app = app
+        end
+
+        def call(env)
+          server = env[:hetznercloud_compute].servers.get(env[:machine].id)
+
+          if env[:machine].state.id == :off
+            env[:ui].info(I18n.t('vagrant_hetznercloud.already_status', status: env[:machine].state.id))
+          else
+            env[:ui].info(I18n.t('vagrant_hetznercloud.stopping'))
+            server.poweroff(async: false)
+          end
+
+          @app.call(env)
+        end
+      end
+    end
+  end
+end

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

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

data/lib/vagrant-hetznercloud/command/images.rb

@@ -0,0 +1,20 @@
+module VagrantPlugins
+  module Hetznercloud
+    module Command
+      class Images < Vagrant.plugin('2', :command)
+        def execute
+          opts = OptionParser.new do |o|
+            o.banner = 'Usage: vagrant hetznercloud images [options]'
+          end
+
+          argv = parse_options(opts)
+          return unless argv
+
+          with_target_vms(argv, provider: :hetznercloud) do |machine|
+            machine.action('list_images')
+          end
+        end
+      end
+    end
+  end
+end

data/lib/vagrant-hetznercloud/command/root.rb

@@ -0,0 +1,61 @@
+require 'vagrant-hetznercloud/action'
+
+module VagrantPlugins
+  module Hetznercloud
+    module Command
+      class Root < Vagrant.plugin('2', :command)
+        def self.synopsis
+          'queries Hetznercloud for available resources'
+        end
+
+        def initialize(argv, env)
+          @main_args, @sub_command, @sub_args = split_main_and_subcommand(argv)
+
+          @subcommands = Vagrant::Registry.new
+          @subcommands.register(:images) do
+            require File.expand_path('../images', __FILE__)
+            Images
+          end
+
+          super(argv, env)
+        end
+
+        def execute
+          if @main_args.include?('-h') || @main_args.include?('--help')
+            # Print the help for all the hetznercloud commands.
+            return help
+          end
+
+          command_class = @subcommands.get(@sub_command.to_sym) if @sub_command
+          return help if !command_class || !@sub_command
+          @logger.debug("Invoking command class: #{command_class} #{@sub_args.inspect}")
+
+          # Initialize and execute the command class
+          command_class.new(@sub_args, @env).execute
+        end
+
+        def help
+          opts = OptionParser.new do |o|
+            o.banner = 'Usage: vagrant hetznercloud <subcommand> [<args>]'
+            o.separator ''
+            o.separator 'Available subcommands:'
+
+            # Add the available subcommands as separators in order to print them
+            # out as well.
+            keys = []
+            @subcommands.each { |key, _value| keys << key.to_s }
+
+            keys.sort.each do |key|
+              o.separator "     #{key}"
+            end
+
+            o.separator ''
+            o.separator 'For help on any individual subcommand run `vagrant hetznercloud <subcommand> -h`'
+          end
+
+          @env.ui.info(opts.help, prefix: false)
+        end
+      end
+    end
+  end
+end

data/lib/vagrant-hetznercloud/config.rb

@@ -0,0 +1,145 @@
+require 'toml'
+
+module VagrantPlugins
+  module Hetznercloud
+    class Config < Vagrant.plugin('2', :config)
+      # The user_data file to use (e.g. for bootstrapping)
+      #
+      # @return [String]
+      attr_accessor :user_data
+
+      # The type of the server to launch, such as 'cx11'. Defaults to 'cx11'.
+      #
+      # @return [String]
+      attr_accessor :server_type
+
+      # The image ID or name like 'centos-7'.
+      #
+      # @return [String]
+      attr_accessor :image
+
+      # The name of the server. Optional. Can be auto generated like h-xxxxxx.
+      #
+      # @return [String]
+      attr_accessor :name
+
+      # The name of the Hetznercloud location to create the server in. It can also be
+      # configured with HETZNERCLOUD_LOCATION environment variable.
+      #
+      # @return [String]
+      attr_accessor :location
+
+      # The name of the Hetznercloud datacenter to create the server in. It can also be
+      # configured with HETZNERCLOUD_DATACENTER environment variable.
+      #
+      # @return [String]
+      attr_accessor :datacenter
+
+      # The interval to wait for checking a server's state. Defaults to 2
+      # seconds.
+      #
+      # @return [Fixnum]
+      attr_accessor :server_check_interval
+
+      # The timeout to wait for a server to become ready. Defaults to 120
+      # seconds.
+      #
+      # @return [Fixnum]
+      attr_accessor :server_ready_timeout
+
+      # Specifies which address to connect to with ssh.
+      # Must be one of:
+      #  - :public_ip_address
+      # This attribute also accepts an array of symbols.
+      #
+      # @return [Symbol]
+      attr_accessor :ssh_host_attribute
+
+      # The API token to access Hetznercloud. It can also be configured with
+      # HETZNERCLOUD_TOKEN environment variable. If not specified it uses the
+      # hcloud cli config file (.config/hcloud/cli.toml)
+      #
+      # @return [String]
+      attr_accessor :token
+
+      # ssh keys as array (e.g. ['testkey'])
+      #
+      # @return [Array]
+      attr_accessor :ssh_keys
+
+      # active context in the hcloud config file
+      # If empty default context is used.
+      #
+      # @return [String]
+      attr_accessor :active_context
+
+      def initialize
+        @user_data             = UNSET_VALUE
+        @server_type           = UNSET_VALUE
+        @image                 = UNSET_VALUE
+        @name                  = UNSET_VALUE
+        @location              = UNSET_VALUE
+        @datacenter            = UNSET_VALUE
+        @server_check_interval = UNSET_VALUE
+        @server_ready_timeout  = UNSET_VALUE
+        @ssh_host_attribute    = UNSET_VALUE
+        @token                 = UNSET_VALUE
+        @ssh_keys              = UNSET_VALUE
+        @active_context        = UNSET_VALUE
+      end
+
+      def finalize!
+        @user_data       = nil if @user_data == UNSET_VALUE
+        @server_type     = 'cx11' if @server_type == UNSET_VALUE
+        @image           = 'centos-7' if @image == UNSET_VALUE
+
+        if @name == UNSET_VALUE
+          require 'securerandom'
+          @name = "h-#{SecureRandom.hex(3)}"
+        end
+
+        @location              = (ENV['HETZNERCLOUD_LOCATION']) if @location == UNSET_VALUE
+        @datacenter            = (ENV['HETZNERCLOUD_DATACENTER']) if @datacenter == UNSET_VALUE
+        @server_check_interval = 2 if @server_check_interval == UNSET_VALUE
+        @server_ready_timeout  = 120 if @server_ready_timeout == UNSET_VALUE
+        @ssh_host_attribute    = nil if @ssh_host_attribute == UNSET_VALUE
+        @active_context        = nil if @active_context == UNSET_VALUE
+        @token                 = (ENV['HETZNERCLOUD_TOKEN'] || get_token(@active_context)) if @token == UNSET_VALUE
+        @ssh_keys              = [] if @ssh_keys == UNSET_VALUE
+      end
+
+      def validate(_machine)
+        errors = _detected_errors
+
+        errors << I18n.t('vagrant_hetznercloud.config.token_required') if @token.nil?
+        errors << I18n.t('vagrant_hetznercloud.config.ssh_keys_required') if @token.nil?
+
+        { 'Hetznercloud Provider' => errors }
+      end
+
+      # Get the token from the hckoud cli config file (if it exists)
+      def get_token(active_context = nil)
+
+              # The config file
+              config_file = ENV['HOME'] + "/.config/hcloud/cli.toml"
+              return nil unless File.exists?(config_file)
+
+              # Load the file
+              config_data = TOML.load_file(config_file)
+
+              # default context if not specified
+              active_context = config_data["active_context"] if active_context.nil?
+
+              context = config_data["contexts"].find { |context|
+                      context["name"] == active_context
+              }
+
+              # Not found
+              return nil if context.nil?
+              return nil unless context.has_key?('token')
+              return context["token"]
+      end
+
+    end
+  end
+end

data/lib/vagrant-hetznercloud/errors.rb

@@ -0,0 +1,21 @@
+module VagrantPlugins
+  module Hetznercloud
+    module Errors
+      class VagrantHetznercloudError < Vagrant::Errors::VagrantError
+        error_namespace('vagrant_hetznercloud.errors')
+      end
+
+      class FogError < VagrantHetznercloudError
+        error_key(:fog_error)
+      end
+
+      class InternalFogError < VagrantHetznercloudError
+        error_key(:internal_fog_error)
+      end
+
+      class ServerReadyTimeout < VagrantHetznercloudError
+        error_key(:server_ready_timeout)
+      end
+    end
+  end
+end

data/lib/vagrant-hetznercloud/plugin.rb

@@ -0,0 +1,77 @@
+begin
+  require 'vagrant'
+rescue LoadError
+  raise 'The Hetznercloud provider 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.5.0'
+  raise 'Hetznercloud provider is only compatible with Vagrant 1.5+'
+end
+
+module VagrantPlugins
+  module Hetznercloud
+    class Plugin < Vagrant.plugin('2')
+      name 'Hetznercloud'
+      description <<-DESC
+      This plugin installs a provider that allows Vagrant to manage
+      machines in Hetznercloud.
+      DESC
+
+      config(:hetznercloud, :provider) do
+        require_relative 'config'
+        Config
+      end
+
+      provider(:hetznercloud, parallel: true, box_optional: true) do
+        # Setup logging and i18n
+        setup_logging
+        setup_i18n
+
+        # Return the provider
+        require_relative 'provider'
+        Provider
+      end
+
+      command(:hetznercloud, primary: false) do
+        require_relative 'command/root'
+        Command::Root
+      end
+
+      # This initializes the internationalization strings.
+      def self.setup_i18n
+        I18n.load_path << File.expand_path('locales/en.yml', Hetznercloud.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 unless 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_hetznercloud')
+          logger.outputters = Log4r::Outputter.stderr
+          logger.level = level
+        end
+      end
+    end
+  end
+end

data/lib/vagrant-hetznercloud/provider.rb

@@ -0,0 +1,48 @@
+module VagrantPlugins
+  module Hetznercloud
+    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', lock: false)
+        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', lock: false)
+
+        state_id = env[:machine_state_id]
+
+        # Get the short and long description
+        short = I18n.t("vagrant_hetznercloud.states.short_#{state_id}")
+        long  = I18n.t("vagrant_hetznercloud.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
+        name = @machine.name.nil? ? 'no name' : @machine.name
+        "Hetznercloud (#{id} with name #{name})"
+      end
+    end
+  end
+end

data/lib/vagrant-hetznercloud/util/timer.rb

@@ -0,0 +1,17 @@
+module VagrantPlugins
+  module Hetznercloud
+    module Util
+      class Timer
+        # A basic utility method that times the execution of the given
+        # block and returns it.
+        def self.time
+          start_time = Time.now.to_f
+          yield
+          end_time = Time.now.to_f
+
+          end_time - start_time
+        end
+      end
+    end
+  end
+end

data/lib/vagrant-hetznercloud/version.rb

@@ -0,0 +1,5 @@
+module VagrantPlugins
+  module Hetznercloud
+    VERSION = '0.0.1'
+  end
+end