vagrant-abiquo 0.0.1

data/lib/vagrant-abiquo/actions/destroy.rb

@@ -0,0 +1,35 @@
+require 'vagrant-abiquo/helpers/client'
+
+module VagrantPlugins
+  module Abiquo
+    module Actions
+      class Destroy
+        include Helpers::Client
+
+        def initialize(app, env)
+          @app = app
+          @machine = env[:machine]
+          @client = client
+          @logger = Log4r::Logger.new('vagrant::abiquo::destroy')
+        end
+
+        def call(env)
+          # submit destroy droplet request
+#          result = @client.request("/droplets/#{@machine.id}/destroy")
+
+          env[:ui].info I18n.t('vagrant_abiquo.info.destroying')
+
+          # wait for the destroy progress to start
+#          @client.wait_for_event(env, result['event_id']) do |response|
+#            break if response['event']['percentage'] != nil
+#          end
+
+          # 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-abiquo/actions/modify_provision_path.rb

@@ -0,0 +1,38 @@
+module VagrantPlugins
+  module DigitalOcean
+    module Actions
+      class ModifyProvisionPath
+        def initialize(app, env)
+          @app = app
+          @machine = env[:machine]
+          @logger =
+            Log4r::Logger.new('vagrant::digitalocean::modify_provision_path')
+        end
+
+        def call(env)
+          # check if provisioning is enabled
+          enabled = true
+          enabled = env[:provision_enabled] if env.has_key?(:provision_enabled)
+          return @app.call(env) if !enabled
+
+          username = @machine.ssh_info()[:username]
+
+          # change ownership of the provisioning path recursively to the
+          # ssh user
+          #
+          # TODO submit patch to vagrant to set appropriate permissions
+          # based on ssh username
+          @machine.config.vm.provisioners.each do |provisioner|
+            cfg = provisioner.config
+            path = cfg.upload_path if cfg.respond_to? :upload_path
+            path = cfg.provisioning_path if cfg.respond_to? :provisioning_path
+            @machine.communicate.sudo("chown -R #{username} #{path}",
+              :error_check => false)
+          end
+
+          @app.call(env)
+        end
+      end
+    end
+  end
+end

data/lib/vagrant-abiquo/actions/power_off.rb

@@ -0,0 +1,33 @@
+require 'vagrant-abiquo/helpers/client'
+
+module VagrantPlugins
+  module Abiquo
+    module Actions
+      class PowerOff
+        include Helpers::Client
+
+        def initialize(app, env)
+          @app = app
+          @machine = env[:machine]
+          @client = client
+          @logger = Log4r::Logger.new('vagrant::abiquo::power_off')
+        end
+
+        def call(env)
+          # submit power off droplet request
+#          result = @client.request("/droplets/#{@machine.id}/power_off")
+
+          # wait for request to complete
+#          env[:ui].info I18n.t('vagrant_abiquo.info.powering_off')
+#          @client.wait_for_event(env, result['event_id'])
+
+          # refresh droplet state with provider
+#          Provider.droplet(@machine, :refresh => true)
+
+          @app.call(env)
+        end
+      end
+    end
+  end
+end
+

data/lib/vagrant-abiquo/actions/power_on.rb

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

data/lib/vagrant-abiquo/actions/reload.rb

@@ -0,0 +1,31 @@
+require 'vagrant-digitalocean/helpers/client'
+
+module VagrantPlugins
+  module DigitalOcean
+    module Actions
+      class Reload
+        include Helpers::Client
+
+        def initialize(app, env)
+          @app = app
+          @machine = env[:machine]
+          @client = client
+          @logger = Log4r::Logger.new('vagrant::digitalocean::reload')
+        end
+
+        def call(env)
+          # submit reboot droplet request
+          result = @client.request("/droplets/#{@machine.id}/reboot")
+
+          # wait for request to complete
+          env[:ui].info I18n.t('vagrant_digital_ocean.info.reloading')
+          @client.wait_for_event(env, result['event_id'])
+
+          @app.call(env)
+        end
+      end
+    end
+  end
+end
+
+

data/lib/vagrant-abiquo/config.rb

@@ -0,0 +1,49 @@
+module VagrantPlugins
+  module Abiquo
+    class Config < Vagrant.plugin('2', :config)
+      attr_accessor :abiquo_api_user
+      attr_accessor :abiquo_api_password
+      attr_accessor :abiquo_api_uri
+      attr_accessor :virtualdatacenter
+      attr_accessor :virtualappliance
+      attr_accessor :label
+      attr_accessor :exposed_nic
+      attr_accessor :template
+      attr_accessor :setup
+
+      alias_method :setup?, :setup
+
+      def initialize
+        @abiquo_api_user        = UNSET_VALUE
+        @abiquo_api_password    = UNSET_VALUE
+        @virtualdatacenter      = UNSET_VALUE
+        @virtualappliance       = UNSET_VALUE
+        @label                  = UNSET_VALUE
+        @template               = UNSET_VALUE
+        @setup                  = UNSET_VALUE
+      end
+
+      def finalize!
+        @abiquo_api_user        = ENV['ABIQUO_API_USER'] if @abiquo_api_user == UNSET_VALUE
+        @abiquo_api_password    = ENV['ABIQUO_API_PASSWORD'] if @abiquo_api_password == UNSET_VALUE
+        @abiquo_api_uri         = ENV['ABIQUO_API_URI'] if @abiquo_api_uri == UNSET_VALUE
+        @virtualdatacenter      = 'VagrantVDC' if @virtualdatacenter == UNSET_VALUE
+        @virtualappliance       = 'VagrantVAPP' if @virtualappliance == UNSET_VALUE
+        @label                  = 'VagrantVM' if @label == UNSET_VALUE
+        @template               = 'TemplateImage' if @template == UNSET_VALUE
+        @setup                  = true if @setup == UNSET_VALUE
+      end
+
+      def validate(machine)
+        errors = []
+        errors << I18n.t('vagrant_abiquo.config.abiquo_api_user') if !@abiquo_api_user
+        errors << I18n.t('vagrant_abiquo.config.abiquo_api_password') if !@abiquo_api_password
+        errors << I18n.t('vagrant_abiquo.config.abiquo_api_uri') if !@abiquo_api_uri
+        errors << I18n.t('vagrant_abiquo.config.virtualdatacenter') if !@virtualdatacenter
+        errors << I18n.t('vagrant_abiquo.config.template') if !@template
+
+        { 'Abiquo Provider' => errors }
+      end
+    end
+  end
+end

