vagrant-simplecloud 0.0.1

data/lib/vagrant-simplecloud/commands/list.rb

@@ -0,0 +1,89 @@
+require 'optparse'
+require 'vagrant-simplecloud/helpers/client'
+
+module VagrantPlugins
+  module SimpleCloud
+    module Commands
+      class List < Vagrant.plugin('2', :command)
+        def self.synopsis
+          "list available images and regions from Simple Cloud"
+        end
+
+        def execute
+          @token = nil
+
+          @opts = OptionParser.new do |o|
+            o.banner = 'Usage: vagrant simplecloud-list [options] <images|regions|sizes> <token>'
+
+            o.on("-r", "--[no-]regions", "show the regions when listing images") do |r|
+              @regions = r
+            end
+          end
+
+          argv = parse_options(@opts)
+          @token = argv[1]
+
+          if @token.nil?
+            usage
+            return 1
+          end
+
+          case argv[0]
+          when "images"
+            result = query('/v2/images')
+            images = Array(result["images"])
+            if @regions
+              images_table = images.map do |image|
+                '%-50s %-20s %-20s %-50s' % ["#{image['distribution']} #{image['name']}", image['slug'], image['id'], image['regions'].join(', ')]
+              end
+              @env.ui.info I18n.t('vagrant_simple_cloud.info.images_with_regions', images: images_table.sort.join("\r\n"))
+            else
+              images_table = images.map do |image|
+                '%-50s %-30s %-30s' % ["#{image['distribution']} #{image['name']}", image['slug'], image['id']]
+              end
+              @env.ui.info I18n.t('vagrant_simple_cloud.info.images', images: images_table.sort.join("\r\n"))
+            end
+          when "regions"
+            result = query('/v2/regions')
+            regions = Array(result["regions"])
+            regions_table = regions.map { |region| '%-30s %-12s' % [region['name'], region['slug']] }
+            @env.ui.info I18n.t('vagrant_simple_cloud.info.regions', regions: regions_table.sort.join("\r\n"))
+          when "sizes"
+            result = query('/v2/sizes')
+            sizes = Array(result["sizes"])
+            sizes_table = sizes.map { |size| '%-15s %-15s %-12s' % ["#{size['memory']}MB", size['vcpus'], size['slug']] }
+            @env.ui.info I18n.t('vagrant_simple_cloud.info.sizes', sizes: sizes_table.sort_by{|s| s['memory']}.join("\r\n"))
+          else
+            usage
+            return 1
+          end
+
+          0
+        rescue Faraday::Error::ConnectionFailed, RuntimeError => e
+          @env.ui.error I18n.t('vagrant_simple_cloud.info.list_error', message: e.message)
+          1
+        end
+
+        def query(path)
+          connection = Faraday.new({
+            :url => "https://api.simplecloud.ru/"
+          })
+
+          result = connection.get(path, per_page: 100) do |req|
+            req.headers['Authorization'] = "Bearer #{@token}"
+          end
+
+          case result.status
+          when 200 then JSON.parse(result.body)
+          when 401 then raise("unauthorized access — is the token correct?")
+          else raise("call returned with status #{result.status}")
+          end
+        end
+
+        def usage
+          @env.ui.info(@opts)
+        end
+      end
+    end
+  end
+end

data/lib/vagrant-simplecloud/commands/rebuild.rb

@@ -0,0 +1,29 @@
+require 'optparse'
+
+module VagrantPlugins
+  module SimpleCloud
+    module Commands
+      class Rebuild < Vagrant.plugin('2', :command)
+
+        # Show description when `vagrant list-commands` is triggered
+        def self.synopsis
+          "plugin: vagrant-simplecloud: destroys and ups the vm with the same ip address"
+        end
+
+        def execute
+          opts = OptionParser.new do |o|
+            o.banner = 'Usage: vagrant rebuild [vm-name]'
+          end
+
+          argv = parse_options(opts)
+
+          with_target_vms(argv) do |machine|
+            machine.action(:rebuild)
+          end
+
+          0
+        end
+      end
+    end
+  end
+end

data/lib/vagrant-simplecloud/config.rb

