vagrant_abiquo 0.0.2

data/lib/vagrant_abiquo/actions/check_state.rb

@@ -0,0 +1,24 @@
+require 'vagrant_abiquo/helpers/client'
+require 'vagrant_abiquo/helpers/abiquo'
+
+module VagrantPlugins
+  module Abiquo
+    module Actions
+      class CheckState
+        include Helpers::Client
+        
+        def initialize(app, env)
+          @app = app
+          @machine = env[:machine]
+          @logger = Log4r::Logger.new('vagrant::abiquo::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_abiquo/actions/create.rb

@@ -0,0 +1,120 @@
+require 'vagrant_abiquo/helpers/client'
+require 'vagrant_abiquo/helpers/abiquo'
+
+module VagrantPlugins
+  module Abiquo
+    module Actions
+      class Create
+        include Helpers::Client
+        include Helpers::Abiquo
+        include Vagrant::Util::Retryable
+
+        def initialize(app, env)
+          @app = app
+          @machine = env[:machine]
+          @client = client
+          @env = env
+          @logger = Log4r::Logger.new('vagrant::abiquo::create')
+        end
+
+        def call(env)
+          # Find for selected virtual datacenter
+          vdc = get_vdc(@machine.provider_config.virtualdatacenter)
+          raise Abiquo::Errors::VDCNotFound, vdc: @machine.provider_config.virtualdatacenter if vdc.nil?
+          
+          # Find for selected virtual appliance
+          vname = vapp_name(@machine)
+          vapp = get_vapp(vdc, vname)
+
+          # Find for selected vm template
+          template = get_template(vdc, @machine.provider_config.template)
+          raise Abiquo::Errors::TemplateNotFound, template: @machine.provider_config.template, vdc: vdc.name if template.nil?
+          
+          # If everything is OK we can proceed to create the VM
+          # VM Template link
+          tmpl_link = template.link(:edit).clone.to_hash
+          tmpl_link['rel'] = "virtualmachinetemplate"
+          
+          # Configured CPU and RAM
+          cpu_cores = @machine.provider_config.cpu_cores
+          ram_mb = @machine.provider_config.ram_mb
+
+          # VM entity
+          vm_definition = {}
+          vm_definition['cpu'] = cpu_cores || template.cpuRequired
+          vm_definition['ram'] = ram_mb || template.ramRequired
+          vm_definition['label'] = @machine.name
+          vm_definition['vdrpEnabled'] = true
+          vm_definition['links'] = [ tmpl_link ]
+
+          # Create VM
+          env[:ui].info I18n.t('vagrant_abiquo.info.create')
+          vm = create_vm(vm_definition, vapp)
+
+          # User Data
+          md = vm.link(:metadata).get
+          mdhash = JSON.parse(md.to_json)
+          if mdhash['metadata'].nil?
+            mdhash['metadata'] = { 'startup-script' => @machine.provider_config.user_data }
+          else
+            mdhash['metadata']['startup-script'] = @machine.provider_config.user_data
+          end
+          @client.put(vm.link(:metadata), mdhash.to_json)
+
+          # Check network
+          unless @machine.provider_config.network.nil?
+            # Network config is not nil, so we have
+            # to attach a specific net.
+            attach_net(vm, @machine.provider_config.network)
+            raise Abiquo::Errors::NetworkError if vm.nil?
+          end
+          vm = vm.link(:edit).get
+
+          # Deploying VM
+          env[:ui].info I18n.t('vagrant_abiquo.info.deploy')
+          task = deploy(vm)
+
+          if task.state == 'FINISHED_SUCCESSFULLY'
+            # Deploy successfully completed
+            env[:ui].info I18n.t('vagrant_abiquo.info.deploycompleted')
+
+            # Give time to the OS to boot.
+            retryable(:tries => 20, :sleep => 5) do
+              next if env[:interrupted]
+              raise 'not ready' if !@machine.communicate.ready?
+            end
+
+            # Find its IP
+            vm = vm.link(:edit).get
+            ip = vm.link(:nic0).title
+            env[:ui].info I18n.t('vagrant_abiquo.info.vm_ip', :ip => ip)
+            @machine.id = vm.url
+          else
+            # Deploy failed
+            env[:ui].error I18n.t('vagrant_abiquo.info.deployfailed')
+          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_abiquo/actions/create_vapp.rb

@@ -0,0 +1,38 @@
+require 'vagrant_abiquo/helpers/client'
+require 'vagrant_abiquo/helpers/abiquo'
+
+module VagrantPlugins
+  module Abiquo
+    module Actions
+      class CreatevApp
+        include Helpers::Client
+        include Helpers::Abiquo
+        
+        def initialize(app, env)
+          @app = app
+          @machine = env[:machine]
+          @logger = Log4r::Logger.new('vagrant::abiquo::create_vapp')
+        end
+
+        def call(env)
+          pconfig = env[:env].vagrantfile.config.finalize![:vm].get_provider_config(:abiquo)
+          @client ||= AbiquoAPI.new(pconfig.abiquo_connection_data)
+
+          @logger.info "Checking vApp '#{pconfig.virtualappliance}'"
+
+          @logger.info "Looking up VDC '#{pconfig.virtualdatacenter}'"
+          vdc = get_vdc(pconfig.virtualdatacenter)
+          raise Abiquo::Errors::VDCNotFound, vdc: pconfig.virtualdatacenter if vdc.nil?
+
+          vapp = get_vapp(vdc, pconfig.virtualappliance)
+          if vapp.nil?
+            @logger.info "vApp '#{pconfig.virtualappliance}' does not exist, creating."
+            create_vapp(vdc, pconfig.virtualappliance)
+          end
+
+          @app.call(env)
+        end
+      end
+    end
+  end
+end

data/lib/vagrant_abiquo/actions/destroy.rb

@@ -0,0 +1,46 @@
+require 'vagrant_abiquo/helpers/client'
+require 'vagrant_abiquo/helpers/abiquo'
+
+module VagrantPlugins
+  module Abiquo
+    module Actions
+      class Destroy
+        include Helpers::Client
+        include Helpers::Abiquo
+        include Vagrant::Util::Retryable
+
+        def initialize(app, env)
+          @app = app
+          @machine = env[:machine]
+          @client = client
+          @logger = Log4r::Logger.new('vagrant::abiquo::destroy')
+        end
+
+        def call(env)
+          env[:ui].info I18n.t('vagrant_abiquo.info.destroying', vm: @machine.name)
+          vm = get_vm(@machine.id)
+          vm.delete
+
+          # Check when task finishes. This may take a while
+          retryable(:tries => 120, :sleep => 5) do
+            begin
+              raise vm.label if vm.refresh
+            rescue AbiquoAPIClient::NotFound
+              env[:ui].info I18n.t('vagrant_abiquo.info.deleted', vm: @machine.name)
+            end
+          end
+
+          vapp = vm.link(:virtualappliance).get
+          vms = vapp.link(:virtualmachines).get.count
+          if vms == 0
+            vapp.delete
+            env[:ui].info I18n.t('vagrant_abiquo.info.deleted_vapp', vapp: vapp.name)
+          end
+
+          @machine.id = nil
+          @app.call(env)
+        end
+      end
+    end
+  end
+end

data/lib/vagrant_abiquo/actions/power_off.rb

@@ -0,0 +1,30 @@
+require 'vagrant_abiquo/helpers/client'
+require 'vagrant_abiquo/helpers/abiquo'
+
+module VagrantPlugins
+  module Abiquo
+    module Actions
+      class PowerOff
+        include Helpers::Client
+        include Helpers::Abiquo
+        include Vagrant::Util::Retryable
+        
+        def initialize(app, env)
+          @app = app
+          @machine = env[:machine]
+          @client = AbiquoAPI.new(@machine.provider_config.abiquo_connection_data)
+          @logger = Log4r::Logger.new('vagrant::abiquo::power_off')
+        end
+
+        def call(env)
+          vm = get_vm(@machine.id)
+          vm = power_off(vm)
+          raise PowerOffError, vm: vm.label, state: vm.state if vm.state != 'OFF'
+
+          @app.call(env)
+        end
+      end
+    end
+  end
+end
+

data/lib/vagrant_abiquo/actions/power_on.rb

@@ -0,0 +1,30 @@
+require 'vagrant_abiquo/helpers/client'
+require 'vagrant_abiquo/helpers/abiquo'
+
+module VagrantPlugins
+  module Abiquo
+    module Actions
+      class PowerOn
+        include Helpers::Client
+        include Helpers::Abiquo
+        include Vagrant::Util::Retryable
+        
+        def initialize(app, env)
+          @app = app
+          @machine = env[:machine]
+          @client = AbiquoAPI.new(@machine.provider_config.abiquo_connection_data)
+          @logger = Log4r::Logger.new('vagrant::abiquo::power_off')
+        end
+
+        def call(env)
+          vm = get_vm(@machine.id)
+          vm = poweron(vm)
+          raise PowerOnError, vm: vm.label, state: vm.state if vm.state != 'ON'
+
+          @app.call(env)
+        end
+      end
+    end
+  end
+end
+

data/lib/vagrant_abiquo/actions/reset.rb

@@ -0,0 +1,37 @@
+require 'vagrant_abiquo/helpers/client'
+require 'vagrant_abiquo/helpers/abiquo'
+
+module VagrantPlugins
+  module Abiquo
+    module Actions
+      class Reset
+        include Helpers::Client
+        include Helpers::Abiquo
+        include Vagrant::Util::Retryable
+
+        def initialize(app, env)
+          @app = app
+          @machine = env[:machine]
+          @client = AbiquoAPI.new(@machine.provider_config.abiquo_connection_data)
+          @logger = Log4r::Logger.new('vagrant::abiquo::reset')
+        end
+
+        def call(env)
+          env[:ui].info I18n.t('vagrant_abiquo.info.reloading')
+          vm = get_vm(@machine.id)
+          vm = reset(vm)
+
+          # Give time to the OS to boot.
+          retryable(:tries => 120, :sleep => 10) do
+            next if env[:interrupted]
+            raise 'not ready' if !@machine.communicate.ready?
+          end
+
+          @app.call(env)
+        end
+      end
+    end
+  end
+end
+
+

data/lib/vagrant_abiquo/config.rb

@@ -0,0 +1,55 @@
+module VagrantPlugins
+  module Abiquo
+    class Config < Vagrant.plugin('2', :config)
+      attr_accessor :abiquo_connection_data
+      attr_accessor :virtualdatacenter
+      attr_accessor :virtualappliance
+      attr_accessor :cpu_cores
+      attr_accessor :ram_mb
+      attr_accessor :template
+      attr_accessor :network
+      attr_accessor :user_data
+
+      def initialize
+        @abiquo_connection_data = UNSET_VALUE
+        @virtualdatacenter      = UNSET_VALUE
+        @virtualappliance       = UNSET_VALUE
+        @template               = UNSET_VALUE
+        @cpu_cores              = 0
+        @ram_mb                 = 0
+        @network                = UNSET_VALUE
+        @user_data              = UNSET_VALUE
+      end
+
+      def finalize!
+        @abiquo_connection_data[:abiquo_api_url] = ENV['ABQ_URL'] if @abiquo_connection_data[:abiquo_api_url].nil?
+        @abiquo_connection_data[:abiquo_username] = ENV['ABQ_USER'] if @abiquo_connection_data[:abiquo_username].nil?
+        @abiquo_connection_data[:abiquo_password] = ENV['ABQ_PASS'] if @abiquo_connection_data[:abiquo_password].nil?
+
+        @virtualdatacenter = ENV['ABQ_VDC'] if @virtualdatacenter == UNSET_VALUE
+        @virtualappliance = ENV['ABQ_VAPP'] if @virtualappliance == UNSET_VALUE
+        @template = ENV['ABQ_TMPL'] if @template == UNSET_VALUE
+
+        @cpu_cores = ENV['ABQ_CPU'] if @cpu_cores == 0
+        @ram_mb = ENV['ABQ_RAM'] if @ram_mb == 0
+        @ram_mb = nil if @ram_mb == 0
+
+        @network = { ENV['ABQ_NET'] => ENV['ABQ_IP'] } if @network == UNSET_VALUE
+
+        if @user_data == UNSET_VALUE
+          # We will make sure the SSH key is injected.
+          @user_data = '#!/bin/bash\necho "vagrant_abiquo :: making sure SSH key gets injected."'
+        end
+      end
+
+      def validate(machine)
+        errors = []
+        errors << I18n.t('vagrant_abiquo.config.abiquo_connection_data') if !@abiquo_connection_data
+        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,45 @@
+module VagrantPlugins
+  module Abiquo
+    module Errors
+      class AbiquoError < Vagrant::Errors::VagrantError
+        error_namespace("vagrant_abiquo.errors")
+      end
+
+      class VDCNotFound < AbiquoError
+        error_key(:vdc_not_found)
+      end
+
+      class TemplateNotFound < AbiquoError
+        error_key(:template_not_found)
+      end
+
+      class PowerOffError < AbiquoError
+        error_key(:poweroff_error)
+      end
+
+      class NetworkError < AbiquoError
+        error_key(:network_error)
+      end
+
+      class APIStatusError < AbiquoError
+        error_key(:api_status)
+      end
+
+      class APIFindError < AbiquoError
+        error_key(:apifind_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/abiquo.rb

@@ -0,0 +1,173 @@
+require 'abiquo-api'
+require 'log4r'
+include Log4r
+
+module VagrantPlugins
+  module Abiquo
+    module Helpers
+      module Abiquo
+        include Helpers::Client
+
+        @logger = Log4r::Logger.new('vagrant::abiquo::helper')
+
+        def vapp_name(machine)
+          machine.provider_config.virtualappliance.nil? ? File.basename(machine.env.cwd) : machine.provider_config.virtualappliance
+        end
+
+        def get_vm(vm_url)
+          vm_lnk = AbiquoAPI::Link.new :href => vm_url,
+                                       :type => 'application/vnd.abiquo.virtualmachine+json',
+                                       :client => client
+          vm_lnk.get
+        end
+
+        def get_vdc(vdc_name)
+          vdcs_lnk = AbiquoAPI::Link.new :href => 'cloud/virtualdatacenters',
+                                         :type => "application/vnd.abiquo.virtualdatacenters+json",
+                                         :client => client
+          vdcs_lnk.get.select {|vd| vd.name == vdc_name }.first
+        end
+
+        def get_vapp(vdc, name)
+          vdc.link(:virtualappliances).get.select {|va| va.name == name }.first
+        end
+
+        def create_vapp(vdc, name)
+          vapp_hash = { 'name' => name }
+          client.post(vdc.link(:virtualappliances), vapp_hash.to_json,
+                    accept: 'application/vnd.abiquo.virtualappliance+json',
+                    content: 'application/vnd.abiquo.virtualappliance+json')
+        end
+
+        def get_template(vdc, template)
+          vdc.link(:templates).get.select {|tmpl| tmpl.name == template }.first
+        end
+
+        def get_network(vm, net_name)
+          vdc = vm.link(:virtualdatacenter).get
+
+          networks = []
+          %w(privatenetworks network externalnetworks).each do |nettype|
+            begin
+            vdc.link(nettype.to_sym).get.each {|n| networks << n}
+            rescue Exception => e
+              @logger.debug "Exception retrieving '#{nettype}' networks."
+              @logger.debug e.message
+              @logger.debug e.backtrace
+            end
+          end
+          networks.select {|n| n.name == net_name }.first
+        end
+
+        def create_vm(vm_def, vapp)
+          client.post(vapp.link(:virtualmachines), vm_def.to_json, 
+              :content => "application/vnd.abiquo.virtualmachine+json", 
+              :accept => "application/vnd.abiquo.virtualmachine+json" )
+        end
+
+        def attach_net(vm, net_data)
+          net_data.each do |net, ip|
+            network = get_network(vm, net)
+            return nil if network.nil?
+
+            if ip
+              abqip = network.link(:ips).get.select {|i| i.ip == ip }.first
+            else
+              abqip = network.link(:ips).get.select {|i| ! i.has_link? :virtualmachine }.first
+            end
+
+            if abqip.nil?
+              if network.type == "EXTERNAL" || network.type == "PUBLIC"
+                # Can't create IP in those nets
+                return nil
+              end
+
+              # We have the net, we don't have the IP, create it
+              ip_hash = {
+                "ipv6" => network.ipv6,
+                "available" => true,
+                "quarantine" => false,
+                "numips" => 1,
+                "ip" => ip
+              }
+              abqip = client.post(network.link(:ips), ip_hash.to_json,
+                                :accept => 'application/vnd.abiquo.privateip+json',
+                                :content => 'application/vnd.abiquo.privateip+json' )
+            end
+
+            ip_lnk = abqip.link(:self).clone
+            ip_lnk.rel = 'nic0'
+            vm.links << {:nic0 => ip_lnk}
+
+            update(vm)
+          end
+        end
+
+        def deploy(vm)
+          task_lnk = client.post(vm.link(:deploy), '').link(:status).href
+          task = AbiquoAPI::Link.new(:href => task_lnk,
+                                     :type => 'application/vnd.abiquo.task+json',
+                                     :client => client).get
+
+          # Check when deploy finishes. This may take a while
+          retryable(:tries => 120, :sleep => 15) do
+            task = task.link(:self).get
+            raise vm.label if task.state == 'STARTED'
+          end
+
+          task
+        end
+
+        def apply_state(vm, state)
+          task_lnk = client.put(vm.link(:state), {"state" => state}.to_json,
+                        :accept => 'application/vnd.abiquo.acceptedrequest+json',
+                        :content => 'application/vnd.abiquo.virtualmachinestate+json').link(:status)
+          task = task_lnk.get
+
+          # Check when task finishes. This may take a while
+          retryable(:tries => 120, :sleep => 5) do
+            task = task.link(:self).get
+            raise vm.label if task.state == 'STARTED'
+          end
+          vm.link(:edit).get
+        end
+
+        def poweroff(vm)
+          apply_state('OFF')
+        end
+
+        def poweron(vm)
+          apply_state('ON')
+        end
+
+        def reset(vm)
+          task = client.post(vm.link(:reset), '',
+                        :accept => 'application/vnd.abiquo.acceptedrequest+json',
+                        :content => 'application/json').link(:status).get
+
+          # Check when task finishes. This may take a while
+          retryable(:tries => 120, :sleep => 5) do
+            task = task.link(:self).get
+            raise vm.label if task.state == 'STARTED'
+          end
+          vm.link(:edit).get
+        end
+
+        def update(vm)
+          task = client.put(vm.link(:edit), vm.to_json,
+                        :accept => 'application/vnd.abiquo.acceptedrequest+json',
+                        :content => vm.link(:edit).type)
+          if task
+            task = task.link(:status).get
+            # Check when task finishes. This may take a while
+            retryable(:tries => 120, :sleep => 5) do
+              task = task.link(:self).get
+              raise vm.label if task.state == 'STARTED'
+            end
+          end
+          vm.link(:edit).get
+        end
+      end
+    end
+  end
+end