vagrant-sakura 0.0.1

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

@@ -0,0 +1,16 @@
+module VagrantPlugins
+  module Sakura
+    module Action
+      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-sakura/action/message_already_created.rb

@@ -0,0 +1,16 @@
+module VagrantPlugins
+  module Sakura
+    module Action
+      class MessageAlreadyCreated
+        def initialize(app, env)
+          @app = app
+        end
+
+        def call(env)
+          env[:ui].info(I18n.t("vagrant_sakura.already_created"))
+          @app.call(env)
+        end
+      end
+    end
+  end
+end

data/lib/vagrant-sakura/action/message_down.rb

@@ -0,0 +1,16 @@
+module VagrantPlugins
+  module Sakura
+    module Action
+      class MessageDown
+        def initialize(app, env)
+          @app = app
+        end
+
+        def call(env)
+          env[:ui].info(I18n.t("vagrant_sakura.down"))
+          @app.call(env)
+        end
+      end
+    end
+  end
+end

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

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

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

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

data/lib/vagrant-sakura/action/power_on.rb

@@ -0,0 +1,23 @@
+require "log4r"
+
+module VagrantPlugins
+  module Sakura
+    module Action
+      class PowerOn
+        def initialize(app, env)
+          @app    = app
+          @logger = Log4r::Logger.new("vagrant_sakura::action::power_on")
+        end
+
+        def call(env)
+          api      = env[:sakura_api]
+          serverid = env[:machine].id
+
+          env[:ui].info(I18n.t("vagrant_sakura.power_on"))
+          api.put("/server/#{serverid}/power")
+          @app.call(env)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,37 @@
+require "log4r"
+
+module VagrantPlugins
+  module Sakura
+    module Action
+      class ReadSSHInfo
+        def initialize(app, env)
+          @app    = app
+          @logger = Log4r::Logger.new("vagrant_sakura::action::read_ssh_info")
+        end
+
+        def call(env)
+          api      = env[:sakura_api]
+          serverid = env[:machine].id
+
+          if serverid.nil?
+            env[:machine_ssh_info] = nil 
+          else
+            begin
+              response = api.get("/server/#{serverid}")
+              env[:machine_ssh_info] = {
+                :host => response["Server"]["Interfaces"][0]["IPAddress"],
+                :port => 22
+              }
+            rescue Driver::NotFoundError
+              @logger.info("Machine couldn't be found, assuming it has been destroyed.")
+              env[:machine].id = nil
+              env[:machine_ssh_info] = nil
+            end
+          end
+
+          @app.call(env)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,35 @@
+require 'log4r'
+require 'vagrant-sakura/driver/api'
+
+module VagrantPlugins
+  module Sakura
+    module Action
+      class ReadState
+        def initialize(app, env)
+          @app    = app
+          @logger = Log4r::Logger.new("vagrant_sakura::action::read_state")
+        end
+
+        def call(env)
+          env[:machine_state_id] = read_state(env[:sakura_api], env[:machine])
+          @app.call(env)
+        end
+
+        # returns one of [ :cleaning, :down, :not_created, :up,  ]
+        def read_state(api, machine)
+
+          return :not_created if machine.id.nil?
+
+          serverid = machine.id
+          begin
+            response = api.get("/server/#{serverid}")
+          rescue Driver::NotFoundError
+            machine.id = nil
+            return :not_created
+          end
+          return response["Server"]["Instance"]["Status"].to_sym
+        end
+      end
+    end
+  end
+end

data/lib/vagrant-sakura/action/reset.rb

