fog-opennebula 0.0.1

data/lib/fog/opennebula/requests/compute/vm_destroy.rb

@@ -0,0 +1,39 @@
+module Fog
+
+  module Compute
+
+    class OpenNebula
+
+      class Real
+
+        def vm_destroy(id)
+          vmpool = ::OpenNebula::VirtualMachinePool.new(client)
+          vmpool.info(-2, id, id, -1)
+
+          vmpool.each do |vm|
+            # true => delete and recreate vm
+            vm.delete(false)
+          end
+        end
+
+      end
+
+      class Mock
+
+        def vm_destroy(id)
+          response = Excon::Response.new
+          response.status = 200
+
+          data['vms'].each do |vm|
+            data['vms'].delete(vm) if vm['id'] == id
+          end
+          true
+        end
+
+      end
+
+    end
+
+  end
+
+end

data/lib/fog/opennebula/requests/compute/vm_disk_snapshot.rb

@@ -0,0 +1,33 @@
+module Fog
+
+  module Compute
+
+    class OpenNebula
+
+      class Real
+
+        def vm_disk_snapshot(id, disk_id, image_name)
+          vmpool = ::OpenNebula::VirtualMachinePool.new(client)
+          vmpool.info(-2, id, id, -1)
+
+          rc = 0
+          vmpool.each do |vm|
+            rc = vm.disk_snapshot_create(disk_id, image_name)
+            raise(rc) if rc.is_a? ::OpenNebula::Error
+          end
+          rc
+        end
+
+      end
+
+      class Mock
+
+        def vm_disk_snapshot(id, disk_id, image_name); end
+
+      end
+
+    end
+
+  end
+
+end

data/lib/fog/opennebula/requests/compute/vm_resume.rb

@@ -0,0 +1,35 @@
+module Fog
+
+  module Compute
+
+    class OpenNebula
+
+      class Real
+
+        def vm_resume(id)
+          vmpool = ::OpenNebula::VirtualMachinePool.new(client)
+          vmpool.info(-2, id, id, -1)
+
+          vmpool.each(&:resume)
+        end
+
+      end
+
+      class Mock
+
+        def vm_resume(id)
+          data['vms'].each do |vm|
+            if id == vm['id']
+              vm['state'] = 'RUNNING'
+              vm['status'] = 3
+            end
+          end
+        end
+
+      end
+
+    end
+
+  end
+
+end

data/lib/fog/opennebula/requests/compute/vm_shutdown.rb

@@ -0,0 +1,22 @@
+module Fog
+
+  module Compute
+
+    class OpenNebula
+
+      class Real
+
+        def vm_shutdown(id)
+          vmpool = ::OpenNebula::VirtualMachinePool.new(client)
+          vmpool.info(-2, id, id, -1)
+
+          vmpool.each(&:shutdown)
+        end
+
+      end
+
+    end
+
+  end
+
+end

data/lib/fog/opennebula/requests/compute/vm_stop.rb

@@ -0,0 +1,21 @@
+module Fog
+
+  module Compute
+
+    class OpenNebula
+
+      class Real
+
+        def vm_stop(id)
+          vmpool = ::OpenNebula::VirtualMachinePool.new(client)
+          vmpool.info(-2, id, id, -1)
+          vmpool.each(&:stop)
+        end
+
+      end
+
+    end
+
+  end
+
+end

data/lib/fog/opennebula/requests/compute/vm_suspend.rb

@@ -0,0 +1,38 @@
+module Fog
+
+  module Compute
+
+    class OpenNebula
+
+      class Real
+
+        def vm_suspend(id)
+          vmpool = ::OpenNebula::VirtualMachinePool.new(client)
+          vmpool.info(-2, id, id, -1)
+
+          vmpool.each(&:suspend)
+        end
+
+      end
+
+      class Mock
+
+        def vm_suspend(id)
+          response = Excon::Response.new
+          response.status = 200
+
+          data['vms'].each do |vm|
+            if id == vm['id']
+              vm['state'] = 'LCM_INIT'
+              vm['status'] = 5
+            end
+          end
+        end
+
+      end
+
+    end
+
+  end
+
+end

data/lib/fog/opennebula/version.rb

