steamcannon-deltacloud-core 0.0.7.1-java

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

@@ -0,0 +1,295 @@
+# Copyright (C) 2010  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.
+#
+# This driver uses the fog library (Geemus - Wesley Beary) to talk to terremark... see
+#                                   http://github.com/geemus/fog
+# see terremark vcloud express api at:
+# 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'
+
+module Deltacloud
+  module Drivers
+    module Terremark
+
+class TerremarkDriver < Deltacloud::BaseDriver
+
+  feature :instances, :user_name
+
+#--
+# Vapp State Map... for use with convert_instance (get an integer back from terremark)
+#--
+VAPP_STATE_MAP = { "0" =>  "PENDING", "1" =>  "PENDING", "2" =>  "STOPPED", "4" =>  "RUNNING" }
+
+#--
+# HARDWARE PROFILES
+#--
+  define_hardware_profile 'default' do
+    cpu   [1,2,4,8]
+    memory  [512, 1024, 2048, 4096, 8192]
+    storage (1..500).to_a
+  end
+  #storage_disks [1..15]
+
+#--
+# IMAGES
+#--
+#aka "vapp_templates"
+  def images(credentials, opts=nil)
+      image_list = []
+      terremark_client = new_client(credentials)
+      safely do
+        vdc_id = terremark_client.default_vdc_id
+        catalogItems = terremark_client.get_catalog(vdc_id).body['CatalogItems']
+        catalogItems.each{ |catalog_item|
+          current_item_id = catalog_item['href'].split('/').last
+          current_item = terremark_client.get_catalog_item(current_item_id).body['Entity']
+            if(current_item['type'] == 'application/vnd.vmware.vcloud.vAppTemplate+xml')
+              image_list << convert_image(current_item, credentials.user)
+            end
+        } #end of catalogItems.each
+      end
+      image_list = filter_on( image_list, :id, opts )
+      image_list = filter_on( image_list, :architecture, opts )
+      image_list = filter_on( image_list, :owner_id, opts )
+      image_list
+  end
+
+#--
+# REALMS
+#--
+#only one realm... everything in US?
+  def realms(credentials, opts=nil)
+     [Realm.new( {
+      :id=>"US-Miami",
+      :name=>"United States - Miami",
+      :state=> "AVAILABLE"
+    } )]
+  end
+
+#--
+# INSTANCES
+#--
+#aka vApps
+  def instances(credentials, opts=nil)
+      instances = []
+      terremark_client = new_client(credentials)
+      safely do
+        vdc_items = terremark_client.get_vdc(terremark_client.default_vdc_id()).body['ResourceEntities']
+        vdc_items.each{|current_item|
+          if(current_item['type'] == 'application/vnd.vmware.vcloud.vApp+xml')
+             vapp_id =  current_item['href'].split('/').last
+             vapp = terremark_client.get_vapp(vapp_id)
+             instances  << convert_instance(vapp, terremark_client, credentials.user)
+          end
+        }#end vdc_items.each
+      end
+      instances = filter_on( instances, :id, opts )
+      instances
+  end
+
+#--
+# FINITE STATE MACHINE
+#--
+#by default new instance --> powered_off
+  define_instance_states do
+    start.to(:pending)            .on( :create )
+    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
+    stopped.to(:finish)           .on( :destroy )
+   end
+
+
+#--
+# CREATE INSTANCE
+#--
+#launch a vapp template. Needs a name, ram, no. cpus, id of vapp_template
+  def create_instance(credentials, image_id, opts)
+    new_vapp = nil
+    vapp_opts = {} #assemble options to pass to Fog::Terremark::Real.instantiate_vapp_template
+    terremark_hwp = hardware_profiles(credentials, {:name => 'default'}).first #sanity check values against default
+    name = opts['name'] #name could be nil or length 0 or too long
+    name = "inst#{Time.now.to_i}" if (name.nil? || (name.length == 0))
+    name = name.slice(0..13) #name < 15 chars (says terremark)
+    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]}")
+    end
+    vapp_opts['cpus'] = opts[:hwp_cpu]
+    vapp_opts['memory'] =  opts[:hwp_memory]
+    safely do
+      terremark_client = new_client(credentials)
+#######
+#FIXME#  what happens if there is an issue getting the new vapp id? (eg even though created succesfully)
+#######
+      vapp_id = terremark_client.instantiate_vapp_template(name, image_id, vapp_opts).body['href'].split('/').last
+      new_vapp = terremark_client.get_vapp(vapp_id)
+      return convert_instance(new_vapp, terremark_client, credentials.user) #return an Instance object
+    end
+  end
+
+#--
+# REBOOT INSTANCE
+#--
+  def reboot_instance(credentials, id)
+    safely do
+      terremark_client =  new_client(credentials)
+      return terremark_client.power_reset(id)
+    end
+  end
+
+#--
+# START INSTANCE
+#--
+def start_instance(credentials, id)
+  safely do
+    terremark_client =  new_client(credentials)
+    return terremark_client.power_on(id)
+  end
+end
+
+#--
+# STOP INSTANCE
+#--
+def stop_instance(credentials, id)
+  safely do
+    terremark_client = new_client(credentials)
+    return terremark_client.power_shutdown(id)
+  end
+end
+
+#--
+# DESTROY INSTANCE
+#--
+#shuts down... in terremark need to do a futher delete to get rid of a vapp entirely
+def destroy_instance(credentials, id)
+  safely do
+    terremark_client = new_client(credentials)
+    return terremark_client.delete_vapp(id)
+  end
+end
+
+def valid_credentials?(credentials)
+  begin
+    new_client(credentials)
+  rescue Deltacloud::AuthException
+    return false
+  end
+  true
+end
+
+#--
+# PRIVATE METHODS:
+#--
+
+ private
+
+#--
+# CONVERT IMAGE
+#--
+#gets a vapp_template from a catalog and makes it a Image
+  def convert_image(catalog_vapp_template, account_name)
+    name = catalog_vapp_template['name']
+    #much fudging ensues
+    #arch = name.scan(/(36|24).bit/).first
+    #k enuf o'that now!
+    arch = "n/a" #Leaving out entirely as we don't get one from terremark (could parse but its a fudge)
+    Image.new( {
+                  :id => catalog_vapp_template['href'].split('/').last,
+                  :name => catalog_vapp_template['name'],
+                  :architecture => arch,
+                  :owner_id => account_name,
+                  :description => catalog_vapp_template['name']
+               })
+  end
+
+#--
+# CONVERT INSTANCE
+#--
+  def convert_instance(vapp, terremark_client, account_name)
+      vapp_private_ip = vapp.body['IpAddress']
+      vapp_public_ip = terremark_client.get_public_ips(terremark_client.default_vdc_id).body['PublicIpAddresses'].first['name']#get_public_address(terremark_client, vapp_private_ip)
+      vapp_status = vapp.body['status']
+      current_state = VAPP_STATE_MAP[vapp_status] #status == 0->BEING_CREATED 2->OFF 4->ON
+      profile = InstanceProfile.new("default")
+      name = vapp.body['name']
+      if current_state != "PENDING" #can only grab this stuff after instance is created
+        profile.cpu = vapp.body['VirtualHardware']['cpu']
+        profile.memory = vapp.body['VirtualHardware']['ram']
+#######
+#FIXME# could be more that one disk... but for now capture only first
+#######
+        disk = ((vapp.body['VirtualHardware']['disks'].first.to_i) / 1024 / 1024).to_s
+        profile.storage = disk
+#######
+#FIXME# this is a hack, shouldn't place this info next to name as some clients may rely on name field... probably will introduce
+####### a new field in the API for this (e.g. description/text field... human readable)
+      #name = "#{name} - [ #{vapp.body['OperatingSystem']['Description']} ]"
+      end
+      Instance.new( {
+                    :id => vapp.body['href'].split('/').last,
+                    :owner_id => "#{account_name}",
+                    #:image_id => "n/a", #cant get this... see https://community.vcloudexpress.terremark.com/en-us/discussion_forums/f/60/t/376.aspx
+                    :name => name,
+                    :realm_id => "US-Miami",
+                    :state => current_state,
+                    :actions => instance_actions_for(current_state),
+                    :public_addresses => vapp_public_ip,
+                    :private_addresses => vapp_private_ip,
+                    :instance_profile => profile
+                    } )
+  end
+
+#--
+# NEW CLIENT
+#--
+#use supplied credentials to make a new client for talking to terremark
+  def new_client(credentials)
+    #Fog constructor expecting  credentials[:terremark_password] and credentials[:terremark_username]
+    terremark_credentials = {:terremark_vcloud_username => "#{credentials.user}", :terremark_vcloud_password => "#{credentials.password}" }
+    safely do
+      terremark_client = Fog::Terremark::Vcloud.new(terremark_credentials)
+      vdc_id = terremark_client.default_vdc_id
+    end
+    if (vdc_id.nil?)
+       raise DeltaCloud::AuthException.new
+    end
+    terremark_client
+  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/hardware_profile.rb