@@ -0,0 +1,64 @@
+module VagrantPlugins
+  module SimpleCloud
+    class Config < Vagrant.plugin('2', :config)
+      attr_accessor :token
+      attr_accessor :image
+      attr_accessor :region
+      attr_accessor :size
+      attr_accessor :private_networking
+      attr_accessor :ipv6
+      attr_accessor :backups_enabled
+      attr_accessor :ca_path
+      attr_accessor :ssh_key_name
+      attr_accessor :setup
+      attr_accessor :user_data
+
+      alias_method :setup?, :setup
+
+      def initialize
+        @token              = UNSET_VALUE
+        @image              = UNSET_VALUE
+        @region             = UNSET_VALUE
+        @size               = UNSET_VALUE
+        @private_networking = UNSET_VALUE
+        @ipv6               = UNSET_VALUE
+        @backups_enable     = UNSET_VALUE
+        @ca_path            = UNSET_VALUE
+        @ssh_key_name       = UNSET_VALUE
+        @setup              = UNSET_VALUE
+        @user_data          = UNSET_VALUE
+      end
+
+      def finalize!
+        @token              = ENV['DO_TOKEN'] if @token == UNSET_VALUE
+        @image              = 'ubuntu-14-04-x64' if @image == UNSET_VALUE
+        @region             = 'nyc2' if @region == UNSET_VALUE
+        @size               = '512mb' if @size == UNSET_VALUE
+        @private_networking = false if @private_networking == UNSET_VALUE
+        @ipv6               = false if @ipv6 == UNSET_VALUE
+        @backups_enabled    = false if @backups_enabled == UNSET_VALUE
+        @ca_path            = nil if @ca_path == UNSET_VALUE
+        @ssh_key_name       = 'Vagrant' if @ssh_key_name == UNSET_VALUE
+        @setup              = true if @setup == UNSET_VALUE
+        @user_data          = nil if @user_data == UNSET_VALUE
+      end
+
+      def validate(machine)
+        errors = []
+        errors << I18n.t('vagrant_simple_cloud.config.token') if !@token
+
+        key = machine.config.ssh.private_key_path
+        key = key[0] if key.is_a?(Array)
+        if !key
+          errors << I18n.t('vagrant_simple_cloud.config.private_key')
+        elsif !File.file?(File.expand_path("#{key}.pub", machine.env.root_path))
+          errors << I18n.t('vagrant_simple_cloud.config.public_key', {
+            :key => "#{key}.pub"
+          })
+        end
+
+        { 'Simple Cloud Provider' => errors }
+      end
+    end
+  end
+end

data/lib/vagrant-simplecloud/errors.rb

@@ -0,0 +1,37 @@
+module VagrantPlugins
+  module SimpleCloud
+    module Errors
+      class SimpleCloudError < Vagrant::Errors::VagrantError
+        error_namespace("vagrant_simple_cloud.errors")
+      end
+
+      class APIStatusError < SimpleCloudError
+        error_key(:api_status)
+      end
+
+      class JSONError < SimpleCloudError
+        error_key(:json)
+      end
+
+      class ResultMatchError < SimpleCloudError
+        error_key(:result_match)
+      end
+
+      class CertificateError < SimpleCloudError
+        error_key(:certificate)
+      end
+
+      class LocalIPError < SimpleCloudError
+        error_key(:local_ip)
+      end
+
+      class PublicKeyError < SimpleCloudError
+        error_key(:public_key)
+      end
+
+      class RsyncError < SimpleCloudError
+        error_key(:rsync)
+      end
+    end
+  end
+end

data/lib/vagrant-simplecloud/helpers/client.rb

