deltacloud-core 0.0.1

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

@@ -0,0 +1,170 @@
+module RightAws
+  class MockEc2
+    
+    def initialize(opts={})
+    end
+
+    def describe_images(id)
+      load_fixtures_for(:images).select { |i| i[:aws_id].eql?(id) }
+    end
+
+    def describe_images_by_owner(id)
+      load_fixtures_for(:images).select { |i| i[:aws_owner].eql?(id) }
+    end
+
+    def describe_images(opts={})
+      load_fixtures_for(:images)
+    end
+
+    def describe_availability_zones(opts={})
+      load_fixtures_for(:realms)
+    end
+
+    def describe_instances(opts={})
+      instances = load_fixtures_for(:instances)
+      instances.each_with_index do |instance, i|
+        instances[i] = update_delayed_state(instance)
+        return [instance] if opts and opts[:id] and instance[:aws_instance_id].eql?(opts[:id])
+      end
+      update_fixtures_for(:instances, instances)
+      instances
+    end
+
+    def run_instances(image_id, min_count, max_count, group_ids, key_name, user_data='', addressing_type = nil, instance_type = nil, kernel_id = nil, ramdisk_id = nil, availability_zone = nil, block_device_mappings = nil)
+
+      instances = load_fixtures_for(:instances)
+      image = load_fixtures_for(:images).select { |img| img[:aws_id].eql?(image_id) }.first
+
+      if availability_zone
+        realm = load_fixtures_for(:realms).select { |realm| realm[:zone_name].eql?(availability_zone) }.first
+      else
+        realm = load_fixtures_for(:realms).first
+      end
+
+      raise Exception unless image
+      raise Exception unless realm
+
+      instance = { }
+      instance[:aws_image_id] = image[:aws_id]
+      instance[:aws_availability_zone] = realm[:zone_name]
+      instance[:aws_instance_type] = instance_type
+      instance[:aws_owner] = user_data
+      instance[:aws_state] = 'pending'
+      instance[:aws_reason] = ''
+      instance[:dns_name] = "#{random_dns}-01-C9.usma2.compute.amazonaws.com"
+      instance[:private_dns_name] = "#{random_dns}-02-P9.usma2.compute.amazonaws.com"
+      instance[:aws_state_code] = "0"
+      instance[:aws_key_name] = "staging"
+      instance[:aws_kernel_id] = "aki-be3adfd7"
+      instance[:aws_ramdisk_id] = "ari-ce34gad7"
+      instance[:aws_groups] = ["default"]
+      instance[:aws_instance_id] = random_instance_id
+      instance[:aws_reservation_id] = "r-aabbccdd"
+      instance[:aws_launch_time] = instance_time_format
+
+      instances << instance
+
+      update_fixtures_for(:instances, instances)
+
+      return [instance]
+    end
+
+
+    def terminate_instances(id)
+      update_instance_state(id, 'stopping', '80')
+    end
+
+    def reboot_instances(id)
+      update_instance_state(id, 'pending', '0')
+    end
+
+    alias :destroy_instance :terminate_instances
+
+    def describe_snapshots(opts={})
+      load_fixtures_for(:storage_snapshot)
+    end
+
+    def describe_volumes(opts={})
+      load_fixtures_for(:storage_volume)
+    end
+
+    private
+
+    def driver_dir
+      File::expand_path(File::join(File::dirname(__FILE__), '../../../../features/support/ec2'))
+    end
+
+    def fixtures_path
+      File::expand_path(File::join(driver_dir, 'fixtures'))
+    end
+
+    def load_fixtures_for(collection)
+      YAML.load_file(File::join(fixtures_path, "#{collection}.yaml"))
+    end
+
+    def update_fixtures_for(collection, new_data)
+      File.open(File::join(fixtures_path, "#{collection}.yaml"), 'w' ) do |out|
+        YAML.dump(new_data, out)
+      end
+      return new_data
+    end
+
+    def instance_time_format
+      DateTime.now.to_s.gsub(/\+(.+)$/, '.000Z')
+    end
+
+    def random_instance_id
+      id_1 = ("%.4s" % Time.now.to_i.to_s.reverse).reverse
+      id_2 = ("%.3s" % Time.now.to_i.to_s.reverse)
+      "i-#{id_1}f#{id_2}"
+    end
+
+    def random_dns
+      "domU-#{rand(90)+10}-#{rand(90)+10}-#{rand(90)+10}-#{rand(90)+10}"
+    end
+
+    def update_delayed_state(instance)
+      time = DateTime.now - DateTime.parse(instance[:aws_launch_time])
+      hours, minutes, seconds, frac = Date.day_fraction_to_time(time)
+
+      if (minutes>(rand(2)+1) or hours>0) and instance[:aws_state].eql?('pending')
+        instance[:aws_state], instance[:aws_state_code] = 'running', '16'
+      end
+
+      if (minutes>(rand(1)+1) or hours>0) and instance[:aws_state].eql?('stopping')
+        instance[:aws_state], instance[:aws_state_code] = 'stopped', '80'
+      end
+
+      return instance
+    end
+
+    def update_instance_state(id, state, state_code)
+      instance = describe_instances(:id => id).first
+      if instance
+        instance[:aws_state], instance[:aws_state_code] = state, state_code
+        instance[:aws_launch_time] = instance_time_format
+        instances = load_fixtures_for(:instances)
+        instances.each_with_index do |inst, i|
+          instances[i] = instance if inst[:aws_instance_id].eql?(id)       
+        end
+        update_fixtures_for(:instances, instances)
+        return instance
+      else
+        raise Exception
+      end
+    end
+
+  end
+end
+
+Deltacloud::Drivers::EC2::EC2Driver.class_eval do
+  alias_method :original_new_client, :new_client
+
+  def new_client(credentials, opts={})
+    if credentials.user != 'mockuser' and credentials.password != 'mockpassword'
+      raise Deltacloud::AuthException.new
+    end
+    RightAws::MockEc2.new
+  end
+
+end

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

