deltacloud-core 0.4.1 → 0.5.0

data/lib/deltacloud/base_driver/base_driver.rb

@@ -14,7 +14,7 @@
 # License for the specific language governing permissions and limitations
 # under the License.
 
-require 'lib/deltacloud/base_driver/exceptions'
+require 'deltacloud/base_driver/exceptions'
 
 module Deltacloud
 
@@ -22,6 +22,10 @@ module Deltacloud
 
     include ExceptionHandler
 
+    def name
+      self.class.name.split('::').last.gsub('Driver', '').downcase
+    end
+
     def self.exceptions(&block)
       ExceptionHandler::exceptions(&block)
     end
@@ -155,6 +159,7 @@ module Deltacloud
     # def delete_firewall(credentials, opts)
     # def create_firewall_rule(credentials, opts)
     # def delete_firewall_rule(credentials, opts)
+    # def providers(credentials)
     def realm(credentials, opts)
       realms = realms(credentials, opts).first if has_capability?(:realms)
     end
@@ -230,6 +235,11 @@ module Deltacloud
       Thread.current[:provider] || ENV['API_PROVIDER']
     end
 
+    # Return an array of the providers statically configured
+    # in the driver's YAML file
+    def configured_providers
+      []
+    end
   end
 
 end

data/lib/deltacloud/core_ext.rb

@@ -17,3 +17,5 @@
 require 'deltacloud/core_ext/string'
 require 'deltacloud/core_ext/integer'
 require 'deltacloud/core_ext/hash'
+require 'deltacloud/core_ext/array'
+require 'deltacloud/core_ext/proc'

data/lib/deltacloud/core_ext/array.rb

@@ -0,0 +1,25 @@
+# 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.
+
+class Array
+  def expand_opts!(more_opts)
+    self << {} unless last.is_a?(Hash)
+    last.update(more_opts)
+  end
+
+  def extract_opts!
+    last.is_a?(Hash) ? pop : {}
+  end
+end

data/lib/deltacloud/core_ext/hash.rb

@@ -26,4 +26,11 @@ class Hash
     #remove the original keys
     self.delete_if{|k,v| remove.include?(k)}
   end
+
+  # Method copied from https://github.com/rails/rails/blob/77efc20a54708ba37ba679ffe90021bf8a8d3a8a/activesupport/lib/active_support/core_ext/hash/keys.rb#L23
+  def symbolize_keys
+    keys.each { |key| self[(key.to_sym rescue key) || key] = delete(key) }
+    self
+  end
+
 end

data/lib/deltacloud/core_ext/proc.rb

@@ -0,0 +1,31 @@
+# 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.
+
+# Original code copied from https://gist.github.com/1417762
+# Copyright 2011 Emmanuel Oga.
+
+class Proc
+
+  Callback = Struct.new(:called, :args) do
+    def method_missing(name, *)
+      name == :"#{called}?" || (name == called && block_given? && yield(*args))
+    end
+  end
+
+  def callback(callable, *args)
+    call Callback.new(callable, *args)
+  end
+
+end

data/lib/deltacloud/core_ext/string.rb

@@ -34,6 +34,8 @@ class String
 
   def pluralize
     return self + 'es' if self =~ /ess$/
+    return self[0, self.length-1] + "ies" if self =~ /ty$/
+    return self if self =~ /data$/
     self + "s"
   end
 
@@ -49,4 +51,17 @@ class String
           tr("-", "_").
           downcase
   end
+
+  def camelize(lowercase_first_letter=nil)
+    s = split('_').map { |w| w.capitalize }.join
+    lowercase_first_letter ? s.uncapitalize : s
+  end
+
+  def uncapitalize
+    self[0, 1].downcase + self[1..-1]
+  end
+
+  def upcase_first
+    self[0, 1].upcase + self[1..-1]
+  end
 end

data/lib/deltacloud/drivers/condor/condor_driver.rb

@@ -105,7 +105,8 @@ module Deltacloud
                 :realm_id => 'default',
                 :instance_profile => InstanceProfile::new(instance.instance_profile.name),
                 :image_id => instance.image_id,
