vagrant-dustcloud 0.0.5

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 272a9f6a7493a0e03ad17e99ae2f3645a2cf379f462e648c744d2029c8d96f90
+  data.tar.gz: cba88ed71023e27524ea5847cc5ad7f5e52004daf9daa0aac483b14a20069dd3
+SHA512:
+  metadata.gz: 3a6acacca644325a3f45971a39079821c1c6925a92b04917fae2f550e7c3838a1c3cc2dc4d321cfe7bf292138a0eaeac418d5a949f5f5c5f7ac142f3d2368741
+  data.tar.gz: be4d1851abbfd48b58da6ecf45c34e132b30d1a27520370c37e63ba9507e6da665b705eac271da2e2b9bead989c9332420e8fa20c08e5497f2e67c5ff243de1c

data/.gitignore

@@ -0,0 +1,21 @@
+# OS-specific
+.DS_Store
+
+# editors
+*.swp
+
+# Bundler/Rubygems
+*.gem
+.bundle
+pkg/*
+tags
+Gemfile.lock
+
+# Vagrant
+.vagrant
+Vagrantfile
+!example_box/Vagrantfile
+
+# RVM files for gemset/ruby setting
+.ruby-*
+.rvmrc

data/Gemfile

@@ -0,0 +1,9 @@
+source "https://rubygems.org"
+
+group :development do
+  gem "vagrant", git: "https://github.com/hashicorp/vagrant.git"
+end
+
+group :plugins do
+  gem "vagrant-dustcloud", path: "."
+end

data/README.md

@@ -0,0 +1,56 @@
+# Vagrant LUDD DUSTcloud Provider
+
+## Features
+ - Boot instances in LUDD DUSTcloud.
+ - SSH into the instances.
+ - Provision the instances with any built-in Vagrant provisioner.
+ - Minimal synced folder support via `rsync`.
+
+## Usage
+Install using the standard Vagrant 1.1+ plugin installation methods. After installing, `vagrant up` and specify the `dustcloud` provider. An example is shown below.
+```
+$ vagrant plugin install vagrant-dustcloud
+...
+$ vagrant up --provider=dustcloud
+...
+```
+
+## Quick Start
+After installing the plugin (instructions above), the quickest way to get started is to actually use a dummy Dustcloud box and specify all the details manually within a config.vm.provider block. So first, add the dummy box using any name you want:
+```
+$ vagrant box add dummy https://git.ludd.ltu.se/ludd/vagrant-dustcloud/raw/master/dummy.box
+...
+```
+And then make a Vagrantfile that looks like the following.
+```ruby
+Vagrant.configure("2") do |config|
+  config.vm.box = "dummy"
+
+  config.vm.provider :dustcloud do |dustcloud|
+    dustcloud.token_file = "~/.dustcloud"
+    dustcloud.image = "focal"
+    dustcloud.flavor = "small"
+  end
+end
+```
+And then run `vagrant up --provider=dustcloud`.
+
+## Development
+To work on the `vagrant-dustcloud` 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)
+and add the following line to your `Vagrantfile` 
+```ruby
+Vagrant.require_plugin "vagrant-dustcloud"
+```
+Use bundler to execute Vagrant:
+```
+$ bundle exec vagrant up --provider=dustcloud
+```

data/Rakefile

@@ -0,0 +1,14 @@
+require 'rubygems'
+require 'bundler/setup'
+
+# Immediately sync all stdout so that tools like buildbot can
+# immediately load in the output.
+$stdout.sync = true
+$stderr.sync = true
+
+# Change to the directory of this file.
+Dir.chdir(File.expand_path("../", __FILE__))
+
+# This installs the tasks that help with gem creation and
+# publishing.
+Bundler::GemHelper.install_tasks

data/example_box/metadata.json

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

data/lib/vagrant-dustcloud.rb

@@ -0,0 +1,18 @@
+require "pathname"
+
+require "vagrant-dustcloud/plugin"
+
+module VagrantPlugins
+  module Dustcloud
+    lib_path = Pathname.new(File.expand_path("../vagrant-dustcloud", __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-dustcloud/action.rb

@@ -0,0 +1,189 @@
+require "pathname"
+
+require "vagrant/action/builder"
+
+module VagrantPlugins
+  module Dustcloud
+    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 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|
+            if !env[:result]
+              b2.use MessageNotCreated
+              next
+            end
+
+            b2.use ConnectDustcloud
+            b2.use StopInstance
+          end
+        end
+      end
+
+      # 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|
+                if !env2[:result]
+                  b3.use MessageNotCreated
+                  next
+                end
+
+                b3.use ConnectDustcloud
+                b3.use ProvisionerCleanup, :before if defined?(ProvisionerCleanup)
+                b3.use TerminateInstance
+              end
+            else
+              b2.use MessageWillNotDestroy
+            end
+          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|
+            if !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 ConnectDustcloud
+          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 ConnectDustcloud
+          b.use ReadState
+        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|
+            if !env[:result]
+              b2.use MessageNotCreated
+              next
+            end
+
+            b2.use SSHExec
+          end
+        end
+      end
+
+      def self.action_ssh_run
+        Vagrant::Action::Builder.new.tap do |b|
+          b.use ConfigValidate
+          b.use Call, IsCreated do |env, b2|
+            if !env[:result]
+              b2.use MessageNotCreated
+              next
+            end
+
+            b2.use SSHRun
+          end
+        end
+      end
+
+      def self.action_prepare_boot
+        Vagrant::Action::Builder.new.tap do |b|
+          b.use Provision
+          b.use SyncedFolders
+        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 ConnectDustcloud
+          b.use Call, IsCreated do |env1, b1|
+            if env1[:result]
+              b1.use Call, IsStopped do |env2, b2|
+                if env2[:result]
+                  b2.use action_prepare_boot
+                  b2.use StartInstance # restart this instance
+                else
+                  b2.use MessageAlreadyCreated # TODO write a better message
+                end
+              end
+            else
+              b1.use action_prepare_boot
+              b1.use RunInstance # launch a new instance
+            end
+          end
+        end
+      end
+
+      def self.action_reload
+        Vagrant::Action::Builder.new.tap do |b|
+          b.use ConfigValidate
+          b.use ConnectDustcloud
+          b.use Call, IsCreated do |env, b2|
+            if !env[:result]
+              b2.use MessageNotCreated
+              next
+            end
+
+            b2.use action_halt
+            b2.use Call, WaitForState, :shutoff, 120 do |env2, b3|
+              if env2[:result]
+                b3.use action_up
+              else
+                # TODO we couldn't reach :stopped, what now?
+              end
+            end
+          end
+        end
+      end
+
+      # The autoload farm
+      action_root = Pathname.new(File.expand_path("../action", __FILE__))
+      autoload :ConnectDustcloud, action_root.join("connect_dustcloud")
+      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 :PackageInstance, action_root.join("package_instance")
+      autoload :ReadSSHInfo, action_root.join("read_ssh_info")
+      autoload :ReadState, action_root.join("read_state")
+      autoload :RunInstance, action_root.join("run_instance")
+      autoload :StartInstance, action_root.join("start_instance")
+      autoload :StopInstance, action_root.join("stop_instance")
+      autoload :TerminateInstance, action_root.join("terminate_instance")
+      autoload :TimedProvision, action_root.join("timed_provision") # some plugins now expect this action to exist
+      autoload :WaitForState, action_root.join("wait_for_state")
+    end
+  end
+end

data/lib/vagrant-dustcloud/action/connect_dustcloud.rb

@@ -0,0 +1,65 @@
+require "log4r"
+require "json"
+
+require 'net/http'
+
+module VagrantPlugins
+    module Dustcloud
+        module Action
+            class ConnectDustcloud
+                def initialize(app, env)
+                    @app = app
+                    @logger = Log4r::Logger.new("vagrant_dustcloud::action::connect_dustcloud")
+                end
+
+                def call(env)
+                    
+                    api_token = env[:machine].provider_config.token.to_s
+                    env[:dustcloud] = DustcloudAPI.new(api_token)
+
+                    pw_file = env[:machine].data_dir.join('ssh_password')
+                    if pw_file.file?
+                        env[:machine_ssh_password] = pw_file.read
+                    end
+
+                    @app.call(env)
+                end
+            end
+
+            class DustcloudAPI
+                def initialize(api_token)
+                    net = Net::HTTP.new("dust.ludd.ltu.se", 443)
+                    net.use_ssl = true
+                    @api_token = api_token
+                    @net = net
+                end
+
+                def get_vm(uuid)
+                    res = @net.get("/cloud/vm/#{uuid}", "X-Dustcloud-Token" => @api_token )
+                    JSON.parse(res.body)
+                end
+
+                def create_vm(image, flavor)
+                    res = @net.post("/cloud/new", "image=#{image}&flavor=#{flavor}", "x-dustcloud-token" => @api_token )
+                    JSON.parse(res.body)
+                end
+
+
+                def start_vm(uuid)
+                    res = @net.post("/cloud/vm/#{uuid}/start", "", "x-dustcloud-token" => @api_token)
+                    JSON.parse(res.body)
+                end
+
+                def stop_vm(uuid)
+                    res = @net.post("/cloud/vm/#{uuid}/stop", "", "x-dustcloud-token" => @api_token)
+                    JSON.parse(res.body)
+                end
+
+                def destroy_vm(uuid)
+                    res = @net.post("/cloud/vm/#{uuid}/delete", "", "x-dustcloud-token" => @api_token)
+                    JSON.parse(res.body)
+                end
+            end
+        end
+    end
+end

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

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

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

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

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

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

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

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

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

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

@@ -0,0 +1,38 @@
+require "log4r"
+
+module VagrantPlugins
+  module Dustcloud
+    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_dustcloud::action::read_ssh_info")
+        end
+
+        def call(env)
+          env[:machine_ssh_info] = read_ssh_info(env[:dustcloud], env)
+
+          @app.call(env)
+        end
+
+        def read_ssh_info(dustcloud, env)
+          machine = env[:machine]
+          return nil if machine.id.nil?
+
+          # Find the machine
+          server = dustcloud.get_vm(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
+
+          return { :host => server["ssh_host"], :port => server["ssh_port"], :username => server["ssh_username"], :password => env[:machine_ssh_password] }
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,33 @@
+require "log4r"
+
+module VagrantPlugins
+  module Dustcloud
+    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_dustcloud::action::read_state")
+        end
+
+        def call(env)
+          env[:machine_state_id] = read_state(env[:dustcloud], env[:machine])
+
+          @app.call(env)
+        end
+
+        def read_state(dustcloud, machine)
+          return :not_created if machine.id.nil?
+
+          # Find the machine
+          server = dustcloud.get_vm(machine.id)
+          if server.nil?
+            return :not_created
+          end
+          return server["status"].downcase.to_sym
+        end
+      end
+    end
+  end
+end

data/lib/vagrant-dustcloud/action/run_instance.rb

@@ -0,0 +1,110 @@
+require "log4r"
+require 'json'
+
+require 'vagrant/util/retryable'
+require 'vagrant-dustcloud/util/timer'
+
+module VagrantPlugins
+  module Dustcloud
+    module Action
+      # This runs the configured instance.
+      class RunInstance
+        include Vagrant::Util::Retryable
+
+        def initialize(app, env)
+          @app    = app
+          @logger = Log4r::Logger.new("vagrant_dustcloud::action::run_instance")
+        end
+
+        def call(env)
+          # Initialize metrics if they haven't been
+          env[:metrics] ||= {}
+
+          flavor = env[:machine].provider_config.flavor.to_s
+          image = env[:machine].provider_config.image.to_s
+
+          env[:ui].info(I18n.t("vagrant_dustcloud.launching_instance"))
+          env[:ui].info(" -- Image: #{image}")
+          env[:ui].info(" -- Flavor: #{flavor}")
+
+          begin
+            server = env[:dustcloud].create_vm(image, flavor)
+          end
+
+          env[:machine].id = server["uuid"]
+          env[:machine_ssh_username] = server["username"]
+          env[:machine_ssh_password] = server["password"]
+          pw_file = env[:machine].data_dir.join('ssh_password')
+          pw_file.open('w+') do |f|
+            f.write(server["password"])
+          end
+
+
+
+          env[:metrics]["instance_ready_time"] = Util::Timer.time do
+            env[:ui].info(I18n.t("vagrant_dustcloud.waiting_for_ready"))
+            total_waited = 0
+            while true
+            # If we're interrupted don't worry about waiting
+              break if env[:interrupted]
+
+              # Wait for the server to be ready
+              vm = env[:dustcloud].get_vm(server["uuid"])
+              if vm["status"] == "ACTIVE"
+                break
+              end
+              sleep(2)
+              total_waited += 2
+              if total_waited > 180
+                raise Errors::InstanceReadyTimeout, timeout: 180
+              end
+            end
+          end
+
+          env[:ui].info("Time to instance ready: #{env[:metrics]["instance_ready_time"]}")
+          if !env[:interrupted]
+            env[:metrics]["instance_ssh_time"] = Util::Timer.time do
+              # Wait for SSH to be ready.
+              env[:ui].info(I18n.t("vagrant_dustcloud.waiting_for_ssh"))
+              network_ready_retries = 0
+              network_ready_retries_max = 10
+              while true
+                # If we're interrupted then just back out
+                break if env[:interrupted]
+                # When an ec2 instance 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 then
+                    network_ready_retries += 1
+                    @logger.warn("SSH not yet up, retrying...")
+                  else
+                    raise e
+                  end
+                end
+                sleep 2
+              end
+            end
+            env[:ui].info("Time for SSH ready: #{env[:metrics]["instance_ssh_time"]}")
+
+            # Ready and booted!
+            env[:ui].info(I18n.t("vagrant_dustcloud.ready"))
+          end
+
+          terminate(env) if env[:interrupted]
+
+          @app.call(env)
+        end
+
+        def terminate(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-dustcloud/action/start_instance.rb

@@ -0,0 +1,82 @@
+require "log4r"
+
+require 'vagrant/util/retryable'
+require 'vagrant-dustcloud/util/timer'
+
+module VagrantPlugins
+  module Dustcloud
+    module Action
+      # This starts a stopped instance.
+      class StartInstance
+
+        def initialize(app, env)
+          @app    = app
+          @logger = Log4r::Logger.new("vagrant_dustcloud::action::start_instance")
+        end
+
+        def call(env)
+          # Initialize metrics if they haven't been
+          env[:metrics] ||= {}
+          env[:ui].info(I18n.t("vagrant_dustcloud.starting"))
+
+          begin
+            env[:dustcloud].start_vm(env[:machine].id)
+
+            env[:metrics]["instance_ready_time"] = Util::Timer.time do
+              env[:ui].info(I18n.t("vagrant_dustcloud.waiting_for_ready"))
+              total_waited = 0
+              while true
+              # If we're interrupted don't worry about waiting
+                break if env[:interrupted]
+  
+                # Wait for the server to be ready
+                vm = env[:dustcloud].get_vm(env[:machine].id)
+                if vm["status"] == "ACTIVE"
+                  break
+                end
+                sleep(2)
+                total_waited += 2
+                if total_waited > 180
+                  raise Errors::InstanceReadyTimeout, timeout: 180
+                end
+              end
+            end
+  
+            env[:ui].info("Time to instance ready: #{env[:metrics]["instance_ready_time"]}")
+            if !env[:interrupted]
+              env[:metrics]["instance_ssh_time"] = Util::Timer.time do
+                # Wait for SSH to be ready.
+                env[:ui].info(I18n.t("vagrant_dustcloud.waiting_for_ssh"))
+                network_ready_retries = 0
+                network_ready_retries_max = 10
+                while true
+                  # If we're interrupted then just back out
+                  break if env[:interrupted]
+                  # When an ec2 instance 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 then
+                      network_ready_retries += 1
+                      @logger.warn("SSH not yet up, retrying...")
+                    else
+                      raise e
+                    end
+                  end
+                  sleep 2
+                end
+              end
+              env[:ui].info("Time for SSH ready: #{env[:metrics]["instance_ssh_time"]}")
+  
+              # Ready and booted!
+              env[:ui].info(I18n.t("vagrant_dustcloud.ready"))
+            end
+          end
+
+          @app.call(env)
+        end
+      end
+    end
+  end
+end

data/lib/vagrant-dustcloud/action/stop_instance.rb

@@ -0,0 +1,26 @@
+require "log4r"
+
+module VagrantPlugins
+  module Dustcloud
+    module Action
+      # This stops the running instance.
+      class StopInstance
+        def initialize(app, env)
+          @app    = app
+          @logger = Log4r::Logger.new("vagrant_dustcloud::action::stop_instance")
+        end
+
+        def call(env)
+          if env[:machine].state.id == :shutoff
+            env[:ui].info(I18n.t("vagrant_dustcloud.already_status", :status => env[:machine].state.id))
+          else
+            env[:ui].info(I18n.t("vagrant_dustcloud.stopping"))
+            env[:dustcloud].stop_vm(env[:machine].id)
+          end
+
+          @app.call(env)
+        end
+      end
+    end
+  end
+end

data/lib/vagrant-dustcloud/action/terminate_instance.rb

@@ -0,0 +1,32 @@
+require "log4r"
+require "json"
+
+module VagrantPlugins
+  module Dustcloud
+    module Action
+      # This terminates the running instance.
+      class TerminateInstance
+        def initialize(app, env)
+          @app    = app
+          @logger = Log4r::Logger.new("vagrant_aws::action::terminate_instance")
+        end
+
+        def call(env)
+         
+          env[:ui].info(I18n.t("vagrant_dustcloud.terminating"))
+          result = env[:dustcloud].destroy_vm(env[:machine].id)
+          if result["errors"].length > 0
+            env[:ui].info(I18n.t("vagrant_dustcloud.terminating_failed"))
+            result["errors"].each do |item|
+              env[:ui].info(" -- #{item}")
+            end
+            env[:ui].info(I18n.t("vagrant_dustcloud.terminating_help"))
+          end
+          env[:machine].id = nil
+
+          @app.call(env)
+        end
+      end
+    end
+  end
+end

data/lib/vagrant-dustcloud/action/timed_provision.rb

@@ -0,0 +1,21 @@
+require "vagrant-aws/util/timer"
+
+module VagrantPlugins
+  module AWS
+    module Action
+      # This is the same as the builtin provision except it times the
+      # provisioner runs.
+      class TimedProvision < Vagrant::Action::Builtin::Provision
+        def run_provisioner(env, name, p)
+          timer = Util::Timer.time do
+            super
+          end
+
+          env[:metrics] ||= {}
+          env[:metrics]["provisioner_times"] ||= []
+          env[:metrics]["provisioner_times"] << [name, timer]
+        end
+      end
+    end
+  end
+end

data/lib/vagrant-dustcloud/action/wait_for_state.rb

@@ -0,0 +1,41 @@
+require "log4r"
+require "timeout"
+
+module VagrantPlugins
+  module Dustcloud
+    module Action
+      # This action will wait for a machine to reach a specific state or quit by timeout
+      class WaitForState
+        # env[:result] will be false in case of timeout.
+        # @param [Symbol] state Target machine state.
+        # @param [Number] timeout Timeout in seconds.
+        def initialize(app, env, state, timeout)
+          @app     = app
+          @logger  = Log4r::Logger.new("vagrant_dustcloud::action::wait_for_state")
+          @state   = state
+          @timeout = timeout
+        end
+
+        def call(env)
+          env[:result] = true
+          if env[:machine].state.id == @state
+            @logger.info("Status of machine is already #{@state}")
+          else
+            @logger.info("Waiting for machine to reach state #{@state}")
+            begin
+              Timeout.timeout(@timeout) do
+                until env[:machine].state.id == @state
+                  sleep 2
+                end
+              end
+            rescue Timeout::Error
+              env[:result] = false # couldn't reach state in time
+            end
+          end
+
+          @app.call(env)
+        end
+      end
+    end
+  end
+end

data/lib/vagrant-dustcloud/config.rb

@@ -0,0 +1,52 @@
+require "vagrant"
+
+module VagrantPlugins
+    module Dustcloud
+        class Config < Vagrant.plugin("2", :config)
+            # @return [String]
+            attr_accessor :token_file
+
+            # @return [String]
+            attr_accessor :token
+
+            # @return [String]
+            attr_accessor :image
+
+            # @return [String]
+            attr_accessor :flavor
+
+            def initialize()
+                @token_file = UNSET_VALUE
+                @token = UNSET_VALUE
+                @image = UNSET_VALUE
+                @flavor = UNSET_VALUE
+            end
+
+            def finalize!
+                @token_file = ENV['HOME'].to_s + '/.dustcloud' if @token_file == UNSET_VALUE
+                @token = Credentials.new.get_token(@token_file) if @token == UNSET_VALUE
+                @image = nil if @image == UNSET_VALUE
+                @flavor = "tiny" if @flavor == UNSET_VALUE
+            end
+
+            def validate(machine)
+                errors = _detected_errors
+
+                errors << "No token specified" if @token.nil? || @token == ""
+                errors << "No image specified" if @image.nil? || @image == ""
+
+                { "LUDD DUSTCloud Provider" => errors }
+            end
+        end
+
+        class Credentials < Vagrant.plugin("2", :config)
+            def get_token(token_file)
+                if !token_file.nil? && File.exists?(token_file)
+                    File.read(token_file)
+                else
+                    ENV["DUSTCLOUD_TOKEN"].to_s
+                end
+            end
+        end
+    end
+end

data/lib/vagrant-dustcloud/errors.rb

@@ -0,0 +1,23 @@
+require "vagrant"
+
+module VagrantPlugins
+  module Dustcloud
+    module Errors
+      class VagrantDustcloudError < Vagrant::Errors::VagrantError
+        error_namespace("vagrant_dustcloud.errors")
+      end
+
+      class APIError < VagrantDustcloudError
+        error_key(:api_error)
+      end
+
+      class InternalAPIError < VagrantDustcloudError
+        error_key(:internal_api_error)
+      end
+
+      class InstanceReadyTimeout < VagrantDustcloudError
+        error_key(:instance_ready_timeout)
+      end
+    end
+  end
+end

data/lib/vagrant-dustcloud/plugin.rb

@@ -0,0 +1,38 @@
+begin
+  require "vagrant"
+rescue LoadError
+  raise "The Vagrant Dustcloud plugin 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.2.0"
+    raise "The Vagrant Dustcloud plugin is only compatible with Vagrant 1.2+"
+  end
+module VagrantPlugins
+    module Dustcloud
+        class Plugin < Vagrant.plugin("2")
+            name "LUDD DUSTcloud Provisioner"
+            description <<-DESC
+            This plugin installs a provider that allows Vagrant to manage
+            machines in LUDD DUSTcloud.
+            DESC
+
+            config(:dustcloud, :provider) do
+              require_relative "config"
+              Config
+            end
+        
+            provider(:dustcloud) do
+                setup_i18n
+
+                require_relative "provider"
+                Provider
+            end
+
+            def self.setup_i18n
+                I18n.load_path << File.expand_path("locales/en.yaml", Dustcloud.source_root)
+                I18n.reload!
+              end
+        end
+    end
+end

data/lib/vagrant-dustcloud/provider.rb

@@ -0,0 +1,49 @@
+require "vagrant"
+
+module VagrantPlugins
+    module Dustcloud
+        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_dustcloud.states.short_#{state_id}")
+                long  = I18n.t("vagrant_dustcloud.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
+                "AWS (#{id})"
+              end
+        end
+    end
+end

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

@@ -0,0 +1,17 @@
+module VagrantPlugins
+    module Dustcloud
+      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-dustcloud/version.rb

@@ -0,0 +1,5 @@
+module VagrantPlugins
+    module Dustcloud
+        VERSION = '0.0.5'
+    end
+end

data/locales/en.yaml

@@ -0,0 +1,71 @@
+en:
+  vagrant_dustcloud:
+    already_status: |-
+      The machine is already %{status}.
+    launching_instance: |-
+      Launching an instance with the following settings...
+    not_created: |-
+      Instance is not created. Please run `vagrant up` first.
+    ready: |-
+      Machine is booted and ready for use!
+    rsync_not_found_warning: |-
+      Warning! Folder sync disabled because the rsync binary is missing in the %{side}.
+      Make sure rsync is installed and the binary can be found in the PATH.
+    rsync_folder: |-
+      Rsyncing folder: %{hostpath} => %{guestpath}
+    starting: |-
+      Starting the instance...
+    stopping: |-
+      Stopping the instance...
+    terminating: |-
+      Terminating the instance...
+    terminating_failed: |-
+      Failed to terminate the instance
+    terminating_help: |-
+      You may need to use the Cloud Dashboard (https://dust.ludd.ltu.se) or contact the administrators.
+    waiting_for_ready: |-
+      Waiting for instance to become "ready"...
+    waiting_for_ssh: |-
+      Waiting for SSH to become available...
+    will_not_destroy: |-
+      The instance '%{name}' will not be destroyed, since the confirmation
+      was declined.
+    config:
+      token_required: |-
+        An access key ID must be specified via "access_key_id"
+    errors:
+      api_error: |-
+        There was an error talking to Dustcloud. The error message is shown
+        below:
+        %{message}
+      internal_api_error: |-
+        There was an error talking to Dustcloud. The error message is shown
+        below:
+        Error: %{error}
+        Response: %{response}
+      instance_ready_timeout: |-
+        The instance never became "ready" in Dustcloud. The timeout currently
+        set waiting for the instance to become ready is %{timeout} seconds.
+        Please verify that the machine properly boots.
+    states:
+      short_not_created: |-
+        not created
+      long_not_created: |-
+        The Dustcloud instance is not created. Run `vagrant up` to create it.
+      short_shutoff: |-
+        shut off
+      long_shutoff: |-
+        The Dustcloud instance is stopped. Run `vagrant up` to start it.
+      short_build: |-
+        building
+      long_build: |-
+        The Dustcloud instance is building/planning. It will soon start installation.
+      short_installing: |-
+        installing
+      long_installing: |-
+        The Dustcloud instance is currently setting up.
+      short_active: |-
+        running
+      long_active: |-
+        The Dustcloud instance is running. To stop this machine, you can run
+        `vagrant halt`. To destroy the machine, you can run `vagrant destroy`.

data/vagrant-dustcloud.gemspec

@@ -0,0 +1,50 @@
+$:.unshift File.expand_path("../lib", __FILE__)
+require "vagrant-dustcloud/version"
+
+Gem::Specification.new do |s|
+    s.name = "vagrant-dustcloud"
+    s.version = VagrantPlugins::Dustcloud::VERSION
+    s.platform = Gem::Platform::RUBY
+    s.license = "MIT"
+    s.authors = "Johan Jatko"
+    s.email = "armedguy@ludd.ltu.se"
+    s.homepage = "https://www.ludd.ltu.se"
+    s.summary = "Enables Vagrant to manage LUDD Dustcloud machines."
+    s.description = "Enables Vagrant to manage LUDD Dustcloud machines."
+
+
+    s.add_development_dependency "rake"
+    # rspec 3.4 to mock File
+    s.add_development_dependency "rspec", "~> 3.4"
+    s.add_development_dependency "rspec-its"
+
+    root_path      = File.dirname(__FILE__)
+    all_files      = Dir.chdir(root_path) { Dir.glob("**/{*,.*}") }
+    all_files.reject! { |file| [".", ".."].include?(File.basename(file)) }
+    gitignore_path = File.join(root_path, ".gitignore")
+    gitignore      = File.readlines(gitignore_path)
+    gitignore.map!    { |line| line.chomp.strip }
+    gitignore.reject! { |line| line.empty? || line =~ /^(#|!)/ }
+  
+    unignored_files = all_files.reject do |file|
+      # Ignore any directories, the gemspec only cares about files
+      next true if File.directory?(file)
+  
+      # Ignore any paths that match anything in the gitignore. We do
+      # two tests here:
+      #
+      #   - First, test to see if the entire path matches the gitignore.
+      #   - Second, match if the basename does, this makes it so that things
+      #     like '.DS_Store' will match sub-directories too (same behavior
+      #     as git).
+      #
+      gitignore.any? do |ignore|
+        File.fnmatch(ignore, file, File::FNM_PATHNAME) ||
+          File.fnmatch(ignore, File.basename(file), File::FNM_PATHNAME)
+      end
+    end
+  
+    s.files         = unignored_files
+    s.executables   = unignored_files.map { |f| f[/^bin\/(.*)/, 1] }.compact
+    s.require_path  = 'lib'
+end

metadata

@@ -0,0 +1,115 @@
+--- !ruby/object:Gem::Specification
+name: vagrant-dustcloud
+version: !ruby/object:Gem::Version
+  version: 0.0.5
+platform: ruby
+authors:
+- Johan Jatko
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2020-09-06 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.4'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.4'
+- !ruby/object:Gem::Dependency
+  name: rspec-its
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Enables Vagrant to manage LUDD Dustcloud machines.
+email: armedguy@ludd.ltu.se
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- Gemfile
+- README.md
+- Rakefile
+- dummy.box
+- example_box/README.md
+- example_box/metadata.json
+- lib/vagrant-dustcloud.rb
+- lib/vagrant-dustcloud/action.rb
+- lib/vagrant-dustcloud/action/connect_dustcloud.rb
+- lib/vagrant-dustcloud/action/is_created.rb
+- lib/vagrant-dustcloud/action/is_stopped.rb
+- lib/vagrant-dustcloud/action/message_already_created.rb
+- lib/vagrant-dustcloud/action/message_not_created.rb
+- lib/vagrant-dustcloud/action/message_will_not_destroy.rb
+- lib/vagrant-dustcloud/action/read_ssh_info.rb
+- lib/vagrant-dustcloud/action/read_state.rb
+- lib/vagrant-dustcloud/action/run_instance.rb
+- lib/vagrant-dustcloud/action/start_instance.rb
+- lib/vagrant-dustcloud/action/stop_instance.rb
+- lib/vagrant-dustcloud/action/terminate_instance.rb
+- lib/vagrant-dustcloud/action/timed_provision.rb
+- lib/vagrant-dustcloud/action/wait_for_state.rb
+- lib/vagrant-dustcloud/config.rb
+- lib/vagrant-dustcloud/errors.rb
+- lib/vagrant-dustcloud/plugin.rb
+- lib/vagrant-dustcloud/provider.rb
+- lib/vagrant-dustcloud/util/timer.rb
+- lib/vagrant-dustcloud/version.rb
+- locales/en.yaml
+- vagrant-dustcloud.gemspec
+homepage: https://www.ludd.ltu.se
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.1.2
+signing_key: 
+specification_version: 4
+summary: Enables Vagrant to manage LUDD Dustcloud machines.
+test_files: []