@@ -0,0 +1,9 @@
+module Fog
+
+  module OpenNebula
+
+    VERSION = '0.0.1'.freeze
+
+  end
+
+end

data/tests/opennebula/compute_tests.rb

@@ -0,0 +1,15 @@
+Shindo.tests('Fog::Compute[:opennebula]', ['opennebula']) do
+  compute = Fog::Compute[:opennebula]
+
+  tests('Compute collections') do
+    %w[networks groups].each do |collection|
+      test("it should respond to #{collection}") { compute.respond_to? collection }
+    end
+  end
+
+  tests('Compute requests') do
+    %w[list_networks].each do |request|
+      test("it should respond to #{request}") { compute.respond_to? request }
+    end
+  end
+end

data/tests/opennebula/models/compute/flavor_tests.rb

@@ -0,0 +1,34 @@
+Shindo.tests('Fog::Compute[:opennebula] | flavor model', ['opennebula']) do
+  flavors = Fog::Compute[:opennebula].flavors
+  flavor = flavors.get_by_name('fogtest').last
+
+  tests('The flavor model should') do
+    tests('have the action') do
+      test('reload') { flavor.respond_to? 'reload' }
+    end
+    tests('have attributes') do
+      model_attribute_hash = flavor.attributes
+      tests('The flavor model should respond to') do
+        %i[name id to_label to_s get_cpu get_vcpu get_memory get_raw get_disk get_os
+           get_graphics get_nic get_sched_ds_requirements get_sched_ds_rank get_sched_requirements
+           get_sched_rank get_context get_user_variables].each do |attribute|
+          test(attribute.to_s) { flavor.respond_to? attribute }
+        end
+      end
+      tests('The attributes hash should have key') do
+        %i[name id content cpu vcpu memory os graphics context user_variables].each do |attribute|
+          test(attribute.to_s) { model_attribute_hash.key? attribute }
+        end
+      end
+    end
+    test('be a kind of Fog::Compute::OpenNebula::Flavor') { flavor.is_a? Fog::Compute::OpenNebula::Flavor }
+    test('have a nic in network fogtest') { flavor.nic[0].vnet.name == 'fogtest' }
+
+    flavor.vcpu = 666
+    flavor.memory = 666
+    test('have a 666 MB memory') { flavor.get_memory == "MEMORY=666\n" }
+    test('have a 666 CPUs') { flavor.get_vcpu == "VCPU=666\n" }
+
+    test('raw parsed properly') { flavor.get_raw == %(RAW=["DATA"="<cpu match='exact'><model fallback='allow'>core2duo</model></cpu>", "TYPE"="kvm"]\n) }
+  end
+end

data/tests/opennebula/models/compute/flavors_tests.rb

@@ -0,0 +1,15 @@
+Shindo.tests('Fog::Compute[:opennebula] | flavors collection', ['opennebula']) do
+  flavors = Fog::Compute[:opennebula].flavors
+
+  tests('The flavors collection should') do
+    test('should be a kind of Fog::Compute::OpenNebula::Flavors') { flavors.is_a? Fog::Compute::OpenNebula::Flavors }
+    tests('should be able to reload itself').succeeds { flavors.reload }
+
+    tests('should be able to get models') do
+      tests('all').succeeds { flavors.all }
+      tests('by instance id').succeeds { flavors.get flavors.first.id }
+      tests('by name').succeeds { flavors.get_by_name 'fogtest' }
+      tests('by filter').succeeds { flavors.get_by_filter ({ name: 'fogtest', id: flavors.first.id }) }
+    end
+  end
+end

data/tests/opennebula/models/compute/group_tests.rb

@@ -0,0 +1,25 @@
+Shindo.tests('Fog::Compute[:opennebula] | group model', ['opennebula']) do
+  groups = Fog::Compute[:opennebula].groups
+  group = groups.last
+
+  tests('The group model should') do
+    tests('have the action') do
+      test('reload') { group.respond_to? 'reload' }
+    end
+    tests('have attributes') do
+      model_attribute_hash = group.attributes
+      attributes =
+        tests('The group model should respond to') do
+          %i[name id to_label].each do |attribute|
+            test(attribute.to_s) { group.respond_to? attribute }
+          end
+        end
+      tests('The attributes hash should have key') do
+        %i[name id].each do |attribute|
+          test(attribute.to_s) { model_attribute_hash.key? attribute }
+        end
+      end
+    end
+    test('be a kind of Fog::Compute::OpenNebula::Group') { group.is_a? Fog::Compute::OpenNebula::Group }
+  end
+end

