occi 1.2.1 → 2.0.0

data/lib/occi/antlr/README.md

@@ -0,0 +1,2 @@
+occi-antlr-ruby
+===============

data/lib/occi/backend/dummy.rb

@@ -0,0 +1,232 @@
+##############################################################################
+#  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: Dummy Backend
+# Author(s): Hayati Bice, Florian Feldhaus, Piotr Kasprzak
+##############################################################################
+
+require 'occi/backend/manager'
+require 'hashie/hash'
+require 'occi/log'
+require 'uuidtools'
+require 'pstore'
+
+module OCCI
+  module Backend
+
+    # ---------------------------------------------------------------------------------------------------------------------         
+    class Dummy
+
+      def initialize
+        @store = PStore.new('collection')
+        @store.transaction do
+          @store['resources'] ||= []
+          @store['links'] ||= []
+        end
+      end
+
+      # ---------------------------------------------------------------------------------------------------------------------     
+      # Operation mappings
+
+      OPERATIONS = {}
+
+      OPERATIONS["http://schemas.ogf.org/occi/infrastructure#compute"] = {
+
+          # Generic resource operations
+          :deploy => :compute_deploy,
+          :update_state => :resource_update_state,
+          :delete => :resource_delete,
+
+          # network specific resource operations
+          :start => :compute_action_start,
+          :stop => :compute_action_stop,
+          :restart => :compute_action_restart,
+          :suspend => :compute_action_suspend
+      }
+
+      OPERATIONS["http://schemas.ogf.org/occi/infrastructure#network"] = {
+
+          # Generic resource operations
+          :deploy => :network_deploy,
+          :update_state => :resource_update_state,
+          :delete => :resource_delete,
+
+          # Network specific resource operations
+          :up => :network_action_up,
+          :down => :network_action_down
+      }
+
+      OPERATIONS["http://schemas.ogf.org/occi/infrastructure#storage"] = {
+
+          # Generic resource operations
+          :deploy => :storage_deploy,
+          :update_state => :resource_update_state,
+          :delete => :resource_delete,
+
+          # Network specific resource operations
+          :online => :storage_action_online,
+          :offline => :storage_action_offline,
+          :backup => :storage_action_backup,
+          :snapshot => :storage_action_snapshot,
+          :resize => :storage_action_resize
+      }
+
+      # ---------------------------------------------------------------------------------------------------------------------
+      def register_existing_resources
+        @store.transaction(read_only=true) do
+          entities = @store['resources'] + @store['links']
+          entities.each do |entity|
+            kind = OCCI::Registry.get_by_id(entity.kind)
+            kind.entities << entity
+            OCCI::Log.debug("#### Number of entities in kind #{kind.type_identifier}: #{kind.entities.size}")
+          end
+        end
+      end
+
+      # TODO: register user defined mixins
+
+      def compute_deploy(compute)
+        compute.id = UUIDTools::UUID.timestamp_create.to_s
+        compute_action_start(compute)
+        store(compute)
+      end
+
+      def storage_deploy(storage)
+        storage.id = UUIDTools::UUID.timestamp_create.to_s
+        storage_action_online(storage)
+        store(storage)
+      end
+
+      def network_deploy(network)
+        network.id = UUIDTools::UUID.timestamp_create.to_s
+        network_action_up(network)
+        store(network)
+      end
+
+      # ---------------------------------------------------------------------------------------------------------------------     
+      def store(resource)
+        OCCI::Log.debug("### DUMMY: Deploying resource with id #{resource.id}")
+        @store.transaction do
+          @store['resources'].delete_if { |res| res.id == resource.id }
+          @store['resources'] << resource
+        end
+      end
+
+      # ---------------------------------------------------------------------------------------------------------------------     
+      def resource_update_state(resource)
+        OCCI::Log.debug("Updating state of resource '#{resource.attributes['occi.core.title']}'...")
+      end
+
+      # ---------------------------------------------------------------------------------------------------------------------     
+      def resource_delete(resource)
+        OCCI::Log.debug("Deleting resource '#{resource.attributes['occi.core.title']}'...")
+        @store.transaction do
+          @store['resources'].delete_if { |res| res.id == resource.id }
+        end
+      end
+
+      # ---------------------------------------------------------------------------------------------------------------------
+      # ACTIONS
+      # ---------------------------------------------------------------------------------------------------------------------
+
+      def compute_action_start(compute, parameters=nil)
+        action_dummy(compute)
+        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#start')
+        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')
+        store(compute)
+      end
+
+      def compute_action_stop(compute, parameters=nil)
+        action_dummy(compute)
+        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')
+        store(compute)
+      end
+
+      def compute_action_restart(compute, parameters=nil)
+        compute_action_start(compute)
+      end
+
+      def compute_action_suspend(compute, parameters=nil)
+        action_dummy(compute)
+        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')
+        store(compute)
+      end
+
+      def storage_action_online(storage, parameters=nil)
+        action_dummy(storage)
+        storage.attributes!.occi!.storage!.state = 'online'
+        storage.links << OCCI::Core::Link.new(:target => storage.location + '?action=offline', :rel => 'http://schemas.ogf.org/occi/infrastructure/storage/action#offline')
+        storage.links << OCCI::Core::Link.new(:target => storage.location + '?action=backup', :rel => 'http://schemas.ogf.org/occi/infrastructure/storage/action#restart')
+        storage.links << OCCI::Core::Link.new(:target => storage.location + '?action=snapshot', :rel => 'http://schemas.ogf.org/occi/infrastructure/storage/action#suspend')
+        storage.links << OCCI::Core::Link.new(:target => storage.location + '?action=resize', :rel => 'http://schemas.ogf.org/occi/infrastructure/storage/action#resize')
+        store(storage)
+      end
+
+      def storage_action_offline(storage, parameters=nil)
+        action_dummy(storage)
+        storage.attributes!.occi!.storage!.state = 'offline'
+        storage.links << OCCI::Core::Link.new(:target => storage.location + '?action=online', :rel => 'http://schemas.ogf.org/occi/infrastructure/storage/action#online')
+        storage.links << OCCI::Core::Link.new(:target => storage.location + '?action=backup', :rel => 'http://schemas.ogf.org/occi/infrastructure/storage/action#restart')
+        storage.links << OCCI::Core::Link.new(:target => storage.location + '?action=snapshot', :rel => 'http://schemas.ogf.org/occi/infrastructure/storage/action#suspend')
+        storage.links << OCCI::Core::Link.new(:target => storage.location + '?action=resize', :rel => 'http://schemas.ogf.org/occi/infrastructure/storage/action#resize')
+        store(storage)
+      end
+
+      def storage_action_backup(storage, parameters=nil)
+        # nothing to do, state and actions stay the same after the backup which is instant for the dummy
+      end
+
+      def storage_action_snapshot(storage, parameters=nil)
+        # nothing to do, state and actions stay the same after the snapshot which is instant for the dummy
+      end
+
+      def storage_action_resize(storage, parameters=nil)
+        puts "Parameters: #{parameters}"
+        storage.attributes!.occi!.storage!.size = parameters[:size].to_i
+        # state and actions stay the same after the resize which is instant for the dummy
+        store(storage)
+      end
+
+      def network_action_up(network, parameters=nil)
+        action_dummy(network)
+        network.attributes!.occi!.network!.state = 'up'
+        network.links << OCCI::Core::Link.new(:target => network.location + '?action=down', :rel => 'http://schemas.ogf.org/occi/infrastructure/network/action#down')
+        store(network)
+      end
+
+      def network_action_down(network, parameters=nil)
+        action_dummy(network)
+        network.attributes!.occi!.network!.state = 'down'
+        network.links << OCCI::Core::Link.new(:target => network.location + '?action=up', :rel => 'http://schemas.ogf.org/occi/infrastructure/network/action#up')
+        store(network)
+      end
+
+      # ---------------------------------------------------------------------------------------------------------------------     
+      def action_dummy(resource, parameters=nil)
+        OCCI::Log.debug("Calling method for resource '#{resource.attributes['occi.core.title']}' with parameters: #{parameters.inspect}")
+        resource.links ||= []
+        resource.links.delete_if { |link| link.rel.include? 'action' }
+      end
+
+    end
+
+  end
+end

