fog-opennebula 0.0.1

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

@@ -0,0 +1,33 @@
+module Fog
+
+  module Compute
+
+    class OpenNebula
+
+      class Real
+
+        def image_pool(filter = {})
+          images = ::OpenNebula::ImagePool.new(client)
+          if filter[:mine].nil?
+            images.info!
+          else
+            images.info_mine!
+          end
+
+          unless filter[:id].nil?
+            images.each do |i|
+              if filter[:id] == i.id
+                return [i] # return an array with only one element - found image
+              end
+            end
+          end
+          images
+        end
+
+      end
+
+    end
+
+  end
+
+end

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

@@ -0,0 +1,87 @@
+module Fog
+
+  module Compute
+
+    class OpenNebula
+
+      class Real
+
+        def list_groups(filter = {})
+          groups = []
+          grouppool = ::OpenNebula::GroupPool.new(client)
+          grouppool.info
+
+          # {
+          #   "GROUP"=>{
+          #     "ID"=>"0",
+          #      "NAME"=>"oneadmin",
+          #      "USERS"=>{"ID"=>["0", "1"]},
+          #      "DATASTORE_QUOTA"=>{},
+          #      "NETWORK_QUOTA"=>{},
+          #      "VM_QUOTA"=>{},
+          #      "IMAGE_QUOTA"=>{}
+          #    }
+          # }
+
+          grouppool.each do |group|
+            filter_missmatch = false
+
+            unless filter.empty?
+              filter.each do |k, v|
+                if group[k.to_s.upcase.to_s] && group[k.to_s.upcase.to_s] != v.to_s
+                  filter_missmatch = true
+                  break
+                end
+              end
+              next if filter_missmatch
+            end
+            groups << { :id => group['ID'], :name => group['NAME'] }
+          end
+          groups
+        end
+
+      end
+
+      class Mock
+
+        def list_groups(filter = {})
+          groups = []
+          net1 = mock_group '1', 'net1'
+          net2 = mock_group '2', 'fogtest'
+
+          grouppool = [net1, net2]
+          grouppool.each do |group|
+            filter_missmatch = false
+
+            unless filter.empty?
+              filter.each do |k, v|
+                if group[k.to_s.upcase.to_s] && group[k.to_s.upcase.to_s] != v.to_s
+                  filter_missmatch = true
+                  break
+                end
+              end
+              next if filter_missmatch
+            end
+            groups << { :id => group['ID'], :name => group['NAME'] }
+          end
+          groups
+        end
+
+        def mock_group(id, name)
+          {
+            'ID'    	 => id,
+            'NAME'  	 => name,
+            'UID'   	 => '5',
+            'GID'   	 => '5',
+            'DESCRIPTION' => 'netDescription',
+            'VLAN'	 => '5'
+          }
+        end
+
+      end
+
+    end
+
+  end
+
+end

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

@@ -0,0 +1,79 @@
+module Fog
+
+  module Compute
+
+    class OpenNebula
+
+      class Real
+
+        def list_networks(filter = {})
+          networks = []
+          netpool = ::OpenNebula::VirtualNetworkPool.new(client)
+          if filter[:id].nil?
+            netpool.info!(-2, -1, -1)
+          elsif filter[:id]
+            filter[:id] = filter[:id].to_i if filter[:id].is_a?(String)
+            netpool.info!(-2, filter[:id], filter[:id])
+          end
+
+          netpool.each do |network|
+            if filter[:network] && filter[:network].is_a?(String) && !filter[:network].empty?
+              next if network.to_hash['VNET']['NAME'] != filter[:network]
+            end
+            if filter[:network_uname] && filter[:network_uname].is_a?(String) && !filter[:network_uname].empty?
+              next if network.to_hash['VNET']['UNAME'] != filter[:network_uname]
+            end
+            if filter[:network_uid] && filter[:network_uid].is_a?(String) && !filter[:network_uid].empty?
+              next if network.to_hash['VNET']['UID'] != filter[:network_uid]
+            end
+            networks << network_to_attributes(network.to_hash)
+          end
+          networks
+        end
+
+        def network_to_attributes(net)
+          return if net.nil?
+
+          h = {
+            :id => net['VNET']['ID'],
+            :name => net['VNET']['NAME'],
+            :uid => net['VNET']['UID'],
+            :uname => net['VNET']['UNAME'],
+            :gid => net['VNET']['GID']
+          }
+
+          h[:description] = net['VNET']['TEMPLATE']['DESCRIPTION'] unless net['VNET']['TEMPLATE']['DESCRIPTION'].nil?
+          h[:vlan] = net['VNET']['VLAN_ID'] unless net['VNET']['VLAN_ID'].nil? || net['VNET']['VLAN_ID'].empty?
+
+          h
+        end
+
+      end
+
+      class Mock
+
+        def list_networks(_filters = {})
+          net1 = mock_network 'fogtest'
+          net2 = mock_network 'net2'
+          [net1, net2]
+        end
+
+        def mock_network(name)
+          {
+            :id => '5',
+            :name => name,
+            :uid => '5',
+            :uname => 'mock',
+            :gid => '5',
+            :description => 'netDescription',
+            :vlan => '5'
+          }
+        end
+
+      end
+
+    end
+
+  end
+
+end

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

