steamcannon-deltacloud-core 0.0.7.1-java

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,50 @@
+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.5')
+    @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={}, version=nil)
+    if version
+      @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
+  
+  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,343 @@
+#
+# Copyright (C) 2009  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.
+
+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
+
+  def supported_collections
+    DEFAULT_COLLECTIONS.reject! { |c| [ :storage_volumes, :storage_snapshots ].include?(c) }
+    DEFAULT_COLLECTIONS + [ :keys ]
+  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' => 'ip.datacenter' })['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_free_ip_from_realm(credentials, opts[:realm_id] || '1')
+      })['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', { 'name' => id, 'power' => 'reboot'})
+    end
+  end
+
+  def destroy_instance(credentials, id)
+    safely do
+      new_client(credentials).request('grid/server/delete', { 'name' => id})
+    end
+  end
+
+  def stop_instance(credentials, id)
+    safely do
+      new_client(credentials).request('grid/server/power', { 'name' => id, 'power' => 'off'})
+    end
+  end
+
+  def start_instance(credentials, id)
+    safely do
+      new_client(credentials).request('grid/server/power', { 'name' => id, 'power' => 'on'})
+    end
+  end
+
+  def key(credentials, opts=nil)
+    keys(credentials, opts).first
+  end
+
+  def keys(credentials, opts=nil)
+    gogrid = new_client( credentials )
+    creds = []
+    safely do
+      gogrid.request('support/password/list')['list'].each do |password|
+        creds << convert_key(password)
+      end
+    end
+    return creds
+  end
+
+  def valid_credentials?(credentials)
+    client = new_client(credentials)
+    # FIXME: We need to do this call to determine if
+    #        GoGrid is working with given credentials. There is no
+    #        other way to check, if given credentials are valid or not.
+    return false unless new_client(credentials).request('common/lookup/list', { 'lookup' => 'ip.datacenter' })
+    true
+  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_key(password)
+    Key.new({
+      :id => password['id'],
+      :username => password['username'],
+      :password => password['password'],
+      :credential_type => :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_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)
+
+    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
+       # 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'],
+      :instance_profile => prof,
+      :name => instance['name'],
+      :realm_id => instance['ip']['datacenter']['id'],
+      :state => state,
+      :actions => instance_actions_for(state),
+      :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_free_ip_from_realm(credentials, realm_id)
+    ip = ""
+    safely do
+      ip = new_client(credentials).request('grid/ip/list', {
+        'ip.type' => '1',
+        'ip.state' => '1',
+        'datacenter' => realm_id
+      })['list'].first['ip']
+    end
+    return ip
+  end
+
+  def safely(&block)
+    begin
+      block.call
+    rescue Exception => e
+      raise Deltacloud::BackendError.new(500, e.class.to_s, e.message, e.backtrace)
+    end
+  end
+
+end
+
+    end
+  end
+end

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

@@ -0,0 +1,13 @@
+require 'gogrid_client'
+require 'ap'
+
+user='fbb1de3897597ccf'
+password='ngieth10'
+
+client=GoGridClient.new('https://api.gogrid.com/api', user, password)
+
+ap client.request('grid/ip/list', {
+  'ip.type' => '1',
+  'ip.state' => '1',
+  'datacenter' => '1'
+})

data/lib/deltacloud/drivers/mock/data/buckets/blobs/blob1.yml

@@ -0,0 +1,5 @@
+:bucket: bucket1
+:content_length: 12627
+:content_type: text/plain
+:last_modified: 2010-09-23 16:44:54 +0100
+:content: "content of blob 1"

data/lib/deltacloud/drivers/mock/data/buckets/blobs/blob2.yml

@@ -0,0 +1,5 @@
+:bucket: bucket1
+:content_length: 4420
+:content_type: text/html
+:last_modified: 2010-09-23 16:55:05 +0100
+:content: "content of blob 2"

data/lib/deltacloud/drivers/mock/data/buckets/blobs/blob3.yml

@@ -0,0 +1,5 @@
+:bucket: bucket1
+:content_length: 98732
+:content_type: text/plain
+:last_modified: 2010-08-14 02:14:31 +0100
+:content: "content of blob 3"

data/lib/deltacloud/drivers/mock/data/buckets/blobs/blob4.yml

@@ -0,0 +1,5 @@
+:bucket: bucket2
+:content_length: 983232
+:content_type: application/octet-stream
+:last_modified: 2010-09-21 06:17:24 +0100
+:content: "content of blob 4"

data/lib/deltacloud/drivers/mock/data/buckets/blobs/blob5.yml

@@ -0,0 +1,5 @@
+:bucket: bucket2
+:content_length: 651922
+:content_type: application/pdf
+:last_modified: 2009-07-21 11:12:13 +0100
+:content: "content of blob 5"

data/lib/deltacloud/drivers/mock/data/buckets/bucket1.yml

@@ -0,0 +1,2 @@
+:blob_list: [blob1, blob2, blob3]
+:size: 3

data/lib/deltacloud/drivers/mock/data/buckets/bucket2.yml

@@ -0,0 +1,2 @@
+:blob_list: [blob4, blob5]
+:size: 2

data/lib/deltacloud/drivers/mock/data/images/img1.yml

@@ -0,0 +1,3 @@
+:description: Fedora 10
+:owner_id: fedoraproject
+:architecture: x86_64

data/lib/deltacloud/drivers/mock/data/images/img2.yml

@@ -0,0 +1,3 @@
+:description: Fedora 10
+:owner_id: fedoraproject
+:architecture: i386

data/lib/deltacloud/drivers/mock/data/images/img3.yml

@@ -0,0 +1,3 @@
+:description: JBoss
+:owner_id: mockuser
+:architecture: i386

data/lib/deltacloud/drivers/mock/data/instances/inst0.yml

@@ -0,0 +1,16 @@
+---
+:realm_id: us
+:public_addresses:
+- img1.inst0.public.com
+:state: RUNNING
+:name: "Mock Instance With Profile Change"
+:private_addresses:
+- img1.inst0.private.com
+:image_id: img1
+:instance_profile: !ruby/object:InstanceProfile
+  id: m1-large
+  memory: "12288"
+:owner_id: mockuser
+:actions:
+- :reboot
+- :stop

data/lib/deltacloud/drivers/mock/data/instances/inst1.yml

@@ -0,0 +1,9 @@
+:name: MockUserInstance
+:state: RUNNING
+:image_id: img3
+:owner_id: mockuser
+:public_addresses: [ img3.inst1.public.com ]
+:private_addresses: [ img3.inst1.private.com ]
+:realm_id: us
+:instance_profile: !ruby/object:InstanceProfile
+  id: m1-small

data/lib/deltacloud/drivers/mock/data/instances/inst2.yml

@@ -0,0 +1,9 @@
+:name: AnotherInstance
+:state: RUNNING
+:image_id: img1
+:owner_id: anotheruser
+:public_addresses: [ img1.inst2.public.com ]
+:private_addresses: [ img1.inst2.private.com ]
+:realm_id: us
+:instance_profile: !ruby/object:InstanceProfile
+  id: m1-large

data/lib/deltacloud/drivers/mock/data/storage_snapshots/snap1.yml

@@ -0,0 +1,4 @@
+:owner_id: fedoraproject
+:created: Wed Jul 29 18:15:24 UTC 2009
+:state: COMPLETED
+:storage_volume_id: vol1

data/lib/deltacloud/drivers/mock/data/storage_snapshots/snap2.yml

@@ -0,0 +1,4 @@
+:owner_id: mockuser
+:created: Wed Jul 29 18:15:24 UTC 2009
+:state: COMPLETED
+:storage_volume_id: vol2

data/lib/deltacloud/drivers/mock/data/storage_snapshots/snap3.yml

@@ -0,0 +1,4 @@
+:owner_id: mockuser
+:created: Wed Jul 29 18:15:24 UTC 2009
+:state: COMPLETED
+:storage_volume_id: vol2