vagrant-niftycloud 0.1.0.dev

data/lib/vagrant-niftycloud/action/sync_folders.rb

@@ -0,0 +1,67 @@
+require "log4r"
+
+require "vagrant/util/subprocess"
+
+module VagrantPlugins
+  module NiftyCloud
+    module Action
+      # This middleware uses `rsync` to sync the folders over to the
+      # NiftyCloud instance.
+      class SyncFolders
+        def initialize(app, env)
+          @app    = app
+          @logger = Log4r::Logger.new("vagrant_niftycloud::action::sync_folders")
+        end
+
+        def call(env)
+          @app.call(env)
+
+          ssh_info = env[:machine].ssh_info
+          env[:machine].config.vm.synced_folders.each do |id, data|
+            begin
+              # Ignore disabled shared folders
+              next if data[:disabled]
+
+              hostpath  = File.expand_path(data[:hostpath], env[:root_path])
+              guestpath = data[:guestpath]
+
+              # Make sure there is a trailing slash on the host path to
+              # avoid creating an additional directory with rsync
+              hostpath = "#{hostpath}/" if hostpath !~ /\/$/
+
+              env[:ui].info(I18n.t("vagrant_niftycloud.rsync_folder",
+                                  :hostpath => hostpath,
+                                  :guestpath => guestpath))
+
+              # Create the guest path
+              env[:machine].communicate.sudo("mkdir -p '#{guestpath}'")
+              env[:machine].communicate.sudo(
+                "chown #{ssh_info[:username]} '#{guestpath}'")
+
+              # Rsync over to the guest path using the SSH info
+              command = [
+                "rsync", "--verbose", "--archive", "-z",
+                "--exclude", ".vagrant/",
+                "-e", "ssh -p #{ssh_info[:port]} -o StrictHostKeyChecking=no -i '#{ssh_info[:private_key_path]}'",
+                hostpath,
+                "#{ssh_info[:username]}@#{ssh_info[:host]}:#{guestpath}"]
+
+              r = Vagrant::Util::Subprocess.execute(*command)
+              if r.exit_code != 0
+                raise Errors::RsyncError,
+                  :guestpath => guestpath,
+                  :hostpath => hostpath,
+                  :stderr => r.stderr
+              end
+            rescue => e
+              raise Errors::RsyncError,
+                :guestpath => guestpath,
+                :hostpath => hostpath,
+                :stderr => e.message
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,61 @@
+# -*- coding: utf-8 -*-
+require "log4r"
+
+module VagrantPlugins
+  module NiftyCloud
+    module Action
+      # This terminates the running instance.
+      class TerminateInstance
+        def initialize(app, env)
+          @app    = app
+          @logger = Log4r::Logger.new("vagrant_niftycloud::action::terminate_instance")
+        end
+
+        def call(env)
+
+          # 例外の定義は以下参照
+          # http://cloud.nifty.com/api/sdk/rdoc/
+          begin
+            env[:ui].info(I18n.t("vagrant_niftycloud.terminating"))
+
+            # 起動直後等、terminate処理できないステータスの場合一旦待つ
+            server = env[:niftycloud_compute].describe_instances(:instance_id => env[:machine].id).reservationSet.item.first.instancesSet.item.first
+            while server.instanceState.name == 'pending'
+              sleep 5
+              server = env[:niftycloud_compute].describe_instances(:instance_id => env[:machine].id).reservationSet.item.first.instancesSet.item.first
+            end
+
+            attribute = env[:niftycloud_compute].describe_instance_attribute(:instance_id => env[:machine].id, :attribute => 'disableApiTermination')
+            if attribute.disableApiTermination.value == 'false'
+              # AWSのように即terminateができないため念のため一旦stopする
+              # TODO API経由でのterminate不可の場合を考慮する必要があるか
+              server = env[:niftycloud_compute].describe_instances(:instance_id => env[:machine].id).reservationSet.item.first.instancesSet.item.first
+              if server.instanceState.name != 'stopped'
+                env[:niftycloud_compute].stop_instances(:instance_id => env[:machine].id, :force => true)
+                while server.instanceState.name != 'stopped'
+                  sleep 5
+                  server = env[:niftycloud_compute].describe_instances(:instance_id => env[:machine].id).reservationSet.item.first.instancesSet.item.first
+                end
+              end
+            end
+
+            # terminate処理
+            server = env[:niftycloud_compute].describe_instances(:instance_id => env[:machine].id).reservationSet.item.first.instancesSet.item.first
+            if server.instanceState.name == 'stopped'
+              response = env[:niftycloud_compute].terminate_instances(:instance_id => env[:machine].id)
+              env[:machine].id = nil
+
+              @app.call(env)
+            end
+          rescue NIFTY::ConfigurationError => e
+            raise VagrantPlugins::NiftyCloud::Errors::NiftyCloudConfigurationError,
+              :message => e.message
+          rescue NIFTY::ArgumentError => e
+            raise VagrantPlugins::NiftyCloud::Errors::NiftyCloudArgumentError,
+              :message => e.message
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,21 @@
+require "vagrant-niftycloud/util/timer"
+
+module VagrantPlugins
+  module NiftyCloud
+    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-niftycloud/config.rb