@@ -0,0 +1,24 @@
+require "log4r"
+
+module VagrantPlugins
+  module Sakura
+    module Action
+      class Reset
+        def initialize(app, env)
+          @app    = app
+        end
+
+        def call(env)
+          api = env[:sakura_api]
+          serverid = env[:machine].id
+
+          # when "PUT /server/#{serverid}/reset" returns, power is up.
+          api.put("/server/#{serverid}/reset")
+          env[:ui].info I18n.t("vagrant_sakura.reset")
+
+          @app.call(env)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,143 @@
+require 'vagrant/util/retryable'
+
+require 'vagrant-sakura/driver/api'
+#require 'vagrant-sakura/util/timer'
+require 'log4r'
+
+module VagrantPlugins
+  module Sakura
+    module Action
+      class RunInstance
+        include Vagrant::Util::Retryable
+
+        def initialize(app, env)
+          @app    = app
+          @logger = Log4r::Logger.new("vagrant_sakura::action::run_instance")
+        end
+
+        def call(env)
+          server_name = env[:machine].name
+          server_name ||= env[:machine].provider_config.server_name
+          server_plan = env[:machine].provider_config.server_plan
+          disk_plan = env[:machine].provider_config.disk_plan
+          disk_source_archive = env[:machine].provider_config.disk_source_archive
+          sshkey_id = env[:machine].provider_config.sshkey_id
+
+          env[:ui].info(I18n.t("vagrant_sakura.creating_instance"))
+          env[:ui].info(" -- Server Name: #{server_name}")
+          env[:ui].info(" -- Server Plan: #{server_plan}")
+          env[:ui].info(" -- Disk Plan: #{disk_plan}")
+          env[:ui].info(" -- Disk Source Archive: #{disk_source_archive}")
+
+          api = env[:sakura_api]
+          data = {
+            "Disk" => {
+              "Name" => server_name,
+              "Zone" => { "ID" => 31001 },      # Ishikari only
+              "Plan" => { "ID" => disk_plan },
+              "Connection" => "virtio",
+              "SourceArchive" => {
+                "ID" => disk_source_archive
+              } 
+            }
+          }
+          response = api.post("/disk", data)
+          unless response["Disk"]["ID"]
+            raise 'no Disk ID returned'
+          end
+          diskid = response["Disk"]["ID"]
+          # Disk Created
+
+          while true
+            response = api.get("/disk/#{diskid}")
+            case response["Disk"]["Availability"]
+            when "available"
+              break
+            when "migrating"
+              migrated = response["Disk"]["MigratedMB"]
+              size = response["Disk"]["SizeMB"]
+              env[:ui].info("Disk #{diskid} is migrating (#{migrated}/#{size})")
+            else
+              status = presponse["Disk"]["Availability"]
+              env[:ui].info("Disk #{diskid} is #{status}")
+            end
+            sleep 3
+          end
+          # Wait for Disk is available
+
+          data = {
+            "Server" => {
+              "Name" => server_name,
+              "Zone" => { "ID" => 31001 },        # Ishikari
+              "ServerPlan" => { "ID" => server_plan },
+              "ConnectedSwitches" => [
+                { "Scope" => "shared", "BandWidthMbps" => 100 }
+              ]
+            }
+          }
+          response = api.post("/server", data)
+          unless response["Server"]["ID"]
+            raise 'no Server ID returned'
+          end
+          env[:machine].id = serverid = response["Server"]["ID"]
+          # Server Created
+
+          response = api.put("/disk/#{diskid}/to/server/#{serverid}")
+          # Disk mounted to Server
+
+          data = {
+            "UserSubnet" => {}
+          }
+          if sshkey_id
+            data["SSHKey"] = { "ID" => sshkey_id }
+          else
+            path = env[:machine].ssh_info[:private_key_path] + '.pub'
+            data["SSHKey"] = { "PublicKey" => File.read(path) }
+          end
+          response = api.put("/disk/#{diskid}/config", data)
+          # Config
+
+          response = api.put("/server/#{serverid}/power")
+          # Power On
+
+          if !env[:interrupted]
+            # Wait for SSH to be ready.
+            env[:ui].info(I18n.t("vagrant_sakura.waiting_for_ssh"))
+            while true
+              break if env[:interrupted]
+              break if env[:machine].communicate.ready?
+              sleep 2
+            end
+
+            #@logger.info("Time for SSH ready: #{env[:metrics]["instance_ssh_time"]}")
+
+            # Ready and booted!
+            env[:ui].info(I18n.t("vagrant_sakura.ready"))
+          end
+
+          # Terminate the instance if we were interrupted
+          terminate(env) if env[:interrupted]
+
+          @app.call(env)
+        end
+
+        def recover(env)
+          return if env["vagrant.error"].is_a?(Vagrant::Errors::VagrantError)
+
+          if env[:machine].provider.state.id != :not_created
+            # Undo the import
+            terminate(env)
+          end
+        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-sakura/command.rb