data/lib/occi/backend/ec2/Compute.rb

@@ -0,0 +1,310 @@
+##############################################################################
+#  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: EC2 Backend
+# Author(s): Max Guenther
+##############################################################################
+
+require 'aws-sdk'
+require 'occi/log'
+
+module OCCI
+  module Backend
+    module EC2
+
+      # ---------------------------------------------------------------------------------------------------------------------
+      module Compute
+
+        # ---------------------------------------------------------------------------------------------------------------------       
+        private
+        # ---------------------------------------------------------------------------------------------------------------------
+
+        def get_backend_instance(compute)
+          # get the ec2 interface
+          ec2 = OCCI::Backend::EC2.get_ec2_interface()
+
+          # get the ec2 backend instance
+          backend_instance = ec2.instances[compute.backend[:id]]
+
+          raise "Problems refreshing compute instance: An instance with the EC2 ID #{compute.backend[:id]} could not be found." if backend_instance.nil?
+          # return the instance
+          return backend_instance
+        end
+
+        def has_console_link(compute)
+          compute.links.each do |link|
+            OCCI::Log.debug("Link: #{link}")
+            if link.kind.term == "console"
+              return true
+            end
+          end
+          return false
+        end
+
+        def key_pair_exists(key_name)
+          ec2 = OCCI::Backend::EC2.get_ec2_interface()
+
+          ec2.key_pairs.each do |key|
+            if key.name == "default_occi_key"
+              return true
+            end
+          end
+          return false
+        end
+
+        public
+        # ---------------------------------------------------------------------------------------------------------------------
+
+        # ---------------------------------------------------------------------------------------------------------------------     
+        def compute_deploy(compute)
+          OCCI::Log.debug("Deploying EC2 instance.")
+
+          # look what template and instance type to use
+          image_id = "ami-973b06e3" # fallback os template
+          instance_type = "t1.micro" # fallback resource template
+          compute.mixins.each do |mixin|
+            mixin.related.each do |related|
+              if related.term == "os_tpl"
+                image_id = mixin.term
+                break # use the first template found
+              elsif related.term == "resource_tpl"
+                instance_type = mixin.term
+                break # use the first template found
+              end
+            end
+          end
+
+          # get the ec2 interface
+          ec2 = OCCI::Backend::EC2.get_ec2_interface()
+
+          # create an instance
+          if key_pair_exists("default_occi_key")
+            backend_instance = ec2.instances.create(:image_id => image_id,
+                                                    :instance_type => instance_type,
+                                                    :key_name => "default_occi_key")
+          else
+            backend_instance = ec2.instances.create(:image_id => image_id,
+                                                    :instance_type => instance_type)
+          end
+
+          # save the id of the instance
+          compute.backend[:id] = backend_instance.id
+
+          # link it to the private ec2 network
+          OCCI::Log.debug("Linking instance to \"/network/ec2_private_network\".")
+          private_network = OCCI::Rendering::HTTP::LocationRegistry.get_object("/network/ec2_private_network")
+          attributes = OCCI::Core::Attributes.new()
+          attributes["occi.networkinterface.interface"] = ""
+          attributes["occi.core.source"] = compute.get_location
+          attributes["occi.core.target"] = "/network/ec2_private_network"
+          ipnetwork = OCCI::CategoryRegistry.get_by_id("http://schemas.ogf.org/occi/infrastructure/networkinterface#ipnetworkinterface")
+          ipnetwork.backend[:network] = "private"
+          mixins = [ipnetwork]
+          private_networkinterface = OCCI::Infrastructure::Networkinterface.new(attributes, mixins)
+          # save the id of the compute backend instance in the network link for future identification
+          private_networkinterface.backend[:backend_id] = backend_instance.id
+          private_networkinterface.backend[:network] = "ec2_private_network"
+          compute.links << private_networkinterface
+          private_network.links << private_networkinterface
+          OCCI::Rendering::HTTP::LocationRegistry.register(private_networkinterface.get_location, private_networkinterface)
+
+          # link it to the public ec2 network
+          OCCI::Log.debug("Linking instance to \"/network/ec2_public_network\".")
+          public_network = OCCI::Rendering::HTTP::LocationRegistry.get_object("/network/ec2_public_network")
+          attributes = OCCI::Core::Attributes.new()
+          attributes["occi.networkinterface.interface"] = ""
+          attributes["occi.core.source"] = compute.get_location
+          attributes["occi.core.target"] = "/network/ec2_public_network"
+          ipnetwork = OCCI::CategoryRegistry.get_by_id("http://schemas.ogf.org/occi/infrastructure/networkinterface#ipnetworkinterface")
+          ipnetwork.backend[:network] = "ec2_public_network"
+          mixins = [ipnetwork]
+          public_networkinterface = OCCI::Infrastructure::Networkinterface.new(attributes, mixins)
+          # save the id of the compute backend instance in the network link for future identification
+          public_networkinterface.backend[:backend_id] = backend_instance.id
+          public_networkinterface.backend[:network] = "public"
+          compute.links << public_networkinterface
+          public_network.links << public_networkinterface
+          OCCI::Rendering::HTTP::LocationRegistry.register(public_networkinterface.get_location, public_networkinterface)
+
+          OCCI::Log.debug("Deployed EC2 instance with EC2 ID: #{compute.backend[:id]}")
+        end
+
+        # ---------------------------------------------------------------------------------------------------------------------     
+        def compute_refresh(compute)
+          OCCI::Log.debug("Refreshing EC2 compute object with backend ID: #{compute.backend[:id]}")
+
+          # get the ec2 backend instance
+          backend_instance = get_backend_instance(compute)
+
+          # check if there are any problems with the backend instance
+          if backend_instance.nil?
+            OCCI::Log.debug("Problems refreshing compute instance: An instance with the EC2 ID #{compute.backend[:id]} could not be found.")
+            return
+          end
+
+          # update the state
+          compute_update_state(compute)
+          OCCI::Log.debug("Refreshed EC2 compute object with backend ID: #{compute.backend[:id]}")
+
+          # setting the architecture
+          compute.attributes["occi.compute.architecture"] = backend_instance.architecture.to_s
+          compute.attributes["ec2.compute.platform"] = backend_instance.platform
+          compute.attributes["ec2.compute.kernel_id"] = backend_instance.kernel_id
+
+          # update public and private ip
+          compute.links.each do |link|
+            if link.kind.term == "networkinterface" and link.backend[:backend_id] == backend_instance.id
+              if link.backend[:network] == "public" and backend_instance.ip_address != nil
+                link.mixins.each do |mixin|
+                  if mixin.backend[:network] == "ec2_public_network"
+                    link.attributes["occi.networkinterface.address"] = backend_instance.ip_address
+                    state = OCCI::Infrastructure::Networkinterface::STATE_ACTIVE
+                    link.state_machine.set_state(state)
+                    link.attributes['occi.networkinterface.state'] = "active"
+                  end
+                end
+              elsif link.backend[:network] == "private" and backend_instance.private_ip_address != nil
+                link.mixins.each do |mixin|
+                  if mixin.backend[:network] == "ec2_private_network"
+                    link.attributes["occi.networkinterface.address"] = backend_instance.private_ip_address
+                    state = OCCI::Infrastructure::Networkinterface::STATE_ACTIVE
+                    link.state_machine.set_state(state)
+                    link.attributes['occi.networkinterface.state'] = "active"
+                  end
+                end
+              end
+            end
+          end
+
+          # create the console link if not already existent and if in state active
+          if compute.state_machine.current_state == OCCI::Infrastructure::Compute::STATE_ACTIVE and not has_console_link(compute) and backend_instance.key_name == "default_occi_key"
+            # create a ConsoleLink
+            OCCI::Log.debug("Creating a ConsoleLink to the EC2 Compute instance.")
+            attributes = OCCI::Core::Attributes.new()
+            attributes['occi.core.target'] = "ssh://" + backend_instance.public_dns_name
+            attributes['occi.core.source'] = compute.get_location
+            mixins = []
+            console_link = OCCI::Infrastructure::ConsoleLink.new(attributes, mixins)
+            # save the id of the compute backend instance in the network link for future identification
+            console_link.backend[:backend_id] = backend_instance.id
+            # link and register
+            location = console_link.get_location
+            compute.links << console_link
+            OCCI::Rendering::HTTP::LocationRegistry.register(location, console_link)
+          end
+        end
+
+        # ---------------------------------------------------------------------------------------------------------------------     
+        def compute_update_state(compute)
+          # get the ec2 backend instance
+          backend_instance = get_backend_instance(compute)
+
+          # map the ec2 state to an OCCI state
+          OCCI::Log.debug("Current EC2 VM state is: #{backend_instance.status}")
+          state = case backend_instance.status
+                    when :running then
+                      OCCI::Infrastructure::Compute::STATE_ACTIVE
+                    when :pending, :shutting_down, :stopping, :terminated then
+                      OCCI::Infrastructure::Compute::STATE_INACTIVE
+                    when :stopped then
+                      OCCI::Infrastructure::Compute::STATE_SUSPENDED
+                    else
+                      OCCI::Infrastructure::Compute::STATE_INACTIVE
+                  end
+          # set the state
+          compute.state_machine.set_state(state)
+          compute.attributes['occi.compute.state'] = compute.state_machine.current_state.name
+        end
+
+        # ---------------------------------------------------------------------------------------------------------------------     
+        def compute_delete(compute)
+          OCCI::Log.debug("Deleting EC2 Compute instance with EC2 ID #{compute.backend[:id]}")
+
+          # get the ec2 backend instance
+          backend_instance = get_backend_instance(compute)
+
+          if backend_instance.nil?
+            OCCI::Log.debug("Problems refreshing compute instance: An instance with the EC2 ID #{compute.backend[:id]} could not be found.")
+            return
+          end
+          # terminate the instance
+          backend_instance.terminate()
+
+          # delete networklinks to the private and public network and the ConsoleLink
+          compute.links.each do |link|
+            if link.backend[:backend_id] == backend_instance.id
+              location = OCCI::Rendering::HTTP::LocationRegistry.get_location_of_object(link)
+              OCCI::Log.debug("Deleting link to #{location}")
+              OCCI::Rendering::HTTP::LocationRegistry.unregister(location)
+            end
+          end
+          OCCI::Log.debug("Deleted EC2 Compute instance with EC2 ID #{compute.backend[:id]}")
+        end
+
+        # ---------------------------------------------------------------------------------------------------------------------
+        # COMPUTE ACTIONS
+        # ---------------------------------------------------------------------------------------------------------------------     
+        # COMPUTE Action start
+        def compute_start(compute, parameters=nil)
+          OCCI::Log.debug("Starting EC2 VM with EC2 instance ID #{compute.backend[:id]}")
+
+          # get the ec2 backend instance
+          backend_instance = get_backend_instance(compute)
+
+          # suspend the instance (in EC2 lingo stop it)
+          backend_instance.start()
+          OCCI::Log.debug("Started EC2 VM with EC2 instance ID #{compute.backend[:id]}")
+        end
+
+        # ---------------------------------------------------------------------------------------------------------------------     
+        # Action stop
+        def compute_stop(compute, parameters=nil)
+          OCCI::Log.debug("Stopping EC2 VM with EC2 instance ID #{compute.backend[:id]}")
+
+          # get the ec2 backend instance
+          backend_instance = get_backend_instance(compute)
+
+          # stop the instance
+          backend_instance.stop()
+          OCCI::Log.debug("Stopped EC2 VM with EC2 instance ID #{compute.backend[:id]}")
+        end
+
+        # ---------------------------------------------------------------------------------------------------------------------     
+        # Action restart
+        def compute_restart(compute, parameters=nil)
+          OCCI::Log.debug("Restarting EC2 VM with EC2 instance ID #{compute.backend[:id]}")
+
+          # get the ec2 backend instance
+          backend_instance = get_backend_instance(compute)
+
+          # restart the instance
+          backend_instance.reboot()
+          OCCI::Log.debug("Restarted EC2 VM with EC2 instance ID #{compute.backend[:id]}")
+        end
+
+        # ---------------------------------------------------------------------------------------------------------------------     
+        # Action suspend
+        def compute_suspend(compute, parameters=nil)
+          OCCI::Log.warning("Stop suspend is not supported on EC2 Compute instances.")
+        end
+
+      end
+
+    end
+  end
+end
+