@@ -0,0 +1,210 @@
+require "vagrant"
+
+module VagrantPlugins
+  module NiftyCloud
+    class Config < Vagrant.plugin("2", :config)
+      # The access key ID for accessing NiftyCloud.
+      #
+      # @return [String]
+      attr_accessor :access_key_id
+
+      # The ID of the AMI to use.
+      #
+      # @return [String]
+      attr_accessor :image_id
+
+      # The zone to launch the instance into. If nil, it will
+      # use the default for your account.
+      #
+      # @return [String]
+      attr_accessor :zone
+
+      # The timeout to wait for an instance to become ready.
+      #
+      # @return [Fixnum]
+      attr_accessor :instance_ready_timeout
+
+      # The type of instance to launch, such as "m1.small"
+      #
+      # @return [String]
+      attr_accessor :instance_type
+
+      # The name of the keypair to use.
+      #
+      # @return [String]
+      attr_accessor :key_name
+
+      # The secret access key for accessing NiftyCloud.
+      #
+      # @return [String]
+      attr_accessor :secret_access_key
+
+      # The firewall to set on the instance.
+      # be a list of IDs. For NiftyCloud, it can be either.
+      #
+      # @return [Array<String>]
+      attr_accessor :firewall
+
+      # The user data string
+      #
+      # @return [String]
+      attr_accessor :user_data
+
+      def initialize(zone_specific=false)
+        @access_key_id      = UNSET_VALUE
+        @image_id           = UNSET_VALUE
+        @zone  = UNSET_VALUE
+        @instance_ready_timeout = UNSET_VALUE
+        @instance_type      = UNSET_VALUE
+        @key_name           = UNSET_VALUE
+        @secret_access_key  = UNSET_VALUE
+        @firewall           = UNSET_VALUE
+        @user_data          = UNSET_VALUE
+
+        # Internal state (prefix with __ so they aren't automatically
+        # merged)
+        @__compiled_zone_configs = {}
+        @__finalized = false
+        @__zone_config = {}
+        @__zone_specific = zone_specific
+      end
+
+      # Allows zone-specific overrides of any of the settings on this
+      # configuration object. This allows the user to override things like
+      # image_id and key name for zones. Example:
+      #
+      #     niftycloud.zone_config "east-12" do |zone|
+      #       zone.image_id = 21
+      #       zone.key_name = "company-east12"
+      #     end
+      #
+      # @param [String] zone The zone name to configure.
+      # @param [Hash] attributes Direct attributes to set on the configuration
+      #   as a shortcut instead of specifying a full block.
+      # @yield [config] Yields a new Nifty Cloud configuration.
+      def zone_config(zone, attributes=nil, &block)
+        # Append the block to the list of zone configs for that zone.
+        # We'll evaluate these upon finalization.
+        @__zone_config[zone] ||= []
+
+        # Append a block that sets attributes if we got one
+        if attributes
+          attr_block = lambda do |config|
+            config.set_options(attributes)
+          end
+
+          @__zone_config[zone] << attr_block
+        end
+
+        # Append a block if we got one
+        @__zone_config[zone] << block if block_given?
+      end
+
+      #-------------------------------------------------------------------
+      # Internal methods.
+      #-------------------------------------------------------------------
+
+      def merge(other)
+        super.tap do |result|
+          # Copy over the zone specific flag. "True" is retained if either
+          # has it.
+          new_zone_specific = other.instance_variable_get(:@__zone_specific)
+          result.instance_variable_set(
+            :@__zone_specific, new_zone_specific || @__zone_specific)
+
+          # Go through all the zone configs and prepend ours onto
+          # theirs.
+          new_zone_config = other.instance_variable_get(:@__zone_config)
+          @__zone_config.each do |key, value|
+            new_zone_config[key] ||= []
+            new_zone_config[key] = value + new_zone_config[key]
+          end
+
+          # Set it
+          result.instance_variable_set(:@__zone_config, new_zone_config)
+        end
+      end
+
+      def finalize!
+        # Try to get access keys from standard NiftyCloud environment variables; they
+        # will default to nil if the environment variables are not present.
+        @access_key_id     = ENV['NIFTY_ACCESS_KEY'] if @access_key_id     == UNSET_VALUE
+        @secret_access_key = ENV['NIFTY_SECRET_KEY'] if @secret_access_key == UNSET_VALUE
+
+        # AMI must be nil, since we can't default that
+        @image_id = nil if @image_id == UNSET_VALUE
+
+        # Set the default timeout for waiting for an instance to be ready
+        @instance_ready_timeout = 300 if @instance_ready_timeout == UNSET_VALUE
+
+        # Default instance type is an mini
+        @instance_type = "mini" if @instance_type == UNSET_VALUE
+
+        # Keypair defaults to nil
+        @key_name = nil if @key_name == UNSET_VALUE
+
+        @zone = nil if @zone == UNSET_VALUE
+
+        # The firewall are empty by default.
+        @firewall = [] if @firewall == UNSET_VALUE
+
+        # User Data is nil by default
+        @user_data = nil if @user_data == UNSET_VALUE
+
+        if !@__zone_specific
+          @__zone_config.each do |zone, blocks|
+            config = self.class.new(true).merge(self)
+
+            # Execute the configuration for each block
+            blocks.each { |b| b.call(config) }
+
+            # The zone name of the configuration always equals the
+            # zone config name:
+            config.zone = zone
+
+            # Finalize the configuration
+            config.finalize!
+
+            # Store it for retrieval
+            @__compiled_zone_configs[zone] = config
+          end
+        end
+
+        # Mark that we finalized
+        @__finalized = true
+      end
+
+      def validate(machine)
+        errors = _detected_errors
+
+        errors << I18n.t("vagrant_niftycloud.config.zone_required") if @zone.nil?
+
+        if @zone
+          # Get the configuration for the zone we're using and validate only
+          # that zone.
+          config = get_zone_config(@zone)
+
+          errors << I18n.t("vagrant_niftycloud.config.access_key_id_required") if \
+            config.access_key_id.nil?
+          errors << I18n.t("vagrant_niftycloud.config.secret_access_key_required") if \
+            config.secret_access_key.nil?
+
+          errors << I18n.t("vagrant_niftycloud.config.image_id_required") if config.image_id.nil?
+        end
+
+        { "NiftyCloud Provider" => errors }
+      end
+
+      # This gets the configuration for a specific zone. It shouldn't
+      # be called by the general public and is only used internally.
+      def get_zone_config(name)
+        if !@__finalized
+          raise "Configuration must be finalized before calling this method."
+        end
+
+        # Return the compiled zone config
+        @__compiled_zone_configs[name] || self
+      end
+    end
+  end
+end

