steamcannon-deltacloud-core 0.1.1.3 → 0.1.2.1

data/bin/deltacloudd

@@ -36,6 +36,9 @@ BANNER
   opts.on( '-p', '--port PORT', 'Use PORT (default: 3001)') do |port|
     ENV["API_PORT"] = port
   end
+  opts.on( '-P', '--provider PROVIDER', 'Use PROVIDER (default is set in the driver)') do |provider|
+    ENV['API_PROVIDER'] = provider
+  end
   opts.on( '-e', '--env ENV', 'Environment (default: "development")') { |env| options[:env] = env }
   opts.on( '-h', '--help', '') { options[:help] = true }
 end
@@ -55,7 +58,10 @@ end
 ENV["API_HOST"] = "localhost" unless ENV["API_HOST"]
 ENV["API_PORT"] = "3001" unless ENV["API_PORT"]
 
-puts "Starting Deltacloud API :: #{ENV["API_DRIVER"]} :: http://#{ENV["API_HOST"]}:#{ENV["API_PORT"]}/api"
+msg = "Starting Deltacloud API :: #{ENV["API_DRIVER"]} "
+msg << ":: #{ENV['API_PROVIDER']} " if ENV['API_PROVIDER']
+msg << ":: http://#{ENV["API_HOST"]}:#{ENV["API_PORT"]}/api"
+puts msg
 puts
 
 dirname="#{File.dirname(__FILE__)}/.."

data/config.ru

@@ -1,7 +1,25 @@
+#
+# Copyright (C) 2009,2010  Red Hat, Inc.
+#
+# Licensed to the Apache Software Foundation (ASF) under one or more
+# contributor license agreements.  See the NOTICE file distributed with
+# this work for additional information regarding copyright ownership.  The
+# ASF licenses this file to you 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.
+
 require 'rubygems'
-require 'sinatra'
 
 $:.unshift File.join(File.dirname(__FILE__), '.')
 
 require 'server.rb'
+
 run Sinatra::Application

data/deltacloud.rb

@@ -1,6 +1,25 @@
-# Add ./lib into load path
+#
+# Copyright (C) 2009,2010  Red Hat, Inc.
+#
+# Licensed to the Apache Software Foundation (ASF) under one or more
+# contributor license agreements.  See the NOTICE file distributed with
+# this work for additional information regarding copyright ownership.  The
+# ASF licenses this file to you 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.
+
 $:.unshift File.join(File.dirname(__FILE__), 'lib')
 
+require 'drivers'
+
 require 'deltacloud/base_driver'
 require 'deltacloud/hardware_profile'
 require 'deltacloud/state_machine'

data/lib/deltacloud/backend_capability.rb

@@ -1,7 +1,26 @@
+#
+# Copyright (C) 2009, 2010  Red Hat, Inc.
+#
+# Licensed to the Apache Software Foundation (ASF) under one or more
+# contributor license agreements.  See the NOTICE file distributed with
+# this work for additional information regarding copyright ownership.  The
+# ASF licenses this file to you 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.
+
 module Deltacloud::BackendCapability
 
   class Failure < StandardError
     attr_reader :capability
+    
     def initialize(capability, msg='')
       super(msg)
       @capability = capability
@@ -9,13 +28,26 @@ module Deltacloud::BackendCapability
   end
 
   attr_reader :capability
+  
   def with_capability(capability)
     @capability = capability
   end
 
+  def has_capability?(backend)
+    !capability or backend.has_capability?(capability)
+  end
+
   def check_capability(backend)
-    if capability and !backend.respond_to?(capability)
+    if !has_capability?(backend)
       raise Failure.new(capability, "#{capability} capability not supported by backend #{backend.class.name}")
     end
   end
+
+  module Helpers
+    def operations_for_collection(collection)
+      collections[collection].operations.values.select { |op| op.has_capability?(driver) }
+    end
+  end
+
+  helpers Helpers
 end

data/lib/deltacloud/base_driver.rb

@@ -1,5 +1,5 @@
 #
