steamcannon-deltacloud-core 0.0.8.1 → 0.1.1.1

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']

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

@@ -26,7 +26,7 @@ module Deltacloud
 class MockDriver < Deltacloud::BaseDriver
 
   def supported_collections
-    DEFAULT_COLLECTIONS + [ :buckets ]
+    DEFAULT_COLLECTIONS + [ :buckets, :keys]
   end
 
   ( REALMS = [
@@ -81,6 +81,7 @@ class MockDriver < Deltacloud::BaseDriver
   end
 
   feature :instances, :user_name
+  feature :instances, :authentication_key
 
   def initialize
     if ENV["DELTACLOUD_MOCK_STORAGE"]
@@ -131,11 +132,21 @@ class MockDriver < Deltacloud::BaseDriver
   # Instances
   #
 
+  def instance(credentials, opts={})
+    check_credentials( credentials )
+    instance_filename = File.join(@storage_root, 'instances', "#{opts[:id]}.yml")
+    return nil unless File.exists?(instance_filename)
+    instance = YAML::load_file(instance_filename)
+    instance[:actions] = instance_actions_for( instance[:state] )
+    instance[:id] = File::basename(instance_filename, ".yml")
+    Instance.new(instance)
+  end
+
   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 ) )
+      instance = YAML::load_file(instance_file)
       if ( instance[:owner_id] == credentials.user )
         instance[:id] = File.basename( instance_file, ".yml" )
         instance[:actions] = instance_actions_for( instance[:state] )
@@ -254,6 +265,49 @@ class MockDriver < Deltacloud::BaseDriver
     snapshots
   end
 
+  def keys(credentials, opts={})
+    check_credentials(credentials)
+    result = []
+    key_dir = File.join(@storage_root, 'keys')
+    Dir[key_dir + '/*.yml'].each do |key_file|
+      result << Key.new(YAML::load(File.read(key_file)))
+    end
+    result = filter_on( result, :id, opts )
+    result
+  end
+
+  def key(credentials, opts={})
+    keys(credentials, opts).first
+  end
+
+  def create_key(credentials, opts={})
+    check_credentials(credentials)
+    key_hash = {
+      :id => opts[:key_name],
+      :credential_type => :key,
+      :fingerprint => Key::generate_mock_fingerprint,
+      :pem_rsa_key => Key::generate_mock_pem
+    }
+    key_dir = File.join(@storage_root, 'keys')
+    if File.exists?(key_dir + "/#{key_hash[:id]}.yml")
+     raise Deltacloud::BackendError.new(403, self.class.to_s, "key-exists",
+                                          ["Key with same name already exists"])
+    end
+    FileUtils.mkdir_p(key_dir) unless File.directory?(key_dir)
+    File.open(key_dir + "/#{key_hash[:id]}.yml", 'w') do |f|
+      f.puts(YAML::dump(key_hash))
+    end
+    return Key.new(key_hash)
+  end
+
+  def destroy_key(credentials, opts={})
+    key = key(credentials, opts)
+    safely do
+      key_dir = File.join(@storage_root, 'keys')
+      File.delete(key_dir + "/#{key.id}.yml")
+    end
+  end
+
 #--
 # Buckets
 #--

data/lib/deltacloud/drivers/rhevm/rhevm_driver.rb

@@ -35,6 +35,10 @@ class RHEVMDriver < Deltacloud::BaseDriver
 
   feature :instances, :user_name
 
+  def supported_collections
+    DEFAULT_COLLECTIONS.reject { |c| [ :storage_volumes, :storage_snapshots ].include?(c) }
+  end
+
   #
   # Execute a Powershell command, and convert the output
   # to YAML in order to get back an array of maps.
@@ -85,6 +89,7 @@ class RHEVMDriver < Deltacloud::BaseDriver
       "STOPPED"
     when "POWERING UP"
       "PENDING"
+    end
   end
 
   define_hardware_profile 'rhevm'
@@ -232,25 +237,6 @@ class RHEVMDriver < Deltacloud::BaseDriver
     vm = execute(credentials, "deleteVm.ps1", image_id)
     vm_to_instance(vm[0])
   end
-
-  #
-  # Storage Volumes
-  #
-
-  def storage_volumes(credentials, ids=nil)
-    volumes = []
-    volumes
-  end
-
-  #
-  # Storage Snapshots
-  #
-
-  def storage_snapshots(credentials, ids=nil)
-    snapshots = []
-    snapshots
-  end
-
 end
 
     end

data/lib/deltacloud/helpers/application_helper.rb

@@ -38,11 +38,15 @@ module ApplicationHelper
   end
 
   def instance_action_method(action)
-    collections[:instances].operations[action.to_sym].method
+    action_method(action, :instances)
   end
 
