vagrant-1cloud 1.1.1 → 1.1.2

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

@@ -1,58 +0,0 @@
-module VagrantPlugins
-  module OneCloud
-    module Actions
-      class SetupUser
-        def initialize(app, env)
-          @app = app
-          @machine = env[:machine]
-          @logger = Log4r::Logger.new('vagrant::onecloud::setup_user')
-        end
-
-        def call(env)
-          # check if a username has been specified
-          return @app.call(env) unless @machine.config.ssh.username
-
-          # override ssh username to root temporarily
-          user = @machine.config.ssh.username
-          @machine.config.ssh.username = 'root'
-
-          env[:ui].info I18n.t('vagrant_1cloud.info.creating_user', {
-            :user => user
-          })
-
-          # create user account
-          @machine.communicate.execute(<<-BASH)
-            groupadd "#{user}"
-            useradd -m -d "/home/#{user}" -g "#{user}" -r "#{user}" -s "/bin/bash"
-            chown #{user}:#{user} -R "/home/#{user}"
-          BASH
-
-          # grant user sudo access with no password requirement
-          @machine.communicate.execute(<<-BASH)
-            echo "#{user} ALL=(ALL:ALL) NOPASSWD: ALL" >> /etc/sudoers
-          BASH
-
-          # create the .ssh directory in the users home
-          @machine.communicate.execute("su #{user} -c 'mkdir -p ~/.ssh'")
-
-          # add the specified key to the authorized keys file
-          path = @machine.config.ssh.private_key_path
-          path = path[0] if path.is_a?(Array)
-          path = File.expand_path(path, @machine.env.root_path)
-          pub_key = OneCloud.public_key(path)
-          @machine.communicate.execute(<<-BASH)
-            touch /home/#{user}/.ssh/authorized_keys
-            echo \"#{pub_key}\" >> /home/#{user}/.ssh/authorized_keys
-            chown #{user}:#{user} -R /home/#{user}/.ssh
-            chmod 600 /home/#{user}/.ssh/authorized_keys
-          BASH
-
-          # reset username
-          @machine.config.ssh.username = user
-
-          @app.call(env)
-        end
-      end
-    end
-  end
-end

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

@@ -1,35 +0,0 @@
-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::onecloud::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['body']['ID'])
-
-          # refresh droplet state with provider
-          Provider.droplet(@machine, :refresh => true)
-
-          @app.call(env)
-        end
-      end
-    end
-  end
-end
-

data/lib/vagrant-1cloud/commands/add_network.rb

@@ -1,59 +0,0 @@
-require 'optparse'
-
-module VagrantPlugins
-  module OneCloud
-    module Commands
-      class AddNetwork < Vagrant.plugin('2', :command)
-
-        # Show description when `vagrant list-commands` is triggered
-        def self.synopsis
-          "plugin: vagrant-1cloud: adds VPS to specific private network"
-        end
-
-        def execute
-          options = {}
-
-          optparse = OptionParser.new do |opts|
-            opts.banner = 'Usage: vagrant add-network [vm-name] [options]'
-
-            opts.on('-n', '--net NETNAME', 'Network name') do |net|
-              options[:Net] = net
-            end
-
-            options[:IP] = nil
-            opts.on('-i', '--ip [IP]', 'Private IP address') do |ip|
-              options[:IP] = ip
-            end
-
-            opts.on('-h', '--help', 'Display this screen') do
-              puts opts
-              exit
-            end
-          end
-
-          begin
-            optparse.parse!
-            mandatory = [:Net]
-            missing = mandatory.select{ |param| options[param].nil? }
-            unless missing.empty?
-              raise OptionParser::MissingArgument.new(missing.join(', '))
-            end
-          rescue OptionParser::InvalidOption, OptionParser::MissingArgument
-            puts $!.to_s
-            puts optparse
-            exit
-          end
-
-          argv = parse_options(optparse)
-
-          with_target_vms(argv) do |machine|
-            machine.provider_config.private_net = {options[:Net] => options[:IP]}
-            machine.action(:addnet)
-          end
-
-          0
-        end
-      end
-    end
-  end
-end

data/lib/vagrant-1cloud/commands/create_network.rb