-# Copyright (C) 2009  Red Hat, Inc.
+# Copyright (C) 2009,2010  Red Hat, Inc.
 #
 # Licensed to the Apache Software Foundation (ASF) under one or more
 # contributor license agreements.  See the NOTICE file distributed with

data/lib/deltacloud/base_driver/base_driver.rb

@@ -42,7 +42,7 @@ module Deltacloud
   end
 
   class BaseDriver
-
+    
     def self.define_hardware_profile(name,&block)
       @hardware_profiles ||= []
       hw_profile = @hardware_profiles.find{|e| e.name == name}
@@ -126,100 +126,90 @@ module Deltacloud
       actions
     end
 
+    ## Capabilities
+    # The rabbit dsl supports declaring a capability that is required
+    # in the backend driver for the call to succeed. A driver can
+    # provide a capability by implementing the method with the same
+    # name as the capability. Below is a list of the capabilities as
+    # the expected method signatures.
+    #
+    # Following the capability list are the resource member show
+    # methods. They each require that the corresponding collection
+    # method be defined
+    #
+    # TODO: standardize all of these to the same signature (credentials, opts)
+    #
+    # def realms(credentials, opts=nil)
+    #
+    # def images(credentials, ops)
+    #
+    # def instances(credentials, ops)
+    # def create_instance(credentials, image_id, opts)
+    # def start_instance(credentials, id)
+    # def stop_instance(credentials, id)
+    # def reboot_instance(credentials, id)
+    #
+    # def storage_volumes(credentials, ops)
+    #
+    # def storage_snapshots(credentials, ops)
+    # 
+    # def buckets(credentials, opts = nil)
+    # def create_bucket(credentials, name, opts=nil)
+    # def delete_bucket(credentials, name, opts=nil)
+    #
+    # def blobs(credentials, opts = nil)
+    # def blob_data(credentials, bucket_id, blob_id, opts)
+    # def create_blob(credentials, bucket_id, blob_id, blob_data, opts=nil)
+    # def delete_blob(credentials, bucket_id, blob_id, opts=nil)
+    #
+    # def keys(credentials, opts)
+    # def create_key(credentials, opts)
+    # def destroy_key(credentials, opts)
+    
     def realm(credentials, opts)
-      realms = realms(credentials, opts)
-      return realms.first unless realms.empty?
-      nil
-    end
-
-    def realms(credentials, opts=nil)
-      []
+      realms = realms(credentials, opts).first if has_capability?(:realms)
     end
 
     def image(credentials, opts)
-      images = images(credentials, opts)
-      return images.first unless images.empty?
-      nil
-    end
-
-    def images(credentials, ops)
-      []
+      images(credentials, opts).first if has_capability?(:images)
     end
 
     def instance(credentials, opts)
-      instances = instances(credentials, opts)
-      return instances.first unless instances.empty?
-      nil
-    end
-
-    def instances(credentials, ops)
-      []
-    end
-
-    def create_instance(credentials, image_id, opts)
-    end
-    def start_instance(credentials, id)
-    end
-    def stop_instance(credentials, id)
-    end
-    def reboot_instance(credentials, id)
+      instances(credentials, opts).first if has_capability?(:instances)
     end
 
     def storage_volume(credentials, opts)
-      volumes = storage_volumes(credentials, opts)
-      return volumes.first unless volumes.empty?
-      nil
-    end
-
-    def storage_volumes(credentials, ops)
-      []
+      storage_volumes(credentials, opts).first if has_capability?(:storage_volumes)
     end
 
     def storage_snapshot(credentials, opts)
-      snapshots = storage_snapshots(credentials, opts)
-      return snapshots.first unless snapshots.empty?
-      nil
-    end
-
-    def storage_snapshots(credentials, ops)
-      []
-    end
-
-    def buckets(credentials, opts = nil)
-      #list of buckets belonging to account
-      []
+      storage_snapshots(credentials, opts).first if has_capability?(:storage_snapshots)
     end
 
     def bucket(credentials, opts = nil)