data/lib/vagrant-abiquo/errors.rb

@@ -0,0 +1,33 @@
+module VagrantPlugins
+  module Abiquo
+    module Errors
+      class AbiquoError < Vagrant::Errors::VagrantError
+        error_namespace("vagrant_abiquo.errors")
+      end
+
+      class APIStatusError < AbiquoError
+        error_key(:api_status)
+      end
+
+      class APIFindError < AbiquoError
+        error_key(:apifind_error)
+      end
+      
+      class RestClientError < AbiquoError
+        error_key(:restclient_error)
+      end
+
+      class JSONError < AbiquoError
+        error_key(:json)
+      end
+
+      class ResultMatchError < AbiquoError
+        error_key(:result_match)
+      end
+
+      class LocalIPError < AbiquoError
+        error_key(:local_ip)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,149 @@
+require 'vagrant-abiquo/helpers/result'
+require 'rest-client'
+require 'json'
+require 'log4r'
+include Log4r
+
+module VagrantPlugins
+  module Abiquo
+    module Helpers
+      module Client
+        def client
+          @client ||= ApiClient.new(@machine)
+        end
+      end
+
+      class ApiClient
+        include Vagrant::Util::Retryable
+
+        def initialize(machine)
+          @timeout = 60
+          @otimeout = 30
+          @logger = Log4r::Logger.new('vagrant::abiquo::apiclient')
+          @config = machine.provider_config
+        end
+
+        def find_id(entity,entity_collection,name)
+          JSON.parse(entity_collection)['collection'].each do |collection|
+            if collection['name'] == name               
+              return collection['id'].to_s
+            end
+          end
+          raise(Errors::APIFindError, {
+              :entity => entity,
+              :name => name
+            })
+        end
+
+        def find_template(entity,entity_collection,name)
+          JSON.parse(entity_collection)['collection'].each do |collection|
+            if collection['name'] == name
+              collection['links'].each do |template_link|
+                if template_link['rel'] == "edit"
+                  return template_link['href']
+                end
+              end
+            end
+          end
+          raise(Errors::APIFindError, {
+              :entity => entity,
+              :name => name
+            })
+        end
+
+        # TO-DO
+        # Crear metodos de FIND_VDC / FIND_VAPP / FIND_VM y eliminarlos de create y provider
+        #
+        def http_request(resource, method, headers={}, data={})
+          begin
+            req = RestClient::Resource.new( resource, :user => @config.abiquo_api_user, :password => @config.abiquo_api_password, :timeout => @timeout, :open_timeout => @otimeout )
+            case method
+              when "GET"
+                if headers.nil? then
+                  res = req.get
+                else
+                  res = req.get(headers)
+                end
+              when "POST"
+                if headers.nil? then
+                  res = req.post
+                else
+                  res = req.post(data,headers)
+                end
+            end
+          rescue => e
+            raise(Errors::RestClientError, {
+              :path => resource,
+              :headers => headers,
+              :data => data,
+              :response => e.to_s
+            })
+          end
+          if res.code == 202 or 
+             res.code == 201 or 
+             res.code == 200 then
+               return res.body
+          end
+        end
+
+#        def request(path, params = {})
+#          begin
+#            @logger.info "Request: #{path}"
+#            result = @client.get(path, params = params.merge({
+#              :client_id => @config.client_id,
+#              :api_key => @config.api_key
+#            }))
+#          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
+
+#          # remove the api key in case an error gets dumped to the console
+#          params[:api_key] = 'REMOVED'
+
+#          begin
+#            body = JSON.parse(result.body)
+#            @logger.info "Response: #{body}"
+#          rescue JSON::ParserError => e
+#            raise(Errors::JSONError, {
+#              :message => e.message,
+#              :path => path,
+#              :params => params,
+#              :response => result.body
+#            })
+#          end
+
+#          if body['status'] != 'OK'
+#            raise(Errors::APIStatusError, {
+#              :path => path,
+#              :params => params,
+#              :status => body['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 event status
+#            result = self.request("/events/#{id}")
+
+#            yield result if block_given?
+#            raise 'not ready' if result['event']['action_status'] != 'done'
+#          end
+#        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,40 @@
+module VagrantPlugins
+  module Abiquo
+    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