@@ -1,135 +0,0 @@
-require 'optparse'
-require 'vagrant-1cloud/helpers/result'
-require 'faraday'
-require 'json'
-
-module VagrantPlugins
-  module OneCloud
-    module Commands
-      class CreateNetwork < Vagrant.plugin('2', :command)
-        include Helpers
-        include Vagrant::Util::Retryable
-
-        # Show description when `vagrant list-commands` is triggered
-        def self.synopsis
-          "plugin: vagrant-1cloud: creates new private network"
-        end
-
-        def execute
-          options = {}
-
-          optparse = OptionParser.new do |opts|
-            opts.banner = 'Usage: vagrant create-network [options]'
-
-            opts.on('-n', '--name NAME', 'Network name') do |name|
-              options[:Name] = name
-            end
-
-            options[:IsDHCP] = false
-            opts.on('-d', '--[no-]dhcp', "Use dhcp or not (default #{options[:IsDHCP]})") do |dhcp|
-              options[:IsDHCP] = dhcp
-            end
-
-            opts.on('-l', '--location LOCATION', 'Network location') do |location|
-              options[:DCLocation] = location
-            end
-
-            opts.on('-t', '--token TOKEN', '1cloud type token') do |token|
-              options[:token] = token
-            end
-
-            opts.on('-h', '--help', 'Display this screen') do
-              puts opts
-              exit
-            end
-          end
-
-          begin
-            optparse.parse!
-            mandatory = [:Name, :DCLocation, :token]
-            missing = mandatory.select{ |param| options[param].nil? }
-            unless missing.empty?
-              raise OptionParser::MissingArgument.new(missing.join(', '))
-            end
-          rescue OptionParser::InvalidOption, OptionParser::MissingArgument
-            puts $!.to_s
-            puts optparse
-            exit
-          end
-
-          result = request(options[:token], '/network')
-          private_network = result['body'].find { |network| network['Name'] == options[:Name] }
-
-          if private_network
-            @env.ui.info I18n.t('vagrant_1cloud.info.network_exists', network: options[:Name])
-          else
-            @env.ui.info I18n.t('vagrant_1cloud.info.network_missing', network: options[:Name])
-
-            result = request(options[:token], '/network', options.except(:token), :post)
-
-            # Waiting for private network to create
-            @env.ui.info I18n.t('vagrant_1cloud.info.creating_private_network')
-            wait_for_network(options[:token], result['body']['ID'])
-          end
-
-          0
-        end
-
-        def request(token, path, params = {}, method = :get)
-          connection = Faraday.new({
-            :url => 'https://api.1cloud.ru/'
-          })
-
-          begin
-            @env.ui.info I18n.t('vagrant_1cloud.info.request', path: path)
-            @env.ui.info I18n.t('vagrant_1cloud.info.params', params: params)
-            result = connection.send(method) do |req|
-              req.url path
-              req.headers['Authorization'] = "Bearer #{token}"
-              req.body = params
-            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
-
-          begin
-            body = JSON.parse(%Q[{"body":#{result.body}}])
-            @env.ui.info I18n.t('vagrant_1cloud.info.response', body: body)
-          rescue JSON::ParserError => e
-            raise(Errors::JSONError, {
-                :message => e.message,
-                :path => path,
-                :params => params,
-                :response => result.body
-            })
-          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_network(token, net_id)
-          retryable(:tries => 400, :sleep => 10) do
-            # check network status
-            result = request(token, "/network/#{net_id}")
-            raise 'Network is not active' if result['body']['State'] != 'Active'
-          end
-        end
-      end
-    end
-  end
-end

data/lib/vagrant-1cloud/commands/rebuild.rb

@@ -1,29 +0,0 @@
-require 'optparse'
-
-module VagrantPlugins
-  module OneCloud
-    module Commands
-      class Rebuild < Vagrant.plugin('2', :command)
-
-        # Show description when `vagrant list-commands` is triggered
-        def self.synopsis
-          "plugin: vagrant-1cloud: 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-1cloud/config.rb

@@ -1,62 +0,0 @@
-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
-      attr_accessor :private_net
-      attr_accessor :ssh_key_name
-
-      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
-        @private_net        = UNSET_VALUE
-        @ssh_key_name       = UNSET_VALUE
-      end
-
-      def finalize!
-        @token              = ENV['DO_TOKEN'] if @token == UNSET_VALUE
-        @image              = '7' if @image == UNSET_VALUE
-        @region             = 'SdnSpb' if @region == UNSET_VALUE
-        @hdd                = '10' 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
-        @private_net        = nil if @private_net == UNSET_VALUE
-        @ssh_key_name       = 'Vagrant' if @ssh_key_name == UNSET_VALUE
-      end
-
-      def validate(machine)
-        errors = []
-        errors << I18n.t('vagrant_1cloud.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_1cloud.config.private_key')
-        elsif !File.file?(File.expand_path("#{key}.pub", machine.env.root_path))
-          errors << I18n.t('vagrant_1cloud.config.public_key', {
-            :key => "#{key}.pub"
-          })
-        end
-
-        { '1cloud Provider' => errors }
-      end
-    end
-  end
-end

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

@@ -1,33 +0,0 @@
-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 PublicKeyError < OneCloudError
-        error_key(:public_key)
-      end
-
-      class RsyncError < OneCloudError
-        error_key(:rsync)
-      end
-    end
-  end
-end

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

@@ -1,181 +0,0 @@
-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::onecloud::apiclient')
-          @config = machine.provider_config
-          @machine = machine
-          @client = Faraday.new({
-            :url => 'https://api.1cloud.ru/',
-            :ssl => {
-              :ca_file => @config.ca_path
-            }
-          })
-        end
-
-        def delete(path, params = {})
-          @client.request :url_encoded
-          request(path, params, :delete)
-        end
-
-        def post(path, params = {})
-          @client.headers['Content-Type'] = 'application/json'
-          request(path, params, :post)
-        end
-
-        def request(path, params = {}, method = :get)
-          begin
-            @logger.info "Request: #{path}"
-            @logger.info "Parameters: #{params}"
-            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 method == :delete
-            begin
-              body = JSON.parse(%Q[{"body":#{result.body}}])
-              @logger.info "Response: #{body}"
-            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, m_id, id)
-          retryable(:tries => 400, :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 'Action is not completed' if result['body']['State'] != 'Completed'
-          end
-        end
-
-        def wait_for_destroy(env, id)
-          retryable(:tries => 400, :sleep => 10) do
-            # stop waiting if interrupted
-            next if env[:interrupted]
-
-            # check action status
-            begin
-              result = @client.send(:get) do |req|
-                req.url "/server/#{id}"
-                req.headers['Authorization'] = "Bearer #{@config.token}"
-              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
-            begin
-              body = JSON.parse(%Q[{"body":#{result.body}}])
-              @logger.info "Response: #{body}"
-            rescue JSON::ParserError => e
-              raise(Errors::JSONError, {
-                  :message => e.message,
-                  :path => path,
-                  :params => params,
-                  :response => result.body
-              })
-            end
-            result = Result.new(body)
-            yield result if block_given?
-            raise 'Destroy is not completed' if result['body']['Message'] != 'Server not found'
-          end
-        end
-
-        def wait_for_network(env, net_id)
-          retryable(:tries => 400, :sleep => 10) do
-            # stop waiting if interrupted
-            next if env[:interrupted]
-
-            # check network status
-            result = self.request("/network/#{net_id}")
-
-            yield result if block_given?
-            raise 'Network is not active' if result['body']['State'] != 'Active'
-          end
-        end
-
-        def wait_for_ssh(env, reboot_num, check_num)
-          i = 0
-          while i <= reboot_num do
-            j = 0
-            while !@machine.communicate.ready? && j < check_num do
-              env[:ui].info I18n.t('vagrant_1cloud.info.ssh_off')
-              sleep 10
-              j += 1
-            end
-
-            if j < check_num
-              env[:ui].info I18n.t('vagrant_1cloud.info.ssh_on')
-              break
-            else
-              if i < reboot_num
-                # 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['body']['ID'])
-
-                i += 1
-              else
-                raise 'No ssh connection'
-              end
-            end
-          end
-        end
-      end
-    end
-  end
-end