deltacloud-core 0.0.6 → 0.0.7

data/lib/deltacloud/drivers/opennebula/opennebula_driver.rb

@@ -180,7 +180,7 @@ class OpennebulaDriver < Deltacloud::BaseDriver
 
 	imageid = computehash['STORAGE/DISK[@type="disk"]'].attributes['href'].split("/").last
 
-	state = (computehash['STATE'].text == 'ACTIVE') ? 'RUNNING' : computehash['STATE'].text
+	state = (computehash['STATE'].text == "ACTIVE") ? "RUNNING" : "STOPPED"
 
 	hwp_name = computehash['INSTANCE_TYPE'] || 'small'
 

data/lib/deltacloud/drivers/rackspace/rackspace_driver.rb

@@ -18,6 +18,7 @@
 
 require 'deltacloud/base_driver'
 require 'deltacloud/drivers/rackspace/rackspace_client'
+require 'cloudfiles'
 
 module Deltacloud
   module Drivers
@@ -27,8 +28,13 @@ class RackspaceDriver < Deltacloud::BaseDriver
 
   feature :instances, :user_name
 
+  def supported_collections
+    DEFAULT_COLLECTIONS + [ :buckets ]
+  end
+
   def hardware_profiles(credentials, opts = nil)
     racks = new_client( credentials )
+    results=""
     safely do
       results = racks.list_flavors.map do |flav|
         HardwareProfile.new(flav["id"].to_s) do
@@ -43,6 +49,7 @@ class RackspaceDriver < Deltacloud::BaseDriver
 
   def images(credentials, opts=nil)
     racks = new_client( credentials )