-                :public_addresses => [ ip_address ],
+                :public_addresses => [ InstanceAddress.new(ip_address) ],
+                :private_addresses => [],
                 :owner_id => instance.owner_id,
                 :description => instance.name,
                 :architecture => 'x86_64',

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

@@ -51,7 +51,7 @@ module Deltacloud
           cpu                1
           memory             0.63 * 1024
           storage            160
-          architecture       'i386'
+          architecture       ['i386','x86_64']
         end
 
         define_hardware_profile('m1.small') do
@@ -134,7 +134,7 @@ module Deltacloud
           opts ||= {}
           if opts[:id]
             safely do
-              img_arr = ec2.describe_images(opts[:id]).collect do |image|
+              img_arr = ec2.describe_images([opts[:id]]).collect do |image|
                 convert_image(image)
               end
             end
@@ -142,7 +142,7 @@ module Deltacloud
           end
           owner_id = opts[:owner_id] || default_image_owner
           safely do
-            img_arr = ec2.describe_images_by_owner(owner_id, default_image_type).collect do |image|
+            img_arr = ec2.describe_images_by_owner([owner_id], default_image_type).collect do |image|
               convert_image(image)
             end
           end
@@ -231,8 +231,14 @@ module Deltacloud
             }]
           end
           safely do
-            new_instance = convert_instance(ec2.launch_instances(image_id, instance_options).first)
-            new_instance
+            new_instances = ec2.launch_instances(image_id, instance_options).collect do |i|
+              convert_instance(i)
+            end
+            if new_instances.size == 1
+              new_instances.first
+            else
+              new_instances
+            end
           end
         end
 
@@ -372,7 +378,8 @@ module Deltacloud
           safely do
             s3_client = new_client(credentials, :s3)
             bucket_location = opts['location']
-            if (bucket_location && bucket_location.size >0)
+            if (bucket_location && bucket_location.size >0 &&
+                                               (not bucket_location.eql?(DEFAULT_REGION)) )
               bucket = Aws::S3::Bucket.create(s3_client, name, true, nil, :location => bucket_location)
             else
               bucket = Aws::S3::Bucket.create(s3_client, name, true)
@@ -694,6 +701,16 @@ module Deltacloud
           end
         end
 
+        def providers(credentials, opts={})
+          ec2 = new_client(credentials)
+          providers = ec2.describe_regions.map{|r| Provider.new( {:id=>r, :name=>r,
+           :url=>"#{ENV['API_HOST']}:#{ENV['API_PORT']}#{settings.root_url}\;provider=#{r}" }) }
+        end
+
+        def configured_providers
+          Deltacloud::Drivers::driver_config[:ec2][:entrypoints]["ec2"].keys
+        end
+
         def valid_credentials?(credentials)
           retval = true
           begin
@@ -778,7 +795,11 @@ module Deltacloud
 
         def convert_instance(instance)
           can_create_image = 'ebs'.eql?(instance[:root_device_type]) and 'RUNNING'.eql?(convert_state(instance[:aws_state]))
