deltacloud-core 0.0.6 → 0.0.7

data/deltacloud.rb

@@ -13,6 +13,8 @@ require 'deltacloud/models/key'
 require 'deltacloud/models/instance_profile'
 require 'deltacloud/models/storage_snapshot'
 require 'deltacloud/models/storage_volume'
+require 'deltacloud/models/bucket'
+require 'deltacloud/models/blob'
 
 require 'deltacloud/validation'
 require 'deltacloud/helpers'

data/lib/deltacloud/base_driver/base_driver.rb

@@ -185,6 +185,36 @@ module Deltacloud
       []
     end
 
+    def buckets(credentials, opts = nil)
+      #list of buckets belonging to account
+      []
+    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)
+    end
+
+    def blobs(credentials, opts = nil)
+      []
+    end
+
+    def blob(credentials, opts = nil)
+       list = blobs(credentials, opts)
+       return list.first unless list.empty?
+    end
+
+    def blob_data(credentials, bucket_id, blob_id, opts)
+    end
+
     def filter_on(collection, attribute, opts)
       return collection if opts.nil?
       return collection if opts[attribute].nil?

data/lib/deltacloud/base_driver/features.rb

@@ -162,5 +162,12 @@ module Deltacloud
       description "Size instances according to changes to a hardware profile"
       # The parameters are filled in from the hardware profiles
     end
+
+    declare_feature :buckets, :bucket_location do
+      description "Take extra location parameter for Bucket creation (e.g. S3, 'eu' or 'us-west-1')"
+      operation :create do
+        param :location, :string, :optional
+      end
+    end
   end
 end

data/lib/deltacloud/base_driver/mock_driver.rb

@@ -3,6 +3,19 @@ require 'deltacloud/method_serializer'
 # Create 'mock' version of original driver client/gem:
 
 module Mock
+
+  class S3 < RightAws::S3
+    include MethodSerializer::Cache
+
+    def self.cached_methods
+      [
+        :buckets
+      ]
+    end
+
+    MethodSerializer::Cache::wrap_methods(self, :cache_dir => File.join(File.dirname(__FILE__), '..', '..', '..', '..', 'tests', 'ec2', 'support'))
+  end
+
   class EC2 < AWS::EC2::Base
 
     include MethodSerializer::Cache
@@ -29,6 +42,7 @@ end
 # Replace original client with mock client
 Deltacloud::Drivers::EC2::EC2Driver.class_eval do
   alias_method :original_new_client, :new_client
+  alias_method :original_s3_client, :s3_client
 
   def new_client(credentials, opts={})
     Mock::EC2.new(
@@ -37,4 +51,8 @@ Deltacloud::Drivers::EC2::EC2Driver.class_eval do
     )
   end
 
+  def s3_client(credentials)
+    Mock::S3.new(credentials.user, credentials.password)
+  end
+
 end

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

@@ -0,0 +1,127 @@
+#
+# Copyright (C) 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.
+
+#Windows Azure (WAZ) gem at http://github.com/johnnyhalife/waz-storage
+require 'waz-blobs'
+require 'deltacloud/base_driver'
+module Deltacloud
+  module Drivers
+    module Azure
+
+class AzureDriver < Deltacloud::BaseDriver
+
+  def supported_collections; [:buckets]
+  end
+
+#--
+# Buckets
+#--
+  def buckets(credentials, opts)
+    buckets = []
+    azure_connect(credentials)
+    safely do
+      WAZ::Blobs::Container.list.each do |waz_container|
+        buckets << convert_container(waz_container)
+      end
+    end
+    buckets = filter_on(buckets, :id, opts)
+  end
+
+#--
+# Create bucket
+#--
+  def create_bucket(credentials, name, opts)
+    bucket = nil
+    azure_connect(credentials)
+    safely do
+      waz_container = WAZ::Blobs::Container.create(name)
+      bucket = convert_container(waz_container)
+    end
+    bucket
+  end
+
+#--
+# Delete bucket
+#--
+  def delete_bucket(credentials, name, opts)
+    azure_connect(credentials)
+    safely do
+      WAZ::Blobs::Container.find(name).destroy!
+    end
+  end
+
+#--
+# Blobs
+#--
+  def blobs(credentials, opts)
+    blob_list = []
+    azure_connect(credentials)
+    safely do
+      the_bucket = WAZ::Blobs::Container.find(opts['bucket'])
+      the_bucket.blobs.each do |waz_blob|
+        blob_list << convert_blob(waz_blob)
+      end
+    end
+    blob_list = filter_on(blob_list, :id, opts)
+    blob_list
+  end
+
+  def blob_data(credentials, bucket_id, blob_id, opts)
+    azure_connect(credentials)
+    # WAZ get blob data methods cant accept blocks for 'streaming'... FIXME
+      yield WAZ::Blobs::Container.find(bucket_id)[blob_id].value
+  end
+
+  private
+
+  def azure_connect(credentials)
+    options = {:account_name => credentials.user, :access_key => credentials.password}
+    safely do
+      WAZ::Storage::Base.establish_connection!(options)
+    end
+  end
+
+  def convert_container(waz_container)
+    blob_list = []
+    waz_container.blobs.each do |blob|
+      blob_list << blob.name
+    end
+    Bucket.new({ :id => waz_container.name,
+                    :name => waz_container.name,
+                    :size => blob_list.size,
+                    :blob_list => blob_list
+                  })
+  end
+
+  def convert_blob(waz_blob)
+    url = waz_blob.url.split('/')
+    bucket = url[url.length-2] #FIXME
+    Blob.new({   :id => waz_blob.name,
+                 :bucket => bucket,
+                 :content_length => waz_blob.metadata[:content_length],
+                 :content_type => waz_blob.metadata[:content_type],
+                 :last_modified => waz_blob.metadata[:last_modified]
+              })
+  end
+
+
+end
+
+    end #module Azure
+  end #module Drivers
+end #module Deltacloud

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

