deltacloud-core 0.0.9 → 0.1.0

data/deltacloud.rb

@@ -15,6 +15,7 @@ require 'deltacloud/models/storage_snapshot'
 require 'deltacloud/models/storage_volume'
 require 'deltacloud/models/bucket'
 require 'deltacloud/models/blob'
+require 'deltacloud/models/load_balancer'
 
 require 'deltacloud/validation'
 require 'deltacloud/helpers'

data/lib/deltacloud/backend_capability.rb

@@ -0,0 +1,21 @@
+module Deltacloud::BackendCapability
+
+  class Failure < StandardError
+    attr_reader :capability
+    def initialize(capability, msg='')
+      super(msg)
+      @capability = capability
+    end
+  end
+
+  attr_reader :capability
+  def with_capability(capability)
+    @capability = capability
+  end
+
+  def check_capability(backend)
+    if capability and !backend.respond_to?(capability)
+      raise Failure.new(capability, "#{capability} capability not supported by backend #{backend.class.name}")
+    end
+  end
+end

data/lib/deltacloud/base_driver/base_driver.rb

@@ -215,6 +215,12 @@ module Deltacloud
     def blob_data(credentials, bucket_id, blob_id, opts)
     end
 
+    def create_blob(credentials, bucket_id, blob_id, blob_data, opts=nil)  
+    end
+    
+    def delete_blob(credentials, bucket_id, blob_id, opts=nil)
+    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

@@ -143,6 +143,14 @@ module Deltacloud
       end
     end
 
+    declare_feature :instances, :security_group do
+      description "Put instance in one or more security groups on launch"
+      operation :create do
+        param :security_group, :array, :optional, nil,
+        "Array of security group names"
+      end
+    end
+
     declare_feature :instances, :authentication_key do
       operation :create do
         param :keyname, :string,  :optional, nil
@@ -169,5 +177,13 @@ module Deltacloud
         param :location, :string, :optional
       end
     end
+
+    declare_feature :instances, :register_to_load_balancer do
+      description "Register instance to load balancer"
+      operation :create do
+        param :load_balancer_id, :string, :optional
+      end
+    end
+
   end
 end

data/lib/deltacloud/base_driver/mock_driver.rb

@@ -16,6 +16,19 @@ module Mock
     MethodSerializer::Cache::wrap_methods(self, :cache_dir => File.join(File.dirname(__FILE__), '..', '..', '..', '..', 'tests', 'ec2', 'support'))
   end
 
+  class ELB < AWS::ELB::Base
+    include MethodSerializer::Cache
+
+    def self.cached_methods
+      [
+        :describe_load_balancers
+      ]
+    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
@@ -44,11 +57,18 @@ 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(
-      :access_key_id => credentials.user,
-      :secret_access_key => credentials.password
-    )
+  def new_client(credentials, provider = :ec2)
+    if provider == :elb
+      Mock::ELB.new(
+        :access_key_id => credentials.user,
+        :secret_access_key => credentials.password
+      )
+    else
+      Mock::EC2.new(
+        :access_key_id => credentials.user,
+        :secret_access_key => credentials.password
+      )
+    end
   end
 
   def s3_client(credentials)

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

@@ -22,29 +22,21 @@ require 'active_support'
 require 'AWS'
 require 'right_aws'
 
-class Instance
-  attr_accessor :keyname
-  attr_accessor :authn_error
-
-  def authn_feature_failed?
-    return true unless authn_error.nil?
-  end
-
-end
-
 module Deltacloud
   module Drivers
     module EC2
 class EC2Driver < Deltacloud::BaseDriver
 
   def supported_collections
-    DEFAULT_COLLECTIONS + [ :keys, :buckets ]
+    DEFAULT_COLLECTIONS + [ :keys, :buckets, :load_balancers ]
   end
 
   feature :instances, :user_data
   feature :instances, :authentication_key
+  feature :instances, :security_group
   feature :images, :owner_id
   feature :buckets, :bucket_location
+  feature :instances, :register_to_load_balancer
 
   define_hardware_profile('m1.small') do
     cpu                1
