occi 1.2.1 → 2.0.0

data/lib/occi/backend/manager.rb

@@ -0,0 +1,131 @@
+##############################################################################
+#  Copyright 2011 Service Computing group, TU Dortmund
+#
+#  Licensed under the Apache License, Version 2.0 (the "License");
+#  you may not use this file except in compliance with the License.
+#  You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+#  Unless required by applicable law or agreed to in writing, software
+#  distributed under the License is distributed on an "AS IS" BASIS,
+#  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#  See the License for the specific language governing permissions and
+#  limitations under the License.
+##############################################################################
+
+##############################################################################
+# Description: OpenNebula Backend
+# Author(s): Hayati Bice, Florian Feldhaus, Piotr Kasprzak
+##############################################################################
+
+require 'rubygems'
+
+require 'occi/backend/opennebula/opennebula'
+require 'occi/backend/ec2/ec2'
+require 'occi/backend/dummy'
+
+#require 'uuidtools'
+#require 'OpenNebula/OpenNebula'
+#require 'occi/CategoryRegistry'
+#require 'occi/rendering/http/LocationRegistry'
+
+# OpenNebula backend
+#require 'occi/backend/opennebula/Compute'
+#require 'occi/backend/opennebula/Network'
+#require 'occi/backend/opennebula/Storage'
+
+# OpenNebula backend based mixins
+#require 'occi/extensions/one/Image'
+#require 'occi/extensions/one/Network'
+#require 'occi/extensions/one/VirtualMachine'
+#require 'occi/extensions/one/VNC'
+
+#require 'occi/extensions/Reservation'
+
+#include OpenNebula
+
+module OCCI
+  module Backend
+
+    # ---------------------------------------------------------------------------------------------------------------------
+    RESOURCE_DEPLOY = :deploy
+    RESOURCE_UPDATE_STATE = :update_state
+    RESOURCE_DELETE = :delete
+
+    # ---------------------------------------------------------------------------------------------------------------------
+    class Manager
+
+      # ---------------------------------------------------------------------------------------------------------------------              
+      private
+      # ---------------------------------------------------------------------------------------------------------------------
+
+      @@backends_classes = {}
+      @@backends_operations = {}
+
+      # ---------------------------------------------------------------------------------------------------------------------
+      public
+      # ---------------------------------------------------------------------------------------------------------------------
+
+      # ---------------------------------------------------------------------------------------------------------------------
+      def self.register_backend(backend_class, operations)
+
+        # Get ident of backend = class name downcased
+        #        backend_ident = Object.const_get(backend_class).name.downcase
+
+        backend_ident = backend_class.name.downcase
+
+        @@backends_classes[backend_ident] = backend_class
+        @@backends_operations[backend_ident] = operations
+      end
+
+      # ---------------------------------------------------------------------------------------------------------------------
+      def self.signal_resource(backend, operation, resource, operation_parameters = nil)
+
+        resource_type = resource.kind
+        backend_ident = backend.class.name.downcase
+
+        raise OCCI::BackendError, "Unknown backend: '#{backend_ident}'" unless @@backends_classes.has_key?(backend_ident)
+
+        operations = @@backends_operations[backend_ident]
+
+        raise OCCI::BackendError, "Resource type '#{resource_type}' not supported!" unless operations.has_key?(resource_type)
+        raise OCCI::BackendError, "Operation '#{operation}' not supported on resource category '#{resource_type}'!" unless operations[resource_type].has_key?(operation.to_sym)
+
+        # Delegate
+
+        if operations[resource_type][operation.to_sym].nil?
+          OCCI::Log.debug("No backend method configured => doing nothing...")
+          return
+        end
+
+        if operation_parameters.nil?
+          # Generic resource operation
+          backend.send(operations[resource_type][operation.to_sym], resource)
+        else
+          # Action related operation, we need to pass on the action parameters
+          backend.send(operations[resource_type][operation.to_sym], resource, operation_parameters)
+        end
+
+      end
+
+      # ---------------------------------------------------------------------------------------------------------------------
+      def self.delegate_action(backend, action, parameters, resource)
+
+        OCCI::Log.debug("Delegating invocation of action [#{action}] on resource [#{resource}] with parameters [#{parameters}] to backend...")
+
+        # Use action term as ident
+        operation = action.term
+
+        begin
+          # TODO: define some convention for result handling!
+          signal_resource(backend, operation, resource, parameters)
+
+        rescue OCCI::BackendError
+          OCCI::Log.error("Action invocation failed!")
+          raise
+        end
+      end
+    end
+  end
+end