@@ -0,0 +1,12 @@
+module VagrantPlugins
+  module Sakura
+    class Command < Vagrant.plugin(2, :command)
+      def execute
+        with_target_vms do |vm|
+          vm.action(:plans)
+        end
+        0
+      end
+    end
+  end
+end

data/lib/vagrant-sakura/config.rb

@@ -0,0 +1,98 @@
+require "vagrant"
+
+module VagrantPlugins
+  module Sakura
+    class Config < Vagrant.plugin("2", :config)
+      # The ACCESS TOKEN to access Sakura Cloud API.
+      #
+      # @return [String]
+      attr_accessor :access_token
+
+      # The ACCESS TOKEN SECRET to access Sakura Cloud API.
+      #
+      # @return [String]
+      attr_accessor :access_token_secret
+
+      # The plan ID of the disk to be connected to the server.
+      #
+      # @return [Fixnum]
+      attr_accessor :disk_plan
+
+      # The source archive of the disk image to be copied to the instance.
+      #
+      # @return [String]
+      attr_accessor :disk_source_archive
+
+      # The name of the server.
+      # 
+      # @return [String]
+      attr_accessor :server_name
+
+      # The Plan ID of the server.
+      # 
+      # @return [Fixnum]
+      attr_accessor :server_plan
+
+      # The resource ID of the SSH public key to login the server.
+      # 
+      # @return [String]
+      attr_accessor :sshkey_id
+
+      # No Zone ID config - there is only one zone available now :)
+      #attr_accessor :zone_id
+
+      def initialize
+        @access_token        = UNSET_VALUE
+        @access_token_secret = UNSET_VALUE
+        @disk_plan           = UNSET_VALUE
+        @disk_source_archive = UNSET_VALUE
+        @server_name         = UNSET_VALUE
+        @server_plan         = UNSET_VALUE
+        @sshkey_id           = UNSET_VALUE
+      end
+
+      def finalize!
+        if @access_token == UNSET_VALUE
+          @access_token = ENV['SAKURA_ACCESS_TOKEN']
+        end
+
+        if @access_token_secret == UNSET_VALUE
+          @access_token_secret = ENV['SAKURA_ACCESS_TOKEN_SECRET']
+        end
+
+        if @disk_plan == UNSET_VALUE
+          @disk_plan = 4  # SSD
+        end
+
+        if @disk_source_archive == UNSET_VALUE
+          @disk_source_archive = 112500182464  # Ubuntu 12.04
+        end
+
+        if @server_name == UNSET_VALUE
+          @server_name = nil
+        end
+
+        if @server_plan == UNSET_VALUE
+          @server_plan = 1001  # 1Core-1GB - cheapest
+        end
+
+        if @sshkey_id == UNSET_VALUE
+          @sshkey_id = nil
+        end
+      end
+
+      def validate(machine)
+        errors = []
+
+        if config.access_token.nil?
+          errors << I18n.t("vagrant_sakura.config.access_token_required")
+        end
+        if config.access_token_secret.nil?
+          errors << I18n.t("vagrant_sakura.config.access_token_secret_required")
+        end
+
+        { "Sakura Provider" => errors }
+      end
+    end
+  end
+end