@@ -192,9 +184,18 @@ class EC2Driver < Deltacloud::BaseDriver
         :monitoring_enabled => true,
         :instance_type => hwp.name,
         :disable_api_termination => false,
-        :instance_initiated_shutdown_behavior => 'terminate'
+        :instance_initiated_shutdown_behavior => 'terminate',
+        :security_group => opts[:security_group]
       )
-      return convert_instance( ec2_instances.instancesSet.item.first, 'pending' )
+      new_instance = convert_instance( ec2_instances.instancesSet.item.first, 'pending' )
+      if opts[:load_balancer_id] and opts[:load_balancer_id]!=""
+        elb = new_client(credentials, :elb)
+        elb.register_instances_with_load_balancer({
+          :instances => [new_instance.id],
+          :load_balancer_name => opts[:load_balancer_id]
+        })
+      end
+      return new_instance
     end
   end
 
@@ -402,19 +403,140 @@ class EC2Driver < Deltacloud::BaseDriver
     end
   end
 
+#--
+# Create Blob
+#--
+  def create_blob(credentials, bucket_id, blob_id, data = nil, opts = nil)
+    s3_client = s3_client(credentials)
+    #data is a construct with the temporary file created by server @.tempfile
+    #also file[:type] will give us the content-type
+    res = s3_client.interface.put(bucket_id, blob_id, data.tempfile, {"Content-Type" => data[:type]})
+    #create a new Blob object and return that
+    Blob.new( { :id => blob_id,
+                :bucket => bucket_id,
+                :content_length => data.tempfile.length,
+                :content_type => data[:type],
+                :last_modified => ''
+              }
+            )
+  end
+
+#--
+# Delete Blob
+#--  
+  def delete_blob(credentials, bucket_id, blob_id, opts=nil)
+    s3_client = s3_client(credentials)
+    s3_client.interface.delete(bucket_id, blob_id)
+  end
+
+  def load_balancer(credentials, opts={})
+    load_balancers(credentials, {
+      :load_balancer_names => [opts[:id]]
+    }).first
+  end
+
+  def load_balancers(credentials, opts=nil)
+    ec2 = new_client( credentials, :elb )
+    result = []
+    safely do
+      loadbalancers = ec2.describe_load_balancers(opts || {})
+      return [] unless loadbalancers.DescribeLoadBalancersResult.LoadBalancerDescriptions
+      loadbalancers.DescribeLoadBalancersResult.LoadBalancerDescriptions.member.each do |loadbalancer|
+        result << convert_load_balancer(credentials, loadbalancer)
+      end
+    end
+    return result
+  end
+
+  def create_load_balancer(credentials, opts={})
+    ec2 = new_client( credentials, :elb )
+    safely do
+      ec2.create_load_balancer({
+        :load_balancer_name => opts['name'],
+        # TODO: Add possibility to push more listeners/realms in one request
+        # Something like 'Hash' in 'Array' parameter
+        :availability_zones => [opts['realm_id']],
+        :listeners => [{
+          :protocol => opts['listener_protocol'],
+          :load_balancer_port => opts['listener_balancer_port'],
+          :instance_port => opts['listener_instance_port']
+         }]
+      })
+      return load_balancer(credentials, opts['name'])
+    end
+  end
+
+  def destroy_load_balancer(credentials, id)
+    ec2 = new_client( credentials, :elb )
+    safely do
+      ec2.delete_load_balancer({
+        :load_balancer_name => id
+      })
+    end
+  end
+
+  def lb_register_instance(credentials, opts={})
+    ec2 = new_client( credentials, :elb)
+    safely do
+      ec2.register_instances_with_load_balancer(:instances => [opts[:instance_id]],
+        :load_balancer_name => opts[:id])
+      load_balancer(credentials, :id => opts[:id])
+    end
+  end
+
+  def lb_unregister_instance(credentials, opts={})
+    ec2 = new_client( credentials, :elb)
+    safely do
+      ec2.deregister_instances_from_load_balancer(:instances => [opts[:instance_id]],
+        :load_balancer_name => opts[:id])
+      load_balancer(credentials, :id => opts[:id])
+    end
+  end
+
   private
 
