vagrant-1cloud 0.0.1

data/lib/vagrant-1cloud/actions/check_state.rb

@@ -0,0 +1,19 @@
+module VagrantPlugins
+  module OneCloud
+    module Actions
+      class CheckState
+        def initialize(app, env)
+          @app = app
+          @machine = env[:machine]
+          @logger = Log4r::Logger.new('vagrant::1cloud::check_state')
+        end
+
+        def call(env)
+          env[:machine_state] = @machine.state.id
+          @logger.info "Machine state is '#{@machine.state.id}'"
+          @app.call(env)
+        end
+      end
+    end
+  end
+end

data/lib/vagrant-1cloud/actions/create.rb

@@ -0,0 +1,70 @@
+require 'vagrant-1cloud/helpers/client'
+
+module VagrantPlugins
+  module OneCloud
+    module Actions
+      class Create
+        include Helpers::Client
+        include Vagrant::Util::Retryable
+
+        def initialize(app, env)
+          @app = app
+          @machine = env[:machine]
+          @client = client
+          @logger = Log4r::Logger.new('vagrant::1cloud::create')
+        end
+
+        def call(env)
+          # submit new droplet request
+          result = @clientservice.post('/server', {
+            :HDD => @machine.provider_config.hdd,
+            :HDDType => @machine.provider_config.hdd_type,
+            :CPU => @machine.provider_config.cpu,
+            :RAM => @machine.provider_config.ram,
+            :DCLocation => @machine.provider_config.region,
+            :ImageID => @machine.provider_config.image,
+            :Name => @machine.config.vm.hostname || @machine.name,
+            :isHighPerformance => @machine.provider_config.hi_perf
+          })
+          
+          # assign the machine id for reference in other commands
+          @machine.id = result['id'].to_s
+
+          # wait for request to complete
+          result = @client.request("/server/#{@machine.id}/action")
+          env[:ui].info I18n.t('vagrant_1cloud.info.creating')
+          @client.wait_for_event(env, @machine.id, result.first['ID'])
+
+          # refresh droplet state with provider
+          droplet = Provider.droplet(@machine, :refresh => true)
+
+          # wait for ssh to be ready
+          retryable(:tries => 120, :sleep => 10) do
+            next if env[:interrupted]
+            raise 'not ready' if !@machine.communicate.ready?
+          end
+
+          @app.call(env)
+        end
+
+        # Both the recover and terminate are stolen almost verbatim from
+        # the Vagrant AWS provider up action
+#        def recover(env)
+#          return if env['vagrant.error'].is_a?(Vagrant::Errors::VagrantError)
+
+#          if @machine.state.id != :not_created
+#            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(Actions.destroy, destroy_env)
+#        end
+      end
+    end
+  end
+end

data/lib/vagrant-1cloud/actions/destroy.rb

@@ -0,0 +1,30 @@
+require 'vagrant-1cloud/helpers/client'
+
+module VagrantPlugins
+  module OneCloud
+    module Actions
+      class Destroy
+        include Helpers::Client
+
+        def initialize(app, env)
+          @app = app
+          @machine = env[:machine]
+          @client = client
+          @logger = Log4r::Logger.new('vagrant::1cloud::destroy')
+        end
+
+        def call(env)
+          # submit destroy droplet request
+          @client.delete("/server/#{@machine.id}")
+
+          env[:ui].info I18n.t('vagrant_1cloud.info.destroying')
+
+          # set the machine id to nil to cleanup local vagrant state
+          @machine.id = nil
+
+          @app.call(env)
+        end
+      end
+    end
+  end
+end

data/lib/vagrant-1cloud/actions/power_off.rb

@@ -0,0 +1,35 @@
+require 'vagrant-1cloud/helpers/client'
+#TODO: --force
+module VagrantPlugins
+  module OneCloud
+    module Actions
+      class PowerOff
+        include Helpers::Client
+
+        def initialize(app, env)
+          @app = app
+          @machine = env[:machine]
+          @client = client
+          @logger = Log4r::Logger.new('vagrant::1cloud::power_off')
+        end
+
+        def call(env)
+          # submit power off droplet request
+          result = @client.post("/server/#{@machine.id}/action", {
+            :Type => 'PowerOff'
+          })
+
+          # wait for request to complete
+          env[:ui].info I18n.t('vagrant_1cloud.info.powering_off')
+          @client.wait_for_event(env, @machine.id, result['ID'])
+
+          # refresh droplet state with provider
+          Provider.droplet(@machine, :refresh => true)
+
+          @app.call(env)
+        end
+      end
+    end
+  end
+end
+

