deltacloud-core 0.0.9 → 0.1.0

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

@@ -41,8 +41,8 @@ module ApplicationHelper
     collections[:instances].operations[action.to_sym].method
   end
 
-  def driver_has_feature?(feature_name)
-    not driver.features(:instances).select{ |f| f.name.eql?(feature_name) }.empty?
+  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 +102,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 +130,16 @@ module ApplicationHelper
     "<pem><![CDATA[#{text.strip}]]></pem>"
   end
 
+  def link_to_action(action, url, method)
+    return link_to(action, url) if method.eql? :get
+    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/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

@@ -32,4 +32,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/{tag.rb → load_balancer.rb}

@@ -16,28 +16,24 @@
 # License for the specific language governing permissions and limitations
 # under the License.
 
-class Tag < BaseModel
 
-  attr_accessor :resource_id
-  attr_accessor :resource_type
-  attr_accessor :values
+class LoadBalancer < BaseModel
 
-  def add_value(name)
-    self.values << Value.new(name, self)
-  end
-
-  class Value
-    attr_accessor :name
-    attr_accessor :tag_id
-
-    def initialize(name, tag_id)
-      self.name, self.tag_id = name, tag_id
-    end
+  attr_accessor :realms
+  attr_accessor :listeners
+  attr_accessor :instances
+  attr_accessor :public_addresses
+  attr_accessor :created_at
 
-    def to_s
-      self.name
-    end
+  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
+

data/lib/sinatra/rabbit.rb

@@ -1,6 +1,7 @@
 require 'sinatra/base'
 require 'sinatra/url_for'
 require 'deltacloud/validation'
+require 'deltacloud/backend_capability'
 
 module Sinatra
 
@@ -13,6 +14,7 @@ module Sinatra
     class Operation
       attr_reader :name, :method
 