@@ -0,0 +1,153 @@
+
+module Deltacloud
+  class HardwareProfile
+
+    UNITS = {
+      :memory => "MB",
+      :storage => "GB",
+      :architecture => "label",
+      :cpu => "count"
+    }
+
+    def self.unit(name)
+      UNITS[name]
+    end
+
+    class Property
+      attr_reader :name, :kind, :default
+      # kind == :range
+      attr_reader :first, :last
+      # kind == :enum
+      attr_reader :values
+      # kind == :fixed
+      attr_reader :value
+
+      def initialize(name, values, opts = {})
+        @name = name
+        if values.is_a?(Range)
+          @kind = :range
+          @first = values.first
+          @last = values.last
+          @default = values.first
+        elsif values.is_a?(Array)
+          @kind = :enum
+          @values = values
+          @default = values.first
+        else
+          @kind = :fixed
+          @value = values
+          @default = @value
+        end
+        @default = opts[:default] if opts[:default]
+      end
+
+      def unit
+        HardwareProfile.unit(name)
+      end
+
+      def param
+        "hwp_#{name}"
+      end
+
+      def fixed?
+        kind == :fixed
+      end
+
+      def to_param
+        return nil if kind == :fixed
+        if kind == :range
+          # FIXME: We can't validate ranges currently
+          args = [param, :string, :optional]
+        else
+          args = [param, :string, :optional, values.collect { |v| v.to_s} ]
+        end
+        Validation::Param.new(args)
+      end
+
+      def include?(v)
+        if kind == :fixed
+          return v == value
+        elsif kind == :range
+          return v >= first && v <= last
+        else
+          return values.include?(v)
+        end
+      end
+    end
+
+    class << self
+      def property(prop)
+        define_method(prop) do |*args|
+          values, opts, *ignored = *args
+          instvar = :"@#{prop}"
+          unless values.nil?
+            @properties[prop] = Property.new(prop, values, opts || {})
+          end
+          @properties[prop]
+        end
+      end
+    end
+
+    attr_reader :name
+    property :cpu
+    property :architecture
+    property :memory
+    property :storage
+
+    def initialize(name,&block)
+      @properties   = {}
+      @name         = name
+      instance_eval &block if block_given?
+    end
+
+    def each_property(&block)
+      @properties.each_value { |prop| yield prop }
+    end
+
+    def properties
+      @properties.values
+    end
+
+    def property(name)
+      @properties[name.to_sym]
+    end
+
+    def default?(prop, v)
+      p = @properties[prop.to_sym]
+      p && p.default.to_s == v
+    end
+
+    def to_hash
+      props = []
+      self.each_property do |p|
+        if p.kind.eql? :fixed
+          props << { :kind => p.kind, :value => p.value, :name => p.name, :unit => p.unit } 
+        else
+          param = { :operation => "create", :method => "post", :name => p.name }
+          if p.kind.eql? :range
+            param[:range] = { :first => p.first, :last => p.last }
+          elsif p.kind.eql? :enum
+            param[:enum] = p.values.collect { |v| { :entry => v } }
+          end
+          param
+          props << { :kind => p.kind, :value => p.default, :name => p.name, :unit => p.unit, :param => param }
+        end
+      end
+      {
+        :id => self.name,
+        :properties => props
+      }
+    end
+
+    def include?(prop, v)
+      p = @properties[prop]
+      p.nil? || p.include?(v)
+    end
+
+    def params
+      @properties.values.inject([]) { |m, prop|
+        m << prop.to_param
+      }.compact
+    end
+  end
+end