-  def driver_has_feature?(feature_name)
-    not driver.features(:instances).select{ |f| f.name.eql?(feature_name) }.empty?
+  def action_method(action, collection)
+    collections[collection].operations[action.to_sym].method
+  end
+
+  def driver_has_feature?(feature_name, collection_name = :instances)
+    not driver.features(collection_name).select{ |f| f.name.eql?(feature_name) }.empty?
   end
 
   def driver_has_auth_features?
@@ -102,6 +106,14 @@ module ApplicationHelper
   end
 
   def instance_action(name)
+    original_instance = driver.instance(credentials, :id => params[:id])
+
+    # If original instance doesn't include called action
+    # return with 405 error (Method is not Allowed)
+    unless driver.instance_actions_for(original_instance.state).include?(name.to_sym)
+      return report_error(405, 'not_allowed')
+    end
+
     @instance = driver.send(:"#{name}_instance", credentials, params["id"])
 
     return redirect(instances_url) if name.eql?(:destroy) or @instance.class!=Instance
@@ -122,4 +134,15 @@ module ApplicationHelper
     "<pem><![CDATA[#{text.strip}]]></pem>"
   end
 
+  def link_to_action(action, url, method)
+    capture_haml do
+      haml_tag :form, :method => :post, :action => url, :class => :link do
+        haml_tag :input, :type => :hidden, :name => '_method', :value => method
+        haml_tag :button, :type => :submit do 
+          haml_concat action
+        end
+      end
+    end
+  end
+
 end

data/lib/deltacloud/models/image.rb

@@ -23,5 +23,6 @@ class Image < BaseModel
   attr_accessor :owner_id
   attr_accessor :description
   attr_accessor :architecture
+  attr_accessor :state
 
-end
+end

data/lib/deltacloud/models/instance.rb

@@ -29,10 +29,27 @@ class Instance < BaseModel
   attr_accessor :private_addresses
   attr_accessor :instance_profile
   attr_accessor :launch_time
- def initialize(init=nil)
-   super(init)
-   self.actions = [] if self.actions.nil?
-   self.public_addresses = [] if self.public_addresses.nil?
-   self.private_addresses = [] if self.private_addresses.nil?
+  attr_accessor :keyname
+  attr_accessor :authn_error
+
+  def initialize(init=nil)
+    super(init)
+    self.actions = [] if self.actions.nil?
+    self.public_addresses = [] if self.public_addresses.nil?
+    self.private_addresses = [] if self.private_addresses.nil?
+  end
+
+  def method_missing(name, *args)
+    if name =~ /is_(\w+)\?/
+      return true if self.state.downcase.eql?($1)
+    else
+      raise NoMethodError
+    end
   end
+
+  def authn_feature_failed?
+    return true unless authn_error.nil?
+  end
+ 
+
 end

data/lib/deltacloud/models/key.rb

@@ -23,6 +23,7 @@ class Key < BaseModel
   attr_accessor :username
   attr_accessor :password
   attr_accessor :pem_rsa_key
+  attr_accessor :state
 
   def is_password?
     true if @credential_type.eql?(:password)
@@ -32,4 +33,20 @@ class Key < BaseModel
     true if @credential_type.eql?(:key)
   end
 
+  # Mock fingerprint generator
+  # 1f:51:ae:28:bf:89:e9:d8:1f:25:5d:37:2d:7d:b8:ca:9f:f5:f1:6f
+  def self.generate_mock_fingerprint
+    (0..19).map { "%02x" % (rand * 0xff) }.join(':')
+  end
+
+  # Mock PEM file
+  # NOTE: This is a fake PEM file, it will not work against SSH
+  def self.generate_mock_pem
+    chars = (('a'..'z').to_a + ('A'..'Z').to_a + ('0'..'9').to_a + %w(= / + ))
+    pem_material = (1..21).map do 
+      (1..75).collect{|a| chars[rand(chars.size)] }.join
+    end.join("\n") + "\n" + (1..68).collect{|a| chars[rand(chars.size)] }.join
+    "-----BEGIN RSA PRIVATE KEY-----\n"+pem_material+"-----END RSA PRIVATE KEY-----"
+  end
+
 end

data/lib/deltacloud/models/load_balancer.rb

@@ -0,0 +1,39 @@
+#
+# 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.
+
+
+class LoadBalancer < BaseModel
+
+  attr_accessor :realms
+  attr_accessor :listeners
+  attr_accessor :instances
+  attr_accessor :public_addresses
+  attr_accessor :created_at
+
+  def add_listener(opts)
+    @listeners << Listener.new(opts)
+  end
+
+  class Listener < BaseModel
+    attr_accessor :protocol
+    attr_accessor :load_balancer_port
+    attr_accessor :instance_port
+  end
+
+end
+