occi 1.2.1 → 2.0.0

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
+

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

@@ -0,0 +1,215 @@
+##############################################################################
+#  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
+##############################################################################
+
+# Amazon Webservices SDK
+require 'aws-sdk'
+
+# EC2 backend
+#require 'occi/backend/ec2/Compute'
+
+# for XML parsing (gem = "xml-simple")
+require 'xmlsimple'
+
+require 'occi/log'
+
+
+module OCCI
+  module Backend
+    module EC2
+      # ---------------------------------------------------------------------------------------------------------------------
+
+      #begin
+      #  ### Create networks
+      #  # Create private network
+      #  attributes = OCCI::Core::Attributes.new()
+      #  attributes['occi.core.title'] = "ec2_private_network"
+      #  attributes['occi.core.summary'] = "This network contains private links to all EC2 compute instances."
+      #  mixins = []
+      #  private_network = OCCI::Infrastructure::Network.new(attributes, mixins)
+      #  OCCI::Rendering::HTTP::LocationRegistry.register("/network/ec2_private_network", private_network)
+      #  private_network.state_machine.set_state(OCCI::Infrastructure::Network::STATE_ACTIVE)
+      #  private_network.attributes['occi.network.state'] = "active"
+      #
+      #  # Create public network
+      #  attributes = OCCI::Core::Attributes.new()
+      #  attributes['occi.core.title'] = "ec2_public_network"
+      #  attributes['occi.core.summary'] = "This network contains public links to all EC2 compute instances."
+      #  mixins = []
+      #  public_network = OCCI::Infrastructure::Network.new(attributes, mixins)
+      #  OCCI::Rendering::HTTP::LocationRegistry.register("/network/ec2_public_network", public_network)
+      #  public_network.state_machine.set_state(OCCI::Infrastructure::Network::STATE_ACTIVE)
+      #  public_network.attributes['occi.network.state'] = "active"
+      #end
+
+      public
+
+      def self.get_ec2_interface
+        ec2 = AWS::EC2.new
+        return ec2.regions[OCCI::Server.config["avail_zone"]]
+      end
+
+      class EC2
+
+        #include Compute
+
+        # ---------------------------------------------------------------------------------------------------------------------     
+        # Operation mappings
+
+
+        OPERATIONS = {}
+
+        OPERATIONS["http://schemas.ogf.org/occi/infrastructure#compute"] = {
+
+            # Generic resource operations
+            :deploy => :compute_deploy,
+            :update_state => :compute_update_state,
+            :refresh => :compute_refresh,
+            :delete => :compute_delete,
+
+            # Compute specific resource operations
+            :start => :compute_start,
+            :stop => :compute_stop,
+            :restart => :compute_restart,
+            :suspend => nil
+        }
+
+        OPERATIONS["http://schemas.ogf.org/occi/infrastructure#network"] = {
+
+            # Generic resource operations
+            :deploy => nil,
+            :update_state => nil,
+            :refresh => nil,
+            :delete => nil,
+
+            # Network specific resource operations
+            :up => nil,
+            :down => nil
+        }
+
+        OPERATIONS["http://schemas.ogf.org/occi/infrastructure#storage"] = {
+
+            # Generic resource operations
+            :deploy => nil,
+            :update_state => nil,
+            :refresh => nil,
+            :delete => nil,
+
+            # Network specific resource operations
+            :online => nil,
+            :offline => nil,
+            :backup => nil,
+            :snapshot => nil,
+            :resize => nil
+        }
+
+        OPERATIONS["http://schemas.ogf.org/gwdg#nfsstorage"] = {
+
+            # Generic resource operations
+            :deploy => nil,
+            :update_state => nil,
+            :refresh => nil,
+            :delete => nil
+        }
+
+        # ---------------------------------------------------------------------------------------------------------------------
+
+        def initialize(access_key_id, secret_access_key)
+          # EC2 access key
+          AWS.config(
+              :access_key_id => access_key_id,
+              :secret_access_key => secret_access_key)
+        end
+
+        def register_templates
+          OCCI::Log.debug("Loading EC2 templates.")
+
+          # import Compute Resource Templates from etc/ec2_templates/resource_templates.xml
+          xml = XmlSimple.xml_in("etc/ec2_templates/resource_templates.xml")
+          xml["instance"].each do |instance|
+            term = instance["term"][0]
+            scheme = "http://mycloud.org/templates/compute#"
+            title = instance["title"][0]
+            attributes = OCCI::Core::Attributes.new()
+            actions = []
+            entities = []
+            related = [OCCI::Infrastructure::ResourceTemplate::MIXIN]
+            mixin = OCCI::Core::Mixin.new(term, scheme, title, attributes, actions, related, entities)
+            OCCI::CategoryRegistry.register(mixin)
+          end
+
+          ## import image templates
+          # get the ec2 interface
+          ec2 = OCCI::Backend::EC2.get_ec2_interface()
+          # register each image
+          ec2.images.each do |image|
+            term = image.id
+            scheme = "http://mycloud.org/templates/os#"
+            title = image.name
+            attributes = OCCI::Core::Attributes.new()
+            actions = []
+            entities = []
+            related = [OCCI::Infrastructure::OSTemplate::MIXIN]
+            mixin = OCCI::Core::Mixin.new(term, scheme, title, attributes, actions, related, entities)
+            OCCI::CategoryRegistry.register(mixin)
+          end
+          OCCI::Log.debug("Finished loading EC2 templates.")
+        end
+
+
+        # ---------------------------------------------------------------------------------------------------------------------     
+        def register_existing_resources
+
+        end
+
+        # ---------------------------------------------------------------------------------------------------------------------
+        def resource_deploy(resource)
+          OCCI::Log.debug("Deploying resource '#{resource.attributes['occi.core.title']}'...")
+        end
+
+        # ---------------------------------------------------------------------------------------------------------------------     
+        def resource_refresh(resource)
+          OCCI::Log.debug("Refreshing resource '#{resource.attributes['occi.core.title']}'...")
+        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']}'...")
+        end
+
+        # ---------------------------------------------------------------------------------------------------------------------
+        # ACTIONS
+        # ---------------------------------------------------------------------------------------------------------------------
+
+        # ---------------------------------------------------------------------------------------------------------------------     
+        def action_dummy(compute, parameters)
+          OCCI::Log.debug("Calling method for resource '#{resource.attributes['occi.core.title']}' with parameters: #{parameters.inspect}")
+        end
+
+      end
+
+    end
+  end
+end