data/lib/deltacloud/helpers/application_helper.rb

@@ -0,0 +1,122 @@
+#
+# 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.
+
+# Methods added to this helper will be available to all templates in the application.
+module ApplicationHelper
+
+  def bread_crumb
+    s = "<ul class='breadcrumb'><li class='first'><a href='#{url_for('/')}'>&#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?
+        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(0, index+1).join("/")
+            s += "<li class='subsequent'><a href=\"#{url_for(link)}\">#{level.gsub(/_/, ' ')}</a></li>\n"
+        end
+      end
+    end
+    s+="</ul>"
+  end
+
+  def instance_action_method(action)
+    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?
+  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 = nil if filter.keys.size.eql?(0)
+      singular = model.to_s.singularize.to_sym
+      @elements = driver.send(model.to_sym, credentials, filter)
+      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)
+    @element = driver.send(model, credentials, { :id => params[:id]} )
+    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, 'not_found')
+    end
+  end
+
+  def report_error(status, template)
+    @error = request.env['sinatra.error']
+    response.status = status
+    respond_to do |format|
+      format.xml { haml :"errors/#{template}", :layout => false }
+      format.html { haml :"errors/#{template}" }
+    end
+  end
+
+  def instance_action(name)
+    @instance = driver.send(:"#{name}_instance", credentials, params["id"])
+
+    return redirect(instances_url) if name.eql?(:destroy) or @instance.class!=Instance
+
+    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(&block)
+    text = capture_haml(&block)
+    text.gsub!("\n", "\n ")
+    "<![CDATA[\n #{text}\n]]>"
+  end
+
+end