@@ -0,0 +1,151 @@
+require 'vagrant-simplecloud/helpers/result'
+require 'faraday'
+require 'json'
+require 'droplet_kit'
+require 'uri'
+require 'net/http'
+require 'net/https'
+
+module VagrantPlugins
+  module SimpleCloud
+    module Helpers
+      module Client
+        def client
+          @client ||= ApiClient.new(@machine)
+        end
+        def simple_client
+          @simple_client ||= SimpleClient.new(access_token: @machine.provider_config.token)
+        end
+      end
+      class SimpleClient < DropletKit::Client
+          include Vagrant::Util::Retryable
+
+          def post(path, params = {})
+                uri = URI.parse("#{connection_options[:url]}#{path}")
+                https = Net::HTTP.new(uri.host,uri.port)
+                https.use_ssl = true
+                req = Net::HTTP::Post.new(uri.path)
+                req['Content-Type'] = connection_options[:headers][:content_type]
+                req['Authorization'] = connection_options[:headers][:authorization]
+                req.set_form_data(params)
+                res = https.request(req)
+                unless /^2\d\d$/ =~ result.code.to_s
+                  raise "Server response error #{result.code} #{path} #{params} #{result.message} #{result.body}"
+                end
+                JSON.parse(res.body)
+          end
+
+          def wait_for_event(env, id)
+            retryable(:tries => 120, :sleep => 10) do
+              # stop waiting if interrupted
+              next if env[:interrupted]
+              # check action status
+              result = self.actions.find(id: id)
+              yield result if block_given?
+              raise 'not ready' if result.status != 'completed'
+            end
+          end
+
+          private
+          def connection_options
+              {
+                  url: "https://api.simplecloud.ru",
+                  headers: {
+                      content_type: 'application/json',
+                      authorization: "Bearer #{access_token}"
+                      }
+              }
+          end
+      end
+      class ApiClient
+        include Vagrant::Util::Retryable
+
+        def initialize(machine)
+          @logger = Log4r::Logger.new('vagrant::simplecloud::apiclient')
+          @config = machine.provider_config
+          @client = Faraday.new({
+            :url => 'https://api.simplecloud.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} #{params}"
+            result = @client.send(method) do |req|
+              req.url path, params
+              req.headers['Authorization'] = "Bearer #{@config.token}"
+            end
+          rescue Faraday::Error::ConnectionFailed => e
+            # TODO this is suspect but because farady 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 method == :delete
+            begin
+              body = JSON.parse(result.body)
+              @logger.info "Response: #{body}"
+              next_page = body["links"]["pages"]["next"] rescue nil
+              unless next_page.nil?
+                uri = URI.parse(next_page)
+                new_path = path.split("?")[0]
+                next_result = self.request("#{new_path}?#{uri.query}")
+                req_target = new_path.split("/")[-1]
+                body["#{req_target}"].concat(next_result["#{req_target}"])
+              end
+            rescue JSON::ParserError => e
+              raise(Errors::JSONError, {
+                :message => e.message,
+                :path => path,
+                :params => params,
+                :response => result.body
+              })
+            end
+          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(body)
+        end
+
+        def wait_for_event(env, id)
+          retryable(:tries => 120, :sleep => 10) do
+            # stop waiting if interrupted
+            next if env[:interrupted]
+
+            # check action status
+            result = self.request("/v2/actions/#{id}")
+
+            yield result if block_given?
+            raise 'not ready' if result['action']['status'] != 'completed'
+          end
+        end
+      end
+    end
+  end
+end

data/lib/vagrant-simplecloud/helpers/result.rb

@@ -0,0 +1,40 @@
+module VagrantPlugins
+  module SimpleCloud
+    module Helpers
+      class Result
+        def initialize(body)
+          @result = body
+        end
+
+        def [](key)
+          @result[key.to_s]
+        end
+
+        def find_id(sub_obj, search) #:ssh_keys, {:name => 'ijin (vagrant)'}
+          find(sub_obj, search)["id"]
+        end
+
+        def find(sub_obj, search)
+          key = search.keys.first #:slug
+          value = search[key].to_s #sfo1
+          key = key.to_s #slug
+
+          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

data/lib/vagrant-simplecloud/plugin.rb

@@ -0,0 +1,31 @@
+module VagrantPlugins
+  module SimpleCloud
+    class Plugin < Vagrant.plugin('2')
+      name 'SimpleCloud'
+      description <<-DESC
+        This plugin installs a provider that allows Vagrant to manage
+        machines using SimpleCloud's API.
+      DESC
+
+      config(:simple_cloud, :provider) do
+        require_relative 'config'
+        Config
+      end
+
+      provider(:simple_cloud) do
+        require_relative 'provider'
+        Provider
+      end
+
+      command(:rebuild) do
+        require_relative 'commands/rebuild'
+        Commands::Rebuild
+      end
+
+      command("simplecloud-list", primary: false) do
+        require_relative 'commands/list'
+        Commands::List
+      end
+    end
+  end
+end