-    #list of objects within bucket
-      list = buckets(credentials, opts)
-      return list.first unless list.empty?
-      nil
-    end
-
-    def create_bucket(credentials, name, opts=nil)
-    end
-
-    def delete_bucket(credentials, name, opts=nil)
+      #list of objects within bucket
+      buckets(credentials, opts).first if has_capability?(:buckets)
     end
-
-    def blobs(credentials, opts = nil)
-      []
-    end
-
+    
     def blob(credentials, opts = nil)
-       list = blobs(credentials, opts)
-       return list.first unless list.empty?
+      blobs(credentials, opts).first if has_capability?(:blobs)
     end
 
-    def blob_data(credentials, bucket_id, blob_id, opts)
+    def key(credentials, opts=nil)
+      keys(credentials, opts).first if has_capability?(:keys)
     end
 
-    def create_blob(credentials, bucket_id, blob_id, blob_data, opts=nil)  
-    end
+    MEMBER_SHOW_METHODS =
+      [ :realm, :image, :instance, :storage_volume, :bucket, :blob, :key ]
     
-    def delete_blob(credentials, bucket_id, blob_id, opts=nil)
+    def has_capability?(capability)
+      if MEMBER_SHOW_METHODS.include?(capability.to_sym)
+        has_capability?(capability.to_s.pluralize)
+      else
+        respond_to?(capability)
+      end
     end
+    
  
     def filter_on(collection, attribute, opts)
       return collection if opts.nil?
@@ -237,8 +227,7 @@ module Deltacloud
     end
 
     def has_collection?(collection)
-      return true if self.supported_collections.include?(collection)
-      return false
+      supported_collections.include?(collection)
     end
 
     def catched_exceptions_list

data/lib/deltacloud/base_driver/features.rb

@@ -117,6 +117,12 @@ module Deltacloud
       self.class.features[collection] || []
     end
 
+    def features_for_operation(collection, operation)
+      features(collection).select do |f|
+        f.operations.detect { |o| o.name == operation }
+      end
+    end
+    
     #
     # Declaration of optional features
     #
@@ -185,11 +191,5 @@ module Deltacloud
       end
     end
 
-    declare_feature :instances, :public_ip do
-      operation :create do
-        param :public_ip, :string, :optional
-      end
-    end
-
   end
 end

data/lib/deltacloud/drivers/azure/azure_driver.rb

@@ -17,8 +17,9 @@
 # under the License.
 
 #Windows Azure (WAZ) gem at http://github.com/johnnyhalife/waz-storage
-require 'waz-blobs'
 require 'deltacloud/base_driver'
+require 'waz-blobs'
+
 module Deltacloud
   module Drivers
     module Azure
@@ -46,6 +47,9 @@ class AzureDriver < Deltacloud::BaseDriver
 # Create bucket
 #--
   def create_bucket(credentials, name, opts)
+    #for whatever reason, bucket names MUST be lowercase...
+    #http://msdn.microsoft.com/en-us/library/dd135715.aspx
+    name.downcase!
     bucket = nil
     azure_connect(credentials)
     safely do
@@ -87,6 +91,33 @@ class AzureDriver < Deltacloud::BaseDriver
       yield WAZ::Blobs::Container.find(bucket_id)[blob_id].value
   end
 
+#--
+# Create Blob
+#--
+  def create_blob(credentials, bucket_id, blob_id, blob_data, opts=nil)
+    azure_connect(credentials)
+    #get a handle to the bucket in order to put there
+    the_bucket = WAZ::Blobs::Container.find(bucket_id)
+    the_bucket.store(blob_id, blob_data[:tempfile], blob_data[:type])
+    Blob.new( { :id => blob_id,
+                :bucket => bucket_id,
+                :content_lengh => blob_data[:tempfile].length,
+                :content_type => blob_data[:type],
+                :last_modified => ''
+            } )
+  end
+
+#--
+# Delete Blob
+#--
+  def delete_blob(credentials, bucket_id, blob_id, opts=nil)
+    azure_connect(credentials)
+    #get a handle to bucket and blob, and destroy!
+    the_bucket = WAZ::Blobs::Container.find(bucket_id)
+    the_blob = the_bucket[blob_id]
+    the_blob.destroy!
+  end
+
   private
 
   def azure_connect(credentials)

