bbrowning-deltacloud-core 0.0.1.1

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,322 @@
+#
+# 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'
+
+class Instance
+  attr_accessor :username
+  attr_accessor :password
+  attr_accessor :authn_error
+
+  def authn_feature_failed?
+    return true unless authn_error.nil?
+  end
+end
+
+module Deltacloud
+  module Drivers
+    module Gogrid
+
+class GogridDriver < Deltacloud::BaseDriver
+
+  feature :instances, :authentication_password
+
+  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
+    client = new_client(credentials)
+    name = (opts[:name] && opts[:name]!='') ? opts[:name] : get_random_instance_name
+    safely do
+      instance = client.request('grid/server/add', {
+        'name' => name,
+        'image' => image_id,
+        'server.ram' => server_ram,
+        'ip' => get_next_free_ip(credentials)
+      })['list'].first
+      if instance
+        login_data = get_login_data(client, instance[:id])
+        if login_data['username'] and login_data['password']
+          instance['username'] = login_data['username']
+          instance['password'] = login_data['password']
+          inst = convert_instance(instance, credentials.user)
+        else
+          inst = convert_instance(instance, credentials.user)
+          inst.authn_error = "Unable to fetch password"
+        end
+        return inst
+      else
+        return nil
+      end
+    end
+  end
+
+  def list_instances(credentials, id)
+    instances = []
+    safely do
+      new_client(credentials).request('grid/server/list')['list'].collect do |instance|
+        if id.nil? or instance['name'] == id
+          instances << convert_instance(instance, credentials.user)
+        end
+      end
+    end
+    instances
+  end
+
+  def instances(credentials, opts=nil)
+    instances = []
+    if opts and opts[:id]
+      begin
+        client = new_client(credentials)
+        instance = client.request('grid/server/get', { 'name' => opts[:id] })['list'].first
+        login_data = get_login_data(client, instance['id'])
+        if login_data['username'] and login_data['password']
+          instance['username'] = login_data['username']
+          instance['password'] = login_data['password']
+          inst = convert_instance(instance, credentials.user)
+        else
+          inst = convert_instance(instance, credentials.user)
+          inst.authn_error = "Unable to fetch password"
+        end
+        instances = [inst]
+      rescue Exception => e
+        if e.message == "400 Bad Request"
+          # in the case of a VM that we just made, the grid/server/get method
+          # throws a "400 Bad Request error".  In this case we try again by
+          # getting a full listing a filtering on the id.  This could
+          # potentially take a long time, but I don't see another way to get
+          # information about a newly created instance
+          instances = list_instances(credentials, opts[:id])
+        end
+      end
+    else
+      instances = list_instances(credentials, nil)
+    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 destroy_instance(credentials, id)
+    safely do
+      new_client(credentials).request('grid/server/delete', { 'id' => id})
+    end
+  end
+
+  def stop_instance(credentials, id)
+    safely do
+      new_client(credentials).request('grid/server/power', { 'id' => id, 'power' => 'off'})
+    end
+  end
+
+  def start_instance(credentials, id)
+    safely do
+      new_client(credentials).request('grid/server/power', { 'id' => id, 'power' => 'on'})
+    end
+  end
+
+  define_instance_states do
+    start.to( :pending )         .automatically
+    pending.to( :running )       .automatically
+    running.to( :stopped )       .on( :stop )
+    stopped.to( :running )       .on( :start )
+    running.to( :finish )       .on( :destroy )
+    stopped.to( :finish )       .on( :destroy )
+  end
+
+  private
+
+  def new_client(credentials)
+    GoGridClient.new('https://api.gogrid.com/api', credentials.user, credentials.password)
+  end
+
+  def get_login_data(client, instance_id)
+    login_data = {}
+    begin
+      client.request('support/password/list')['list'].each do |passwd|
+        next unless passwd['server']
+        if passwd['server']['id'] == instance_id
+          login_data['username'], login_data['password'] = passwd['username'], passwd['password']
+          break
+        end
+      end
+    rescue Exception => e
+      login_data[:error] = e.message
+    end
+    return login_data
+  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(
+       # 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
+       # what I can tell, 'name' per user is unique, so it should be sufficient
+       # to uniquely identify this instance.
+      :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 => [],
+      :username => instance['username'],
+      :password => instance['password']
+    )
+  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

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