data/lib/vagrant-1cloud/actions/power_on.rb

@@ -0,0 +1,36 @@
+require 'vagrant-1cloud/helpers/client'
+
+module VagrantPlugins
+  module OneCloud
+    module Actions
+      class PowerOn
+        include Helpers::Client
+
+        def initialize(app, env)
+          @app = app
+          @machine = env[:machine]
+          @client = client
+          @logger = Log4r::Logger.new('vagrant::1cloud::power_on')
+        end
+
+        def call(env)
+          # submit power on droplet request
+          result = @client.post("/server/#{@machine.id}/action", {
+            :Type => 'PowerOn'
+          })
+
+          # wait for request to complete
+          env[:ui].info I18n.t('vagrant_1cloud.info.powering_on')
+          @client.wait_for_event(env, @machine.id, result['ID'])
+
+          # refresh droplet state with provider
+          Provider.droplet(@machine, :refresh => true)
+
+          @app.call(env)
+        end
+      end
+    end
+  end
+end
+
+

data/lib/vagrant-1cloud/actions/reload.rb

@@ -0,0 +1,33 @@
+require 'vagrant-1cloud/helpers/client'
+
+module VagrantPlugins
+  module OneCloud
+    module Actions
+      class Reload
+        include Helpers::Client
+
+        def initialize(app, env)
+          @app = app
+          @machine = env[:machine]
+          @client = client
+          @logger = Log4r::Logger.new('vagrant::1cloud::reload')
+        end
+
+        def call(env)
+          # submit reboot droplet request
+          result = @client.post("/server/#{@machine.id}/action", {
+            :Type => 'PowerReboot'
+          })
+
+          # wait for request to complete
+          env[:ui].info I18n.t('vagrant_1cloud.info.reloading')
+          @client.wait_for_event(env, @machine.id, result['ID'])
+
+          @app.call(env)
+        end
+      end
+    end
+  end
+end
+
+

data/lib/vagrant-1cloud/actions/shut_down.rb

@@ -0,0 +1,35 @@
+require 'vagrant-1cloud/helpers/client'
+
+module VagrantPlugins
+  module OneCloud
+    module Actions
+      class ShutDown
+        include Helpers::Client
+
+        def initialize(app, env)
+          @app = app
+          @machine = env[:machine]
+          @client = client
+          @logger = Log4r::Logger.new('vagrant::1cloud::shut_down')
+        end
+
+        def call(env)
+          # submit shutdown droplet request
+          result = @client.post("/server/#{@machine.id}/action", {
+            :Type => 'ShutDownGuestOS'
+          })
+
+          # wait for request to complete
+          env[:ui].info I18n.t('vagrant_1cloud.info.shutting_down')
+          @client.wait_for_event(env, @machine.id, result['ID'])
+
+          # refresh droplet state with provider
+          Provider.droplet(@machine, :refresh => true)
+
+          @app.call(env)
+        end
+      end
+    end
+  end
+end
+

data/lib/vagrant-1cloud/config.rb

@@ -0,0 +1,46 @@
+module VagrantPlugins
+  module OneCloud
+    class Config < Vagrant.plugin('2', :config)
+      attr_accessor :token
+      attr_accessor :image
+      attr_accessor :region
+      attr_accessor :hdd
+      attr_accessor :hdd_type
+      attr_accessor :cpu
+      attr_accessor :ram
+      attr_accessor :hi_perf
+      attr_accessor :ca_path
+
+      def initialize
+        @token              = UNSET_VALUE
+        @image              = UNSET_VALUE
+        @region             = UNSET_VALUE
+        @hdd                = UNSET_VALUE
+        @hdd_type           = UNSET_VALUE
+        @cpu                = UNSET_VALUE
+        @ram                = UNSET_VALUE
+        @hi_perf            = UNSET_VALUE
+        @ca_path            = UNSET_VALUE
+      end
+
+      def finalize!
+        @token              = ENV['DO_TOKEN'] if @token == UNSET_VALUE
+        @image              = '7' if @image == UNSET_VALUE
+        @region             = 'SDN_SPb' if @region == UNSET_VALUE
+        @hdd                = '1' if @hdd == UNSET_VALUE
+        @hdd_type           = 'SAS' if @hdd_type == UNSET_VALUE
+        @cpu                = '1' if @cpu == UNSET_VALUE
+        @ram                = '512' if @ram == UNSET_VALUE
+        @hi_perf            = false if @hi_perf == UNSET_VALUE
+        @ca_path            = nil if @ca_path == UNSET_VALUE
+      end
+
+      def validate(machine)
+        errors = []
+        errors << I18n.t('vagrant_1cloud.config.token') if !@token
+
+        { '1cloud Provider' => errors }
+      end
+    end
+  end
+end

