occi 2.0.1 → 2.0.2

data/lib/occi/version.rb

@@ -1,3 +1,3 @@
 module OCCI
-  VERSION = "2.0.1" unless defined?(::OCCI::VERSION)
+  VERSION = "2.0.2" unless defined?(::OCCI::VERSION)
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: occi
 version: !ruby/object:Gem::Version
-  version: 2.0.1
+  version: 2.0.2
   prerelease: 
 platform: ruby
 authors:
@@ -38,15 +38,6 @@ files:
 - lib/occi/antlr/OCCILexer.rb
 - lib/occi/antlr/OCCIParser.rb
 - lib/occi/antlr/README.md
-- lib/occi/backend/dummy.rb
-- lib/occi/backend/ec2/Compute.rb
-- lib/occi/backend/ec2/compute.rb
-- lib/occi/backend/ec2/ec2.rb
-- lib/occi/backend/manager.rb
-- lib/occi/backend/opennebula/compute.rb
-- lib/occi/backend/opennebula/network.rb
-- lib/occi/backend/opennebula/opennebula.rb
-- lib/occi/backend/opennebula/storage.rb
 - lib/occi/core/action.rb
 - lib/occi/core/attribute_properties.rb
 - lib/occi/core/attributes.rb
@@ -58,13 +49,6 @@ files:
 - lib/occi/core/mixin.rb
 - lib/occi/core/resource.rb
 - lib/occi/exceptions.rb
-- lib/occi/extensions/monitoring/cpu.rb
-- lib/occi/extensions/monitoring/memory.rb
-- lib/occi/extensions/monitoring/metric.rb
-- lib/occi/extensions/monitoring/netrx.rb
-- lib/occi/extensions/monitoring/nettx.rb
-- lib/occi/extensions/one/VNC.rb
-- lib/occi/extensions/one/vnc.rb
 - lib/occi/log.rb
 - lib/occi/parse.rb
 - lib/occi/registry.rb

data/lib/occi/backend/dummy.rb

@@ -1,232 +0,0 @@
-##############################################################################
-#  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

@@ -1,310 +0,0 @@
-##############################################################################
-#  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
-