data/lib/occi/backend/opennebula/compute.rb

@@ -0,0 +1,360 @@
+##############################################################################
+#  Copyright 2011 Service Computing group, TU Dortmund
+#
+#  Licensed under the Apache License, Version 2.0 (the "License");
+#  you may not use this file except in compliance with the License.
+#  You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+#  Unless required by applicable law or agreed to in writing, software
+#  distributed under the License is distributed on an "AS IS" BASIS,
+#  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#  See the License for the specific language governing permissions and
+#  limitations under the License.
+##############################################################################
+
+##############################################################################
+# Description: OpenNebula Backend
+# Author(s): Hayati Bice, Florian Feldhaus, Piotr Kasprzak
+##############################################################################
+
+require 'occi/log'
+require 'erubis'
+
+module OCCI
+  module Backend
+    module OpenNebula
+
+      # ---------------------------------------------------------------------------------------------------------------------
+      module Compute
+
+        TEMPLATECOMPUTERAWFILE = 'compute.erb'
+
+        # ---------------------------------------------------------------------------------------------------------------------       
+        #        private
+        # ---------------------------------------------------------------------------------------------------------------------
+
+        # ---------------------------------------------------------------------------------------------------------------------     
+        # PARSE OPENNEBULA COMPUTE OBJECT
+        def compute_parse_backend_object(backend_object)
+
+          # get information on compute object from OpenNebula backend
+          backend_object.info
+
+          compute_kind = OCCI::Registry.get_by_id("http://schemas.ogf.org/occi/infrastructure#compute")
+
+          compute = Hashie::Mash.new
+
+          compute.kind = compute_kind.type_identifier
+          compute.mixins = %w|http://opennebula.org/occi/infrastructure#compute|
+          compute.id = self.generate_occi_id(compute_kind, backend_object.id.to_s)
+          compute.title = backend_object['NAME']
+          compute.summary = backend_object['TEMPLATE/DESCRIPTION'] if backend_object['TEMPLATE/DESCRIPTION']
+
+          compute.attributes!.occi!.compute!.cores = backend_object['TEMPLATE/VCPU'].to_i if backend_object['TEMPLATE/VCPU']
+          compute.attributes!.occi!.compute!.architecture = "x64" if backend_object['TEMPLATE/ARCHITECTURE'] == "x86_64"
+          compute.attributes!.occi!.compute!.architecture = "x86" if backend_object['TEMPLATE/ARCHITECTURE'] == "i686"
+          compute.attributes!.occi!.compute!.memory = backend_object['TEMPLATE/MEMORY'].to_f/1000 if backend_object['TEMPLATE/MEMORY']
+
+          compute.attributes!.org!.opennebula!.compute!.cpu = backend_object['TEMPLATE/CPU'].to_f if backend_object['TEMPLATE/CPU']
+          compute.attributes!.org!.opennebula!.compute!.kernel = backend_object['TEMPLATE/KERNEL'] if backend_object['TEMPLATE/KERNEL']
+          compute.attributes!.org!.opennebula!.compute!.initrd = backend_object['TEMPLATE/INITRD'] if backend_object['TEMPLATE/INITRD']
+          compute.attributes!.org!.opennebula!.compute!.root = backend_object['TEMPLATE/ROOT'] if backend_object['TEMPLATE/ROOT']
+          compute.attributes!.org!.opennebula!.compute!.kernel_cmd = backend_object['TEMPLATE/KERNEL_CMD'] if backend_object['TEMPLATE/KERNEL_CMD']
+          compute.attributes!.org!.opennebula!.compute!.bootloader = backend_object['TEMPLATE/BOOTLOADER'] if backend_object['TEMPLATE/BOOTLOADER']
+          compute.attributes!.org!.opennebula!.compute!.boot = backend_object['TEMPLATE/BOOT'] if backend_object['TEMPLATE/BOOT']
+
+          compute = OCCI::Core::Resource.new(compute)
+
+          compute_set_state(backend_object, compute)
+
+          # TODO: refactor VNC handling
+          #if backend_object['TEMPLATE/GRAPHICS/TYPE'] == 'vnc' \
+          #and backend_object['HISTORY_RECORDS/HISTORY/HOSTNAME'] \
+          #and not OCCI::Server.config[:novnc_path].nil? \
+          #and not OCCI::Server.config[:vnc_proxy_base_port].nil?
+          #
+          #  vnc_host = backend_object['HISTORY_RECORDS/HISTORY/HOSTNAME']
+          #  vnc_port = backend_object['TEMPLATE/GRAPHICS/PORT']
+          #
+          #  vnc_proxy_host = URI.parse(OCCI::Server.location).host
+          #
+          #  # The noVNC proxy_port
+          #  proxy_port = OCCI::Server.config[:vnc_proxy_base_port].to_i + vnc_port.to_i
+          #
+          #  OCCI::Log.debug("NOVNC path: #{OCCI::Server.config[:novnc_path]}")
+          #  OCCI::Log.debug("Graphics type: #{backend_object['TEMPLATE/GRAPHICS/TYPE']}")
+          #  OCCI::Log.debug("VNC base port: #{OCCI::Server.config[:vnc_proxy_base_port]}")
+          #  OCCI::Log.debug("VNC port: #{vnc_port}")
+          #  OCCI::Log.debug("VNC host: #{vnc_host}")
+          #
+          #  compute.mixins << OCCI::Registry.get_by_id("http://schemas.ogf.org/occi/infrastructure/compute#console")
+          #
+          #  if occi_object.attributes['opennebula.vm.vnc'].nil? or occi_object.backend[:novnc_pipe].nil?
+          #
+          #    # CREATE PROXY FOR VNC SERVER
+          #    begin
+          #      novnc_cmd = "#{OCCI::Server.config[:novnc_path]}/utils/websockify"
+          #      pipe = IO.popen("#{novnc_cmd} --web #{OCCI::Server.config[:novnc_path]} #{proxy_port} #{vnc_host}:#{vnc_port}")
+          #
+          #      if pipe
+          #        vnc_url = OCCI::Server.config[:server].chomp('/') + ':' + vnc_port + '/vnc_auto.html?host=' + vnc_proxy_host + '&port=' + vnc_port
+          #        OCCI::Log.debug("VNC URL: #{vnc_url}")
+          #        occi_object.backend[:novnc_pipe] = pipe
+          #        occi_object.attributes['opennebula.vm.vnc'] = vnc_host + ':' + vnc_port
+          #        occi_object.attributes['opennebula.vm.web_vnc'] = vnc_url
+          #      end
+          #    rescue Exception => e
+          #      OCCI::Log.error("Error in creating VNC proxy: #{e.message}")
+          #    end
+          #  end
+          #  OCCI::Registry.get_by_id(kind).entities << compute
+          #end
+
+          compute_parse_links(compute, backend_object)
+
+          # register compute resource in entities of compute kind
+          compute_kind.entities << compute
+        end
+
+        # ---------------------------------------------------------------------------------------------------------------------
+        # PARSE OPENNEBULA DEPENDENCIES TO E.G. STORAGE AND NETWORK LINKS
+        def compute_parse_links(compute, backend_object)
+          # create links for all storage instances
+          backend_object.each('TEMPLATE/DISK') do |disk|
+            OCCI::Log.debug("Storage Backend ID: #{disk['IMAGE_ID']}")
+
+            link = OCCI::Core::Link.new
+            storagelink_kind = OCCI::Registry.get_by_id('http://schemas.ogf.org/occi/infrastructure#storagelink')
+            link.kind = storagelink_kind.type_identifier
+            link.id = self.generate_occi_id(storagelink_kind, disk['IMAGE_ID'].to_s)
+            storage_kind = OCCI::Registry.get_by_id('http://schemas.ogf.org/occi/infrastructure#storage')
+            storage_id = self.generate_occi_id(storage_kind, disk['IMAGE_ID'].to_s)
+            target = storage_kind.entities.select { |entity| entity.id == storage_id }.first
+            if target.nil?
+              one_storage = Image.new(Image.build_xml(disk['IMAGE_ID']), @one_client)
+              self.storage_parse_backend_object(one_storage)
+              target = storage_kind.entities.select { |entity| entity.id == storage_id }.first
+            end
+            link.target = target.location
+            link.title = target.title
+            link.summary = target.summary
+            link.rel = storage_kind.type_identifier
+            link.source = compute.location
+            link.mixins << OCCI::Registry.get_by_id('http://opennebula.org/occi/infrastructure#storagelink')
+            link.attributes!.occi!.storagelink!.deviceid = disk['TARGET'] if disk['TARGET']
+            link.attributes!.org!.opennebula!.storagelink!.bus = disk['BUS'] if disk['BUS']
+            link.attributes!.org!.opennebula!.storagelink!.driver = disk['DRIVER'] if disk['TARGET']
+
+            # check link attributes against definition in kind and mixins
+            link.check
+
+            storagelink_kind.entities << link
+          end
+
+          #create links for all network instances
+          backend_object.each('TEMPLATE/NIC') do |nic|
+            OCCI::Log.debug("Network Backend ID: #{nic['NETWORK_ID']}")
+
+            link = OCCI::Core::Link.new
+            networkinterface_kind = OCCI::Registry.get_by_id('http://schemas.ogf.org/occi/infrastructure#networkinterface')
+            link.kind = networkinterface_kind.type_identifier
+            link.id = self.generate_occi_id(networkinterface_kind, nic['NETWORK_ID'].to_s)
+            network_kind = OCCI::Registry.get_by_id('http://schemas.ogf.org/occi/infrastructure#network')
+            network_id = self.generate_occi_id(network_kind, nic['NETWORK_ID'].to_s)
+            target = network_kind.entitis.select { |entity| entity.id == network_id }.first
+            if target.nil?
+              one_network = VirtualNetwork.new(VirtualNetwork.build_xml(nic['NETWORK_ID']), @one_client)
+              self.network_parse_backend_object(one_network)
+              target = network_kind.entities.select { |entity| entity.id == network_id }.first
+            end
+            link.target = target.location
+            link.title = target.title
+            link.summary = target.summary
+            link.rel = network_kind.type_identifier
+            link.source = compute.location
+            link.mixins << OCCI::Registry.get_by_id('http://schemas.ogf.org/occi/infrastructure/networkinterface#ipnetworkinterface')
+            link.mixins << OCCI::Registry.get_by_id('http://opennebula.org/occi/infrastructure#networkinterface')
+            link.attributes!.occi!.networkinterface!.address = nic['IP'] if nic['IP']
+            link.attributes!.occi!.networkinterface!.mac = nic['MAC'] if nic['MAC']
+            link.attributes!.occi!.networkinterface!.interface = nic['TARGET'] if nic['TARGET']
+            link.attributes!.org!.opennebula!.networkinterface!.bridge = nic['BRIDGE'] if nic['BRIDGE']
+            link.attributes!.org!.opennebula!.networkinterface!.script = nic['SCRIPT'] if nic['SCRIPT']
+            link.attributes!.org!.opennebula!.networkinterface!.white_ports_tcp = nic['WHITE_PORTS_TCP'] if nic['WHITE_PORTS_TCP']
+            link.attributes!.org!.opennebula!.networkinterface!.black_ports_tcp = nic['BLACK_PORTS_TCP'] if nic['BLACK_PORTS_TCP']
+            link.attributes!.org!.opennebula!.networkinterface!.white_ports_udp = nic['WHITE_PORTS_UDP'] if nic['WHITE_PORTS_UDP']
+            link.attributes!.org!.opennebula!.networkinterface!.black_ports_udp = nic['BLACK_PORTS_UDP'] if nic['BLACK_PORTS_UDP ']
+            link.attributes!.org!.opennebula!.networkinterface!.icmp = nic['ICMP'] if nic['ICMP ']
+
+            # check link attributes against definition in kind and mixins
+            link.check
+
+            networkinterface_kind.entities << link
+          end
+        end
+
+        # ---------------------------------------------------------------------------------------------------------------------
+        public
+        # ---------------------------------------------------------------------------------------------------------------------
+
+        # ---------------------------------------------------------------------------------------------------------------------
+        def compute_deploy(compute)
+          os_tpl = compute.mixins!.select { |mixin| mixin.related_to?("http://schemas.ogf.org/occi/infrastructure#os_tpl") }.first
+
+          backend_object = nil
+
+          templates = TemplatePool.new(@one_client, OpenNebula::INFO_ACL)
+          templates.info
+          template = templates.select { |template| template['NAME'] == os_tpl.title }.first
+          if template
+            template.info
+            template['TEMPLATE/VCPU'] = compute.attributes.occi.compute.cores if compute.attributes!.occi!.compute!.cores
+            template['TEMPLATE/MEMORY'] = (compute.attributes.occi.compute.memory.to_f * 1000).to_s if compute.attributes!.occi!.compute!.memory
+            template['TEMPLATE/ARCHITECTURE'] = compute.attributes.occi.compute.architecture if compute.attributes!.occi!.compute!.architecture
+            template['TEMPLATE/CPU'] = compute.attributes.occi.compute.speed if compute.attributes!.occi!.compute!.speed
+            backend_object = template.instantiate
+            check_rc(backend_object)
+          else
+            backend_object = VirtualMachine.new(VirtualMachine.build_xml, @one_client)
+
+            template_location = OCCI::Server.config["TEMPLATE_LOCATION"] + TEMPLATECOMPUTERAWFILE
+            template = Erubis::Eruby.new(File.read(template_location)).evaluate(:compute => compute)
+
+            OCCI::Log.debug("Parsed template #{template}")
+            rc = backend_object.allocate(template)
+            check_rc(rc)
+            OCCI::Log.debug("Return code from OpenNebula #{rc}") if rc != nil
+          end
+
+          backend_object.info
+          compute.id = self.generate_occi_id(OCCI::Registry.get_by_id(compute.kind), backend_object['ID'].to_s)
+
+          compute_set_state(backend_object, compute)
+
+          OCCI::Log.debug("OpenNebula automatically triggers action start for Virtual Machines")
+          OCCI::Log.debug("Changing state to started")
+        end
+
+        # ---------------------------------------------------------------------------------------------------------------------
+        def compute_set_state(backend_object, compute)
+          OCCI::Log.debug("current VM state is: #{backend_object.lcm_state_str}")
+          compute.links ||= []
+          case backend_object.lcm_state_str
+            when "RUNNING" then
+              compute.attributes!.occi!.compute!.state = "active"
+              compute.links << OCCI::Core::Link.new(:target=>compute.location + '?action=stop',:rel=>'http://schemas.ogf.org/occi/infrastructure/compute/action#stop')
+              compute.links << OCCI::Core::Link.new(:target=>compute.location + '?action=restart',:rel=>'http://schemas.ogf.org/occi/infrastructure/compute/action#restart')
+              compute.links << OCCI::Core::Link.new(:target=>compute.location + '?action=suspend',:rel=>'http://schemas.ogf.org/occi/infrastructure/compute/action#suspend')
+            when "PROLOG", "BOOT", "SAVE_STOP", "SAVE_SUSPEND", "SAVE_MIGRATE", "MIGRATE", "PROLOG_MIGRATE", "PROLOG_RESUME" then
+              compute.attributes!.occi!.compute!.state = "inactive"
+              compute.links << OCCI::Core::Link.new(:target=>compute.location + '?action=stop',:rel=>'http://schemas.ogf.org/occi/infrastructure/compute/action#stop')
+              compute.links << OCCI::Core::Link.new(:target=>compute.location + '?action=restart',:rel=>'http://schemas.ogf.org/occi/infrastructure/compute/action#restart')
+            when "SUSPENDED" then
+              compute.attributes!.occi!.compute!.state = "suspended"
+              compute.links << OCCI::Core::Link.new(:target=>compute.location + '?action=start',:rel=>'http://schemas.ogf.org/occi/infrastructure/compute/action#start')
+            when "FAIL" then
+              compute.attributes!.occi!.compute!.state = "error"
+              compute.links << OCCI::Core::Link.new(:target=>compute.location + '?action=start',:rel=>'http://schemas.ogf.org/occi/infrastructure/compute/action#start')
+            else
+              compute.attributes!.occi!.compute!.state = "inactive"
+              compute.links << OCCI::Core::Link.new(:target=>compute.location + '?action=start',:rel=>'http://schemas.ogf.org/occi/infrastructure/compute/action#start')
+          end
+        end
+
+        # ---------------------------------------------------------------------------------------------------------------------
+        def compute_delete(compute)
+          backend_object=VirtualMachine.new(VirtualMachine.build_xml(compute.backend[:id]), @one_client)
+
+          rc = backend_object.finalize
+          check_rc(rc)
+          # TODO: VNC
+          #OCCI::Log.debug("killing NoVNC pipe with pid #{compute.backend[:novnc_pipe].pid}") unless compute.backend[:novnc_pipe].nil?
+          #Process.kill 'INT', compute.backend[:novnc_pipe].pid unless compute.backend[:novnc_pipe].nil?
+        end
+
+        # ---------------------------------------------------------------------------------------------------------------------
+        # GET ALL COMPUTE INSTANCES
+        def compute_register_all_instances
+          backend_object_pool = VirtualMachinePool.new(@one_client)
+          backend_object_pool.info(OCCI::Backend::OpenNebula::OpenNebula::INFO_ACL, -1, -1, OpenNebula::VirtualMachinePool::INFO_NOT_DONE)
+          compute_register_all_objects(backend_object_pool)
+        end
+
+        # ---------------------------------------------------------------------------------------------------------------------
+        # GET ALL COMPUTE TEMPLATES
+        def compute_register_all_templates
+          backend_object_pool = TemplatePool.new(@one_client, INFO_ACL)
+          backend_object_pool.info
+          compute_register_all_objects(backend_object_pool, template = true)
+        end
+
+        # ---------------------------------------------------------------------------------------------------------------------
+        # GET ALL COMPUTE OBJECTS
+        def compute_register_all_objects(backend_object_pool, template = false)
+          backend_object_pool.each { |backend_object| compute_parse_backend_object(backend_object) }
+        end
+
+        # ---------------------------------------------------------------------------------------------------------------------
+        # COMPUTE ACTIONS
+        # ---------------------------------------------------------------------------------------------------------------------
+
+        # ---------------------------------------------------------------------------------------------------------------------
+        def compute_action_dummy(compute, parameters)
+        end
+
+        # ---------------------------------------------------------------------------------------------------------------------
+        # COMPUTE Action start
+        def compute_start(compute, parameters)
+          backend_object = VirtualMachine.new(VirtualMachine.build_xml(compute.backend[:id]), @one_client)
+          rc = backend_object.resume
+          check_rc(rc)
+        end
+
+        # ---------------------------------------------------------------------------------------------------------------------
+        # Action stop
+        def compute_stop(compute, parameters)
+          backend_object = VirtualMachine.new(VirtualMachine.build_xml(compute.backend[:id]), @one_client)
+          # TODO: implement parameters when available in OpenNebula
+          case parameters
+            when 'method="graceful"'
+              OCCI::Log.debug("Trying to stop VM graceful")
+              rc = backend_object.shutdown
+            when 'method="acpioff"'
+              OCCI::Log.debug("Trying to stop VM via ACPI off")
+              rc = backend_object.shutdown
+            else # method="poweroff" or no method specified
+              OCCI::Log.debug("Powering off VM")
+              rc = backend_object.shutdown
+          end
+          check_rc(rc)
+        end
+
+        # ---------------------------------------------------------------------------------------------------------------------
+        # Action restart
+        def compute_restart(compute, parameters)
+          backend_object = VirtualMachine.new(VirtualMachine.build_xml(compute.backend[:id]), @one_client)
+          # TODO: implement parameters when available in OpenNebula
+          case parameters
+            when "graceful"
+              rc = vm.reboot
+            when "warm"
+              rc = vm.reboot
+            else # "cold" or no parameter specified
+              rc = vm.resubmit
+          end
+          check_rc(rc)
+        end
+
+        # ---------------------------------------------------------------------------------------------------------------------
+        # Action suspend
+        def compute_suspend(compute, parameters)
+          backend_object = VirtualMachine.new(VirtualMachine.build_xml(compute.backend[:id]), @one_client)
+          rc = vm.suspend
+          check_rc(rc)
+        end
+
+      end
+    end
+  end
+end