@@ -0,0 +1,79 @@
+module Fog
+
+  module Compute
+
+    class OpenNebula
+
+      class Real
+
+        def list_vms(filter = {})
+          vms = []
+          vmpool = ::OpenNebula::VirtualMachinePool.new(client)
+          if filter[:id].nil?
+            vmpool.info(-2, -1, -1, -1)
+          elsif filter[:id]
+            filter[:id] = filter[:id].to_i if filter[:id].is_a?(String)
+            vmpool.info(-2, filter[:id], filter[:id], -1)
+          end
+
+          vmpool.each do |vm|
+            one = vm.to_hash
+            data = {}
+            data['onevm_object'] = vm
+            data['status'] =  vm.state
+            data['state']  =  vm.lcm_state_str
+            data['id']     =  vm.id
+            data['gid']    =  vm.gid
+            data['uuid']   =  vm.id
+            data['name']   =  one['VM']['NAME'] unless one['VM']['NAME'].nil?
+            data['user']   =  one['VM']['UNAME'] unless one['VM']['UNAME'].nil?
+            data['group']  =  one['VM']['GNAME'] unless one['VM']['GNAME'].nil?
+
+            unless one['VM']['TEMPLATE'].nil?
+              data['cpu']    =  one['VM']['TEMPLATE']['VCPU'] unless one['VM']['TEMPLATE']['VCPU'].nil?
+              data['memory'] =  one['VM']['TEMPLATE']['MEMORY'] unless one['VM']['TEMPLATE']['MEMORY'].nil?
+              unless one['VM']['TEMPLATE']['NIC'].nil?
+                if one['VM']['TEMPLATE']['NIC'].is_a?(Array)
+                  data['ip'] = one['VM']['TEMPLATE']['NIC'][0]['IP']
+                  data['mac'] = one['VM']['TEMPLATE']['NIC'][0]['MAC']
+                else
+                  data['ip'] = one['VM']['TEMPLATE']['NIC']['IP'] unless one['VM']['TEMPLATE']['NIC']['IP'].nil?
+                  data['mac'] = one['VM']['TEMPLATE']['NIC']['MAC'] unless one['VM']['TEMPLATE']['NIC']['MAC'].nil?
+                end
+              end
+            end
+
+            vms << data
+          end
+          vms
+        end
+
+      end
+
+      module Shared
+
+        private
+
+      end
+
+      class Mock
+
+        def list_vms(filter = {})
+          vms = []
+          data['vms'].each do |vm|
+            if filter[:id].nil?
+              vms << vm
+            elsif filter[:id] == vm['id']
+              vms << vm
+            end
+          end
+          vms
+        end
+
+      end
+
+    end
+
+  end
+
+end

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

@@ -0,0 +1,120 @@
+module Fog
+
+  module Compute
+
+    class OpenNebula
+
+      class Real
+
+        def template_pool(filter = {})
+          templates = ::OpenNebula::TemplatePool.new(client)
+          if filter[:id].nil?
+            templates.info!(-2, -1, -1)
+          elsif filter[:id]
+            filter[:id] = filter[:id].to_i if filter[:id].is_a?(String)
+            templates.info!(-2, filter[:id], filter[:id])
+          end
+
+          templates = templates.map do |t|
+            # filtering by name
+            # done here, because OpenNebula:TemplatePool does not support something like .delete_if
+            if filter[:name] && filter[:name].is_a?(String) && !filter[:name].empty?
+              next if t.to_hash['VMTEMPLATE']['NAME'] != filter[:name]
+            end
+            if filter[:uname] && filter[:uname].is_a?(String) && !filter[:uname].empty?
+              next if t.to_hash['VMTEMPLATE']['UNAME'] != filter[:uname]
+            end
+            if filter[:uid] && filter[:uid].is_a?(String) && !filter[:uid].empty?
+              next if t.to_hash['VMTEMPLATE']['UID'] != filter[:uid]
+            end
+
+            h = Hash[
+              :id => t.to_hash['VMTEMPLATE']['ID'],
+              :name => t.to_hash['VMTEMPLATE']['NAME'],
+              :content => t.template_str,
+              :USER_VARIABLES => '' # Default if not set in template
+            ]
+            h.merge! t.to_hash['VMTEMPLATE']['TEMPLATE']
+
+            # h["NIC"] has to be an array of nic objects
+            nics = h['NIC'] unless h['NIC'].nil?
+            h['NIC'] = [] # reset nics to a array
+            if nics.is_a? Array
+              nics.each do |n|
+                if n['NETWORK_ID']
+                  vnet = networks.get(n['NETWORK_ID'].to_s)
+                elsif n['NETWORK']
+                  vnet = networks.get_by_name(n['NETWORK'].to_s)
+                else
+                  next
+                end
+                h['NIC'] << interfaces.new(:vnet => vnet, :model => n['MODEL'] || 'virtio')
+              end
+            elsif nics.is_a? Hash
+              nics['model'] = 'virtio' if nics['model'].nil?
+              # nics["uuid"] = "0" if nics["uuid"].nil? # is it better is to remove this NIC?
+              n = networks.get_by_filter(
+                :id => nics['NETWORK_ID'],
+                :network => nics['NETWORK'],
+                :network_uname => nics['NETWORK_UNAME'],
+                :network_uid => nics['NETWORK_UID']
+              )
+              n.each do |i|
+                h['NIC'] << interfaces.new(:vnet => i)
+              end
+            end
+
+            # every key should be lowercase
+            ret_hash = {}
+            h.each_pair do |k, v|
+              ret_hash.merge!(k.downcase => v)
+            end
+            ret_hash
+          end
+
+          templates.delete nil
+          raise Fog::Compute::OpenNebula::NotFound, 'Flavor/Template not found' if templates.empty?
+
+          templates
+        end
+
+      end
+
+      class Mock
+
+        def template_pool(_filter = {})
+          nic1 = Mock_nic.new
+          nic1.vnet = networks.first
+
+          data['template_pool']
+          data['template_pool'].each do |tmpl|
+            tmpl['nic'][0] = nic1
+          end
+          data['template_pool']
+        end
+
+        class Mock_nic
+
+          attr_accessor :vnet
+
+          def id
+            2
+          end
+
+          def name
+            'fogtest'
+          end
+
+          def model
+            'virtio-net'
+          end
+
+        end
+
+      end
+
+    end
+
+  end
+
+end

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