@@ -0,0 +1,45 @@
+require 'digest/md5'
+require 'cgi'
+require 'open-uri'
+require 'json'
+
+class GoGridClient
+
+  def initialize(server='https://api.gogrid.com/api',
+                 apikey='YOUR API KEY',
+                 secret='YOUR SHARED SECRET', 
+                 format='json',
+                 version='1.4')
+    @server = server
+    @secret = secret
+    @default_params = {'format'=>format, 'v'=>version,'api_key' => apikey}
+  end    
+  
+  def getRequestURL(method,params)
+    requestURL = @server+'/'+method+'?'
+  	call_params = @default_params.merge(params)
+  	call_params['sig']=getSignature(@default_params['api_key'],@secret)
+  	requestURL = requestURL+encode_params(call_params)
+  end
+  
+  def getSignature(key,secret)
+    Digest::MD5.hexdigest(key+secret+"%.0f"%Time.new.to_f)
+  end
+  
+  def sendAPIRequest(method,params={})
+    open(getRequestURL(method,params)).read
+  end
+
+  def request(method, params={})
+    begin
+      JSON::parse(sendAPIRequest(method, params))
+    rescue Exception => e
+      STDERR.puts("ERROR: #{e.message}")
+    end
+  end
+  
+  def encode_params(params)
+    params.map {|k,v| "#{CGI.escape(k.to_s)}=#{CGI.escape(v.to_s)}" }.join("&")
+  end
+    
+end

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