@@ -18,7 +18,9 @@
 
 
 require 'deltacloud/base_driver'
+require 'active_support'
 require 'AWS'
+require 'right_aws'
 
 class Instance
   attr_accessor :keyname
@@ -36,12 +38,13 @@ module Deltacloud
 class EC2Driver < Deltacloud::BaseDriver
 
   def supported_collections
-    DEFAULT_COLLECTIONS + [ :keys ]
+    DEFAULT_COLLECTIONS + [ :keys, :buckets ]
   end
 
   feature :instances, :user_data
   feature :instances, :authentication_key
   feature :images, :owner_id
+  feature :buckets, :bucket_location
 
   define_hardware_profile('m1.small') do
     cpu                1
@@ -201,7 +204,7 @@ class EC2Driver < Deltacloud::BaseDriver
       # at this point, the action has succeeded but our follow-up
       # "describe_instances" failed for some reason.  Create a simple Instance
       # object with only the ID and new state in place
-      state = backup.instancesSet.item.first.currentState.name
+      state = convert_state(backup.instancesSet.item.first.currentState.name)
       Instance.new( {
         :id => id,
         :state => state,
@@ -319,6 +322,83 @@ class EC2Driver < Deltacloud::BaseDriver
     return realms ? true : false
   end
 
+#--
+# Buckets
+#-- get a list of your buckets from the s3 service
+  def buckets(credentials, opts)
+    buckets = []
+    safely do
+      s3_client = s3_client(credentials)
+      bucket_list = s3_client.buckets
+      bucket_list.each do |current|
+        buckets << convert_bucket(current)
+      end
+    end
+    buckets = filter_on(buckets, :id, opts)
+    buckets
+  end
+
+#--
+# Create bucket
+#--
+#valid values for bucket location: 'EU'|'us-west1'|'ap-southeast-1' - if you
+#don't specify a location then by default buckets are created in 'us-east'
+#[but if you *do* specify 'us-east' things blow up]
+  def create_bucket(credentials, name, opts={})
+    bucket = nil
+    safely do
+      begin
+        s3_client = s3_client(credentials)
+        bucket_location = opts['location']
+        if bucket_location
+          bucket = RightAws::S3::Bucket.create(s3_client, name, true, nil, :location => bucket_location)
+        else
+          bucket = RightAws::S3::Bucket.create(s3_client, name, true)
+        end #if
+        rescue RightAws::AwsError => e
+          raise e unless e.message =~ /BucketAlreadyExists/
+          raise Deltacloud::BackendError.new(409, e.class.to_s, e.message, e.backtrace)
+      end #begin
+    end #do
+    convert_bucket(bucket)
+  end
+
+#--
+# Delete_bucket
+#--
+  def delete_bucket(credentials, name, opts={})
+    s3_client = s3_client(credentials)
+    safely do
+      s3_client.interface.delete_bucket(name)
+    end
+  end
+
+#--
+# Blobs
+#--
+  def blobs(credentials, opts = nil)
+    s3_client = s3_client(credentials)
+    blobs = []
+    safely do
+      s3_bucket = s3_client.bucket(opts['bucket'])
+      s3_bucket.keys({}, true).each do |s3_object|
+        blobs << convert_object(s3_object)
+      end
+    end
+    blobs = filter_on(blobs, :id, opts)
+    blobs
+  end
+
+#--
+# Blob data
+#--
+  def blob_data(credentials, bucket_id, blob_id, opts)
+    s3_client = s3_client(credentials)
+    s3_client.interface.get(bucket_id, blob_id) do |chunk|
+      yield chunk
+    end
+  end
+
   private
 
   def new_client(credentials)
@@ -360,9 +440,23 @@ class EC2Driver < Deltacloud::BaseDriver
     } )
   end
 