@@ -0,0 +1,97 @@
+module Fog
+
+  module Compute
+
+    class OpenNebula
+
+      class Real
+
+        def vm_allocate(attr = {})
+          if attr[:flavor].nil?
+            raise ArgumentError, "Attribute flavor is nil! #{attr.inspect}"
+          end
+          if attr[:name].nil? || attr[:name].empty?
+            raise ArgumentError, "Attribute name is nil or empty! #{attr.inspect}"
+          end
+
+          xml = ::OpenNebula::VirtualMachine.build_xml
+          vm  = ::OpenNebula::VirtualMachine.new(xml, client)
+          rc = vm.allocate(attr[:flavor].to_s + "\nNAME=\"" + attr[:name] + '"')
+
+          raise(rc) if rc.is_a? ::OpenNebula::Error
+
+          # -1 - do not change the owner
+          vm.chown(-1, attr[:gid].to_i) unless attr[:gid].nil?
+
+          # TODO
+          # check if vm is created vmid.class == One error class
+          vm.info!
+
+          one = vm.to_hash
+          data = {}
+          data['onevm_object'] = vm
+          data['status'] =  vm.state
+          data['state']  =  vm.lcm_state_str
+          data['id']     =  vm.id
+          data['uuid']   =  vm.id
+          data['gid']    =  vm.gid
+          data['name']   =  one['VM']['NAME'] unless one['VM']['NAME'].nil?
+          data['user']   =  one['VM']['UNAME'] unless one['VM']['UNAME'].nil?
+          data['group']  =  one['VM']['GNAME'] unless one['VM']['GNAME'].nil?
+
+          unless one['VM']['TEMPLATE'].nil?
+            temp = one['VM']['TEMPLATE']
+            data['cpu']    =  temp['VCPU']	unless temp['VCPU'].nil?
+            data['memory'] =  temp['MEMORY']	unless temp['MEMORY'].nil?
+            unless temp['NIC'].nil?
+              if one['VM']['TEMPLATE']['NIC'].is_a?(Array)
+                data['mac']	=	temp['NIC'][0]['MAC']	unless temp['NIC'][0]['MAC'].nil?
+                data['ip']	=	temp['NIC'][0]['IP']	unless temp['NIC'][0]['IP'].nil?
+              else
+                data['mac']	=	temp['NIC']['MAC']	unless temp['NIC']['MAC'].nil?
+                data['ip']	=	temp['NIC']['IP']	unless temp['NIC']['IP'].nil?
+              end
+            end
+          end
+
+          data
+        rescue StandardError => err
+          raise(err)
+        end
+
+      end
+
+      class Mock
+
+        def vm_allocate(attr = {})
+          response = Excon::Response.new
+          response.status = 200
+
+          id = rand(1000)
+          ids = []
+
+          data['vms'].each do |vm|
+            ids << vm['id']
+            next unless vm['id'] == id
+
+            id = rand(1000) while ids.include?(id)
+            break
+          end
+
+          data = {}
+          data['id'] = id
+          data['flavor'] = attr[:flavor]
+          data['name'] = attr[:name]
+          data['state'] = 'RUNNING'
+          data['status'] = 3
+          self.data['vms'] << data
+          data
+        end
+
+      end
+
+    end
+
+  end
+
+end