vagrant-aliyun 0.0.2

data/lib/vagrant-aliyun/action/start_instance.rb

@@ -0,0 +1,90 @@
+require "log4r"
+require 'json'
+require "aliyun"
+
+module VagrantPlugins
+  module AliyunECS
+    module Action
+      # This runs the configured instance.
+      class StartInstance
+
+        def initialize(app, env)
+          @app    = app
+          @logger = Log4r::Logger.new("vagrant_aliyun::action::start_instance")
+        end
+
+        def call(env)
+          start_instance(env[:machine], env)
+
+          @app.call(env)
+        end
+
+        def start_instance(machine, env)
+          return nil if machine.id.nil?
+
+          config = machine.provider_config
+          options = {
+            :access_key_id => config.access_key_id,
+            :access_key_secret => config.access_key_secret
+          }
+          Aliyun.config options
+          ecs = Aliyun::ECS.new
+
+          env[:ui].info(I18n.t("vagrant_aliyun.starting"))
+          ecs.start_instance :instance_id=>machine.id
+
+          # Wait for the instance to be ready first
+          env[:ui].info(I18n.t("vagrant_aliyun.waiting_for_ready"))
+          begin
+            instance = ecs.describe_instance_attribute :instance_id=>machine.id
+            Timeout.timeout(config.instance_ready_timeout) do
+              until instance["Status"] == "Running"
+                sleep 2
+                instance = ecs.describe_instance_attribute :instance_id=>machine.id
+              end
+            end
+          rescue Timeout::Error
+            env[:result] = false # couldn't reach state in time
+            # Delete the instance
+            terminate(env)
+
+            # Notify the user
+            raise Errors::InstanceReadyTimeout,
+              timeout: config.instance_ready_timeout
+          end
+
+          if !env[:interrupted]
+            # Wait for SSH to be ready.
+            env[:ui].info(I18n.t("vagrant_aliyun.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 ECS 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(I18n.t("vagrant_aliyun.waiting_for_ssh, retrying"))
+                else
+                  raise e
+                end
+              end
+              sleep 2
+            end
+
+            # Ready and booted!
+            env[:ui].info(I18n.t("vagrant_aliyun.ready"))
+          end
+
+          # Terminate the instance if we were interrupted
+          terminate(env) if env[:interrupted]
+        end
+
+      end
+    end
+  end
+end

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

@@ -0,0 +1,52 @@
+require "log4r"
+
+module VagrantPlugins
+  module AliyunECS
+    module Action
+      # This stops the running instance.
+      class StopInstance
+        def initialize(app, env)
+          @app    = app
+          @logger = Log4r::Logger.new("vagrant_aliyun::action::stop_instance")
+        end
+
+        def call(env)
+          stop_instance(env[:machine], env)
+
+          @app.call(env)
+        end
+
+        def stop_instance(machine, env)
+          return nil if machine.id.nil?
+
+          config = machine.provider_config
+          options = {
+            :access_key_id => config.access_key_id,
+            :access_key_secret => config.access_key_secret
+          }
+          Aliyun.config options
+          ecs = Aliyun::ECS.new
+
+          if machine.state.id == :stopped
+            env[:ui].info(I18n.t("vagrant_aliyun.already_status", :status => machine.state.id))
+          else
+            env[:ui].info(I18n.t("vagrant_aliyun.stopping"))
+            ecs.stop_instance :instance_id=>machine.id
+            begin
+              instance = ecs.describe_instance_attribute :instance_id=>machine.id
+              Timeout.timeout(config.instance_ready_timeout) do
+                until instance["Status"] == "Stopped"
+                  sleep 2
+                  instance = ecs.describe_instance_attribute :instance_id=>machine.id
+                end
+              end
+            rescue Timeout::Error
+              env[:result] = false # couldn't reach state in time
+            end
+          end
+
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,51 @@
+require "log4r"
+
+module VagrantPlugins
+  module AliyunECS
+    module Action
+      # This stops the running instance.
+      class TerminateInstance
+        def initialize(app, env)
+          @app    = app
+          @logger = Log4r::Logger.new("vagrant_aliyun::action::terminate_instance")
+        end
+
+        def call(env)
+          terminate_instance(env[:machine], env)
+
+          @app.call(env)
+        end
+
+        def terminate_instance(machine, env)
+          return nil if machine.id.nil?
+
+          config = machine.provider_config
+          options = {
+            :access_key_id => config.access_key_id,
+            :access_key_secret => config.access_key_secret
+          }
+          Aliyun.config options
+          ecs = Aliyun::ECS.new
+
+          env[:ui].info(I18n.t("vagrant_aliyun.terminating"))
+          ecs.stop_instance :instance_id=>machine.id
+
+          begin
+            instance = ecs.describe_instance_attribute :instance_id=>machine.id
+            Timeout.timeout(config.instance_ready_timeout) do
+              until instance["Status"] == "Stopped"
+                sleep 2
+                instance = ecs.describe_instance_attribute :instance_id=>machine.id
+              end
+            end
+          rescue Timeout::Error
+            env[:result] = false # couldn't reach state in time
+          end
+
+          ecs.delete_instance :instance_id=>machine.id
+          machine.id = nil
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,41 @@
+require "log4r"
+require "timeout"
+
+module VagrantPlugins
+  module AliyunECS
+    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_aliyun::action::wait_for_state")
+          @state   = state
+          @timeout = timeout
+        end
+
+        def call(env)
+          env[:result] = true
+          if env[:machine].state.id == @state
+            @logger.info(I18n.t("vagrant_aliyun.already_status", :status => @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-aliyun/action/warn_networks.rb

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

data/lib/vagrant-aliyun/action.rb

@@ -0,0 +1,182 @@
+require "pathname"
+require "aliyun"
+require "vagrant/action/builder"
+
+module VagrantPlugins
+  module AliyunECS
+    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 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 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
+          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 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 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
+        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 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 Call, IsCreated do |env, b2|
+            if !env[:result]
+              b2.use MessageNotCreated
+              next
+            end
+
+            b2.use action_halt
+            b2.use Call, WaitForState, :stopped, 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 :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 :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 :WaitForState, action_root.join("wait_for_state")
+      autoload :WarnNetworks, action_root.join("warn_networks")
+
+    end
+  end
+end

data/lib/vagrant-aliyun/config.rb

@@ -0,0 +1,55 @@
+require "vagrant"
+
+module VagrantPlugins
+  module AliyunECS
+    class Config < Vagrant.plugin("2", :config)
+      
+      attr_accessor :access_key_id
+      attr_accessor :access_key_secret
+      attr_accessor :region_id
+      attr_accessor :image_id
+      attr_accessor :instance_type
+      attr_accessor :internet_max_bandwidth_out
+      attr_accessor :security_group_id
+      attr_accessor :password
+      attr_accessor :instance_ready_timeout
+
+      def initialize()
+        @access_key_id = UNSET_VALUE
+        @access_key_secret = UNSET_VALUE
+        @region_id = UNSET_VALUE
+        @image_id = UNSET_VALUE
+        @instance_type = UNSET_VALUE
+        @internet_max_bandwidth_out = UNSET_VALUE
+        @security_group_id = UNSET_VALUE
+        @password = UNSET_VALUE
+        @instance_ready_timeout    = UNSET_VALUE
+      end
+
+      def finalize!
+        @access_key_id = nil if @access_key_id == UNSET_VALUE
+        @access_key_secret = nil if @access_key_secret == UNSET_VALUE
+        @region_id = nil if @region_id == UNSET_VALUE
+        @image_id = nil if @image_id == UNSET_VALUE
+        @instance_type = nil if @instance_type == UNSET_VALUE
+        @internet_max_bandwidth_out = nil if @internet_max_bandwidth_out == UNSET_VALUE
+        @security_group_id = nil if @security_group_id == UNSET_VALUE
+        @password = nil if @password == UNSET_VALUE
+        @instance_ready_timeout = 120 if @instance_ready_timeout == UNSET_VALUE
+      end
+
+      def validate(machine)
+        errors = _detected_errors
+        errors << I18n.t("vagrant_aliyun.config.access_key_id_required") if @access_key_id.nil?
+        errors << I18n.t("vagrant_aliyun.config.access_key_secret_required") if @access_key_secret.nil?
+        errors << I18n.t("vagrant_aliyun.config.region_id_required") if @region_id.nil?
+        errors << I18n.t("vagrant_aliyun.config.image_id_required") if @image_id.nil?
+        errors << I18n.t("vagrant_aliyun.config.instance_type_required") if @instance_type.nil?
+        errors << I18n.t("vagrant_aliyun.config.internet_max_bandwidth_out_required") if @internet_max_bandwidth_out.nil?
+        errors << I18n.t("vagrant_aliyun.config.security_group_id_required") if @security_group_id.nil?
+        errors << I18n.t("vagrant_aliyun.config.password_required") if @password.nil?
+        { "Aliyun Provider" => errors }
+      end
+    end
+  end
+end