-  def new_client(credentials)
+  def new_client(credentials, provider_type = :ec2)
     opts = {
       :access_key_id => credentials.user,
       :secret_access_key => credentials.password
     }
     opts[:server] = ENV['DCLOUD_EC2_URL'] if ENV['DCLOUD_EC2_URL']
     safely do
-      AWS::EC2::Base.new(opts)
+      case provider_type
+        when :ec2
+          AWS::EC2::Base.new(opts)
+        when :elb
+          AWS::ELB::Base.new(opts)
+      end
     end
   end
 
+  def convert_load_balancer(credentials, loadbalancer)
+    balancer_realms = loadbalancer.AvailabilityZones.member.collect do |m|
+      realm(credentials, m)
+    end
+    balancer = LoadBalancer.new({
+      :id => loadbalancer['LoadBalancerName'],
+      :created_at => loadbalancer['CreatedTime'],
+      :public_addresses => [loadbalancer['DNSName']],
+      :realms =>  balancer_realms
+    })
+    balancer.listeners = []
+    balancer.instances = []
+    loadbalancer.Listeners.member.each do |listener|
+      balancer.add_listener({
+        :protocol => listener['Protocol'],
+        :load_balancer_port => listener['LoadBalancerPort'],
+        :instance_port => listener['InstancePort']
+      })
+    end
+    loadbalancer.Instances.member.each do |instance|
+      balancer.instances << instances(credentials, :id => instance['InstanceId']).first
+    end if loadbalancer.Instances
+    balancer
+  end
+
+
   def convert_key(key)
     Key.new({
       :id => key['keyName'],

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

@@ -9,7 +9,7 @@ class GoGridClient
                  apikey='YOUR API KEY',
                  secret='YOUR SHARED SECRET', 
                  format='json',
-                 version='1.5')
+                 version='1.6')
     @server = server
     @secret = secret
     @default_params = {'format'=>format, 'v'=>version,'api_key' => apikey}
@@ -35,12 +35,9 @@ class GoGridClient
       @default_params['v'] = version
     else
       @default_params['v'] = '1.5'
-    end
-    begin
-      JSON::parse(sendAPIRequest(method, params))
-    rescue Exception => e
-      STDERR.puts("ERROR: #{e.message}")
-    end
+   end
+    request = sendAPIRequest(method, params)
+    JSON::parse(request)
   end
   
   def encode_params(params)

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

@@ -45,7 +45,7 @@ class GogridDriver < Deltacloud::BaseDriver
 
   def supported_collections
     DEFAULT_COLLECTIONS.reject! { |c| [ :storage_volumes, :storage_snapshots ].include?(c) }
-    DEFAULT_COLLECTIONS + [ :keys ]
+    DEFAULT_COLLECTIONS + [ :keys, :load_balancers ]
   end
 
   def images(credentials, opts=nil)
@@ -176,6 +176,88 @@ class GogridDriver < Deltacloud::BaseDriver
     end
   end
 