data/lib/deltacloud/drivers/ec2/ec2_driver.rb

@@ -1,5 +1,4 @@
-#
-# Copyright (C) 2010  Red Hat, Inc.
+# Copyright (C) 2009, 2010  Red Hat, Inc.
 #
 # Licensed to the Apache Software Foundation (ASF) under one or more
 # contributor license agreements.  See the NOTICE file distributed with
@@ -41,11 +40,12 @@ module Deltacloud
 
         feature :instances, :user_data
         feature :instances, :authentication_key
-        feature :instances, :public_ip
         feature :instances, :security_group
         feature :images, :owner_id
         feature :buckets, :bucket_location
 
+        DEFAULT_REGION = 'us-east-1'
+
         define_hardware_profile('t1.micro') do
           cpu                1
           memory             0.63 * 1024
@@ -121,14 +121,6 @@ module Deltacloud
           stopped.to( :finish )         .automatically
         end
 
-        def valid_credentials?(credentials)
-          # FIXME: We need to do this call to determine if
-          #        EC2 is working with given credentials. There is no
-          #        other way to check, if given credentials are valid or not.
-          realms = realms(credentials) rescue false
-          return realms ? true : false
-        end
-        
         def images(credentials, opts={})
           ec2 = new_client(credentials)
           img_arr = []
@@ -168,6 +160,16 @@ module Deltacloud
             inst_arr = ec2.describe_instances.collect do |instance| 
               convert_instance(instance) if instance
             end.flatten
+            tags = ec2.describe_tags(
+              'Filter.1.Name' => 'resource-type', 'Filter.1.Value' => 'instance'
+            )
+            inst_arr.each do |inst|
+              name_tag = tags.select { |t| (t[:aws_resource_id] == inst.id) and t[:aws_key] == 'name' }
+              unless name_tag.empty?
+                inst.name = name_tag.first[:aws_value]
+              end
+            end
+            delete_unused_tags(credentials, inst_arr.collect {|inst| inst.id})
           end
           inst_arr = filter_on( inst_arr, :id, opts )
           filter_on( inst_arr, :state, opts )
@@ -183,8 +185,8 @@ module Deltacloud
           instance_options.merge!(:group_ids => opts[:security_group]) if opts[:security_group]
           safely do
             new_instance = convert_instance(ec2.launch_instances(image_id, instance_options).first)
-            if opts[:public_ip]
-              ec2.associate_address(new_instance.id, opts[:public_ip])
+            if opts[:name]
+              tag_instance(credentials, new_instance, opts[:name])
             end
             new_instance
           end
@@ -202,7 +204,9 @@ module Deltacloud
         def destroy_instance(credentials, instance_id)
           ec2 = new_client(credentials)
           puts "Terminating instance #{instance_id}"
+          instance_id = instance_id
           if ec2.terminate_instances([instance_id])
+            untag_instance(credentials, instance_id)
             instance(credentials, instance_id)
           else
             raise Deltacloud::BackendError.new(500, "Instance", "Instance cannot be terminated", "")
@@ -221,10 +225,6 @@ module Deltacloud
           end
         end
 
-        def key(credentials, opts={})
-          keys(credentials, :id => opts[:id]).first
-        end
-
         def create_key(credentials, opts={})
           ec2 = new_client(credentials)
           safely do
@@ -319,14 +319,18 @@ module Deltacloud
         #--  
         def delete_blob(credentials, bucket_id, blob_id, opts=nil)
           s3_client = new_client(credentials, :s3)
-          s3_client.interface.delete(bucket_id, blob_id)
+          safely do
+            s3_client.interface.delete(bucket_id, blob_id)
+          end
         end
 
 
         def blob_data(credentials, bucket_id, blob_id, opts)
           s3_client = new_client(credentials, :s3)