+  def convert_state(ec2_state)
+    case ec2_state
+    when "terminated"
+      "STOPPED"
+    when "stopped"
+      "STOPPED"
+    when "running"
+      "RUNNING"
+    when "pending"
+      "PENDING"
+    when "shutting-down"
+      "STOPPED"
+    end
+  end
+
   def convert_instance(ec2_instance, owner_id)
-    state = ec2_instance['instanceState']['name'].upcase
-    state_key = state.downcase.underscore.to_sym
+    state = convert_state(ec2_instance['instanceState']['name'])
     realm_id = ec2_instance['placement']['availabilityZone']
     (realm_id = nil ) if ( realm_id == '' )
     hwp_name = ec2_instance['instanceType']
@@ -404,6 +498,36 @@ class EC2Driver < Deltacloud::BaseDriver
     } )
   end
 
+  def s3_client(credentials)
+    safely do
+      s3_client = RightAws::S3.new(credentials.user, credentials.password)
+    end
+  end
+
+  def convert_bucket(s3_bucket)
+    #get blob list:
+    blob_list = []
+    s3_bucket.keys.each do |s3_object|
+      blob_list << s3_object.name
+    end
+    #can use AWS::S3::Owner.current.display_name or current.id
+    Bucket.new(  { :id => s3_bucket.name,
+                      :name => s3_bucket.name,
+                      :size => s3_bucket.keys.length,
+                      :blob_list => blob_list
+                    }
+                 )
+  end
+
+  def convert_object(s3_object)
+    Blob.new({   :id => s3_object.name,
+                 :bucket => s3_object.bucket.name.to_s,
+                 :content_length => s3_object.size,
+                 :content_type => s3_object.content_type,
+                 :last_modified => s3_object.last_modified
+              })
+  end
+
   def catched_exceptions_list
     {
       :auth => [ AWS::AuthFailure ],

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

@@ -285,6 +285,9 @@ class GogridDriver < Deltacloud::BaseDriver
     end
     prof = InstanceProfile.new("server", opts)
 
+    hwp_name = instance['image']['name']
+    state = convert_server_state(instance['state']['name'], instance['id'])
+
     Instance.new(
        # note that we use 'name' as the id here, because newly created instances
        # don't get a real ID until later on.  The name is good enough; from
@@ -296,8 +299,8 @@ class GogridDriver < Deltacloud::BaseDriver
       :instance_profile => prof,
       :name => instance['name'],
       :realm_id => instance['ip']['datacenter']['id'],
-      :state => convert_server_state(instance['state']['name'], instance['id']),
-      :actions => instance_actions_for(convert_server_state(instance['state']['name'], instance['id'])),
+      :state => state,
+      :actions => instance_actions_for(state),
       :public_addresses => [ instance['ip']['ip'] ],
       :private_addresses => [],
       :username => instance['username'],

data/lib/deltacloud/drivers/mock/mock_driver.rb

@@ -185,34 +185,28 @@ class MockDriver < Deltacloud::BaseDriver
     Instance.new( instance )
   end
 
-  def start_instance(credentials, id)
+  def update_instance_state(credentials, id, state)
     instance_file = "#{@storage_root}/instances/#{id}.yml"
     instance_yml  = YAML.load( File.read( instance_file ) )
-    instance_yml[:state] = 'RUNNING'
+    instance_yml[:id] = id
+    instance_yml[:state] = state
+    instance_yml[:actions] = instance_actions_for( instance_yml[:state] )
     File.open( instance_file, 'w' ) do |f|
       f << YAML.dump( instance_yml )
     end
     Instance.new( instance_yml )
   end
 
+  def start_instance(credentials, id)
+    update_instance_state(credentials, id, 'RUNNING')
+  end
+
   def reboot_instance(credentials, id)
-    instance_file = "#{@storage_root}/instances/#{id}.yml"
-    instance_yml  = YAML.load( File.read( instance_file ) )
-    instance_yml[:state] = 'RUNNING'
-    File.open( instance_file, 'w' ) do |f|
-      f << YAML.dump( instance_yml )
-    end
-    Instance.new( instance_yml )
+    update_instance_state(credentials, id, 'RUNNING')
   end
 
   def stop_instance(credentials, id)
-    instance_file = "#{@storage_root}/instances/#{id}.yml"
-    instance_yml  = YAML.load( File.read( instance_file ) )
-    instance_yml[:state] = 'STOPPED'
-    File.open( instance_file, 'w' ) do |f|
-      f << YAML.dump( instance_yml )
-    end
-    Instance.new( instance_yml )
+    update_instance_state(credentials, id, 'STOPPED')
   end