vagrant-scaleway 0.1.0

data/lib/vagrant-scaleway/action/destroy_server.rb

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

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

@@ -0,0 +1,18 @@
+module VagrantPlugins
+  module Scaleway
+    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-scaleway/action/is_stopped.rb

@@ -0,0 +1,18 @@
+module VagrantPlugins
+  module Scaleway
+    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 == :stopped
+          @app.call(env)
+        end
+      end
+    end
+  end
+end

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

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

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

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

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

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

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

@@ -0,0 +1,50 @@
+module VagrantPlugins
+  module Scaleway
+    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_scaleway::action::read_ssh_info')
+        end
+
+        def call(env)
+          env[:machine_ssh_info] = read_ssh_info(env[:scaleway_compute], env[:machine])
+
+          @app.call(env)
+        end
+
+        def read_ssh_info(scaleway, machine)
+          return nil if machine.id.nil?
+
+          # Find the machine
+          server = scaleway.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 public_dns_name private_ip_address private_dns_name)
+          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-scaleway/action/read_state.rb

@@ -0,0 +1,36 @@
+module VagrantPlugins
+  module Scaleway
+    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_scaleway::action::read_state')
+        end
+
+        def call(env)
+          env[:machine_state_id] = read_state(env[:scaleway_compute], env[:machine])
+
+          @app.call(env)
+        end
+
+        def read_state(scaleway, machine)
+          return :not_created if machine.id.nil?
+
+          # Find the machine
+          server = scaleway.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.state.to_sym
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,90 @@
+require 'vagrant/util/retryable'
+require 'vagrant-scaleway/util/timer'
+
+module VagrantPlugins
+  module Scaleway
+    module Action
+      # This starts a stopped server.
+      class StartServer
+        include Vagrant::Util::Retryable
+
+        def initialize(app, _env)
+          @app    = app
+          @logger = Log4r::Logger.new('vagrant_scaleway::action::start_server')
+        end
+
+        def call(env)
+          # Initialize metrics if they haven't been
+          env[:metrics] ||= {}
+
+          config = env[:machine].provider_config
+
+          server = env[:scaleway_compute].servers.get(env[:machine].id)
+
+          env[:ui].info(I18n.t('vagrant_scaleway.starting'))
+
+          begin
+            server.poweron
+          rescue Fog::Scaleway::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_scaleway.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_scaleway.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 Exception => e
+                  if network_ready_retries < network_ready_retries_max
+                    network_ready_retries += 1
+                    @logger.warn(I18n.t('vagrant_scaleway.waiting_for_ssh, retrying'))
+                  else
+                    raise e
+                  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_scaleway.ready'))
+          end
+
+          @app.call(env)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,26 @@
+module VagrantPlugins
+  module Scaleway
+    module Action
+      # This stops the running server.
+      class StopServer
+        def initialize(app, _env)
+          @app    = app
+          @logger = Log4r::Logger.new('vagrant_scaleway::action::stop_server')
+        end
+
+        def call(env)
+          server = env[:scaleway_compute].servers.get(env[:machine].id)
+
+          if env[:machine].state.id == :stopped
+            env[:ui].info(I18n.t('vagrant_scaleway.already_status', status: env[:machine].state.id))
+          else
+            env[:ui].info(I18n.t('vagrant_scaleway.stopping'))
+            server.poweroff(false)
+          end
+
+          @app.call(env)
+        end
+      end
+    end
+  end
+end

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

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

data/lib/vagrant-scaleway/config.rb

@@ -0,0 +1,113 @@
+module VagrantPlugins
+  module Scaleway
+    class Config < Vagrant.plugin('2', :config)
+      # The bootscript ID. If nil, the default bootscript for the image will be
+      # used.
+      #
+      # @return [String]
+      attr_accessor :bootscript
+
+      # The type of the server to launch, such as 'C1'. Defaults to 'C2S'.
+      #
+      # @return [String]
+      attr_accessor :commercial_type
+
+      # The image ID.
+      #
+      # @return [String]
+      attr_accessor :image
+
+      # The name of the server.
+      #
+      # @return [String]
+      attr_accessor :name
+
+      # The organization ID. It can also be configured with SCW_ORGANIZATION
+      # environment variable.
+      #
+      # @return [String]
+      attr_accessor :organization
+
+      # The security group to associate with the server. If nil, organization's
+      # default security group will be used.
+      #
+      # @return [String]
+      attr_accessor :security_group
+
+      # 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
+      #  - :public_dns_name
+      #  - :private_ip_address
+      #  - :private_dns_name
+      # This attribute also accepts an array of symbols.
+      #
+      # @return [Symbol]
+      attr_accessor :ssh_host_attribute
+
+      # Tags to apply to the server.
+      #
+      # @return [Array]
+      attr_accessor :tags
+
+      # The API token to access Scaleway. It can also be configured with
+      # SCW_TOKEN environment variable.
+      #
+      # @return [String]
+      attr_accessor :token
+
+      def initialize
+        @bootscript            = UNSET_VALUE
+        @commercial_type       = UNSET_VALUE
+        @image                 = UNSET_VALUE
+        @name                  = UNSET_VALUE
+        @organization          = UNSET_VALUE
+        @server_check_interval = UNSET_VALUE
+        @server_ready_timeout  = UNSET_VALUE
+        @security_group        = UNSET_VALUE
+        @ssh_host_attribute    = UNSET_VALUE
+        @tags                  = []
+        @token                 = UNSET_VALUE
+      end
+
+      def finalize!
+        @bootscript      = nil if @bootscript == UNSET_VALUE
+        @commercial_type = 'C2S' if @commercial_type == UNSET_VALUE
+        @image           = '75c28f52-6c64-40fc-bb31-f53ca9d02de9' if @image == UNSET_VALUE
+
+        if @name == UNSET_VALUE
+          require 'securerandom'
+          @name = "scw-#{SecureRandom.hex(3)}"
+        end
+
+        @organization          = ENV['SCW_ORGANIZATION'] if @organization == UNSET_VALUE
+        @server_check_interval = 2 if @server_check_interval == UNSET_VALUE
+        @server_ready_timeout  = 120 if @server_ready_timeout == UNSET_VALUE
+        @security_group        = nil if @security_group == UNSET_VALUE
+        @ssh_host_attribute    = nil if @ssh_host_attribute == UNSET_VALUE
+        @token                 = ENV['SCW_TOKEN'] if @token == UNSET_VALUE
+      end
+    end
+
+    def validate(machine)
+      errors = _detected_errors
+
+      errors << I18n.t('vagrant_scaleway.config.organization_required') if @organization.nil?
+      errors << I18n.t('vagrant_scaleway.config.token_required') if @token.nil?
+
+      { 'Scaleway Provider' => errors }
+    end
+  end
+end