vagrant-iijgp 0.0.1

data/lib/vagrant-iijgp/action/stop_virtual_machine.rb

@@ -0,0 +1,31 @@
+module VagrantPlugins
+  module ProviderIijGp
+    module Action
+      class StopVirtualMachine
+        def initialize(app, env)
+          @app = app
+          @logger = Log4r::Logger.new("vagrant_iijgp::action::stop_virtual_machine")
+        end
+
+        def call(env)
+          @env = env
+
+          force = env[:force_halt] if env.has_key?(:force_halt)
+          env[:ui].info I18n.t("vagrant.actions.vm.halt.#{force ? "force" : "graceful"}")
+
+          config = env[:machine].provider_config
+          gp = config.gp_service_code
+          gc = env[:machine].id
+
+          vm = env[:iijapi].gp(gp).gc(gc)
+          vm.stop(force)
+
+          env[:ui].info I18n.t("vagrant_iijgp.wait_for_stop")
+          vm.wait_for_stop { env[:ui].info "-- current_status: #{vm.status}" }
+
+          @app.call(env)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,96 @@
+require "vagrant/util/scoped_hash_override"
+require "vagrant/util/subprocess"
+
+module VagrantPlugins
+  module ProviderIijGp
+    module Action
+      class SyncFolders
+        include Vagrant::Util::ScopedHashOverride
+
+        def initialize(app, env)
+          @app = app
+          @logger = Log4r::Logger.new("vagrant_iijgp::action::sync_folders")
+        end
+
+        def call(env)
+          @env = env
+
+          prepare_folders
+
+          @app.call(env)
+
+          install_rsync_guest
+          rsync
+        end
+
+        def install_rsync_guest
+          @env[:ui].info I18n.t("vagrant_iijgp.install_rsync")
+          @env[:machine].communicate.execute("yum install -y rsync")
+        end
+
+        def rsync
+          ssh_info = @env[:machine].ssh_info
+
+          synced_folders.each do |id, data|
+            hostpath  = File.expand_path(data[:hostpath], @env[:root_path])
+            guestpath = data[:guestpath]
+
+            # append tailing slash for rsync
+            hostpath = hostpath + '/' if hostpath !~ /\/$/
+            guestpath = guestpath + '/' if guestpath !~ /\/$/
+
+            @env[:machine].communicate.execute(%Q[mkdir -p "#{guestpath}" && chown "#{ssh_info[:username]}" "#{guestpath}"])
+
+            ssh_command = %Q[ssh -p #{ssh_info[:port]} -o StrictHostKeyChecking=no -o UserKnownHostsFile=/dev/null -o IdentitiesOnly=yes -i "#{ssh_info[:private_key_path]}"]
+            command = %w[rsync -avz --exclude .vagrant/ -e] +
+              [ssh_command, hostpath, "#{ssh_info[:username]}@#{ssh_info[:host]}:#{guestpath}"]
+
+            @logger.info ("-- rsync command: #{command.inspect}")
+            @env[:ui].info I18n.t("vagrant_iijgp.rsync_folder", :hostpath => hostpath, :guestpath => guestpath)
+            ret = Vagrant::Util::Subprocess.execute(*command)
+            if ret.exit_code != 0
+              raise Errors::RsyncError, :guestpath => guestpath, :hostpath => hostpath, :stderr => ret.stderr
+            end
+          end
+        end
+
+        # Returns an actual list of IIJGP shared folders
+        def synced_folders
+          {}.tap do |result|
+            @env[:machine].config.vm.synced_folders.each do |id, data|
+              data = scoped_hash_override(data, :iijgp)
+
+              # Ignore NFS shared folders
+              next if data[:nfs]
+
+              # Ignore disabled shared folders
+              next if data[:disabled]
+
+              result[id] = data.dup
+            end
+          end
+        end
+
+        # Prepares the synced folders by verifying they exist and creating them
+        # if they don't.
+        def prepare_folders
+          synced_folders.each do |id, options|
+            hostpath = Pathname.new(options[:hostpath]).expand_path(@env[:root_path])
+
+            if !hostpath.directory? && options[:create]
+              # Host path doesn't exist, so let's create it.
+              @logger.debug("Host path doesn't exist, creating: #{hostpath}")
+
+              begin
+                hostpath.mkpath
+              rescue Errno::EACCES
+                raise Vagrant::Errors::SharedFolderCreateFailed,
+                  :path => hostpath.to_s
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/vagrant-iijgp/action/vagrant_tweaks.rb

@@ -0,0 +1,22 @@
+module VagrantPlugins
+  module ProviderIijGp
+    module Action
+      class VagrantTweaks
+        def initialize(app, env)
+          @app = app
+          @logger = Log4r::Logger.new("vagrant_iijgp::action::vagrant_tweaks")
+        end
+
+        def call(env)
+          case env[:machine].provider_config.vagrant_tweaks
+          when :allow_root_notty_sudo
+            env[:machine].communicate.execute(%q[grep "^Defaults:root !requiretty$" /etc/sudoers ||] +
+                                              %q[(chmod 600 /etc/sudoers && sed -i.bak 's/^Defaults\s*requiretty/Defaults requiretty\nDefaults:root !requiretty/g' /etc/sudoers; chmod 400 /etc/sudoers)])
+          end
+
+          @app.call(env)
+        end
+      end
+    end
+  end
+end

data/lib/vagrant-iijgp/action.rb

@@ -0,0 +1,182 @@
+require "vagrant/action/builder"
+
+module VagrantPlugins
+  module ProviderIijGp
+    module Action
+      include Vagrant::Action::Builtin
+
+      def self.action_boot
+        Vagrant::Action::Builder.new.tap do |b|
+          b.use Provision
+          b.use SyncFolders
+          b.use SetLabel
+          b.use Boot
+          b.use WaitForCommunicator, [:starting, :running]
+        end
+      end
+
+      def self.action_destroy
+        Vagrant::Action::Builder.new.tap do |b|
+          b.use Call, IsCreated do |env1, b1|
+            if !env1[:result]
+              b1.use MessageNotCreated
+              next
+            end
+
+            b1.use Call, DestroyConfirm do |env2, b2|
+              if env2[:result]
+                b2.use EnvSet, :force_halt => true
+                b2.use action_halt
+                b2.use Destroy
+                b2.use ProvisionerCleanup
+              else
+                b2.use MessageWillNotDestroy
+              end
+            end
+          end
+        end
+      end
+
+      def self.action_halt
+        Vagrant::Action::Builder.new.tap do |b|
+          b.use ConfigValidate
+          b.use PrepareIIJAPI
+          b.use Call, IsCreated do |env1, b1|
+            if env1[:result]
+              b1.use Call, IsStopped do |env2, b2|
+                if !env2[:result]
+                  b2.use StopVirtualMachine
+                end
+              end
+            else
+              b1.use MessageNotCreated
+            end
+          end
+        end
+      end
+
+      def self.action_provision
+        Vagrant::Action::Builder.new.tap do |b|
+          b.use ConfigValidate
+          b.use PrepareIIJAPI
+          b.use Call, ReadState do |env1, b1|
+            case env1[:machine_state]
+            when :running
+              b1.use Provision
+              b1.use SyncFolders
+              b1.use VagrantTweaks
+            when :not_created, :initialized
+              b1.use MessageNotCreated
+            else
+              b1.use MessageInvalidStatus
+            end
+          end
+        end
+      end
+
+      def self.action_reload
+        Vagrant::Action::Builder.new.tap do |b|
+          b.use ConfigValidate
+          b.use PrepareIIJAPI
+          b.use Call, IsCreated do |env1, b1|
+            if !env1[:result]
+              b1.use MessageNotCreated
+              next
+            end
+
+            b1.use action_halt
+            b1.use action_up
+          end
+        end
+      end
+
+      def self.action_read_ssh_info
+        Vagrant::Action::Builder.new.tap do |b|
+          b.use ConfigValidate
+          b.use PrepareIIJAPI
+          b.use ReadSSHInfo
+        end
+      end
+
+      def self.action_read_state
+        Vagrant::Action::Builder.new.tap do |b|
+          b.use ConfigValidate
+          b.use PrepareIIJAPI
+          b.use ReadState
+        end
+      end
+
+      def self.action_ssh
+        Vagrant::Action::Builder.new.tap do |b|
+          b.use ConfigValidate
+          b.use PrepareIIJAPI
+          b.use CheckRunning
+          b.use SSHExec
+        end
+      end
+
+      def self.action_ssh_run
+        Vagrant::Action::Builder.new.tap do |b|
+          b.use ConfigValidate
+          b.use PrepareIIJAPI
+          b.use CheckRunning
+          b.use SSHRun
+        end
+      end
+
+      def self.action_start
+        Vagrant::Action::Builder.new.tap do |b|
+          b.use Call, IsStopped do |env1, b1|
+            if env1[:result]
+              b1.use action_boot
+            else
+              b1.use MessageAlreadyRunning
+              next
+            end
+          end
+        end
+      end
+
+      def self.action_up
+        Vagrant::Action::Builder.new.tap do |b|
+          b.use ConfigValidate
+          b.use PrepareIIJAPI
+          b.use Call, ReadState do |env1, b1|
+            case env1[:machine_state]
+            when :not_created, :initialized
+              b1.use CreateVM
+              b1.use action_start
+              b1.use VagrantTweaks
+            when :stopped
+              b1.use action_start
+            when :running
+              b1.use MessageAlreadyRunning
+            else
+              b1.use MessageInvalidStatus
+            end
+          end
+        end
+      end
+
+      action_root = Pathname.new(File.expand_path("../action", __FILE__))
+      autoload :Boot, action_root.join("boot")
+      autoload :CheckRunning, action_root.join("check_running")
+      autoload :CreateVM, action_root.join("create_vm")
+      autoload :Destroy, action_root.join("destroy")
+      autoload :IsCreated, action_root.join("is_created")
+      autoload :IsStopped, action_root.join("is_stopped")
+      autoload :MessageAlreadyRunning, action_root.join("message_already_running")
+      autoload :MessageInvalidStatus, action_root.join("message_invalid_status")
+      autoload :MessageNotCreated, action_root.join("message_not_created")
+      autoload :MessageWillNotDestroy, action_root.join("message_will_not_destroy")
+      autoload :PrepareIIJAPI, action_root.join("prepare_iijapi")
+      autoload :ReadSSHInfo, action_root.join("read_ssh_info")
+      autoload :ReadState, action_root.join("read_state")
+      autoload :SetLabel, action_root.join("set_label")
+      autoload :StopVirtualMachine, action_root.join("stop_virtual_machine")
+      autoload :SyncFolders, action_root.join("sync_folders")
+      autoload :VagrantTweaks, action_root.join("vagrant_tweaks")
+
+    end
+  end
+end

data/lib/vagrant-iijgp/config.rb

@@ -0,0 +1,78 @@
+module VagrantPlugins
+  module ProviderIijGp
+    class Config < Vagrant.plugin("2", :config)
+      attr_accessor :endpoint
+
+      attr_accessor :access_key
+      attr_accessor :secret_key
+
+      attr_accessor :gp_service_code
+      attr_accessor :gc_service_code
+
+      attr_accessor :virtual_machine_type
+      attr_accessor :os
+
+      attr_accessor :ssh_public_key
+
+      attr_accessor :label
+
+      attr_accessor :vagrant_tweaks
+
+      attr_accessor :api_max_retry_count
+      attr_accessor :api_retry_wait
+
+      def initialize
+        @endpoint = UNSET_VALUE
+        @access_key = UNSET_VALUE
+        @secret_key = UNSET_VALUE
+        @gp_service_code = UNSET_VALUE
+        @gc_service_code = UNSET_VALUE
+        @virtual_machine_type = UNSET_VALUE
+        @os = UNSET_VALUE
+        @ssh_public_key = UNSET_VALUE
+        @label = UNSET_VALUE
+        @vagrant_tweaks = UNSET_VALUE
+        @api_max_retry_count = UNSET_VALUE
+        @api_retry_wait = UNSET_VALUE
+      end
+
+      def finalize!
+        @endpoint = nil if @endpoint == UNSET_VALUE
+        @access_key = ENV['IIJAPI_ACCESS_KEY'] if @access_key == UNSET_VALUE
+        @secret_key = ENV['IIJAPI_SECRET_KEY'] if @secret_key == UNSET_VALUE
+
+        @gc_service_code = nil if @gc_service_code == UNSET_VALUE
+
+        @virtual_machine_type = 'V10' if @virtual_machine_type == UNSET_VALUE
+        @os = 'CentOS6_64_U' if @os == UNSET_VALUE
+        @ssh_public_key = nil if @ssh_public_key == UNSET_VALUE
+        @label = nil if @label == UNSET_VALUE
+        @vagrant_tweaks = :allow_root_notty_sudo if @vagrant_tweaks == UNSET_VALUE
+        @api_max_retry_count = 10 if @api_max_retry_count == UNSET_VALUE
+        @api_retry_wait = 60 if @api_retry_wait == UNSET_VALUE
+      end
+
+      def validate(machine)
+        errors = _detected_errors
+
+        unless @access_key
+          errors << I18n.t("vagrant_iijgp.config.access_key_is_required")
+        end
+
+        unless @secret_key
+          errors << I18n.t("vagrant_iijgp.config.secret_key_is_required")
+        end
+
+        unless @ssh_public_key
+          errors << I18n.t("vagrant_iijgp.config.ssh_public_key_is_required")
+        end
+
+        if @gp_service_code.nil? or @gp_service_code == UNSET_VALUE
+          errors << I18n.t("vagrant_iijgp.config.gp_service_code_is_required")
+        end
+
+        { "IIJ GP Provider" => errors }
+      end
+    end
+  end
+end

data/lib/vagrant-iijgp/errors.rb

@@ -0,0 +1,19 @@
+require "vagrant"
+
+module VagrantPlugins
+  module ProviderIijGp
+    module Errors
+      class VagrantIijGpError < Vagrant::Errors::VagrantError
+        error_namespace("vagrant_iijgp.errors")
+      end
+
+      class RsyncError < VagrantIijGpError
+        error_key(:rsync_error)
+      end
+
+      class MismatchServiceCode < VagrantIijGpError
+        error_key(:mismatch_service_code)
+      end
+    end
+  end
+end

data/lib/vagrant-iijgp/plugin.rb

@@ -0,0 +1,53 @@
+require "vagrant"
+require "log4r"
+
+module VagrantPlugins
+  module ProviderIijGp
+    class Plugin < Vagrant.plugin("2")
+      name "IIJ GP provider"
+      description <<-EOF
+      The IIJ GP provider allows Vagrant to manage and control
+      virtual machine in IIJ GIO hosting package service.
+      EOF
+
+      config(:iijgp, :provider) do
+        require_relative "config"
+        Config
+      end
+
+      provider(:iijgp, :parallel => true) do
+        setup_logging
+        setup_i18n
+
+        require_relative "provider"
+        Provider
+      end
+
+      def self.setup_logging
+        require "log4r"
+
+        level = nil
+        begin
+          level = Log4r.const_get(ENV["VAGRANT_LOG"].upcase)
+        rescue NameError
+        end
+
+        level = nil unless level.is_a?(Integer)
+
+        # Set the logging level on all "vagrant_iijgp" namespaced
+        # logs as long as we have a valid level.
+        if level
+          logger = Log4r::Logger.new("vagrant_iijgp")
+          logger.outputters = Log4r::Outputter.stderr
+          logger.level = level
+          logger = nil
+        end
+      end
+
+      def self.setup_i18n
+        I18n.load_path << File.expand_path("locales/en.yml", ProviderIijGp.source_root)
+        I18n.reload!
+      end
+    end
+  end
+end

data/lib/vagrant-iijgp/provider.rb

@@ -0,0 +1,45 @@
+module VagrantPlugins
+  module ProviderIijGp
+    class Provider < Vagrant.plugin('2', :provider)
+      def initialize(machine)
+        @logger = Log4r::Logger.new("")
+        @machine = machine
+      end
+      attr_reader :machine
+
+      # @param [Symbol] name Name of the action.
+      # @return [Object] A callable action sequence object.
+      #   +nil+ means that we don't support the given action.
+      def action(name)
+        method = "action_#{name}"
+        if Action.respond_to? method
+          Action.send(method)
+        else
+          # the specified action is not supported
+          nil
+        end
+      end
+
+      # @return [Hash] SSH information. For the structure of this hash
+      #   read the accompanying documentation for this method.
+      def ssh_info
+        env = @machine.action('read_ssh_info')
+        env[:machine_ssh_info]
+      end
+
+      # @return [MachineState]
+      def state
+        env = @machine.action('read_state')
+
+        state = env[:machine_state]
+
+        # Translate into short/long descriptions
+        short = I18n.t("vagrant_iijgp.state.#{state}.short")
+        long = I18n.t("vagrant_iijgp.state.#{state}.long")
+
+        # Return the MachineState object
+        Vagrant::MachineState.new(state, short, long)
+      end
+    end
+  end
+end

data/lib/vagrant-iijgp/version.rb

@@ -0,0 +1,5 @@
+module VagrantPlugins
+  module ProviderIijGp
+    VERSION = "0.0.1"
+  end
+end

data/lib/vagrant-iijgp.rb

@@ -0,0 +1,18 @@
+require "pathname"
+
+require "vagrant-iijgp/plugin"
+
+module VagrantPlugins
+  module ProviderIijGp
+    lib_path = Pathname.new(File.expand_path("../vagrant-iijgp", __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/locales/en.yml

@@ -0,0 +1,70 @@
+en:
+  vagrant_iijgp:
+    wait_for_configured: |-
+      Waiting for the import of the root SSH key to complete.
+    wait_for_start: |-
+      Waiting for start...
+    wait_for_stop: |-
+      Waiting for stop...
+    vm_already_running: |-
+      Virtual Machine already running.
+    vm_not_created: |-
+      Virtual Machine is not created.
+    invalid_status: |-
+      The action is not allowed in the current status (%{state}).
+    import_root_ssh_public_key: |-
+      Importing your SSH public key into the Virtual Machine.
+    install_rsync: |-
+      Installing rsync on the Virtual Machine.
+    rsync_folder: |-
+      Rsyncing folder: %{hostpath} => %{guestpath}
+
+    config:
+      access_key_is_required: |-
+        access_key is required
+      secret_key_is_required: |-
+        secret_key is required
+      gp_service_code_is_required: |-
+        gp_service_code is required
+      ssh_public_key_is_required: |-
+        ssh_public_key is required
+
+    state:
+      running:
+        short: |-
+          Running
+        long: |-
+          The virtual machine is running.
+
+      stopped:
+        short: |-
+          Stopped
+        long: |-
+          The virtual machine is stopped.
+
+      starting:
+        short: |-
+          Starting
+        long: |-
+          The virtual machine is starting.
+
+      stopping:
+        short: |-
+          Stopping
+        long: |-
+          The virtual machine is stopping.
+
+      initialized:
+        short: |-
+          Initialized
+        long: |-
+          The virtual machine is initialized.
+
+    errors:
+      rsync_error: |-
+        An error occured while attempting to rsync.
+      mismatch_service_code: |-
+        There is no match between the service code which is stored in vagrant (%{machine_id})
+        and the service code which is specified in the configuration file (%{provider_config}).
+        If you changed the service code in the setting file after `vagrant up`,
+        you should wipe out the setting in `.vagrant/machines/<name>/id`.

data/sample/Vagrantfile

@@ -0,0 +1,38 @@
+# -*- mode: ruby; coding: utf-8 -*-
+# vi: set ft=ruby :
+
+Vagrant.configure("2") do |config|
+  config.vm.box = "dummy"
+
+  config.vm.provider :iijgp do |iijgp, override|
+    iijgp.access_key = "YOUR ACCESS KEY"
+    iijgp.secret_key = "YOUR SECRET KEY"
+    iijgp.gp_service_code = "gpXXXXXXXX"
+    iijgp.ssh_public_key = File.read("#{ENV['HOME']}/.ssh/id_rsa.pub")
+
+    override.ssh.username = "root"
+    override.ssh.private_key_path = "#{ENV['HOME']}/.ssh/id_rsa"
+  end
+
+  config.vm.define "vm1" do |c|
+    c.vm.provider :iijgp do |iijgp|
+      iijgp.gc_service_code = "gcXXXXXXXX"
+      iijgp.label = "vagrant-iijgp test vm1"
+    end
+  end
+
+  config.vm.define "vm2" do |c|
+    c.vm.provider :iijgp do |iijgp|
+      iijgp.gc_service_code = "gcYYYYYYYY"
+      iijgp.label = "vagrant-iijgp test vm2"
+    end
+  end
+
+  config.vm.define "another_gp_vm3" do |c|
+    c.vm.provider :iijgp do |iijgp, override|
+      iijgp.gp_service_code = "gpZZZZZZZZ"
+      iijgp.gc_service_code = "gcZZZZZZZZ"
+      iijgp.label = "vagrant-iijgp test vm3"
+    end
+  end
+end

data/vagrant-iijgp.gemspec

@@ -0,0 +1,28 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'vagrant-iijgp/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "vagrant-iijgp"
+  spec.version       = VagrantPlugins::ProviderIijGp::VERSION
+  spec.authors       = ["Takahiro HIMURA"]
+  spec.email         = ["taka@himura.jp"]
+  spec.description   = %q{Vagrant plugin for IIJ GIO Hosting Package service}
+  spec.summary       = %q{Vagrant plugin for IIJ GIO Hosting Package service}
+  spec.homepage      = "https://github.com/iij/vagrant-iijgp/"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files`.split($/)
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_runtime_dependency "iij-sakagura"
+
+  spec.add_development_dependency "bundler", "~> 1.3"
+  spec.add_development_dependency "rake"
+  spec.add_development_dependency "rspec-core"
+  spec.add_development_dependency "rspec-expectations"
+  spec.add_development_dependency "mocha"
+end