deltacloud-core 0.5.0 → 1.0.0

data/lib/deltacloud/helpers/application_helper.rb

@@ -1,267 +0,0 @@
-# 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.
-
-# Methods added to this helper will be available to all templates in the application.
-
-require 'benchmark'
-
-module ApplicationHelper
-
-  include Deltacloud
-
-  def bread_crumb
-    s = "<ul class='breadcrumb'><li class='first'><a href='#{settings.root_url}'>&#948</a></li>"
-    url = request.path_info.split('?')  #remove extra query string parameters
-    levels = url[0].split('/') #break up url into different levels
-    levels.each_with_index do |level, index|
-      unless level.blank?
-        next if "/#{level}" == settings.root_url
-        if index == levels.size-1 || (level == levels[levels.size-2] && levels[levels.size-1].to_i > 0)
-          s += "<li class='subsequent'>#{level.gsub(/_/, ' ')}</li>\n" unless level.to_i > 0
-        else
-          link = levels.slice(2, index-1).join("/")
-          s += "<li class='subsequent'><a href=\"#{api_url_for(link)}\">#{level.gsub(/_/, ' ')}</a></li>\n"
-        end
-      end
-    end
-    s+="<li class='docs'>#{link_to_documentation}</li>"
-    s+="</ul>"
-  end
-
-  def instance_action_method(action)
-    action_method(action, :instances)
-  end
-
-  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?
-    driver_has_feature?(:authentication_password) || driver_has_feature?(:authentication_key)
-  end
-
-  def driver_auth_feature_name
-    return 'key' if driver_has_feature?(:authentication_key)
-    return 'password' if driver_has_feature?(:authentication_password)
-  end
-
-  def driver_has_bucket_location_feature?
-    driver.features(:buckets).each do |feat|
-      return true if feat.name == :bucket_location
-    end
-    false
-  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
-      @benchmark = Benchmark.measure do
-        @elements = driver.send(model.to_sym, credentials, filter)
-      end
-      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 { convert_to_json(singular, @elements) }
-      end
-  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 { convert_to_json(model, @element) }
-      end
-    else
-        report_error(404)
-    end
-  end
-
-  def report_error(code=nil)
-    @error, @code = request.env['sinatra.error'], 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.json { json_return_error(@error) }
-      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
-
-    @instance = driver.send(:"#{name}_instance", credentials, params["id"])
-
-    if name == :destroy or @instance.class!=Instance
-      respond_to do |format|
-        format.xml { return 204 }
-        format.json { return 204 }
-        format.html { return redirect(instances_url) }
-      end
-    end
-
-    respond_to do |format|
-      format.xml { haml :"instances/show" }
-      format.html { haml :"instances/show" }
-      format.json {convert_to_json(:instance, @instance) }
-    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=')
-    if uri.include?('?')
-      uri+="&format=#{format}"
-    else
-      uri+="?format=#{format}"
-    end
-    '<a data-ajax="false" data-icon="grid" href="%s">%s</a>' % [uri, "#{format}".upcase]
-  end
-
-  def link_to_documentation
-    return '' unless request.env['REQUEST_URI']
-    uri = request.env['REQUEST_URI'].dup
-    uri.gsub!(settings.root_url,
-              api_url_for(:docs)) unless uri.include?("docs") #i.e. if already serving under /api/docs, leave it be
-    '<a href="%s">[ Documentation ]</a>' % uri
-  end
-
-  def action_url
-    if [:index].include?(@operation.name)
-      api_url_for("#{@collection.name.to_s}")
-    elsif [:show, :stop, :start, :reboot, :attach, :detach].include?(@operation.name)
-      api_url_for("#{@collection.name.to_s}/:id/#{@operation.name}")
-    elsif [:destroy].include?(@operation.name)
-      api_url_for("#{@collection.name.to_s}/:id")
-    else
-      api_url_for("#{@collection.name}/#{@operation.name}")
-    end
-  end
-
-  def image_for_state(state)
-    state_img = "stopped" if (state!='RUNNING' or state!='PENDING')
-    "<img src='/images/#{state.downcase}.png' title='#{state}'/>"
-  end
-
-  def truncate_words(text, length = 10)
-    return nil unless text
-    return text if text.length<=length
-    end_string = "...#{text[(text.length-(length/2))..text.length]}"
-    "#{text[0..(length/2)]}#{end_string}"
-  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" }
-    end
-  end
-
-  def new_blob_form_url(bucket)
-    bucket_url(@bucket.name) + "/" + NEW_BLOB_FORM_ID
-  end
-end

data/lib/deltacloud/helpers/hardware_profiles_helper.rb

@@ -1,50 +0,0 @@
-# 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 HardwareProfilesHelper
-
-  def format_hardware_property(prop)
-    return "∅" 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?
-      ""
-    else
-      "with #{o.join(", ")}"
-    end
-  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

data/lib/deltacloud/helpers/json_helper.rb

@@ -1,31 +0,0 @@
-# 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 JSONHelper
-
-  def json_features_for_entrypoint(entrypoint)
-    features = driver.features(entrypoint.first).collect { |feature| feature.name }
-    features.empty? ? {} : { :features => features }
-  end
-
-  def json_return_error(error)
-    error_output=Hash.new
-    error_output[:url]    =request.env['REQUEST_URI']
-    error_output[:status] =response.status
-    error_output[:message]=error.message if error
-    error_output.to_json
-  end
-
-end