data/lib/deltacloud/helpers/blob_stream.rb

@@ -0,0 +1,51 @@
+# Copyright (C) 2010  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.
+
+#--
+# based on the example from http://macournoyer.com/blog/2009/06/04/pusher-and-async-with-thin/
+#--
+require 'eventmachine'
+class BlobStream
+  AsyncResponse = [-1, {}, []].freeze
+  def self.call(env, 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, {'Content-Type' => "#{params['content_type']}", 'Content-Length' => "#{params['content_length']}"}, body] }
+    #call the driver from here. the driver method yields for every chunk of blob it receives. We 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
+    body.succeed
+    AsyncResponse # Tells Thin to not close the connection and continue it's work on other request
+  end
+end
+
+class DeferrableBody
+  include EventMachine::Deferrable
+
+  def call(body)
+    body.each do |chunk|
+      @body_callback.call(chunk)
+    end
+  end
+
+  def each(&blk)
+    @body_callback = blk
+  end
+end

data/lib/deltacloud/helpers/conversion_helper.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.
+
+
+require 'deltacloud/base_driver'
+
+module ConversionHelper
+
+  def convert_to_json(type, obj)
+    if ( [ :flavor, :account, :image, :realm, :instance, :storage_volume, :storage_snapshot, :hardware_profile ].include?( type ) )
+      if Array.eql?(obj.class)
+        data = obj.collect do |o|
+          o.to_hash.merge({ :href => self.send(:"#{type}_url", type.eql?(:hardware_profile) ? o.name : o.id ) })
+        end
+        type = type.to_s.pluralize
+      else
+        data = obj.to_hash
+        data.merge!({ :href => self.send(:"#{type}_url", data[:id]) })
+      end
+      return { :"#{type}" => data }.to_json
+    end
+  end
+
+end

data/lib/deltacloud/helpers/hardware_profiles_helper.rb

@@ -0,0 +1,35 @@
+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.rb

@@ -0,0 +1,5 @@
+require 'deltacloud/helpers/application_helper'
+require 'deltacloud/helpers/conversion_helper'
+require 'deltacloud/helpers/hardware_profiles_helper'
+
+helpers ApplicationHelper, ConversionHelper, HardwareProfilesHelper