-          Instance.new(
+          inst_profile_opts={}
+          if instance[:aws_instance_type] == "t1.micro"
+            inst_profile_opts[:hwp_architecture]=instance[:architecture]
+          end
+         Instance.new(
             :id => instance[:aws_instance_id],
             :name => instance[:aws_image_id],
             :state => convert_state(instance[:aws_state]),
@@ -787,11 +808,12 @@ module Deltacloud
             :actions => instance_actions_for(convert_state(instance[:aws_state])),
             :keyname => instance[:ssh_key_name],
             :launch_time => instance[:aws_launch_time],
-            :instance_profile => InstanceProfile.new(instance[:aws_instance_type]),
+            :instance_profile => InstanceProfile.new(instance[:aws_instance_type], inst_profile_opts),
             :realm_id => instance[:aws_availability_zone],
-            :private_addresses => instance[:private_dns_name],
-            :public_addresses => instance[:dns_name],
+            :public_addresses => [InstanceAddress.new(instance[:dns_name], :type => :hostname)],
+            :private_addresses => [InstanceAddress.new(instance[:private_dns_name], :type => :hostname)],
             :firewalls => instance[:aws_groups],
+            :storage_volumes => instance[:block_device_mappings].map{|vol| {vol.values.first=>vol.keys.first } },
             :create_image => can_create_image
           )
         end

data/lib/deltacloud/drivers/eucalyptus/eucalyptus_driver.rb

@@ -75,7 +75,7 @@ module Deltacloud
         end
 
         def default_image_owner
-          nil  # list all images
+          "self" 
         end
 
         def default_image_type

data/lib/deltacloud/drivers/gogrid/gogrid_driver.rb

@@ -471,7 +471,7 @@ class GogridDriver < Deltacloud::BaseDriver
       :realm_id => instance['ip']['datacenter']['id'],
       :state => state,
       :actions => instance_actions_for(state),
-      :public_addresses => [ instance['ip']['ip'] ],
+      :public_addresses => [ InstanceAddress.new(instance['ip']['ip']) ],
       :private_addresses => [],
       :username => instance['username'],
       :password => instance['password'],

data/lib/deltacloud/drivers/google/google_driver.rb

@@ -0,0 +1,233 @@
+# 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 'fog'
+
+module Deltacloud
+  module Drivers
+    module Google
+
+class GoogleDriver < Deltacloud::BaseDriver
+
+  def supported_collections; [:buckets]
+  end
+
+  feature :buckets, :bucket_location
+
+#--
+# Buckets
+#--
+  def buckets(credentials, opts={})
+    buckets = []
+    google_client = new_client(credentials)
+    safely do
+      if opts[:id]
+        bucket = google_client.get_bucket(opts[:id])
+        buckets << convert_bucket(bucket.body)
+      else
+        google_client.get_service.body['Buckets'].each do |bucket|
+          buckets << Bucket.new({:name => bucket['Name'], :id => bucket['Name']})
+        end
+      end
+    end
+    buckets = filter_on(buckets, :id, opts)
+  end
+
+#--
+# Create bucket - valid values for location {'EU','US'}
+#--
+  def create_bucket(credentials, name, opts={})
+    google_client = new_client(credentials)
+    safely do
+      bucket_location = opts['location']
+      if (bucket_location && bucket_location.size > 0)
+        res = google_client.put_bucket(name, {"LocationConstraint" => opts['location']})
+      else
+        google_client.put_bucket(name)
+      end
+      #res.status should be eql 200 - but fog will explode if not all ok...
+      Bucket.new({ :id => name,
+                   :name => name,
+                   :size => 0,
+                   :blob_list => [] })
+    end
+  end
+
+#--
+# Delete bucket
+#--
+  def delete_bucket(credentials, name, opts={})
+    google_client = new_client(credentials)
+    safely do
+      google_client.delete_bucket(name)
+    end
+  end
+
+#--
+# Blobs
+#--
+  def blobs(credentials, opts={})
+    blobs = []
+    google_client = new_client(credentials)
+    safely do
+      google_blob = google_client.head_object(opts['bucket'], opts[:id]).headers
+      meta_hash = google_blob.inject({}){|result, (k,v)| result[k]=v if k=~/^x-goog-meta-/i ; result}
+      meta_hash.gsub_keys("x-goog-meta-", "")
+      blobs << Blob.new({   :id => opts[:id],
+                 :bucket => opts['bucket'],
+                 :content_length => google_blob['Content-Length'],
+                 :content_type => google_blob['Content-Type'],
+                 :last_modified => google_blob['Last-Modified'],
+                 :user_metadata => meta_hash
+              })
+
+    end
+    blobs
+  end
+
+  def blob_data(credentials, bucket_id, blob_id, opts={})
+    google_client = new_client(credentials)
+    safely do
+      google_client.get_object(bucket_id, blob_id) do |chunk|
+        yield chunk
+      end
+    end
+  end
+
+#--
+# Create Blob
+#--
+  def create_blob(credentials, bucket_id, blob_id, blob_data, opts={})
+    google_client = new_client(credentials)
+    safely do
+      dcloud_blob_metadata = BlobHelper::extract_blob_metadata_hash(opts)
+      BlobHelper::rename_metadata_headers(opts, 'x-goog-meta-')
+      opts['Content-Type'] = blob_data[:type]
+      google_client.put_object(bucket_id, blob_id, blob_data[:tempfile], opts)
+      Blob.new({ :id => blob_id,
+                 :bucket => bucket_id,
+                 :content_length => File.size(blob_data[:tempfile]).to_s,
+                 :content_type => blob_data[:type],
+                 :last_modified => "",
+                 :user_metadata => dcloud_blob_metadata  })
+    end
+  end
+
+  #params: {:user,:password,:bucket,:blob,:content_type,:content_length,:metadata}
+  def blob_stream_connection(params)
+    client = Fog::Storage.new({:provider => :google, :google_storage_access_key_id => params[:user],
+                               :google_storage_secret_access_key => params[:password]})
+    google_request_uri = "https://#{client.instance_variable_get(:@host)}"
+    uri = URI.parse(google_request_uri)
+    conn_params = {} # build hash for the Fog signature method
+    conn_params[:headers] = {} #put the metadata here
+    conn_params[:host] = uri.host
+    conn_params[:path] = "#{params[:bucket]}/#{CGI.escape(params[:blob])}"
+    conn_params[:method] = "PUT"
+    timestamp = Fog::Time.now.to_date_header
+    conn_params[:headers]['Date'] = timestamp
+    conn_params[:headers]['Content-Type'] = params[:content_type]
+    metadata = params[:metadata] || {}
+    BlobHelper::rename_metadata_headers(metadata, 'x-goog-meta-')
+    metadata.each{|k,v| conn_params[:headers][k]=v}
+    auth_string = "GOOG1 #{params[:user]}:#{client.signature(conn_params)}"
+
+    http = Net::HTTP.new(uri.host, uri.port)
+    http.use_ssl = true
+    http.verify_mode = OpenSSL::SSL::VERIFY_NONE
+    request = Net::HTTP::Put.new("/#{conn_params[:path]}")
+    request['Host'] = conn_params[:host]
+    request['Date'] = conn_params[:headers]['Date']
+    request['Content-Type'] = conn_params[:headers]['Content-Type']
+    request['Content-Length'] = params[:content_length]
+    request['Authorization'] = auth_string
+    metadata.each{|k,v| request[k] = v}
+    return http, request
+  end
+
+#--
+# Delete Blob
+#--
+  def delete_blob(credentials, bucket_id, blob_id, opts={})
+    google_client = new_client(credentials)
+    safely do
+      google_client.delete_object(bucket_id, blob_id)
+    end
+  end
+
+#-
+# Blob Metadada
+#-
+  def blob_metadata(credentials, opts = {})
+    google_client = new_client(credentials)
+    safely do
+      google_blob = google_client.head_object(opts['bucket'], opts[:id]).headers
+      meta_hash = google_blob.inject({}){|result, (k,v)| result[k]=v if k=~/^x-goog-meta-/i ; result}
+      meta_hash.gsub_keys("x-goog-meta-", "")
+    end
+  end
+
+#-
+# Update Blob Metadata
+#-
+  def update_blob_metadata(credentials, opts={})
+    google_client = new_client(credentials)
+    safely do
+      meta_hash = BlobHelper::rename_metadata_headers(opts['meta_hash'], 'x-goog-meta-')
+      options = {'x-goog-metadata-directive'=>'REPLACE'}
+      options.merge!(meta_hash)
+      bucket = opts['bucket']
+      blob = opts[:id]
+      google_client.copy_object(bucket, blob, bucket, blob, options) #source,source,target,target,options
+      meta_hash.gsub_keys("x-goog-meta-", "")
+    end
+  end
+
+  def valid_credentials?(credentials)
+    begin
+      new_client(credentials)
+    rescue
+      return false
+    end
+    return true
+  end
+
+  private
+
+  def new_client(credentials)
+    safely do
+      Fog::Storage.new({ :provider => :google, :google_storage_access_key_id => credentials.user,
+                         :google_storage_secret_access_key => credentials.password})
+
+    end
+  end
+
+  def convert_bucket(bucket)
+    blob_list = []
+    bucket['Contents'].each do |blob|
+      blob_list << blob['Key']
+    end
+    Bucket.new({    :id => bucket['Name'],
+                    :name => bucket['Name'],
+                    :size => blob_list.size,
+                    :blob_list => blob_list
+                  })
+  end
+
+end
+
+    end
+  end
+end