vagrant-mos 0.8.39

data/example_box/README.md

@@ -0,0 +1,13 @@
+# Vagrant MOS Example Box
+
+Vagrant providers each require a custom provider-specific box format.
+This folder shows the example contents of a box for the `mos` provider.
+To turn this into a box:
+
+```
+$ tar cvzf mos.box ./metadata.json ./Vagrantfile
+```
+
+This box works by using Vagrant's built-in Vagrantfile merging to setup
+defaults for MOS. These defaults can easily be overwritten by higher-level
+Vagrantfiles (such as project root Vagrantfiles).

data/example_box/Vagrantfile

@@ -0,0 +1,8 @@
+# -*- mode: ruby -*-
+# vi: set ft=ruby :
+
+Vagrant.configure("2") do |config|
+  config.vm.provider :mos do |mos|
+    mos.ami = "fa1026fe-c082-4ead-8458-802bf65ca64c"
+  end
+end

data/example_box/metadata.json

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

data/lib/vagrant-mos.rb

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

@@ -0,0 +1,212 @@
+require "pathname"
+
+require "vagrant/action/builder"
+
+module VagrantPlugins
+  module MOS
+    module Action
+      # Include the built-in modules so we can use them as top-level things.
+      include Vagrant::Action::Builtin
+
+      def self.action_package
+        Vagrant::Action::Builder.new.tap do |b|
+          b.use Call, IsCreated do |env, b2|
+            if !env[:result]
+              b2.use MessageNotCreated
+              next
+            end
+
+            # Connect to MOS and then Create a package from the server instance
+            b2.use ConnectMOS
+            b2.use PackageInstance
+          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|
+            if !env[:result]
+              b2.use MessageNotCreated
+              next
+            end
+
+            b2.use ConnectMOS
+            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 ConnectMOS
+                b3.use ElbDeregisterInstance
+                b3.use TerminateInstance
+                b3.use ProvisionerCleanup if defined?(ProvisionerCleanup)
+              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
+            b2.use SyncedFolders
+          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 ConnectMOS
+          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 ConnectMOS
+          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
+          b.use WarnNetworks
+          #b.use ElbRegisterInstance
+        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 ConnectMOS
+          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 ConnectMOS
+          b.use Call, IsCreated do |env, b2|
+            if !env[:result]
+              b2.use MessageNotCreated
+              next
+            end
+
+            b2.use action_halt
+            b2.use Call, WaitForState, "ready", 120 do |env2, b3|
+              if env2[:result]
+                #b3.use action_up
+                b3.use StartInstance
+              else
+                # TODO we couldn't reach :stopped, what now?
+                b3.use StartInstance
+              end
+            end
+          end
+        end
+      end
+
+      # The autoload farm
+      action_root = Pathname.new(File.expand_path("../action", __FILE__))
+      autoload :ConnectMOS, action_root.join("connect_mos")
+      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")
+      autoload :WarnNetworks, action_root.join("warn_networks")
+      autoload :ElbRegisterInstance, action_root.join("elb_register_instance")
+      autoload :ElbDeregisterInstance, action_root.join("elb_deregister_instance")
+    end
+  end
+end

data/lib/vagrant-mos/action/connect_mos.rb

@@ -0,0 +1,51 @@
+require "fog"
+require "mos_sdk"
+require "log4r"
+
+module VagrantPlugins
+  module MOS
+    module Action
+      # This action connects to MOS, verifies credentials work, and
+      # puts the MOS connection object into the `:mos_compute` key
+      # in the environment.
+      class ConnectMOS
+        def initialize(app, env)
+          @app = app
+          @logger = Log4r::Logger.new("vagrant_mos::action::connect_mos")
+        end
+
+        def call(env)
+          # Get the region we're going to booting up in
+          region = env[:machine].provider_config.region
+
+          # Get the configs
+          region_config = env[:machine].provider_config.get_region_config(region)
+
+          # Build the fog config
+          fog_config = {
+              :provider => :mos,
+              :region => region
+          }
+          if region_config.use_iam_profile
+            fog_config[:use_iam_profile] = true
+          else
+            fog_config[:mos_access_key_id] = region_config.access_key_id
+            fog_config[:mos_secret_access_key] = region_config.secret_access_key
+            fog_config[:mos_secret_url] = region_config.secret_access_url
+            #fog_config[:mos_session_token] = region_config.session_token
+          end
+
+          fog_config[:endpoint] = region_config.endpoint if region_config.endpoint
+          fog_config[:version] = region_config.version if region_config.version
+
+          @logger.info("Connecting to MOS...")
+          #env[:mos_compute] = Fog::Compute.new(fog_config)
+          env[:mos_compute] = MosSdk::Client.new(region_config.access_key_id, region_config.secret_access_key, region_config.secret_access_url)
+          # env[:mos_elb]     = Fog::MOS::ELB.new(fog_config.except(:provider, :endpoint))
+
+          @app.call(env)
+        end
+      end
+    end
+  end
+end

data/lib/vagrant-mos/action/elb_deregister_instance.rb

@@ -0,0 +1,24 @@
+require 'vagrant-mos/util/elb'
+
+module VagrantPlugins
+  module MOS
+    module Action
+      # This registers instance in ELB
+      class ElbDeregisterInstance
+        include ElasticLoadBalancer
+
+        def initialize(app, env)
+          @app    = app
+          @logger = Log4r::Logger.new("vagrant_mos::action::elb_deregister_instance")
+        end
+
+        def call(env)
+          if elb_name = env[:machine].provider_config.elb
+            deregister_instance env, elb_name, env[:machine].id
+          end
+          @app.call(env)
+        end
+      end
+    end
+  end
+end

data/lib/vagrant-mos/action/elb_register_instance.rb

@@ -0,0 +1,24 @@
+require 'vagrant-mos/util/elb'
+
+module VagrantPlugins
+  module MOS
+    module Action
+      # This registers instance in ELB
+      class ElbRegisterInstance
+        include ElasticLoadBalancer
+
+        def initialize(app, env)
+          @app    = app
+          @logger = Log4r::Logger.new("vagrant_mos::action::elb_register_instance")
+        end
+
+        def call(env)
+          @app.call(env)
+          if elb_name = env[:machine].provider_config.elb
+            register_instance env, elb_name, env[:machine].id
+          end
+        end
+      end
+    end
+  end
+end

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

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

@@ -0,0 +1,19 @@
+module VagrantPlugins
+  module MOS
+    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)
+          puts env[:machine].state.id
+          env[:result] = env[:machine].state.id == "ready"
+          @app.call(env)
+        end
+      end
+    end
+  end
+end

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

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

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

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

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

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