-          s3_client.interface.get(bucket_id, blob_id) do |chunk|
-            yield chunk
+          safely do
+            s3_client.interface.get(bucket_id, blob_id) do |chunk|
+              yield chunk
+            end
           end
         end
 
@@ -401,12 +405,82 @@ module Deltacloud
           end
         end
 
+        def valid_credentials?(credentials)
+          retval = true
+          begin
+            realms(credentials)
+          rescue Deltacloud::BackendError
+            retval = false
+          end
+          retval
+        end
+
         private
 
         def new_client(credentials, type = :ec2)
-          case type
-            when :ec2 then Aws::Ec2.new(credentials.user, credentials.password)
-            when :s3 then Aws::S3.new(credentials.user, credentials.password)
+          klass = case type
+                    when :elb then Aws::Elb
+                    when :ec2 then Aws::Ec2
+                    when :s3 then Aws::S3
+                  end
+          klass.new(credentials.user, credentials.password, :server => endpoint_for_service(type))
+        end
+
+        DEFAULT_SERVICE_ENDPOINTS = {
+          'ec2' => {
+            'ap-southeast-1' => 'ec2.ap-southeast-1.amazonaws.com',
+            'eu-west-1' => 'ec2.eu-west-1.amazonaws.com',
+            'us-east-1' => 'ec2.us-east-1.amazonaws.com',
+            'us-west-1' => 'ec2.us-west-1.amazonaws.com'
+          },
+          
+          'elb' => {
+            'ap-southeast-1' => 'elasticloadbalancing.ap-southeast-1.amazonaws.com',
+            'eu-west-1' => 'elasticloadbalancing.eu-west-1.amazonaws.com',
+            'us-east-1' => 'elasticloadbalancing.us-east-1.amazonaws.com',
+            'us-west-1' => 'elasticloadbalancing.us-west-1.amazonaws.com'
+          },
+          
+          's3' => {
+            'ap-southeast-1' => 's3.amazonaws.com',
+            'eu-west-1' => 's3.amazonaws.com',
+            'us-east-1' => 's3.amazonaws.com',
+            'us-west-1' => 's3.amazonaws.com'
+          }
+        }
+
+        def endpoint_for_service(service)
+          endpoint = (Thread.current[:provider] || ENV['API_PROVIDER'] || DEFAULT_REGION)
+          # return the endpoint if it does not map to a default endpoint, allowing
+          # the endpoint to be a full hostname instead of a region.
+          DEFAULT_SERVICE_ENDPOINTS[service.to_s][endpoint] || endpoint
+        end
+
+        def tag_instance(credentials, instance, name)
+          ec2 = new_client(credentials)
+          safely do
+            ec2.create_tag(instance.id, 'name', name)
+          end
+        end
+
+        def untag_instance(credentials, instance_id)
+          ec2 = new_client(credentials)
+          safely do
+            ec2.delete_tag(instance_id, 'name')
+          end
+        end
+
+        def delete_unused_tags(credentials, inst_ids)
+          ec2 = new_client(credentials)
+          tags = []
+          safely do
+            tags = ec2.describe_tags('Filter.1.Name' => 'resource-type', 'Filter.1.Value' => 'instance')
+            tags.collect! { |t| t[:aws_resource_id] }
+            inst_ids.each do |inst_id|
+              unless tags.include?(inst_id)
+                ec2.delete_tag(inst_id, 'name')
+              end
+            end
           end
         end
         
@@ -425,6 +499,16 @@ module Deltacloud
           )
         end
 
+        def convert_object(s3_object)
+          Blob.new(
+            :id => s3_object.name,
+            :bucket => s3_object.bucket.name.to_s,
+            :content_length => s3_object.headers['content-length'],
+            :content_type => s3_object.headers['content-type'],
+            :last_modified => s3_object.last_modified
+          )  
+        end
+
         def convert_realm(realm)
           Realm.new(
             :id => realm[:zone_name],