data/tests/opennebula/models/compute/groups_tests.rb

@@ -0,0 +1,14 @@
+Shindo.tests('Fog::Compute[:opennebula] | groups collection', ['opennebula']) do
+  groups = Fog::Compute[:opennebula].groups
+
+  tests('The groups collection') do
+    test('should be a kind of Fog::Compute::OpenNebula::Groups') { groups.is_a? Fog::Compute::OpenNebula::Groups }
+    tests('should be able to reload itself').succeeds { groups.reload }
+    tests('should be able to get a model by id') do
+      tests('by instance id').succeeds { groups.get groups.first.id }
+    end
+    tests('should be able to get a model by name') do
+      tests('by instance id').succeeds { groups.get_by_name 'fogtest' }
+    end
+  end
+end

data/tests/opennebula/models/compute/network_tests.rb

@@ -0,0 +1,24 @@
+Shindo.tests('Fog::Compute[:opennebula] | network model', ['opennebula']) do
+  networks = Fog::Compute[:opennebula].networks
+  network = networks.get_by_name('fogtest')
+
+  tests('The network model should') do
+    tests('have the action') do
+      test('reload') { network.respond_to? 'reload' }
+    end
+    tests('have attributes') do
+      model_attribute_hash = network.attributes
+      tests('The network model should respond to') do
+        %i[name id vlan uid uname gid description].each do |attribute|
+          test(attribute.to_s) { network.respond_to? attribute }
+        end
+      end
+      tests('The attributes hash should have key') do
+        %i[name id uid uname gid].each do |attribute|
+          test(attribute.to_s) { model_attribute_hash.key? attribute }
+        end
+      end
+    end
+    test('be a kind of Fog::Compute::OpenNebula::Network') { network.is_a? Fog::Compute::OpenNebula::Network }
+  end
+end

data/tests/opennebula/models/compute/networks_tests.rb

@@ -0,0 +1,14 @@
+Shindo.tests('Fog::Compute[:opennebula] | networks collection', ['opennebula']) do
+  networks = Fog::Compute[:opennebula].networks
+
+  tests('The networks collection') do
+    test('should be a kind of Fog::Compute::OpenNebula::Networks') { networks.is_a? Fog::Compute::OpenNebula::Networks }
+    tests('should be able to reload itself').succeeds { networks.reload }
+    tests('should be able to get a model') do
+      tests('all').succeeds { networks.all }
+      tests('by instance id').succeeds { networks.get networks.first.id }
+      tests('by filter').succeeds { networks.get_by_filter ({ id: networks.first.id }) }
+      tests('by name').succeeds { networks.get_by_name 'fogtest' }
+    end
+  end
+end

data/tests/opennebula/requests/compute/vm_allocate_tests.rb