@@ -0,0 +1,239 @@
+#
+# Copyright (C) 2009  Red Hat, Inc.
+#
+# This library is free software; you can redistribute it and/or
+# modify it under the terms of the GNU Lesser General Public
+# License as published by the Free Software Foundation; either
+# version 2.1 of the License, or (at your option) any later version.
+#
+# This library is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+# Lesser General Public License for more details.
+#
+# You should have received a copy of the GNU Lesser General Public
+# License along with this library; if not, write to the Free Software
+# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
+
+require 'deltacloud/base_driver'
+require 'deltacloud/drivers/gogrid/gogrid_client'
+
+module Deltacloud
+  module Drivers
+    module Gogrid
+
+class GogridDriver < Deltacloud::BaseDriver
+
+  define_hardware_profile 'server' do
+    cpu            2
+    memory         [512, 1024, 2048, 4096, 8192]
+    storage        10
+  end
+
+  # The only valid option for flavors is server RAM for now
+  def flavors(credentials, opts=nil)
+    flavors = []
+    safely do
+      flavors=new_client(credentials).request('common/lookup/list', { 'lookup' => 'server.ram' })['list'].collect do |flavor|
+        convert_flavor(flavor)
+      end
+    end
+    flavors = filter_on( flavors, :id, opts )
+    flavors = filter_on( flavors, :architecture, opts )
+    flavors
+  end
+
+  def images(credentials, opts=nil)
+    imgs = []
+    if opts and opts[:id]
+      safely do
+        imgs = [convert_image(new_client(credentials).request('grid/image/get', { 'id' => opts[:id] })['list'].first)]
+      end
+    else
+      safely do
+        imgs = new_client(credentials).request('grid/image/list', { 'state' => 'Available'})['list'].collect do |image|
+          convert_image(image, credentials.user)
+        end
+      end
+    end
+    imgs = filter_on( imgs, :architecture, opts )
+    imgs.sort_by{|e| [e.owner_id, e.description]}
+  end
+
+  def realms(credentials, opts=nil)
+    safely do
+      new_client(credentials).request('common/lookup/list', { 'lookup' => 'image.type' })['list'].collect do |realm|
+        convert_realm(realm)
+      end
+    end
+  end
+
+  def create_instance(credentials, image_id, opts=nil)
+    server_ram = nil
+    if opts[:hwp_memory]
+      mem = opts[:hwp_memory].to_i
+      server_ram = (mem == 512) ? "512MB" : "#{mem / 1024}GB"
+    else
+      server_ram = "512MB"
+    end
+    name = (opts[:name] && opts[:name]!='') ? opts[:name] : get_random_instance_name
+    safely do
+      convert_instance(new_client(credentials).request('grid/server/add', {
+        'name' => name,
+        'image' => image_id,
+        'server.ram' => server_ram,
+        'ip' => get_next_free_ip(credentials)
+      })['list'].first, credentials.user)
+    end
+  end
+
+  def instances(credentials, opts=nil)
+    instances = []
+    if opts and opts[:id]
+      safely do
+        instance = new_client(credentials).request('grid/server/get', { 'id' => opts[:id]})['list'].first
+        instances = [convert_instance(instance, credentials.user)]
+      end
+    else
+      safely do
+        instances = new_client(credentials).request('grid/server/list')['list'].collect do |instance|
+          convert_instance(instance, credentials.user)
+        end
+      end
+    end
+    instances = filter_on( instances, :state, opts )
+    instances
+  end
+
+  def reboot_instance(credentials, id)
+    safely do
+      new_client(credentials).request('grid/server/power', { 'id' => id, 'power' => 'reboot'})
+    end
+  end
+
+  def stop_instance(credentials, id)
+    safely do
+      new_client(credentials).request('grid/server/power', { 'id' => id, 'power' => 'off'})
+    end
+  end
+
+  def destroy_instance(credentials, id)
+    safely do
+      new_client(credentials).request('grid/server/delete', { 'id' => id})
+    end
+  end
+
+  define_instance_states do
+    start.to( :pending )         .automatically
+    pending.to( :running )       .automatically
+    running.to( :stopped )       .on( :stop )
+    stopped.to( :running )       .on( :start )
+    stopped.to( :finish )        .automatically
+  end
+
+  private
+
+  def new_client(credentials)
+    GoGridClient.new('https://api.gogrid.com/api', credentials.user, credentials.password)
+  end
+
+  def convert_image(gg_image, owner_id=nil)
+    Image.new( {
+      :id=>gg_image['id'],
+      :name => gg_image['friendlyName'],
+      :description=> convert_description(gg_image),
+      :owner_id=>gg_image['owner']['name'],
+      :architecture=>convert_arch(gg_image['description']),
+    } )
+  end
+
+  def convert_description(image)
+    if image['price'].eql?(0)
+      image['description']
+    else
+      "#{image['description']} (#{image['price']}$)"
+    end
+  end
+
+  def convert_flavor(flavor)
+    Flavor.new(
+      :id => flavor['id'],
+      :architecture => 'x86',
+      :memory => flavor['name'].tr('G', ''),
+      :storage => '1'
+    )
+  end
+
+  def convert_realm(realm)
+    Realm.new(
+      :id => realm['id'],
+      :name => realm['name'],
+      :state => :unlimited,
+      :storage => :unlimited
+    )
+  end
+
+  def convert_arch(description)
+    description.include?('64-bit') ? 'x86_64' : 'i386'
+  end
+
+  def convert_instance(instance, owner_id)
+    opts = {}
+    unless instance['ram']['id'] == "1"
+      mem = instance['ram']['name']
+      if mem == "512MB"
+        opts[:hwp_memory] = "512"
+      else
+        opts[:hwp_memory] = (mem.to_i * 1024).to_s
+      end
+    end
+    prof = InstanceProfile.new("server", opts)
+
+    Instance.new(
+      :id => instance['name'],
+      :owner_id => owner_id,
+      :image_id => instance['image']['id'],
+      :flavor_id => instance['ram']['id'],
+      :instance_profile => prof,
+      :name => instance['name'],
+      :realm_id => instance['type']['id'],
+      :state => convert_server_state(instance['state']['name'], instance['id']),
+      :actions => instance_actions_for(convert_server_state(instance['state']['name'], instance['id'])),
+      :public_addresses => [ instance['ip']['ip'] ],
+      :private_addresses => []
+    )
+  end
+
+  def get_random_instance_name
+    "Server #{Time.now.to_i.to_s.reverse[0..3]}#{rand(9)}"
+  end
+
+  def convert_server_state(state, id)
+    return 'PENDING' unless id
+    state.eql?('Off') ? 'STOPPED' : 'RUNNING'
+  end
+
+  def get_next_free_ip(credentials)
+    ip = ""
+    safely do
+      ip = new_client(credentials).request('grid/ip/list', {
+        'ip.type' => '1',
+        'ip.state' => '1'
+      })['list'].first['ip']
+    end
+    return ip
+  end
+
+  def safely(&block)
+    begin
+      block.call
+    rescue Exception => e
+      puts "ERROR: #{e.message}"
+    end
+  end
+
+end
+
+    end
+  end
+end