data/lib/vagrant-1cloud/errors.rb

@@ -0,0 +1,33 @@
+module VagrantPlugins
+  module OneCloud
+    module Errors
+      class OneCloudError < Vagrant::Errors::VagrantError
+        error_namespace("vagrant_1cloud.errors")
+      end
+
+      class APIStatusError < OneCloudError
+        error_key(:api_status)
+      end
+
+      class JSONError < OneCloudError
+        error_key(:json)
+      end
+
+      class ResultMatchError < OneCloudError
+        error_key(:result_match)
+      end
+
+      class CertificateError < OneCloudError
+        error_key(:certificate)
+      end
+
+      class LocalIPError < OneCloudError
+        error_key(:local_ip)
+      end
+
+      class RsyncError < OneCloudError
+        error_key(:rsync)
+      end
+    end
+  end
+end

data/lib/vagrant-1cloud/helpers/client.rb

@@ -0,0 +1,83 @@
+require 'vagrant-1cloud/helpers/result'
+require 'faraday'
+require 'json'
+
+module VagrantPlugins
+  module OneCloud
+    module Helpers
+      module Client
+        def client
+          @client ||= ApiClient.new(@machine)
+        end
+      end
+
+      class ApiClient
+        include Vagrant::Util::Retryable
+
+        def initialize(machine)
+          @logger = Log4r::Logger.new('vagrant::1cloud::apiclient')
+          @config = machine.provider_config
+          @client = Faraday.new({
+            :url => 'https://api.1cloud.ru/',
+            :ssl => {
+              :ca_file => @config.ca_path
+            }
+          })
+        end
+
+        def delete(path, params = {}, method = :delete)
+          @client.request :url_encoded
+          request(path, params, :delete)
+        end
+
+        def post(path, params = {}, method = :post)
+          @client.headers['Content-Type'] = 'application/json'
+          request(path, params, :post)
+        end
+
+        def request(path, params = {}, method = :get)
+          begin
+            @logger.info "Request: #{path}"
+            result = @client.send(method) do |req|
+              req.url path
+              req.headers['Authorization'] = "Bearer #{@config.token}"
+              req.body = params.to_json
+            end
+          rescue Faraday::Error::ConnectionFailed => e
+            # TODO this is suspect but because faraday wraps the exception
+            #      in something generic there doesn't appear to be another
+            #      way to distinguish different connection errors :(
+            if e.message =~ /certificate verify failed/
+              raise Errors::CertificateError
+            end
+            raise e
+          end
+
+          unless /^2\d\d$/ =~ result.status.to_s
+            raise(Errors::APIStatusError, {
+              :path => path,
+              :params => params,
+              :status => result.status,
+              :response => body.inspect
+            })
+          end
+
+          Result.new(result)
+        end
+
+        def wait_for_event(env, m_id, id)
+          retryable(:tries => 120, :sleep => 10) do
+            # stop waiting if interrupted
+            next if env[:interrupted]
+
+            # check action status
+            result = self.request("/server/#{m_id}/action/#{id}")
+
+            yield result if block_given?
+            raise 'not ready' if result['State'] != 'Completed'
+          end
+        end
+      end
+    end
+  end
+end

data/lib/vagrant-1cloud/helpers/result.rb

@@ -0,0 +1,40 @@
+module VagrantPlugins
+  module OneCloud
+    module Helpers
+      class Result
+        def initialize(body)
+          @result = body
+        end
+
+        def [](key)
+          @result[key.to_s]
+        end
+
+        def find_id(sub_obj, search)
+          find(sub_obj, search)["id"]
+        end
+
+        def find(sub_obj, search)
+          key = search.keys.first
+          value = search[key].to_s
+          key = key.to_s
+
+          result = @result[sub_obj.to_s].inject(nil) do |result, obj|
+            obj[key] == value ? obj : result
+          end
+
+          result || error(sub_obj, key, value)
+        end
+
+        def error(sub_obj, key, value)
+          raise(Errors::ResultMatchError, {
+           :key => key,
+           :value => value,
+           :collection_name => sub_obj.to_s,
+           :sub_obj => @result[sub_obj.to_s]
+          })
+        end
+      end
+    end
+  end
+end