@@ -0,0 +1,70 @@
+Shindo.tests('Fog::Compute[:opennebula] | vm_create and vm_destroy request', 'opennebula') do
+  compute = Fog::Compute[:opennebula]
+  name_base = Time.now.to_i
+  f = compute.flavors.get_by_name('fogtest')
+
+  tests("Get 'fogtest' flavor/template") do
+    test("could not get template with name 'fogtest'! This is required for live tests!") { f.is_a? Array }
+    raise ArgumentError, "Could not get a template with the name 'fogtest'" unless f
+  end
+
+  f = f.first
+  response = {}
+
+  tests('Allocate VM') do
+    response = compute.vm_allocate(name: 'fog-' + name_base.to_s, flavor: f)
+    test('response should be a kind of Hash') { response.is_a? Hash }
+    test('id should be a one-id (Fixnum)') { response['id'].is_a? Integer }
+  end
+
+  tests('Destroy VM') do
+    compute.vm_destroy(response['id'])
+    test('vm should not be in array of vms') do
+      vm_not_exist = true
+      compute.list_vms.each do |vm|
+        vm_not_exist = false if vm['id'] == response['id']
+      end
+      vm_not_exist
+    end
+    test('vm should not be in array of vms by filter') do
+      vm_not_exist = true
+      compute.list_vms(id: response['id']).each do |vm|
+        vm_not_exist = false if vm['id'] == response['id']
+      end
+      vm_not_exist
+    end
+  end
+
+  # tests("Create VM from template (clone)") do
+  #  response = compute.create_vm(:name => 'fog-'+(name_base+ 1).to_s, :template_name => 'hwp_small', :cluster_name => 'Default')
+  #  test("should be a kind of OVIRT::VM") { response.kind_of?  OVIRT::VM}
+  # end
+
+  tests('Fail Creating VM - no flavor') do
+    begin
+      response = compute.vm_allocate(name: 'fog-' + name_base.to_s, flavor: nil)
+      test('should be a kind of Hash') { response.is_a? Hash } # mock never raise exceptions
+    rescue StandardError => e
+      # should raise vm name already exist exception.
+      test('error should be a kind of ArgumentError') { e.is_a? ArgumentError }
+    end
+  end
+  tests('Fail Creating VM - nil name') do
+    begin
+      response = compute.vm_allocate(name: nil, flavor: f)
+      test('should be a kind of Hash') { response.is_a? Hash } # mock never raise exceptions
+    rescue StandardError => e
+      # should raise vm name already exist exception.
+      test('error should be a kind of ArgumentError') { e.is_a? ArgumentError }
+    end
+  end
+  tests('Fail Creating VM - empty name') do
+    begin
+      response = compute.vm_allocate(name: '', flavor: f)
+      test('should be a kind of Hash') { response.is_a? Hash } # mock never raise exceptions
+    rescue StandardError => e
+      # should raise vm name already exist exception.
+      test('error should be a kind of ArgumentError') { e.is_a? ArgumentError }
+    end
+  end
+end

data/tests/opennebula/requests/compute/vm_disk_snapshot_test.rb

@@ -0,0 +1,44 @@
+Shindo.tests('Fog::Compute[:opennebula] | vm_create and destroy request', 'opennebula') do
+  compute = Fog::Compute[:opennebula]
+
+  name_base = Time.now.to_i
+  f = compute.flavors.get_by_name('fogtest')
+  tests("Get 'fogtest' flavor/template") do
+    test("Got template with name 'fogtest'") { f.is_a? Array }
+    raise ArgumentError, "Could not get a template with the name 'fogtest'! This is required for live tests!" unless f
+  end
+
+  f = f.first
+  newvm = compute.servers.new
+  newvm.flavor = f
+  newvm.name = 'fogtest-' + name_base.to_s
+  vm = newvm.save
+
+  tests('Start VM') do
+    test('response should be a kind of Hash') { vm.is_a? Fog::Compute::OpenNebula::Server }
+    test('id should be a one-id (Fixnum)') { vm.id.is_a? Integer }
+    vm.wait_for { (vm.state == 'RUNNING') }
+    test('VM should be in RUNNING state') { vm.state == 'RUNNING' }
+    sleep(30) # waiting for 30 seconds to let VM finish booting
+  end
+
+  tests('Create snapshot of the disk and shutdown VM') do
+    img_id = compute.vm_disk_snapshot(vm.id, 0, 'fogtest-' + name_base.to_s)
+    test('Image ID of created snapshot should be a kind of Fixnum') { img_id.is_a? Integer }
+    5.times do # wait maximum 5 seconds
+      sleep(1) # The delay is needed for some reason between issueing disk-snapshot and shutdown
+      images = compute.image_pool(mine: true, id: img_id)
+      test("Got Image with ID=#{img_id}") { images.is_a? Array }
+      break if images[0].state == 4 # LOCKED, it is normal we must shutdown VM for image to go into READY state
+    end
+    compute.servers.shutdown(vm.id)
+    image_state = 4
+    25.times do # Waiting for up to 50 seconds for Image to become READY
+      sleep(2)
+      images = compute.image_pool(mine: true, id: img_id)
+      image_state = images[0].state
+      break if image_state == 1
+    end
+    test("New image with ID=#{img_id} should be in state READY.") { image_state == 1 }
+  end
+end