+ def create_load_balancer(credentials, opts={})
+    gogrid = new_client(credentials)
+    balancer, l_instance = nil, nil
+    safely do
+      virtip = get_free_ip_from_realm(credentials, opts['realm_id'])
+      if opts['instance_id']
+        l_instance = instance(credentials, :id => opts['instance_id'])
+        real_ip = {
+          'realiplist.0.port' => opts['listener_inst_port'],
+          'realiplist.0.ip' => l_instance ? l_instance.public_addresses.first : ""
+        }
+      else
+        real_ip = false
+      end
+      request = {
+        'name' => opts['name'],
+        'virtualip.ip' => virtip,
+        'virtualip.port' => opts['listener_lbr_port'],
+      }
+      request.merge!(real_ip) if real_ip
+      balancer = gogrid.request('grid/loadbalancer/add', request)['list'].first
+    end
+    balancer = convert_load_balancer(credentials, balancer)
+    balancer.instances = [l_instance] if l_instance
+    balancer
+  end
+
+  def destroy_load_balancer(credentials, id)
+    gogrid = new_client(credentials)
+    balancer = nil
+    safely do
+      balancer = gogrid.request('grid/loadbalancer/delete', { 'name' => id })
+      balancer = load_balancer(credentials, :id => id) unless balancer
+    end
+    convert_load_balancer(credentials, balancer)
+  end
+
+  def load_balancers(credentials, opts={})
+    gogrid = new_client(credentials)
+    balancers = []
+    safely do
+      balancer = gogrid.request('grid/loadbalancer/list', opts || {})['list'].each do |balancer|
+        balancers << balancer
+      end
+    end
+    balancers.collect { |b| convert_load_balancer(credentials, b) }
+  end
+
+  def load_balancer(credentials, opts={})
+    gogrid = new_client(credentials)
+    balancer = nil
+    begin
+      balancer = gogrid.request('grid/loadbalancer/get', { 'name' => opts[:id] })['list'].first
+      balancer['instances'] = instances(credentials)
+      return convert_load_balancer(credentials, balancer)
+    rescue OpenURI::HTTPError
+      balancer = load_balancers(credentials, :id => opts[:id]).first
+    end
+  end
+
+
+  def lb_register_instance(credentials, opts={})
+    client = new_client(credentials)
+    instance = instance(credentials, :id => opts[:instance_id])
+    balancer = client.request('grid/loadbalancer/get', { 'name' => opts[:id]})['list'].first
+    safely do
+      convert_load_balancer(credentials, client.request('grid/loadbalancer/edit', {
+        "id" => balancer['id'],
+        "realiplist.#{balancer['realiplist'].size}.ip" => instance.public_addresses.first,
+        "realiplist.#{balancer['realiplist'].size}.port" => balancer['virtualip']['port']
+      }))
+    end
+  end
+
+  # Move this to capabilities
+  def lb_unregister_instance(credentials, opts={})
+      raise Deltacloud::BackendFeatureUnsupported.new('501',
+    'Unregistering instances from load balancer is not supported in GoGrid')
+  end
+
+
+
   def key(credentials, opts=nil)
     keys(credentials, opts).first
   end
@@ -213,8 +295,39 @@ class GogridDriver < Deltacloud::BaseDriver
 
   def new_client(credentials)
     GoGridClient.new('https://api.gogrid.com/api', credentials.user, credentials.password)
+  end
 
+  def convert_load_balancer(credentials, loadbalancer)
+    if loadbalancer['datacenter']
+      b_realm = realm(credentials, :id => loadbalancer['datacenter']['id'])
+    else
+      # Report first Realm until loadbalancer become ready
+      b_realm = realm(credentials, :id => 1)
+    end
+    balancer = LoadBalancer.new({
+      :id => loadbalancer['name'],
+      :realms => [b_realm]
+    })
+    balancer.public_addresses = [loadbalancer['virtualip']['ip']['ip']] if loadbalancer['virtualip'] and loadbalancer['virtualip']['ip']
+    balancer.listeners = []
+    balancer.instances = []
+    instance_ips = []
+    loadbalancer['realiplist'].each do |instance_ip|
+      balancer.add_listener({
+        :protocol => 'TCP',
+        :load_balancer_port => loadbalancer['virtualip']['port'],
+        :instance_port => instance_ip['port']
+      })
+      instance_ips << instance_ip['ip']['ip']
+    end if loadbalancer['realiplist']
+    balancer.instances = get_load_balancer_instances(instance_ips, loadbalancer['instances'])
+    return balancer
   end
+ 
+  def get_load_balancer_instances(instance_ips, instances)
+    instances.select { |i| instance_ips.include?(i.public_addresses.first) } if instances
+  end
+
 
   def get_login_data(client, instance_id)
     login_data = {}
@@ -316,11 +429,11 @@ class GogridDriver < Deltacloud::BaseDriver
     state.eql?('Off') ? 'STOPPED' : 'RUNNING'
   end
 
-  def get_free_ip_from_realm(credentials, realm_id)
+  def get_free_ip_from_realm(credentials, realm_id, ip_type = 1)
     ip = ""
     safely do
       ip = new_client(credentials).request('grid/ip/list', {
-        'ip.type' => '1',
+        'ip.type' => "#{ip_type}",
         'ip.state' => '1',
         'datacenter' => realm_id
       })['list'].first['ip']