data/lib/vagrant-niftycloud/errors.rb

@@ -0,0 +1,35 @@
+require "vagrant"
+
+module VagrantPlugins
+  module NiftyCloud
+    module Errors
+      class VagrantNiftyCloudError < Vagrant::Errors::VagrantError
+        error_namespace("vagrant_niftycloud.errors")
+      end
+
+      class NiftyCloudConfigurationError < VagrantNiftyCloudError
+        error_key(:niftycloud_configuration_error)
+      end
+
+      class NiftyCloudArgumentError < VagrantNiftyCloudError
+        error_key(:niftycloud_argument_error)
+      end
+      
+      class NiftyCloudResponseError < VagrantNiftyCloudError
+        error_key(:niftycloud_response_error)
+      end
+
+      class NiftyCloudResponseFormatError < VagrantNiftyCloudError
+        error_key(:niftycloud_response_format_error)
+      end
+
+      class InstanceReadyTimeout < VagrantNiftyCloudError
+        error_key(:instance_ready_timeout)
+      end
+
+      class RsyncError < VagrantNiftyCloudError
+        error_key(:rsync_error)
+      end
+    end
+  end
+end

data/lib/vagrant-niftycloud/plugin.rb

@@ -0,0 +1,73 @@
+begin
+  require "vagrant"
+rescue LoadError
+  raise "The Vagrant NiftyCloud 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 NiftyCloud plugin is only compatible with Vagrant 1.2+"
+end
+
+module VagrantPlugins
+  module NiftyCloud
+    class Plugin < Vagrant.plugin("2")
+      name "NiftyCloud"
+      description <<-DESC
+      This plugin installs a provider that allows Vagrant to manage
+      machines in NiftyCloud.
+      DESC
+
+      config(:niftycloud, :provider) do
+        require_relative "config"
+        Config
+      end
+
+      provider(:niftycloud, parallel: true) do
+        # Setup logging and i18n
+        setup_logging
+        setup_i18n
+
+        # Return the provider
+        require_relative "provider"
+        Provider
+      end
+
+      # This initializes the internationalization strings.
+      def self.setup_i18n
+        I18n.load_path << File.expand_path("locales/en.yml", NiftyCloud.source_root)
+        I18n.reload!
+      end
+
+      # This sets up our log level to be whatever VAGRANT_LOG is.
+      def self.setup_logging
+        require "log4r"
+
+        level = nil
+        begin
+          level = Log4r.const_get(ENV["VAGRANT_LOG"].upcase)
+        rescue NameError
+          # This means that the logging constant wasn't found,
+          # which is fine. We just keep `level` as `nil`. But
+          # we tell the user.
+          level = nil
+        end
+
+        # Some constants, such as "true" resolve to booleans, so the
+        # above error checking doesn't catch it. This will check to make
+        # sure that the log level is an integer, as Log4r requires.
+        level = nil if !level.is_a?(Integer)
+
+        # Set the logging level on all "vagrant" namespaced
+        # logs as long as we have a valid level.
+        if level
+          logger = Log4r::Logger.new("vagrant_niftycloud")
+          logger.outputters = Log4r::Outputter.stderr
+          logger.level = level
+          logger = nil
+        end
+      end
+    end
+  end
+end