@@ -0,0 +1,275 @@
+#
+# 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'
+
+module Deltacloud
+  module Drivers
+    module Mock
+class MockDriver < Deltacloud::BaseDriver
+
+  ( REALMS = [
+    Realm.new({
+      :id=>'us',
+      :name=>'United States',
+      :limit=>:unlimited,
+      :state=>'AVAILABLE',
+    }),
+    Realm.new({
+      :id=>'eu',
+      :name=>'Europe',
+      :limit=>:unlimited,
+      :state=>'AVAILABLE',
+    }),
+  ] ) unless defined?( REALMS )
+
+  define_hardware_profile('m1-small') do
+    cpu              1
+    memory         1.7 * 1024
+    storage        160
+    architecture 'i386'
+  end
+
+  define_hardware_profile('m1-large') do
+    cpu                2
+    memory           (7.5*1024 .. 15*1024), :default => 10 * 1024
+    storage          [ 850, 1024 ]
+    architecture     'x86_64'
+  end
+
+  define_hardware_profile('m1-xlarge') do
+    cpu              4
+    memory           (12*1024 .. 32*1024)
+    storage          [ 1024, 2048, 4096 ]
+    architecture     'x86_64'
+  end
+
+  # Some clouds tell us nothing about hardware profiles (e.g., OpenNebula)
+  define_hardware_profile 'opaque'
+
+  define_instance_states do
+    start.to( :pending )       .on( :create )
+
+    pending.to( :running )     .automatically
+
+    running.to( :running )     .on( :reboot )
+    running.to( :stopped )     .on( :stop )
+
+    stopped.to( :running )     .on( :start )
+    stopped.to( :finish )      .on( :destroy )
+  end
+
+  feature :instances, :user_name
+
+  def initialize
+    if ENV["DELTACLOUD_MOCK_STORAGE"]
+      @storage_root = ENV["DELTACLOUD_MOCK_STORAGE"]
+    elsif ENV["USER"]
+      @storage_root = File::join("/var/tmp", "deltacloud-mock-#{ENV["USER"]}")
+    else
+      raise "Please set either the DELTACLOUD_MOCK_STORAGE or USER environment variable"
+    end
+    if ! File::directory?(@storage_root)
+      FileUtils::rm_rf(@storage_root)
+      FileUtils::mkdir_p(@storage_root)
+      data = Dir::glob(File::join(File::dirname(__FILE__), "data", "*"))
+      FileUtils::cp_r(data, @storage_root)
+    end
+  end
+
+  def realms(credentials, opts=nil)
+    return REALMS if ( opts.nil? )
+    results = REALMS
+    results = filter_on( results, :id, opts )
+    results
+  end
+
+  #
+  # Images
+  #
+
+  def images(credentials, opts=nil )
+    check_credentials( credentials )
+    images = []
+    Dir[ "#{@storage_root}/images/*.yml" ].each do |image_file|
+      image = YAML.load( File.read( image_file ) )
+      image[:id] = File.basename( image_file, ".yml" )
+      image[:name] = image[:description]
+      images << Image.new( image )
+    end
+    images = filter_on( images, :id, opts )
+    images = filter_on( images, :architecture, opts )
+    if ( opts && opts[:owner_id] == 'self' )
+      images = images.select{|e| e.owner_id == credentials.user }
+    else
+      images = filter_on( images, :owner_id, opts )
+    end
+    images.sort_by{|e| [e.owner_id,e.description]}
+  end
+
+  #
+  # Instances
+  #
+
+  def instances(credentials, opts=nil)
+    check_credentials( credentials )
+    instances = []
+    Dir[ "#{@storage_root}/instances/*.yml" ].each do |instance_file|
+      instance = YAML.load( File.read( instance_file ) )
+      if ( instance[:owner_id] == credentials.user )
+        instance[:id] = File.basename( instance_file, ".yml" )
+        instance[:actions] = instance_actions_for( instance[:state] )
+        instances << Instance.new( instance )
+      end
+    end
+    instances = filter_on( instances, :id, opts )
+    instances = filter_on( instances, :state, opts )
+    instances
+  end
+
+  def create_instance(credentials, image_id, opts)
+    check_credentials( credentials )
+    ids = Dir[ "#{@storage_root}/instances/*.yml" ].collect{|e| File.basename( e, ".yml" )}
+
+    count = 0
+    while true
+      next_id = "inst" + count.to_s
+      if not ids.include?(next_id)
+        break
+      end
+      count = count + 1
+    end
+
+    realm_id = opts[:realm_id]
+    if ( realm_id.nil? )
+      realm = realms(credentials).first
+      ( realm_id = realm.id ) if realm
+    end
+
+    hwp = find_hardware_profile(credentials, opts[:hwp_id], image_id)
+
+    name = opts[:name] || "i-#{Time.now.to_i}"
+
+    instance = {
+      :name=>name,
+      :state=>'RUNNING',
+      :image_id=>image_id,
+      :owner_id=>credentials.user,
+      :public_addresses=>["#{image_id}.#{next_id}.public.com"],
+      :private_addresses=>["#{image_id}.#{next_id}.private.com"],
+      :instance_profile => InstanceProfile.new(hwp.name, opts),
+      :realm_id=>realm_id,
+      :actions=>instance_actions_for( 'RUNNING' )
+    }
+    File.open( "#{@storage_root}/instances/#{next_id}.yml", 'w' ) {|f|
+      YAML.dump( instance, f )
+    }
+    instance[:id] = next_id
+    Instance.new( instance )
+  end
+
+  def start_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 )
+  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 )
+  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 )
+  end
+
+
+  def destroy_instance(credentials, id)
+    check_credentials( credentials )
+    FileUtils.rm( "#{@storage_root}/instances/#{id}.yml" )
+  end
+
+  #
+  # Storage Volumes
+  #
+
+  def storage_volumes(credentials, opts=nil)
+    check_credentials( credentials )
+    volumes = []
+    Dir[ "#{@storage_root}/storage_volumes/*.yml" ].each do |storage_volume_file|
+      storage_volume = YAML.load( File.read( storage_volume_file ) )
+      if ( storage_volume[:owner_id] == credentials.user )
+        storage_volume[:id] = File.basename( storage_volume_file, ".yml" )
+        volumes << StorageVolume.new( storage_volume )
+      end
+    end
+    volumes = filter_on( volumes, :id, opts )
+    volumes
+  end
+
+  #
+  # Storage Snapshots
+  #
+
+  def storage_snapshots(credentials, opts=nil)
+    check_credentials( credentials )
+    snapshots = []
+    Dir[ "#{@storage_root}/storage_snapshots/*.yml" ].each do |storage_snapshot_file|
+      storage_snapshot = YAML.load( File.read( storage_snapshot_file ) )
+      if ( storage_snapshot[:owner_id] == credentials.user )
+        storage_snapshot[:id] = File.basename( storage_snapshot_file, ".yml" )
+        snapshots << StorageSnapshot.new( storage_snapshot )
+      end
+    end
+    snapshots = filter_on( snapshots, :id, opts )
+    snapshots
+  end
+
+  private
+
+  def check_credentials(credentials)
+    if ( credentials.user != 'mockuser' )
+      raise Deltacloud::AuthException.new
+    end
+
+    if ( credentials.password != 'mockpassword' )
+      raise Deltacloud::AuthException.new
+    end
+  end
+
+
+end
+
+    end
+  end
+end