vagrant-scaleway 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: fd75bdfdd4882cdab032133e1d2fb774aa575e16
+  data.tar.gz: 19b03b5498e88328ba42a6028e8be1d22a3a3cfb
+SHA512:
+  metadata.gz: 99bd7fc3bdb655ba213880457fa284db2aca08fee2336beacf0fbf0f86a6c63e1f5ea852285c6beb94b949ef7bf4ad077b385d271a4943927b10af6a07b9a907
+  data.tar.gz: 40690821c51c739ef925a71d07b72c2ebafdc49c16d1c0510dd2e4e415d16f79059fdd2177453ed1388b05a13f349a03a2c402ce8062f8b59107bc8c2f28d0fa

data/.gitignore

@@ -0,0 +1,10 @@
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+/Vagrantfile

data/.ruby-version

@@ -0,0 +1 @@
+2.2.5

data/Gemfile

@@ -0,0 +1,12 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in vagrant-scaleway.gemspec
+gemspec
+
+group :development do
+  gem 'vagrant', git: 'https://github.com/mitchellh/vagrant.git'
+end
+
+group :plugins do
+  gem 'vagrant-scaleway', path: '.'
+end

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2016 Satoshi Matsumoto
+
+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,69 @@
+# Vagrant Scaleway Provider
+
+[![Gem](https://img.shields.io/gem/v/vagrant-scaleway.svg?style=flat-square)](https://rubygems.org/gems/vagrant-scaleway)
+
+This is a [Vagrant](http://www.vagrantup.com/) plugin that adds a Scaleway
+provider to Vagrant, allowing Vagrant to control and provision machines in
+Scaleway.
+
+## Features
+
+- Boot Scaleway servers.
+- SSH into the servers.
+- Provision the servers with any built-in Vagrant provisioner.
+- Minimal synced folder support via rsync.
+
+## Prerequisites
+
+Prior to using this plugin, you will first need to create an API token and
+identify your organization ID. Please see the following help for instructions.
+
+- [How to generate an API token](https://www.scaleway.com/docs/generate-an-api-token/)
+- [How to retrieve my organization ID through the API](https://www.scaleway.com/docs/retrieve-my-organization-id-throught-the-api/)
+
+## Installation
+
+Install using standard Vagrant plugin installation methods.
+
+    $ vagrant plugin install vagrant-scaleway
+
+## Usage
+
+First, make a Vagrantfile that looks like the following:
+
+```ruby
+Vagrant.configure('2') do |config|
+  config.vm.provider :scaleway do |scaleway, override|
+    scaleway.organization = 'YOUR_ORGANIZATION_UUID'
+    scaleway.token = 'YOUR_TOKEN'
+
+    override.ssh.private_key_path = '~/.ssh/id_rsa'
+  end
+end
+```
+
+And then run `vagrant up` and specify the `scaleway` provider:
+
+    $ vagrant up --provider=scaleway
+
+## Development
+
+To work on the `vagrant-scaleway` plugin, clone this repository out, and use
+[Bundler](http://gembundler.com) to get the dependencies:
+
+    $ bundle
+
+If those pass, you're ready to start developing the plugin. You can test
+the plugin without installing it into your Vagrant environment by just
+creating a `Vagrantfile` in the top level of this directory (it is gitignored)
+that uses it, and uses bundler to execute Vagrant:
+
+    $ bundle exec vagrant up --provider=scaleway
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/kaorimatz/vagrant-scaleway.
+
+## License
+
+The plugin is available as open source under the terms of the [MIT License](http://opensource.org/licenses/MIT).

data/Rakefile

@@ -0,0 +1,9 @@
+require 'bundler/gem_tasks'
+require 'rake/testtask'
+
+Rake::TestTask.new(:test) do |t|
+  t.libs << 'test'
+  t.test_files = FileList['test/**/*_test.rb']
+end
+
+task default: :test

data/example_box/metadata.json

@@ -0,0 +1,3 @@
+{
+    "provider": "scaleway"
+}

data/lib/vagrant-scaleway.rb

@@ -0,0 +1,17 @@
+require 'pathname'
+require 'vagrant-scaleway/plugin'
+
+module VagrantPlugins
+  module Scaleway
+    lib_path = Pathname.new(File.expand_path('../vagrant-scaleway', __FILE__))
+    autoload :Action, lib_path.join('action')
+    autoload :Errors, lib_path.join('errors')
+
+    # This returns the path to the source of this plugin.
+    #
+    # @return [Pathname]
+    def self.source_root
+      @source_root ||= Pathname.new(File.expand_path('../../', __FILE__))
+    end
+  end
+end

data/lib/vagrant-scaleway/action.rb

@@ -0,0 +1,179 @@
+require 'vagrant/action/builder'
+
+module VagrantPlugins
+  module Scaleway
+    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 terminate the remote machine.
+      def self.action_destroy
+        Vagrant::Action::Builder.new.tap do |b|
+          b.use Call, DestroyConfirm do |env, b2|
+            if env[:result]
+              b2.use ConfigValidate
+              b2.use Call, IsCreated do |env2, b3|
+                unless env2[:result]
+                  b3.use MessageNotCreated
+                  next
+                end
+
+                b3.use ConnectScaleway
+                b3.use ProvisionerCleanup, :before if defined?(ProvisionerCleanup)
+                b3.use DestroyServer
+              end
+            else
+              b2.use MessageWillNotDestroy
+            end
+          end
+        end
+      end
+
+      # This action is called to halt the remote machine.
+      def self.action_halt
+        Vagrant::Action::Builder.new.tap do |b|
+          b.use ConfigValidate
+          b.use Call, IsCreated do |env, b2|
+            unless env[:result]
+              b2.use MessageNotCreated
+              next
+            end
+
+            b2.use ConnectScaleway
+            b2.use StopServer
+          end
+        end
+      end
+
+      # This action is called when `vagrant provision` is called.
+      def self.action_provision
+        Vagrant::Action::Builder.new.tap do |b|
+          b.use ConfigValidate
+          b.use Call, IsCreated do |env, b2|
+            unless env[:result]
+              b2.use MessageNotCreated
+              next
+            end
+
+            b2.use Provision
+          end
+        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 ConnectScaleway
+          b.use ReadSSHInfo
+        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 ConfigValidate
+          b.use ConnectScaleway
+          b.use ReadState
+        end
+      end
+
+      # This action is called to restart the remote machine.
+      def self.action_reload
+        Vagrant::Action::Builder.new.tap do |b|
+          b.use ConfigValidate
+          b.use ConnectScaleway
+          b.use Call, IsCreated do |env1, b1|
+            unless env1[:result]
+              b1.use MessageNotCreated
+              next
+            end
+
+            b1.use action_halt
+            b1.use action_up
+          end
+        end
+      end
+
+      # This action is called to SSH into the machine.
+      def self.action_ssh
+        Vagrant::Action::Builder.new.tap do |b|
+          b.use ConfigValidate
+          b.use Call, IsCreated do |env, b2|
+            unless env[:result]
+              b2.use MessageNotCreated
+              next
+            end
+
+            b2.use SSHExec
+          end
+        end
+      end
+
+      # This action is called to execute a command on the machine via SSH.
+      def self.action_ssh_run
+        Vagrant::Action::Builder.new.tap do |b|
+          b.use ConfigValidate
+          b.use Call, IsCreated do |env, b2|
+            unless env[:result]
+              b2.use MessageNotCreated
+              next
+            end
+
+            b2.use SSHRun
+          end
+        end
+      end
+
+      # 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 BoxCheckOutdated
+          b.use ConnectScaleway
+          b.use Call, IsCreated do |env1, b1|
+            if env1[:result]
+              b1.use Call, IsStopped do |env2, b2|
+                if env2[:result]
+                  b2.use Provision
+                  b2.use SyncedFolders
+                  b2.use WarnNetworks
+                  b2.use StartServer
+                else
+                  b2.use MessageAlreadyCreated
+                end
+              end
+            else
+              b1.use Provision
+              b1.use SyncedFolders
+              b1.use WarnNetworks
+              b1.use CreateServer
+              b1.use StartServer
+            end
+          end
+        end
+      end
+
+      # The autoload farm
+      action_root = Pathname.new(File.expand_path('../action', __FILE__))
+      autoload :ConnectScaleway, action_root.join('connect_scaleway')
+      autoload :CreateServer, action_root.join('create_server')
+      autoload :IsCreated, action_root.join('is_created')
+      autoload :IsStopped, action_root.join('is_stopped')
+      autoload :MessageAlreadyCreated, action_root.join('message_already_created')
+      autoload :MessageNotCreated, action_root.join('message_not_created')
+      autoload :MessageWillNotDestroy, action_root.join('message_will_not_destroy')
+      autoload :ReadSSHInfo, action_root.join('read_ssh_info')
+      autoload :ReadState, action_root.join('read_state')
+      autoload :StartServer, action_root.join('start_server')
+      autoload :StopServer, action_root.join('stop_server')
+      autoload :WarnNetworks, action_root.join('warn_networks')
+      autoload :DestroyServer, action_root.join('destroy_server')
+    end
+  end
+end

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

@@ -0,0 +1,34 @@
+require 'fog/scaleway'
+
+module VagrantPlugins
+  module Scaleway
+    module Action
+      # This action connects to Scaleway, verifies credentials work, and
+      # puts the Scaleway connection object into the `:scaleway_compute` key
+      # in the environment.
+      class ConnectScaleway
+        def initialize(app, _env)
+          @app    = app
+          @logger = Log4r::Logger.new('vagrant_scaleway::action::connect_scaleway')
+        end
+
+        def call(env)
+          # Get the configs
+          provider_config = env[:machine].provider_config
+
+          # Build the fog config
+          fog_config = {
+            provider:              :scaleway,
+            scaleway_organization: provider_config.organization,
+            scaleway_token:        provider_config.token
+          }
+
+          @logger.info('Connecting to Scaleway...')
+          env[:scaleway_compute] = Fog::Compute.new(fog_config)
+
+          @app.call(env)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,75 @@
+require 'vagrant/util/retryable'
+require 'vagrant-scaleway/util/timer'
+
+module VagrantPlugins
+  module Scaleway
+    module Action
+      # This creates the configured server.
+      class CreateServer
+        include Vagrant::Util::Retryable
+
+        def initialize(app, _env)
+          @app    = app
+          @logger = Log4r::Logger.new('vagrant_scaleway::action::create_server')
+        end
+
+        def call(env)
+          # Initialize metrics if they haven't been
+          env[:metrics] ||= {}
+
+          config = env[:machine].provider_config
+
+          bootscript      = config.bootscript
+          commercial_type = config.commercial_type
+          image           = config.image
+          name            = config.name
+          security_group  = config.security_group
+          tags            = config.tags
+
+          env[:ui].info(I18n.t('vagrant_scaleway.creating_server'))
+          env[:ui].info(" -- Bootscript: #{bootscript}") if bootscript
+          env[:ui].info(" -- Commercial Type: #{commercial_type}")
+          env[:ui].info(" -- Image: #{image}")
+          env[:ui].info(" -- Name: #{name}")
+          env[:ui].info(" -- Security Group: #{security_group}") if security_group
+          env[:ui].info(" -- Tags: #{tags}") unless tags.empty?
+
+          options = {
+            name:            name,
+            image:           image,
+            commercial_type: commercial_type,
+            tags:            tags
+          }
+
+          options[:bootscript] = bootscript if bootscript
+          options[:security_group] = security_group if security_group
+
+          begin
+            server = env[:scaleway_compute].servers.create(options)
+          rescue Fog::Scaleway::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
+
+          # Immediately save the ID since it is created at this point.
+          env[:machine].id = server.id
+
+          begin
+            @app.call(env)
+          rescue Exception => e
+            # Delete the server
+            terminate(env)
+
+            raise e
+          end
+
+          # Terminate the server if we were interrupted
+          terminate(env) if env[:interrupted]
+        end
+      end
+    end
+  end
+end