+    results=""
     safely do
       results = racks.list_images.map do |img|
         Image.new( {
@@ -75,8 +82,8 @@ class RackspaceDriver < Deltacloud::BaseDriver
     end
     Instance.new( {
       :id => id,
-      :state => "REBOOT",
-      :actions => instance_actions_for( state ),
+      :state => "RUNNING",
+      :actions => instance_actions_for( "RUNNING" ),
     } )
   end
 
@@ -141,6 +148,88 @@ class RackspaceDriver < Deltacloud::BaseDriver
   end
 
 
+
+
+  define_instance_states do
+    start.to( :pending )          .on( :create )
+
+    pending.to( :running )        .automatically
+
+    running.to( :running )        .on( :reboot )
+    running.to( :shutting_down )  .on( :stop )
+
+    shutting_down.to( :stopped )  .automatically
+
+    stopped.to( :finish )         .automatically
+  end
+
+#--
+# Buckets
+#--
+  def buckets(credentials, opts)
+    bucket_list = []
+    cf = cloudfiles_client(credentials)
+    safely do
+      cf.containers.each do |container_name|
+        current = cf.container(container_name)
+        bucket_list << convert_container(current)
+      end #containers.each
+    end #safely
+    bucket_list = filter_on(bucket_list, :id, opts)
+    bucket_list
+  end
+
+#--
+# Create Bucket
+#--
+  def create_bucket(credentials, name, opts)
+    bucket = nil
+    cf = cloudfiles_client(credentials)
+    safely do
+      new_bucket = cf.create_container(name)
+      bucket = convert_container(new_bucket)
+    end
+    bucket
+  end
+
+#--
+# Delete Bucket
+#--
+  def delete_bucket(credentials, name, opts)
+    cf = cloudfiles_client(credentials)
+    safely do
+      cf.delete_container(name)
+    end
+  end
+
+#--
+# Blobs
+#--
+  def blobs(credentials, opts)
+    cf = cloudfiles_client(credentials)
+    blobs = []
+    safely do
+      cf_container = cf.container(opts['bucket'])
+      cf_container.objects.each do |object_name|
+        blobs << convert_object(cf_container.object(object_name))
+      end
+    end
+    blobs = filter_on(blobs, :id, opts)
+    blobs
+  end
+
+#-
+# Blob data
+#-
+  def blob_data(credentials, bucket_id, blob_id, opts)
+    cf = cloudfiles_client(credentials)
+    cf.container(bucket_id).object(blob_id).data_stream do |chunk|
+      yield chunk
+    end
+  end
+
+private
+
   def convert_srv_to_instance(srv)
     inst = Instance.new(:id => srv["id"].to_s,
                         :owner_id => "root",
@@ -163,17 +252,27 @@ class RackspaceDriver < Deltacloud::BaseDriver
     end
   end
 
-  define_instance_states do
-    start.to( :pending )          .on( :create )
-
-    pending.to( :running )        .automatically
-
-    running.to( :running )        .on( :reboot )
-    running.to( :shutting_down )  .on( :stop )
+  def convert_container(cf_container)
+    Bucket.new({ :id => cf_container.name,
+                    :name => cf_container.name,
+                    :size => cf_container.count,
+                    :blob_list => cf_container.objects
+                 })
+  end
 
-    shutting_down.to( :stopped )  .automatically
+  def convert_object(cf_object)
+    Blob.new({   :id => cf_object.name,
+                 :bucket => cf_object.container.name,
+                 :content_length => cf_object.bytes,
+                 :content_type => cf_object.content_type,
+                 :last_modified => cf_object.last_modified
+              })
+  end
 
-    stopped.to( :finish )         .automatically
+  def cloudfiles_client(credentials)
+    safely do
+      CloudFiles::Connection.new(credentials.user, credentials.password)
+    end
   end
 
   def safely(&block)

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

@@ -78,10 +78,13 @@ class RHEVMDriver < Deltacloud::BaseDriver
 
   def statify(state)
     st = state.nil? ? "" : state.upcase()
-    return "running" if st == "UP"
-    return "stopped" if st == "DOWN"
-    return "pending" if st == "POWERING UP"
-    st
+    case st
+    when "UP"
+      "RUNNING"
+    when "DOWN"
+      "STOPPED"
+    when "POWERING UP"
+      "PENDING"
   end
 
   define_hardware_profile 'rhevm'

data/lib/deltacloud/helpers/application_helper.rb

@@ -54,6 +54,13 @@ module ApplicationHelper
     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]
@@ -100,8 +107,8 @@ module ApplicationHelper
     return redirect(instances_url) if name.eql?(:destroy) or @instance.class!=Instance
 
     respond_to do |format|
-      format.html { haml :"instances/show" }
       format.xml { haml :"instances/show" }
+      format.html { haml :"instances/show" }
       format.json {convert_to_json(:instance, @instance) }
     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/models/blob.rb

@@ -0,0 +1,26 @@
+#
+# 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 Blob < BaseModel
+  #already has an id from basemodel (for the key)
+  attr_accessor :bucket
+  attr_accessor :content_length
+  attr_accessor :content_type
+  attr_accessor :last_modified
+  attr_accessor :content
+end

data/lib/deltacloud/models/bucket.rb

@@ -0,0 +1,24 @@
+#
+# 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 Bucket < BaseModel
+
+  attr_accessor :name
+  attr_accessor :size
+  attr_accessor :blob_list
+end

data/lib/drivers.rb

@@ -6,6 +6,7 @@ DRIVERS = {
   :rimuhosting => { :name => "RimuHosting"},
   :opennebula => { :name => "Opennebula", :class => "OpennebulaDriver" },
   :terremark => { :name => "Terremark"},
+  :azure => { :name => "Azure" },
   :mock => { :name => "Mock" }
 }
 

data/lib/sinatra/respond_to.rb

@@ -1,93 +1,132 @@
+# respond_to (The MIT License)
+
+# Permission is hereby granted, free of charge, to any person obtaining a copy of this software
+# and associated documentation files (the 'Software'), to deal in the Software without restriction,
+# including without limitation the rights to use, copy, modify, merge, publish, distribute,
+# sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is 
+# furnished to do so, subject to the following conditions:
+#
+# THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT 
+# NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, 
+# DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE
+
 require 'sinatra/base'
-require 'sinatra/accept_media_types'
+require 'rack/accept'
 
-# Accept header parsing was looked at but deemed
-# too much of an irregularity to deal with.  Problems with the header
-# differences from IE, Firefox, Safari, and every other UA causes
-# problems with the expected output.  The general expected behavior
-# would be serve html when no extension provided, but most UAs say
-# they will accept application/xml with out a quality indicator, meaning
-# you'd get the xml block served insead.  Just plain retarded, use the
-# extension and you'll never be suprised.
+use Rack::Accept
 
 module Sinatra
   module RespondTo
-    class UnhandledFormat < Sinatra::NotFound; end
-    class MissingTemplate < Sinatra::NotFound
-      def code; 500 end
+
+    class MissingTemplate < Sinatra::NotFound; end
+
+    # Define all MIME types you want to support here.
+    # This conversion table will be used for auto-negotiation
+    # with browser in sinatra when no 'format' parameter is specified.
+
+    SUPPORTED_ACCEPT_HEADERS = {
+      :xml => [
+        'text/xml',
+        'application/xml'
+      ],
+      :html => [
+        'text/html',
+        'application/xhtml+xml'
+      ],
+      :json => [
+        'application/json'
+      ]
+    }
+
+    # We need to pass array of available response types to
+    # best_media_type method
+    def accept_to_array
+      SUPPORTED_ACCEPT_HEADERS.keys.collect do |key|
+        SUPPORTED_ACCEPT_HEADERS[key]
+      end.flatten
     end
 
-    TEXT_MIME_TYPES = [:txt, :html, :js, :json, :xml, :rss, :atom, :css, :asm, :c, :cc, :conf,
-                       :csv, :cxx, :diff, :dtd, :f, :f77, :f90, :for, :gemspec, :h, :hh, :htm,
-                       :log, :mathml, :mml, :p, :pas, :pl, :pm, :py, :rake, :rb, :rdf, :rtf, :ru,
-                       :s, :sgm, :sgml, :sh, :svg, :svgz, :text, :wsdl, :xhtml, :xsl, :xslt, :yaml,
-                       :yml, :ics, :png]
+    # Then, when we get best media type for response, we need
+    # to know which format to choose
+    def lookup_format_from_mime(mime)
+      SUPPORTED_ACCEPT_HEADERS.keys.each do |format|
+        return format if SUPPORTED_ACCEPT_HEADERS[format].include?(mime)
+      end
+    end
 
     def self.registered(app)
+
       app.helpers RespondTo::Helpers
 
-      app.set :default_charset, 'utf-8'
-      app.set :default_content, :html
-      app.set :assume_xhr_is_js, true
-
-      # We remove the trailing extension so routes
-      # don't have to be of the style
-      #
-      #   get '/resouce.:format'
-      #
-      # They can instead be of the style
-      #
-      #   get '/resource'
-      #
-      # and the format will automatically be available in <tt>format</tt>
       app.before do
-        # Let through sinatra image urls in development
+
+        # Skip development error image and static content
         next if self.class.development? && request.path_info =~ %r{/__sinatra__/.*?.png}
+        next if options.static? && options.public? && (request.get? || request.head?) && static_file?(request.path_info)
 
-        unless options.static? && options.public? && (request.get? || request.head?) && static_file?(request.path_info)
-          rpi = request.path_info.sub(%r{\.([^\./]+)$}, '')
-
-          if (not $1) or ($1 and TEXT_MIME_TYPES.include?($1.to_sym))
-            request.path_info, ext = rpi, nil
-            if ! $1.nil?
-              ext = $1
-            elsif env['HTTP_ACCEPT'].nil? || env['HTTP_ACCEPT'].empty?
-              ext = options.default_content
-            end
-            if ext
-              @mime_types = [ Helpers::mime_type(ext) ]
-              format ext
-            end
-          end
+        # Remove extension from URI
+        # Extension will be available as a 'extension' method (extension=='txt')
+       
+        extension request.path_info.match(/\.([^\.\/]+)$/).to_a.first
+
+        # If ?format= is present, ignore all Accept negotiations because
+        # we are not dealing with browser
+        if request.params.has_key? 'format'
+          format params['format'].to_sym
+        end
+        
+        # Let's make a little exception here to handle
+        # /api/instance_states[.gv/.png] calls
+        if extension.eql?('gv')
+          format :gv
+        elsif extension.eql?('png')
+          format :png
         end
-      end
 
-     app.configure :development do |dev|
-        dev.error UnhandledFormat do
-          content_type :html, :charset => 'utf-8'
+        # Get Rack::Accept::Response object and find best possible
+        # mime type to output.
+        # This negotiation works fine with latest rest-client gem:
+        #
+        # RestClient.get 'http://localhost:3001/api', {:accept => :json } =>
+        # 'application/json'
+        # RestClient.get 'http://localhost:3001/api', {:accept => :xml } =>
+        # 'application/xml'
+        #
+        # Also browsers like Firefox (3.6.x) and Chromium reporting
+        # 'application/xml+xhtml' which is recognized as :html reponse
+        # In browser you can force output using ?format=[format] parameter.
+
+        rack_accept = env['rack-accept.request']
+
+        if rack_accept.media_type.to_s.strip.eql?('Accept:')
+          format :xml
+        else
+          format lookup_format_from_mime(rack_accept.best_media_type(accept_to_array))
+        end
 
-          (<<-HTML).gsub(/^ {10}/, '')
-          <!DOCTYPE html>
-          <html>
-          <head>
-            <style type="text/css">
-            body { text-align:center;font-family:helvetica,arial;font-size:22px;
-              color:#888;margin:20px}
-            #c {margin:0 auto;width:500px;text-align:left}
-            </style>
-          </head>
-          <body>
-            <h2>Sinatra doesn't know this ditty.</h2>
-            <img src='/__sinatra__/404.png'>
-            <div id="c">
-              Try this:
-              <pre>#{request.request_method.downcase} '#{request.path_info}' do\n  respond_to do |wants|\n    wants.#{format} { "Hello World" }\n  end\nend</pre>
-            </div>
-          </body>
-          </html>
-          HTML
+      end
+
+      app.class_eval do
+        # This code was copied from respond_to plugin
+        # http://github.com/cehoffman/sinatra-respond_to
+        # MIT License
+        alias :render_without_format :render
+        def render(*args, &block)
+          assumed_layout = args[1] == :layout
+          args[1] = "#{args[1]}.#{format}".to_sym if args[1].is_a?(::Symbol)
+          render_without_format *args, &block
+        rescue Errno::ENOENT => e
+          raise MissingTemplate, "#{args[1]}.#{args[0]}" unless assumed_layout
+          raise e
         end
+        private :render
+      end
 
+      # This code was copied from respond_to plugin
+      # http://github.com/cehoffman/sinatra-respond_to
+      app.configure :development do |dev|
         dev.error MissingTemplate do
           content_type :html, :charset => 'utf-8'
           response.status = request.env['sinatra.error'].code
@@ -103,7 +142,6 @@ module Sinatra
           layout = case engine
                    when 'haml' then "!!!\n%html\n  %body= yield"
                    when 'erb' then "<html>\n  <body>\n    <%= yield %>\n  </body>\n</html>"
-                   when 'builder' then ::Sinatra::VERSION =~ /^1.0/ ? "xml << yield" : "builder do |xml|\n  xml << yield\nend"
                    end
 
           layout = "<small>app.#{format}.#{engine}</small>\n<pre>#{escape_html(layout)}</pre>"
@@ -117,19 +155,16 @@ module Sinatra
               color:#888;margin:20px}
             #c {margin:0 auto;width:500px;text-align:left;}
             small {float:right;clear:both;}
-            pre {clear:both;}
+            pre {clear:both;text-align:left;font-size:70%;width:500px;margin:0 auto;}
             </style>
           </head>
           <body>
             <h2>Sinatra can't find #{request.env['sinatra.error'].message}</h2>
             <img src='/__sinatra__/500.png'>
+            <pre>#{request.env['sinatra.error'].backtrace.join("\n")}</pre>
             <div id="c">
-              Try this:<br />
-              #{layout}
-              <small>#{path}.#{format}.#{engine}</small>
-              <pre>Hello World!</pre>
               <small>application.rb</small>
-              <pre>#{request.request_method.downcase} '#{request.path_info}' do\n  respond_to do |wants|\n    wants.#{engine == 'builder' ? 'xml' : 'html'} { #{engine} :#{path}#{",\n#{' '*32}layout => :app" if layout} }\n  end\nend</pre>
+              <pre>#{request.request_method.downcase} '#{request.path_info}' do\n  respond_to do |wants|\n    wants.#{format} { #{engine} :#{path} }\n  end\nend</pre>
             </div>
           </body>
           </html>
@@ -137,75 +172,23 @@ module Sinatra
         end
 
       end
-
-      app.class_eval do
-        private
-          def accept_list
-            @mime_types || Rack::AcceptMediaTypes.new(env['HTTP_ACCEPT'] || '')
-          end
-
-          # Changes in 1.0 Sinatra reuse render for layout so we store
-          # the original value to tell us if this is an automatic attempt
-          # to do a layout call.  If it is, it might fail with Errno::ENOENT
-          # and we want to pass that back to sinatra since it isn't a MissingTemplate
-          # error
-          def render_with_format(*args, &block)
-            assumed_layout = args[1] == :layout
-            args[1] = "#{args[1]}.#{format}".to_sym if args[1].is_a?(::Symbol)
-            render_without_format *args, &block
-          rescue Errno::ENOENT => e
-            raise MissingTemplate, "#{args[1]}.#{args[0]}" unless assumed_layout
-            raise e
-          end
-          alias_method :render_without_format, :render
-          alias_method :render, :render_with_format
-
-          if ::Sinatra::VERSION =~ /^0\.9/
-            def lookup_layout_with_format(*args)
-              args[1] = "#{args[1]}.#{format}".to_sym if args[1].is_a?(::Symbol)
-              lookup_layout_without_format *args
-            end
-            alias_method :lookup_layout_without_format, :lookup_layout
-            alias_method :lookup_layout, :lookup_layout_with_format
-          end
-      end
     end
 
     module Helpers
-      # Patch the content_type function to remember the set type
-      # This helps cut down on time in the format helper so it
-      # doesn't have to do a reverse lookup on the header
+
+      # This code was copied from respond_to plugin
+      # http://github.com/cehoffman/sinatra-respond_to
       def self.included(klass)
         klass.class_eval do
-          def content_type_with_save(*args)
+          alias :content_type_without_save :content_type
+          def content_type(*args)
             content_type_without_save *args
             @_format = args.first.to_sym
             response['Content-Type']
           end
-          alias_method :content_type_without_save, :content_type
-          alias_method :content_type, :content_type_with_save
-        end if ::Sinatra::VERSION =~ /^1.0/
-      end
-
-      def self.mime_type(sym)
-        ::Sinatra::Base.respond_to?(:mime_type) && ::Sinatra::Base.mime_type(sym) || ::Sinatra::Base.media_type(sym)
-      end
-
-      def format(val=nil)
-        unless val.nil?
-          mime_type = ::Sinatra::RespondTo::Helpers.mime_type(val)
-          fail "Unknown media type #{val}\nTry registering the extension with a mime type" if mime_type.nil?
-
-          @_format = val.to_sym
-          response['Content-Type'].sub!(/^[^;]+/, mime_type)
-          charset options.default_charset if Sinatra::RespondTo::TEXT_MIME_TYPES.include?(format) and format!=:png
         end
-
-        @_format
       end
 
-      # This is mostly just a helper so request.path_info isn't changed when
-      # serving files from the public directory
       def static_file?(path)
         public_dir = File.expand_path(options.public)
         path = File.expand_path(File.join(public_dir, unescape(path)))
@@ -213,60 +196,43 @@ module Sinatra
         path[0, public_dir.length] == public_dir && File.file?(path)
       end
 
-      def charset(val=nil)
-        fail "Content-Type must be set in order to specify a charset" if response['Content-Type'].nil?
-
-        if response['Content-Type'] =~ /charset=[^;]+/
-          response['Content-Type'].sub!(/charset=[^;]+/, (val == '' && '') || "charset=#{val}")
-        else
-          response['Content-Type'] += ";charset=#{val}"
-        end unless val.nil?
 
-        response['Content-Type'][/charset=([^;]+)/, 1]
+      # Extension holds trimmed extension. This is extra usefull
+      # when you want to build original URI (with extension)
+      # You can simply call "#{request.env['REQUEST_URI']}.#{extension}"
+      def extension(val=nil)
+        @_extension ||= val
+        @_extension
       end
-
-      def respond_to(&block)
-        wants = Format.new
-        yield wants
-        fmt, type, handler = match_accept_type(accept_list, wants)
-        raise UnhandledFormat if fmt.nil?
-        format fmt
-        handler.nil? ? nil : handler.call
+      
+      # This helper will holds current format. Helper should be
+      # accesible from all places in Sinatra
+      def format(val=nil)
+        @_format ||= val
+        @_format
       end
 
-      def match_accept_type(mime_types, format)
-        selected = []
-        accepted_types = mime_types.map {|type| Regexp.escape(type).gsub(/\\\*/,'.*') }
-        # Fix for Chrome based browsers which returns XML when 'xhtml' is requested.
-        if env['HTTP_USER_AGENT'] =~ /Chrome/ and accepted_types.size>1
-          accepted_types[0], accepted_types[1] = accepted_types[1], accepted_types[0]
-          if accepted_types[0].eql?('application/xhtml\\+xml')
-            accepted_types[0] = 'text/html'
-          end
+      def respond_to(&block)
+        wants = {}
+        
+        def wants.method_missing(type, *args, &handler)
+          self[type] = handler
         end
-        accepted_types.each do |at|
-          format.each do |fmt, ht, handler|
-            (selected = [fmt, ht, handler]) and break if ht.match(at)
-          end
-          break unless selected.empty?
+        
+        # Set proper content-type and encoding for
+        # text based formats
+        if [:xml, :gv, :html, :json].include?(format)
+          content_type format, :charset => 'utf-8'
         end
-        selected
-      end
+        yield wants
+        # Raise this error if requested format is not defined
+        # in respond_to { } block.
+        raise MissingTemplate if wants[format].nil?
 
-      # NOTE Array instead of hash because order matters (wildcard type
-      # matches first handler)
-      class Format < Array #:nodoc:
-        def method_missing(format, *args, &handler)
-          mt = Sinatra::RespondTo::Helpers.mime_type(format)
-          if mt.nil?
-            Sinatra::Base.send(:fail, "Unknown media type for respond_to: #{format}\nTry registering the extension with a mime type")
-          end
-          self << [format.to_s, mt, handler]
-        end
+        wants[format].call
       end
+
     end
+
   end
 end
-
-Rack::Mime::MIME_TYPES.merge!({ ".gv" => "text/plain" })
-Sinatra::Application.register Sinatra::RespondTo