deltacloud-core 0.5.0 → 1.0.0

data/lib/deltacloud/drivers/terremark/terremark_driver.rb

@@ -19,8 +19,7 @@
 # https://community.vcloudexpress.terremark.com/en-us/product_docs/w/wiki/d-complete-vcloud-express-api-document.aspx
 #
 # 02 May 2010
-#
-require 'deltacloud/base_driver'
+
 require 'fog'
 require 'excon'
 require 'nokogiri'
@@ -30,12 +29,11 @@ module Deltacloud
     module Terremark
 
 class TerremarkDriver < Deltacloud::BaseDriver
-
   feature :instances, :user_name do
-    constraint :max_length, 15
+    { :max_length => 50 }
   end
 
-  USER_NAME_MAX = feature(:instances, :user_name).constraints[:max_length]
+  USER_NAME_MAX = constraints(:collection => :instances, :feature => :user_name)[:max_length]
 
 #--
 # Vapp State Map... for use with convert_instance (get an integer back from terremark)
@@ -118,8 +116,8 @@ VAPP_STATE_MAP = { "0" =>  "PENDING", "1" =>  "PENDING", "2" =>  "STOPPED", "4"
     pending.to(:stopped)          .automatically
     stopped.to(:running)          .on( :start )
     running.to(:running)          .on( :reboot )
-    running.to(:shutting_down)    .on( :stop )
-    shutting_down.to(:stopped)    .automatically
+    running.to(:stopping)         .on( :stop )
+    stopping.to(:stopped)         .automatically
     stopped.to(:finish)           .on( :destroy )
    end
 
@@ -141,7 +139,9 @@ VAPP_STATE_MAP = { "0" =>  "PENDING", "1" =>  "PENDING", "2" =>  "STOPPED", "4"
     end
     unless ( (terremark_hwp.include?(:cpu, opts[:hwp_cpu].to_i)) &&
               (terremark_hwp.include?(:memory, opts[:hwp_memory].to_i)) ) then
-       raise Deltacloud::Validation::Failure.new(Deltacloud::Validation::Param.new(["cpu"]), "Error with cpu and/or memory values. you said cpu->#{opts[:hwp_cpu]} and mem->#{opts[:hwp_memory]}")
+        raise Deltacloud::ExceptionHandler::ValidationFailure.new(
+          StandardError.new("Error with cpu and/or memory values. you said cpu->#{opts[:hwp_cpu]} and mem->#{opts[:hwp_memory]}")
+        )
     end
     vapp_opts['cpus'] = opts[:hwp_cpu]
     vapp_opts['memory'] =  opts[:hwp_memory]

data/lib/deltacloud/drivers/vsphere/vsphere_driver.rb

@@ -14,18 +14,17 @@
 # under the License.
 #
 
-require 'deltacloud/base_driver'
 require 'rbvmomi'
 require 'deltacloud/drivers/vsphere/vsphere_client'
 
-module Deltacloud::Drivers::VSphere
+module Deltacloud::Drivers::Vsphere
 
   MAPPER_STORAGE_ROOT = File::join("/var/tmp", "deltacloud-vsphere-#{ENV["USER"]}")
 
-  class VSphereDriver < Deltacloud::BaseDriver
+  class VsphereDriver < Deltacloud::BaseDriver
 
     include Deltacloud::Drivers::VSphere::Helper
-    include Deltacloud::Drivers::VSphere::FileManager
+    include VSphere::FileManager
 
     # You can use 'user_iso' feature to set 'user_iso' parameter when creating
     # a new instance where this parameter can hold gzipped CDROM iso which will
@@ -34,6 +33,8 @@ module Deltacloud::Drivers::VSphere
     feature :instances, :user_data
     feature :instances, :user_name
 
+    define_hardware_profile('default')
+
     # There is just one hardware profile where memory is measured using maximum
     # memory available on ESX for virtual machines and CPU using maximum free
     # CPU cores in ESX.
@@ -64,8 +65,8 @@ module Deltacloud::Drivers::VSphere
       pending.to(:stopped)        .automatically
       stopped.to(:running)        .on( :start )
       running.to(:running)        .on( :reboot )
-      running.to(:shutting_down)  .on( :stop )
-      shutting_down.to(:stopped)  .automatically
+      running.to(:stopping)       .on( :stop )
+      stopping.to(:stopped)       .automatically
       stopped.to(:finish)         .on( :destroy )
     end
 
@@ -75,7 +76,7 @@ module Deltacloud::Drivers::VSphere
     def images(credentials, opts=nil)
       cloud = new_client(credentials)
       img_arr = []
-
+      profiles = hardware_profiles(credentials)
       # Skip traversing through all instances in all datacenters when ID
       # attribute is set
       safely do
@@ -104,7 +105,8 @@ module Deltacloud::Drivers::VSphere
             :architecture => image_architecture,
             :owner_id => credentials.user,
             :description => properties[:full_name],
-            :state => image_state
+            :state => image_state,
+            :hardware_profiles => profiles
           )
         end
       end
@@ -117,7 +119,7 @@ module Deltacloud::Drivers::VSphere
       safely do
         find_vm(credentials, opts[:id])[:instance].MarkAsTemplate
       end
-      images(credentials, :id => opts[:id])
+      image(credentials, :id => opts[:id])
     end
 
     # List all datacenters managed by the vSphere or vCenter entrypoint.
@@ -350,11 +352,20 @@ module Deltacloud::Drivers::VSphere
         status 401
       end
 
+      on /nodename nor servname provided/ do
+        status 502
+      end
+
       on /ERROR/ do
         status 500
       end
 
-      on /RbVmomi::Fault/ do
+      on /(RbVmomi::Fault|ToolsUnavailable)/ do
+        status 502
+      end
+
+      on /Undefined namespace prefix/ do
+        message 'VSphere Internal Error'
         status 502
       end
 
@@ -362,6 +373,18 @@ module Deltacloud::Drivers::VSphere
         status 502
       end
 
+      on /Requested datastore does not exists or misconfigured/ do
+        status 502
+      end
+
+      on /Connection timed out/ do
+        status 504
+      end
+
+      on /execution expired/ do
+        status 504
+      end
+
       on /Invalid/ do
         status 400
       end
@@ -370,10 +393,13 @@ module Deltacloud::Drivers::VSphere
 
     def valid_credentials?(credentials)
       begin
-        RbVmomi::VIM.connect(:host => host_endpoint, :user => credentials.user, :password => credentials.password, :insecure => true)
-        return true
-      rescue
+        RbVmomi::VIM.connect(:host => host_endpoint, :user => credentials.user, :password => credentials.password, :insecure => true) && true
+      rescue RbVmomi::Fault::InvalidLogin
         return false
+      rescue => e
+        safely do
+          raise e
+        end
       end
     end
 

data/lib/deltacloud/drivers/vsphere/vsphere_filemanager.rb

@@ -164,6 +164,7 @@ module VSphere
     # return the url like https://<server_address>/folder/<path>/<file_name>?<query_infos>
 
     def buildUrl(datastore,file="")
+      raise "Requested datastore does not exists or misconfigured" unless datastore.respond_to?(:'_connection')
       uri=URI::HTTPS::build(:host=>datastore._connection.http.address)
       uri.path= ["/folder",DIRECTORY_PATH,file].join("/") if file
       query={:dcPath => datastore.send(:datacenter).name, :dsName => datastore.name }

data/lib/deltacloud/helpers.rb

@@ -1,4 +1,3 @@
-#
 # 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
@@ -14,10 +13,83 @@
 # License for the specific language governing permissions and limitations
 # under the License.
 
-require 'deltacloud/helpers/application_helper'
-require 'deltacloud/helpers/json_helper'
-require 'deltacloud/helpers/conversion_helper'
-require 'deltacloud/helpers/hardware_profiles_helper'
-require 'deltacloud/helpers/blob_stream'
+require_relative 'helpers/driver_helper'
+require_relative 'helpers/auth_helper'
+require_relative 'helpers/url_helper'
+require_relative 'helpers/deltacloud_helper'
+require_relative 'helpers/rabbit_helper'
+require_relative 'helpers/blob_stream_helper'
+
+module Deltacloud::Collections
+  class Base < Sinatra::Base
+
+    include Sinatra::Rabbit
+    extend Deltacloud::Helpers::Drivers
+    include Sinatra::Rabbit::Features
+
+    helpers Deltacloud::Helpers::Drivers
+    helpers Sinatra::AuthHelper
+    helpers Sinatra::UrlForHelper
+    helpers Rack::RespondTo::Helpers
+    helpers Deltacloud::Helpers::Application
+
+    register Rack::RespondTo
+
+    enable :xhtml
+    enable :dump_errors
+    enable :show_errors
+    enable :method_override
+    disable :show_exceptions
+
+    set :config, Deltacloud[:deltacloud]
+    set :root_url, config.root_url
+    set :root_path, config.root_url
+    set :version, config.version
+    set :root, File.join(File.dirname(__FILE__), '..', '..')
+    set :views, root + '/views'
+    set :public_folder, root + '/public'
+
+    Sinatra::Rabbit.set :root_path, "#{config.root_url}/"
+
+    error do
+      report_error
+    end
+
+    error Deltacloud::ExceptionHandler::ValidationFailure do
+      report_error
+    end
+
+    before do
+      # Respond with 400, If we don't get a http Host header,
+      halt 400, "Unable to find HTTP Host header" if @env['HTTP_HOST'] == nil
+    end
+
+    after do
+      headers 'Server' => 'Apache-Deltacloud/' + settings.version
+    end
+
+    def self.new_route_for(route, &block)
+      get route_for('/' + route.to_s + '/new') do
+        instance_eval(&block) if block_given?
+        respond_to do |format|
+          format.html do
+            haml :"#{route}/new"
+          end
+        end
+      end
+    end
+
+    def self.check_capability(opts={})
+      Sinatra::Rabbit.set :check_capability, opts[:for]
+    end
+
+    def self.check_features(opts={})
+      Sinatra::Rabbit.set :check_features, opts[:for]
+    end
+
+    def self.route_for(url)
+      "#{settings.root_url}#{url}"
+    end
 
-helpers ApplicationHelper, ConversionHelper, HardwareProfilesHelper, JSONHelper
+  end
+end

data/lib/{sinatra/lazy_auth.rb → deltacloud/helpers/auth_helper.rb}

@@ -14,12 +14,11 @@
 # License for the specific language governing permissions and limitations
 # under the License.
 
-require 'sinatra/base'
-
 # Lazy Basic HTTP authentication. Authentication is only forced when the
 # credentials are actually needed.
+
 module Sinatra
-  module LazyAuth
+  module AuthHelper
     class LazyCredentials
       def initialize(app)
         @app = app
@@ -49,9 +48,7 @@ module Sinatra
         end
         unless provided?
           auth = Rack::Auth::Basic::Request.new(@app.request.env)
-          unless auth.provided? && auth.basic? && auth.credentials
-            @app.authorize!
-          end
+          @app.authorize! unless auth.provided? && auth.basic? && auth.credentials
           @user = auth.credentials[0]
           @password = auth.credentials[1]
           @provided = true
@@ -61,9 +58,9 @@ module Sinatra
     end
 
     def authorize!
-      r = "#{driver_symbol}-deltacloud@#{HOSTNAME}"
+      r = "#{Thread.current[:driver]}-deltacloud@#{ENV['HOSTNAME']}"
       response['WWW-Authenticate'] = %(Basic realm="#{r}")
-      throw(:halt, [401, "Not authorized\n"])
+      throw(:halt, [401, report_error(401)])
     end
 
     # Request the current user's credentials. Actual credentials are only
@@ -73,5 +70,4 @@ module Sinatra
     end
   end
 
-  helpers LazyAuth
 end

data/lib/deltacloud/helpers/{blob_stream.rb → blob_stream_helper.rb}

@@ -14,6 +14,7 @@
 # under the License.
 
 include Deltacloud
+
 begin
   require 'eventmachine'
   #--
@@ -22,20 +23,20 @@ begin
   #--
   class BlobStream
     AsyncResponse = [-1, {}, []].freeze
-    def self.call(env, credentials, params)
-      body = DeferrableBody.new
+    def self.call(context, credentials, params)
+     body = DeferrableBody.new
       #Get the headers out asap. Don't specify a content-type let
       #the client guess and if they can't they SHOULD default to
       #'application/octet-stream' anyway as per:
       #http://www.w3.org/Protocols/rfc2616/rfc2616-sec7.html#sec7.2.1
-      EM.next_tick { env['async.callback'].call [200, {
+      EM.next_tick { context.env['async.callback'].call [200, {
         'Content-Type' => "#{params['content_type']}",
         'Content-Disposition' => params["content_disposition"],
         'Content-Length' => "#{params['content_length']}"}, body]
       }
       #call the driver from here. the driver method yields for every chunk
       #of blob it receives. Then use body.call to write that chunk as received.
-      driver.blob_data(credentials, params[:bucket], params[:blob], params) {|chunk| body.call ["#{chunk}"]} #close blob_data block
+      context.driver.blob_data(credentials, params[:id], params[:blob_id], params) {|chunk| body.call ["#{chunk}"]} #close blob_data block
       body.succeed
       AsyncResponse # Tell Thin to not close connection & work other requests
     end
@@ -148,7 +149,6 @@ require 'base64'
 class BlobStreamIO
 
   attr_accessor :size, :provider, :sock
-
   def initialize(request)
     @client_request = request
     @size = 0
@@ -158,7 +158,7 @@ class BlobStreamIO
     #deal with blob_metadata: (X-Deltacloud-Blobmeta-name: value)
     user_meta = BlobHelper::extract_blob_metadata_hash(request.env)
     @content_length = request.env['CONTENT_LENGTH']
-    @http, provider_request = driver.blob_stream_connection({:user=>user,
+    @http, provider_request = Deltacloud::API.driver.blob_stream_connection({:user=>user,
        :password=>password, :bucket=>bucket, :blob=>blob, :metadata=> user_meta,
        :content_type=>content_type, :content_length=>@content_length })
     @content_length = @content_length.to_i #for comparison of size in '<< (data)'
@@ -187,7 +187,7 @@ class BlobStreamIO
   def self.is_put_blob(request = nil)
     path = request.env['PATH_INFO']
     method = request.env['REQUEST_METHOD']
-    if ( path =~ /^#{Regexp.escape(settings.root_url)}\/buckets/ && method == 'PUT' )
+    if ( path =~ /^#{Regexp.escape(Deltacloud::API.settings.root_url)}\/buckets/ && method == 'PUT' )
       return true
     else
       return false

data/lib/deltacloud/helpers/deltacloud_helper.rb

@@ -0,0 +1,286 @@
+# 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.
+
+module Deltacloud::Helpers
+  module Application
+
+    require 'benchmark'
+
+    def auth_feature_name
+      return 'key' if driver.class.has_feature?(:instances, :authentication_key)
+      return 'password' if driver.class.has_feature?(:instances, :authentication_password)
+    end
+
+    def instance_action_method(action)
+      action_method(action, Sinatra::Rabbit::InstancesCollection)
+    end
+
+    def action_method(action, collection)
+      http_method = collection.operation(action).http_method
+      http_method || Sinatra::Rabbit::BaseCollection.http_method_for(action)
+    end
+
+    def filter_all(model)
+      filter = {}
+      filter.merge!(:id => params[:id]) if params[:id]
+      filter.merge!(:architecture => params[:architecture]) if params[:architecture]
+      filter.merge!(:owner_id => params[:owner_id]) if params[:owner_id]
+      filter.merge!(:state => params[:state]) if params[:state]
+      filter = {} if filter.keys.size.eql?(0)
+      singular = model.to_s.singularize.to_sym
+      begin
+        @benchmark = Benchmark.measure do
+          @elements = driver.send(model.to_sym, credentials, filter)
+        end
+      rescue
+        @exception = $!
+      end
+      if @elements
+        headers['X-Backend-Runtime'] = @benchmark.real.to_s
+        instance_variable_set(:"@#{model}", @elements)
+        respond_to do |format|
+          format.html { haml :"#{model}/index" }
+          format.xml { haml :"#{model}/index" }
+          format.json { @media_type=:xml; to_json(haml(:"#{model}/index")) }
+        end
+      else
+        report_error(@exception.respond_to?(:code) ? @exception.code : 500)
+      end
+    end
+
+    def xml_to_json(model)
+      @media_type = :xml
+      to_json(haml(:"#{model}"))
+    end
+
+    def to_json(xml)
+      Crack::XML.parse(xml).to_json
+    end
+
+    def show(model)
+      @benchmark = Benchmark.measure do
+        @element = driver.send(model, credentials, { :id => params[:id]} )
+      end
+      headers['X-Backend-Runtime'] = @benchmark.real.to_s
+      instance_variable_set("@#{model}", @element)
+      if @element
+        respond_to do |format|
+          format.html { haml :"#{model.to_s.pluralize}/show" }
+          format.xml { haml :"#{model.to_s.pluralize}/show" }
+          format.json { @media_type=:xml; to_json(haml(:"#{model.to_s.pluralize}/show")) }
+        end
+      else
+        report_error(404)
+      end
+    end
+
+    def report_error(code=nil)
+      @error, @code = (request.env['sinatra.error'] || @exception), code
+      @code = 500 if not @code and not @error.class.method_defined? :code
+      response.status = @code || @error.code
+      respond_to do |format|
+        format.xml {  haml :"errors/#{@code || @error.code}", :layout => false }
+        format.html { haml :"errors/#{@code || @error.code}", :layout => :error }
+      end
+    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)
+      end
+
+      @benchmark = Benchmark.measure do
+        @instance = driver.send(:"#{name}_instance", credentials, params[:id])
+      end
+
+      headers['X-Backend-Runtime'] = @benchmark.real.to_s
+
+      if name == :destroy
+        response = respond_to do |format|
+          format.html { redirect(instances_url) }
+        end
+        halt 204, response
+      end
+
+      unless @instance.class == Instance
+        redirect instance_url(params[:id])
+      else
+        response = respond_to do |format|
+          format.xml { haml :"instances/show" }
+          format.html { haml :"instances/show" }
+          format.json { xml_to_json("instances/show") }
+        end
+        halt 202, response
+      end
+    end
+
+    def cdata(text = nil, &block)
+      text ||= capture_haml(&block)
+      "<![CDATA[#{text.strip}]]>"
+    end
+
+    def render_cdata(text)
+      "<![CDATA[#{text.strip}]]>"
+    end
+
+    def link_to_action(action, url, method)
+      capture_haml do
+        haml_tag :form, :method => :post, :action => url, :class => [:link, method], :'data-ajax' => 'false' do
+          haml_tag :input, :type => :hidden, :name => '_method', :value => method
+          haml_tag :button, :type => :submit, :'data-ajax' => 'false', :'data-inline' => "true" do
+            haml_concat action
+          end
+        end
+      end
+    end
+
+    def link_to_format(format)
+      return unless request.env['REQUEST_URI']
+      uri = request.env['REQUEST_URI']
+      return if uri.include?('format=')
+      uri += uri.include?('?') ? "&format=#{format}" : "?format=#{format}"
+      capture_haml do
+        haml_tag :a, :href => uri, :'data-ajax' => 'false', :'data-icon' => 'grid' do
+          haml_concat format.to_s.upcase
+        end
+      end
+    end
+
+    def image_for_state(state)
+      state_img = "stopped" if (state!='RUNNING' or state!='PENDING')
+      capture_haml do
+        haml_tag :img, :src => "/images/#{state}" % state.downcase, :title => state
+      end
+    end
+
+    # Reverse the entrypoints hash for a driver from drivers.yaml; note that
+    # +d+ is a hash, not an actual driver object
+    def driver_provider(d)
+      result = {}
+      if d[:entrypoints]
+        d[:entrypoints].each do |kind, details|
+          details.each do |prov, url|
+            result[prov] ||= {}
+            result[prov][kind] = url
+          end
+        end
+      end
+      result
+    end
+
+    def header(title, opts={}, &block)
+      opts[:theme] ||= 'b'
+      opts[:back] ||= 'true'
+      capture_haml do
+        haml_tag :div, :'data-role' => :header, :'data-theme' => opts[:theme], :'data-add-back-btn' => opts[:back] do
+          haml_tag :a, :'data-rel' => :back do
+            haml_concat "Back"
+          end if opts[:back] == 'true'
+          haml_tag :h1 do
+            haml_concat title
+          end
+          block.call if block_given?
+        end
+      end
+    end
+
+    def subheader(title, opts={})
+      opts[:theme] ||= 'a'
+      capture_haml do
+        haml_tag :div, :'data-role' => :header, :'data-theme' => opts[:theme] do
+          haml_tag :p, :class => 'inner-right' do
+            haml_concat title
+          end
+        end
+      end
+    end
+
+    def translate_error_code(code)
+      case code
+      when 400; { :message => "Bad Request" }
+      when 401; { :message => "Unauthorized" }
+      when 403; { :message => "Forbidden" }
+      when 404; { :message => "Not Found" }
+      when 405; { :message => "Method Not Allowed" }
+      when 406; { :message => "Not Acceptable" }
+      when 500; { :message => "Internal Server Error" }
+      when 502; { :message => "Backend Server Error" }
+      when 504; { :message => "Gateway Timeout" }
+      when 501; { :message => "Not Supported" }
+      end
+    end
+
+    NEW_BLOB_FORM_ID = 'new_blob_form_d15cfd90' unless defined?(NEW_BLOB_FORM_ID)
+
+    def new_blob_form_url(bucket)
+      bucket_url(@bucket.name) + "/" + NEW_BLOB_FORM_ID
+    end
+
+    def format_hardware_property(prop)
+      return "&empty;" unless prop
+      u = hardware_property_unit(prop)
+      case prop.kind
+      when :range
+        "#{prop.first} #{u} - #{prop.last} #{u} (default: #{prop.default} #{u})"
+      when :enum
+        prop.values.collect{ |v| "#{v} #{u}"}.join(', ') + " (default: #{prop.default} #{u})"
+      else
+        "#{prop.value} #{u}"
+      end
+    end
+
+    def format_instance_profile(ip)
+      o = ip.overrides.collect do |p, v|
+        u = hardware_property_unit(p)
+        "#{p} = #{v} #{u}"
+      end
+      if o.empty?
+        nil
+      else
+        "with #{o.join(", ")}"
+      end
+    end
+
+    def order_hardware_profiles(profiles)
+      #have to deal with opaque hardware profiles
+      uncomparables = profiles.select{|x| x.cpu.nil? or x.memory.nil? }
+      if uncomparables.empty?
+        profiles.sort_by{|a| [a.cpu.default, a.memory.default] }
+      else
+        (profiles - uncomparables).sort_by{|a| [a.cpu.default, a.memory.default] } + uncomparables
+      end
+    end
+
+    def additional_features_for?(collection_name, apart_from = [])
+      features_arr = (driver.class.features[collection_name.to_sym] || [] )  - apart_from
+      not features_arr.empty?
+    end
+
+    private
+    def hardware_property_unit(prop)
+      u = ::Deltacloud::HardwareProfile::unit(prop)
+      u = "" if ["label", "count"].include?(u)
+      u = "vcpus" if prop == :cpu
+      u
+    end
+
+
+
+  end
+end