+      include ::Deltacloud::BackendCapability
       include ::Deltacloud::Validation
 
       STANDARD = {
@@ -58,6 +60,7 @@ module Sinatra
       def control(&block)
         op = self
         @control = Proc.new do
+          op.check_capability(driver)
           op.validate(params)
           instance_eval(&block)
         end

data/parse.rb

@@ -0,0 +1,7 @@
+require 'rubygems'
+require 'nokogiri'
+require 'ap'
+
+doc = Nokogiri::XML(File.read("/home/mfojtik/Autounattend.xml"))
+
+ap (doc/"//*[local-name()='component']/*[local-name()='ProductKey']").text

data/public/javascripts/application.js

@@ -3,30 +3,16 @@
 
 $(document).ready(function() {
 
-  $("a.delete").click(function(e) {
-    var original_url = $(this).attr('href')
-    $.ajax({
-      url : original_url,
-      type : 'DELETE',
-      cache : false,
-      success: function(data) {
-        window.location = original_url.replace(/\/([\w_-]+)$/i, '')
+  if ($('select#list_instances').length) {
+    $('select#list_instances').html("<option>Loading instances...</option>");
+    $.getJSON("/api/instances?state=RUNNING&format=json",
+      function(data){
+        $('select#list_instances').empty();
+        $.each(data.instances, function(i,item){
+          $('select#list_instances').append('<option value="'+item.id+'">'+item.id+'</option>');
+        });
       }
-    })
-    return false;
-  })
-
-  $("a.post").click(function(e) {
-    var original_url = $(this).attr('href')
-    $.ajax({
-      url : original_url,
-      type : 'POST',
-      dataType : 'xml',
-      success: function(data) {
-        window.location = original_url.replace(/\/([\w_-]+)$/i, '')
-      }
-    })
-    return false;
-  })
+    );
+  }
 
 })

data/public/stylesheets/compiled/application.css

@@ -611,3 +611,5 @@ input[type='radio'] {
 table.docs { border : 1px solid #ccc }
 table.docs td { border : 1px solid #ccc }
 table.docs table td { border : none }
+
+td form.link { display : inline }

data/server.rb

@@ -32,6 +32,9 @@ error Deltacloud::Validation::Failure do
   report_error(400, "validation_failure")
 end
 
+error Deltacloud::BackendCapability::Failure do
+  report_error(405, "backend_capability_failure")
+end
 error Deltacloud::AuthException do
   report_error(403, "auth_exception")
 end
@@ -82,6 +85,7 @@ END
     Operation will list all available realms. Realms can be filtered using
     the "architecture" parameter.
 END
+    with_capability :realms
     param :id,            :string
     param :architecture,  :string,  :optional,  [ 'i386', 'x86_64' ]
     control { filter_all(:realms) }
@@ -90,6 +94,7 @@ END
   #FIXME: It always shows whole list
   operation :show do
     description 'Show an realm identified by "id" parameter.'
+    with_capability :realm
     param :id,           :string, :required
     control { show(:realm) }
   end
@@ -108,6 +113,7 @@ END
     available to the current use. Images can be filtered using the
     "owner_id" and "architecture" parameters.
 END
+    with_capability :images
     param :id,            :string
     param :architecture,  :string,  :optional
     control { filter_all(:images) }
@@ -115,6 +121,7 @@ END
 
   operation :show do
     description 'Show an image identified by "id" parameter.'
+    with_capability :image
     param :id,           :string, :required
     control { show(:image) }
   end
@@ -168,11 +175,87 @@ get "/api/instances/new" do
   @image   = driver.image( credentials, :id => params[:image_id] )
   @hardware_profiles = driver.hardware_profiles(credentials, :architecture => @image.architecture )
   @realms = driver.realms(credentials)
+  if driver_has_feature?(:register_to_load_balancer)
+    @load_balancers = driver.load_balancers(credentials)
+  end
   respond_to do |format|
     format.html { haml :"instances/new" }
   end
 end
 
+get '/api/load_balancers/new' do
+  @realms = driver.realms(credentials)
+  @instances = driver.instances(credentials) if driver_has_feature?(:register_instance, :load_balancers)
+  respond_to do |format|
+    format.html { haml :"load_balancers/new" }
+  end
+end
+
+
+collection :load_balancers do
+  description "Load balancers"
+
+  operation :index do
+    description "List of all active load balancers"
+    control do
+      filter_all :load_balancers
+    end
+  end
+
+  operation :show do
+    description "Show details about given load balancer"
+    param :id,  :string,  :required
+    control { show :load_balancer }
+  end
+
+  operation :create do
+    description "Create a new load balancer"
+    param :name,  :string,  :required
+    param :realm_id,  :string,  :required
+    param :listener_protocol,  :string,  :required, ['HTTP', 'TCP']
+    param :listener_balancer_port,  :string,  :required
+    param :listener_instance_port,  :string,  :required
+    control do
+      @load_balancer = driver.create_load_balancer(credentials, params)
+      respond_to do |format|
+        format.xml { haml :"load_balancers/show" }
+        format.html { haml :"load_balancers/show" }
+      end
+    end
+  end
+
+  operation :register, :method => :post, :member => true do
+    description "Add instance to loadbalancer"
+    param :id,  :string,  :required
+    param :instance_id, :string,  :required
+    control do
+      driver.lb_register_instance(credentials, params)
+      redirect(load_balancer_url(params[:id]))
+    end
+  end
+
+  operation :unregister, :method => :post, :member => true do
+    description "Remove instance from loadbalancer"
+    param :id,  :string,  :required
+    param :instance_id, :string,  :required
+    control do
+      driver.lb_unregister_instance(credentials, params)
+      redirect(load_balancer_url(params[:id]))
+    end
+  end
+
+  operation :destroy do
+    description "Destroy given load balancer"
+    param :id,  :string,  :required
+    control do
+      driver.destroy_load_balancer(credentials, params[:id])
+      redirect(load_balancers_url)
+    end
+  end
+
+end
+
+
 collection :instances do
   description <<END
   An instance is a concrete machine realized from an image.
@@ -181,6 +264,7 @@ END
 
   operation :index do
     description "List all instances."
+    with_capability :instances
     param :id,            :string,  :optional
     param :state,         :string,  :optional
     control { filter_all(:instances) }
@@ -188,12 +272,14 @@ END
 
   operation :show do
     description 'Show an instance identified by "id" parameter.'
+    with_capability :instance
     param :id,           :string, :required
     control { show(:instance) }
   end
 
   operation :create do
     description "Create a new instance."
+    with_capability :create_instance
     param :image_id,     :string, :required
     param :realm_id,     :string, :optional
     param :hwp_id,       :string, :optional
@@ -217,24 +303,28 @@ END
 
   operation :reboot, :method => :post, :member => true do
     description "Reboot a running instance."
+    with_capability :reboot_instance
     param :id,           :string, :required
     control { instance_action(:reboot) }
   end
 
   operation :start, :method => :post, :member => true do
     description "Start an instance."
+    with_capability :start_instance
     param :id,           :string, :required
     control { instance_action(:start) }
   end
 
   operation :stop, :method => :post, :member => true do
     description "Stop a running instance."
+    with_capability :stop_instance
     param :id,           :string, :required
     control { instance_action(:stop) }
   end
 
   operation :destroy do
     description "Destroy an instance."
+    with_capability :destroy_instance
     param :id,           :string, :required
     control { instance_action(:destroy) }
   end
@@ -250,6 +340,7 @@ END
 
   operation :index do
     description "List of available hardware profiles."
+    with_capability :hardware_profiles
     param :id,          :string
     param :architecture,  :string,  :optional,  [ 'i386', 'x86_64' ]
     control do
@@ -264,6 +355,7 @@ END
 
   operation :show do
     description "Show specific hardware profile."
+    with_capability :hardware_profile
     param :id,          :string,    :required
     control do
       @profile =  driver.hardware_profile(credentials, params[:id])
@@ -286,12 +378,14 @@ collection :storage_snapshots do
 
   operation :index do
     description "List of storage snapshots."
+    with_capability :storage_snapshots
     param :id,            :string
     control { filter_all(:storage_snapshots) }
   end
 
   operation :show do
     description "Show storage snapshot."
+    with_capability :storage_snapshot
     param :id,          :string,    :required
     control { show(:storage_snapshot) }
   end
@@ -302,12 +396,14 @@ collection :storage_volumes do
 
   operation :index do
     description "List of storage volumes."
+    with_capability :storage_volumes
     param :id,            :string
     control { filter_all(:storage_volumes) }
   end
 
   operation :show do
     description "Show storage volume."
+    with_capability :storage_volume
     param :id,          :string,    :required
     control { show(:storage_volume) }
   end
@@ -324,6 +420,7 @@ collection :keys do
 
   operation :index do
     description "List all available credentials which could be used for instance authentication."
+    with_capability :keys
     control do
       filter_all :keys
     end
@@ -331,18 +428,16 @@ collection :keys do
 
   operation :show do
     description "Show details about given instance credential."
+    with_capability :key
     param :id,  :string,  :required
     control { show :key }
   end
 
   operation :create do
     description "Create a new instance credential if backend supports this."
+    with_capability :create_key
     param :name,  :string,  :required
     control do
-      unless driver.respond_to?(:create_key)
-        raise Deltacloud::BackendFeatureUnsupported.new('501',
-          'Creating instance credentials is not supported in backend')
-      end
       @key = driver.create_key(credentials, { :key_name => params[:name] })
       respond_to do |format|
         format.html { haml :"keys/show" }
@@ -353,12 +448,9 @@ collection :keys do
 
   operation :destroy do
     description "Destroy given instance credential if backend supports this."
+    with_capability :destroy_key
     param :id,  :string,  :required
     control do
-      unless driver.respond_to?(:destroy_key)
-        raise Deltacloud::BackendFeatureUnsupported.new('501',
-          'Creating instance credentials is not supported in backend')
-      end
       driver.destroy_key(credentials, { :key_name => params[:id]})
       redirect(keys_url)
     end
@@ -366,6 +458,35 @@ collection :keys do
 
 end
 
+#get html form for creating a new blob
+get '/api/buckets/:bucket/new_blob' do
+  @bucket_id = params[:bucket]
+  respond_to do |format|
+    format.html {haml :"blobs/new"}
+  end
+end
+
+#create a new blob
+post '/api/buckets/:bucket' do
+  bucket_id = params[:bucket]
+  blob_id = params['blob_id']
+  blob_data = params['blob_data']
+  @blob = driver.create_blob(credentials, bucket_id, blob_id, blob_data )
+  respond_to do |format|
+    format.html { haml :"blobs/show"}
+    format.xml { haml :"blobs/show" }
+  end
+end
+
+#delete a blob
+delete '/api/buckets/:bucket/:blob' do
+  bucket_id = params[:bucket]
+  blob_id = params[:blob]
+  driver.delete_blob(credentials, bucket_id, blob_id)
+  redirect(bucket_url(bucket_id))
+end
+
+#Get a particular blob's particulars (not actual blob data)
 get '/api/buckets/:bucket/:blob' do
   @blob = driver.blob(credentials, { :id => params[:blob], 'bucket' => params[:bucket]})
   if @blob
@@ -379,13 +500,7 @@ get '/api/buckets/:bucket/:blob' do
   end
 end
 
-get '/api/buckets/new' do
-  respond_to do |format|
-    format.html { haml :"buckets/new" }
-  end
-end
-
-
+#get the content of a particular blob
 get '/api/buckets/:bucket/:blob/content' do
   @blob = driver.blob(credentials, { :id => params[:blob], 'bucket' => params[:bucket]})
   params['content_length'] = @blob.content_length
@@ -393,11 +508,19 @@ get '/api/buckets/:bucket/:blob/content' do
   BlobStream.call(env, credentials, params)
 end
 
+#Get html form for creating a new bucket
+get '/api/buckets/new' do
+  respond_to do |format|
+    format.html { haml :"buckets/new" }
+  end
+end
+
 collection :buckets do
   description "Cloud Storage buckets - aka buckets|directories|folders"
 
   operation :index do
     description "List buckets associated with this account"
+    with_capability :buckets
     param :id,        :string
     param :name,      :string
     param :size,      :string
@@ -406,12 +529,14 @@ collection :buckets do
 
   operation :show do
     description "Show bucket"
+    with_capability :bucket
     param :id,        :string
     control { show(:bucket) }
   end
 
   operation :create do
     description "Create a new bucket (POST /api/buckets)"
+    with_capability :create_bucket
     param :name,      :string,    :required
     control do
       @bucket = driver.create_bucket(credentials, params[:name], params)
@@ -431,6 +556,7 @@ collection :buckets do
 
   operation :destroy do
     description "Delete a bucket by name - bucket must be empty"
+    with_capability :delete_bucket
     param :id,    :string,    :required
     control do
       driver.delete_bucket(credentials, params[:id], params)