data/lib/deltacloud/method_serializer.rb

@@ -1,83 +0,0 @@
-#
-# 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 'base64'
-require 'digest'
-
-module MethodSerializer
-
-  module Cache
-
-    def cache_dir
-      storage_dir = $methods_cache_dir || File.join(File.dirname(__FILE__), 'cache')
-      class_dir = self.class.name.split('::').last
-      class_dir ||= self.class.name
-      File.join(storage_dir, class_dir.downcase)
-    end
-
-    def serialize_data(method_name, args, data)
-      File.open(cache_file_name(method_name, args), 'w') do |f|
-        f.puts(Base64.encode64(Marshal.dump(data)))
-      end
-      return data
-    end
-
-    def deserialize_data(method_name, args)
-      begin
-        data = File.readlines(cache_file_name(method_name, args)).join
-        Marshal.load(Base64.decode64(data))
-      rescue Errno::ENOENT
-        return false
-      end
-    end
-
-    def args_hash(args)
-      if args.class == Hash
-        args = args.to_a.collect {|i| [i[0].to_s, i[1]]}.sort
-      end
-      Digest::SHA1.hexdigest(args.to_s)
-    end
-
-    def cache_file_name(method_name, args)
-      FileUtils.mkdir_p(cache_dir) unless File.directory?(cache_dir)
-      method_name = $scenario_prefix ? "#{$scenario_prefix}_#{method_name}" : method_name
-      File.join(cache_dir, "#{method_name}.#{args_hash(args)}")
-    end
-
-    def self.wrap_methods(c, opts={})
-      $methods_cache_dir = opts[:cache_dir]
-      $scenario_prefix = nil
-      c.class_eval do
-        cached_methods.each do |m|
-          next if c.instance_methods(false).include?("original_#{m}")
-          alias_method "original_#{m}".to_sym, m.to_sym
-          define_method m.to_sym do |*args|
-            args = args.first if args.size.eql?(1) and not args.first.class.eql?(Array)
-            output = deserialize_data(m, args)
-            unless output
-              output = method("original_#{m}".to_sym).to_proc[args]
-              return serialize_data(m, args, output)
-            else
-              return output
-            end
-          end
-        end
-      end
-    end
-
-  end
-
-end

data/lib/deltacloud/validation.rb

@@ -1,107 +0,0 @@
-#
-# 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::Validation
-
-  class Failure < Deltacloud::ExceptionHandler::DeltacloudException
-    attr_reader :param
-    def initialize(e, message=nil)
-      message ||= e.message
-      super(400, e.class.name, message, [])
-    end
-    def name
-      param.name if @param
-    end
-  end
-
-  class Param
-    attr_reader :name, :klass, :type, :options, :description
-
-    def initialize(args)
-      @name = args[0]
-      @klass = args[1] || :string
-      @type = args[2] || :optional
-      @options = args[3] || []
-      @description = args[4] || ''
-    end
-
-    def required?
-      type.eql?(:required)
-    end
-
-    def optional?
-      type.eql?(:optional)
-    end
-
-    def valid_value?(value)
-      true if (options.kind_of?(Range) or options.kind_of?(Array)) and options.include?(value)
-      true if options.kind_of?(String) and not options.empty?
-    end
-
-    def valid_hwp_value?(profile, value)
-      profile.property(@name.to_s.gsub(/^hwp_/, '')).valid?(value)
-    end
-
-    def hwp_property?
-      true if name.to_s =~ /^hwp_(cpu|memory|storage|architecture)/
-    end
-  end
-
-  def param(*args)
-    raise "Duplicate param #{args[0]} #{params.inspect} #{self.class.name}" if params[args[0]]
-    p = Param.new(args)
-    params[p.name] = p
-  end
-
-  def params
-    @params ||= {}
-    @params
-  end
-
-  # Add the parameters in hash +new+ to already existing parameters. If
-  # +new+ contains a parameter with an already existing name, the old
-  # definition is clobbered.
-  def add_params(new)
-    # We do not check for duplication on purpose: multiple calls
-    # to add_params should be cumulative
-    new.each { |p|  @params[p.name] = p }
-  end
-
-  def each_param(&block)
-    params.each_value { |p| yield p }
-  end
-
-  def validate(current_driver, all_params, values, credentials)
-    all_params.each do |key, p|
-      if p.required? and not values[p.name]
-        raise Failure.new(p, "Required parameter #{p.name} not found")
-      end
-      next unless values[p.name]
-      if p.hwp_property?
-        profile = current_driver.hardware_profile(credentials, values['hwp_id'])
-        raise Failure.new(p, "Unknown hardware profile selected #{values['hwp_id']}") unless profile
-        unless p.valid_hwp_value?(profile, values[p.name])
-          raise Failure.new(p, "Hardware profile property #{p.name} has invalid value #{values[p.name]}")
-        end
-      else
-        if not p.options.empty? and p.valid_value?(values[p.name])
-          raise Failure.new(p, "Parameter #{p.name} has value #{values[p.name]} which is not in #{p.options.join(", ")}")
-        end
-      end
-    end
-  end
-
-end