deltacloud-core 0.4.0 → 0.4.1

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

@@ -27,7 +27,7 @@ module VSphere
   # he have to pad the content of the iso file
   # that mean a limit of 400 kb file since
   # 1 sector of iso file = 2048 bytes
-  ISO_SECTORS=200
+  ISO_SECTORS=202
 
   RbVmomi::VIM::Datastore::class_eval do
     def soap
@@ -43,7 +43,7 @@ module VSphere
     end
 
     def user_data!(datastore,base64_content,file_name)
-      command="#{MKISOFS_EXECUTABLE} -stream-file-name #{file_name}.txt -stream-media-size #{ISO_SECTORS}"
+      command="#{MKISOFS_EXECUTABLE} -stream-file-name deltacloud-user-data.txt -stream-media-size #{ISO_SECTORS}"
       iso_file=''
       Open3::popen3(command) do |stdin, stdout, stderr|
         stdin.write(base64_content.unpack("m"))

data/lib/deltacloud/helpers.rb

@@ -18,5 +18,6 @@ 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'
 
 helpers ApplicationHelper, ConversionHelper, HardwareProfilesHelper, JSONHelper

data/lib/deltacloud/helpers/application_helper.rb

@@ -92,6 +92,7 @@ module ApplicationHelper
     @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|
@@ -152,7 +153,7 @@ module ApplicationHelper
 
   def link_to_action(action, url, method)
     capture_haml do
-      haml_tag :form, :method => :post, :action => url, :class => [:link, method] 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
@@ -258,7 +259,7 @@ module ApplicationHelper
   def address_type(address)
     case address
       when /^(\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3})?$/; :ipv4
-      when /^.*:([\-\d]+)$/; :vnc
+      when /^(\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}:[\-\d]+)$/; :vnc
       when /^(\S{1,2}:\S{1,2}:\S{1,2}:\S{1,2}:\S{1,2}:\S{1,2})?$/; :mac
       else :hostname
     end

data/lib/deltacloud/helpers/blob_stream.rb

@@ -63,23 +63,6 @@ rescue LoadError => e
   end
 end
 
-class Hash
-
-  def gsub_keys(rgx_pattern, replacement)
-    remove = []
-    self.each_key do |key|
-      if key.to_s.match(rgx_pattern)
-         new_key = key.to_s.gsub(rgx_pattern, replacement).downcase
-         self[new_key] = self[key]
-         remove << key
-      end
-    end
-    #remove the original keys
-    self.delete_if{|k,v| remove.include?(k)}
-  end
-
-end
-
 module BlobHelper
 
   def self.extract_blob_metadata_hash(env_hash)

data/{deltacloud.rb → lib/deltacloud/models.rb}

@@ -14,16 +14,6 @@
 # License for the specific language governing permissions and limitations
 # under the License.
 
-$:.unshift File.join(File.dirname(__FILE__), 'lib')
-
-require 'drivers'
-
-require 'deltacloud/core_ext'
-
-require 'deltacloud/base_driver'
-require 'deltacloud/hardware_profile'
-require 'deltacloud/state_machine'
-require 'deltacloud/helpers'
 require 'deltacloud/models/base_model'
 require 'deltacloud/models/realm'
 require 'deltacloud/models/image'
@@ -38,6 +28,3 @@ require 'deltacloud/models/blob'
 require 'deltacloud/models/load_balancer'
 require 'deltacloud/models/firewall'
 require 'deltacloud/models/firewall_rule'
-
-require 'deltacloud/validation'
-require 'deltacloud/runner'

data/lib/sinatra/rabbit.rb

@@ -59,7 +59,8 @@ module Sinatra
       def initialize(coll, name, opts, &block)
         @name = name.to_sym
         opts = STANDARD[@name].merge(opts) if standard?
-        @collection = coll
+        @path_generator = opts[:path_generator]
+        @collection, @standard = coll, opts[:standard]
         raise "No method for operation #{name}" unless opts[:method]
         @method = opts[:method].to_sym
         @member = opts[:member]
@@ -74,7 +75,7 @@ module Sinatra
       end
 
       def standard?
-        STANDARD.keys.include?(name)
+        STANDARD.keys.include?(name) || @standard
       end
 
       def form?
@@ -125,8 +126,17 @@ module Sinatra
         end
       end
 
+      def member?
+        if standard?
+          @member || STANDARD[name][:member]
+        else
+          @member
+        end
+      end
+
       def path(args = {})
-        if @member
+        return @path_generator.call(self) if @path_generator
+        if member?
           if standard?
             "#{@collection.name}/:id"
           else
@@ -190,12 +200,12 @@ module Sinatra
     end
 
     class Collection
-      attr_reader :name, :operations
+      attr_reader :name, :operations, :subcollections
 
       def initialize(name, &block)
         @name = name
         @description = ""
-        @operations = {}
+        @operations, @subcollections = {}, {}
         @global = false
         instance_eval(&block) if block_given?
         generate_documentation
@@ -203,6 +213,10 @@ module Sinatra
         generate_options
       end
 
+      def subcollection?
+        self.class == SubCollection
+      end
+
       # Set/Return description for collection
       # If first parameter is not present, full description will be
       # returned.
@@ -280,13 +294,21 @@ module Sinatra
         @operations[name] = Operation.new(self, name, opts, &block)
       end
 
+      def collection(name, opts={}, &block)
+        if subcollections.keys.include?(name)
+          raise DuplicateOperationException::new(500, "DuplicateSubcollection", "Subcollection #{name} is already defined", [])
+        end
+        subcollections[name] = SubCollection.new(self, name, opts, &block)
+        subcollections[name].generate
+      end
+
       def generate
         operations.values.reject { |op| op.member }.each { |o| o.generate }
         operations.values.select { |op| op.member }.each { |o| o.generate }
         app = ::Sinatra::Application
         collname = name # Work around Ruby's weird scoping/capture
         app.send(:define_method, "#{name.to_s.singularize}_url") do |id|
-            api_url_for "#{collname}/#{id}", :full
+          api_url_for "#{collname}/#{id}", :full
         end
         if index_op = operations[:index]
           app.send(:define_method, "#{name}_url") do
@@ -296,12 +318,66 @@ module Sinatra
       end
 
       def check_supported(driver)
-        unless global? || driver.has_collection?(@name)
+        unless global? || driver.has_collection?(@name) || self.kind_of?(Sinatra::Rabbit::SubCollection)
           raise UnsupportedCollectionException
         end
       end
     end
 
+    class SubCollection < Collection
+
+      attr_accessor :parent
+
+      def initialize(parent, name, opts={}, &block)
+        self.parent = parent
+        super(name, &block)
+      end
+
+      def operation(name, opts = {}, &block)
+        if @operations.keys.include?(name)
+          raise DuplicateOperationException::new(500, "DuplicateOperation", "Operation #{name} is already defined", [])
+        end
+        # Preserve self as local variable to workaround Ruby namespace
+        # weirdness
+        c = self
+        path_generator = Proc.new do |obj|
+          if obj.member?
+            if obj.standard?
+              "#{parent.name}/:#{parent.name.to_s.singularize}/:#{c.name.to_s.singularize}"
+            else
+              "#{parent.name}/:#{parent.name.to_s.singularize}/:#{c.name.to_s.singularize}/#{name}"
+            end
+          else
+            if obj.form?
+              "#{parent.name}/:id/:#{parent.name.to_s.singularize}/#{obj.name}"
+            else
+              "#{parent.name}/:#{parent.name.to_s.singularize}"
+            end
+          end
+        end
+        opts.merge!({
+          :path_generator => path_generator
+        })
+        @operations[name] = Operation.new(self, name, opts, &block)
+      end
+
+      def generate
+        operations.values.reject { |op| op.member }.each { |o| o.generate }
+        operations.values.select { |op| op.member }.each { |o| o.generate }
+        app = ::Sinatra::Application
+        collname = name # Work around Ruby's weird scoping/capture
+        app.send(:define_method, "#{parent.name.to_s}_#{name.to_s.singularize}_url") do |id, subid|
+          api_url_for "#{collname}/#{id}/#{subid}", :full
+        end
+        if index_op = operations[:index]
+          app.send(:define_method, "#{parent.name.to_s}_#{name}_url") do
+            api_url_for index_op.path.gsub(/\/\?$/,''), :full
+          end
+        end
+      end
+
+    end
+
     def collections
       @collections ||= {}
     end

data/lib/sinatra/sinatra_verbose.rb

@@ -0,0 +1,73 @@
+#
+# 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 'sinatra/base'
+
+module Sinatra
+  module VerboseLogger
+
+    module Helpers
+
+      def info(message)
+        puts sprintf("\033[1;34m[INFO: #{caller_method_name}]\033[0m: %s", message.inspect)
+      end
+
+      alias :debug :info
+
+      def warn(message)
+        puts sprintf("\033[1;31m[WARN: #{caller_method_name}]\033[0m: %s", message.inspect)
+      end
+
+      private
+
+      def caller_method_name
+        caller(2).first
+      end
+
+    end
+
+    def enable_verbose_logging!
+      disable :logging
+      before {
+        puts sprintf("\n\033[1;29mProcessing %s\033[0m (for %s at #{Time.now}) [%s] [\033[1;29m%s\033[0m]",
+                     request.path_info, request.ip, request.request_method, driver_name)
+        puts "Parameters: #{params.inspect}"
+        if provider=Thread::current[:provider] || ENV['API_PROVIDER']
+          puts "Provider: #{provider}"
+        end
+        puts "Authentication: #{request.env['HTTP_AUTHORIZATION'].split(' ').first}" if request.env['HTTP_AUTHORIZATION']
+        puts "Server: #{request.env['SERVER_SOFTWARE']}"
+        puts "Accept: #{request.env['HTTP_ACCEPT']}"
+        puts
+      }
+      after {
+        puts sprintf("\nCompleted in \033[1;29m%4f\033[0m | %4f | %s | \033[1;36m%s\033[0m | %s\n",
+                     response.header['X-Backend-Runtime'] || 0, response.header['X-Runtime'] || 0, response.status, response.content_type, request.url)
+      }
+    end
+
+    def self.registered(app)
+      app.helpers VerboseLogger::Helpers
+      app.enable_verbose_logging! if ENV['API_VERBOSE']
+    end
+  end
+end
+
+Sinatra::Application.register Sinatra::VerboseLogger
+
+Deltacloud::BaseDriver.class_eval do
+  include Sinatra::VerboseLogger::Helpers
+end

data/lib/sinatra/url_for.rb

@@ -59,15 +59,21 @@ module Sinatra
       when :path_only
         base = request.script_name
       when :full
-        scheme = request.env['HTTP_X_FORWARDED_SCHEME'] || request.scheme
-        port = request.env['HTTP_X_FORWARDED_PORT'] || request.port
-        if ((scheme == 'http' && port.to_s == '80') ||
+        scheme = request.scheme
+        port = request.port
+        request_host = request.host
+        if request.env['HTTP_X_FORWARDED_FOR']
+          scheme = request.env['HTTP_X_FORWARDED_SCHEME'] || scheme
+          port = request.env['HTTP_X_FORWARDED_PORT']
+          request_host = request.env['HTTP_X_FORWARDED_HOST']
+        end
+        if (port.nil? || port == "" ||
+            (scheme == 'http' && port.to_s == '80') ||
             (scheme == 'https' && port.to_s == '443'))
           port = ""
         else
           port = ":#{port}"
         end
-        request_host = HOSTNAME ? HOSTNAME : request.host
         base = "#{scheme}://#{request_host}#{port}#{request.script_name}"
       else
         raise TypeError, "Unknown url_for mode #{mode}"

data/server.rb

@@ -15,7 +15,6 @@
 
 require 'sinatra'
 require 'deltacloud'
-require 'drivers'
 require 'json'
 require 'sinatra/rack_accept'
 require 'sinatra/static_assets'
@@ -24,7 +23,7 @@ require 'sinatra/lazy_auth'
 require 'erb'
 require 'haml'
 require 'open3'
-require 'lib/deltacloud/helpers/blob_stream'
+require 'sinatra/sinatra_verbose'
 require 'sinatra/rack_driver_select'
 require 'sinatra/rack_runtime'
 require 'sinatra/rack_etag'
@@ -32,7 +31,7 @@ require 'sinatra/rack_date'
 require 'sinatra/rack_matrix_params'
 require 'sinatra/rack_syslog'
 
-set :version, '0.4.0'
+set :version, '0.4.1'
 
 include Deltacloud::Drivers
 set :drivers, Proc.new { driver_config }
@@ -48,7 +47,7 @@ use Rack::Date
 
 configure do
   set :views, File.dirname(__FILE__) + '/views'
-  set :public, File.dirname(__FILE__) + '/public'
+  set :public_folder, File.dirname(__FILE__) + '/public'
   # Try to load the driver on startup to fail early if there are issues
   driver
 end
@@ -78,6 +77,15 @@ error 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
+
 # Redirect to /api
 get '/' do redirect root_url, 301; end
 
@@ -753,39 +761,6 @@ collection :keys do
 
 end
 
-#create a new blob using PUT - streams through deltacloud
-put "#{Sinatra::UrlForHelper::DEFAULT_URI_PREFIX}/buckets/:bucket/:blob" do
-  if(env["BLOB_SUCCESS"]) #ie got a 200ok after putting blob
-    content_type = env["CONTENT_TYPE"]
-    content_type ||=  ""
-    @blob = driver.blob(credentials, {:id => params[:blob],
-                                      'bucket' => params[:bucket]})
-    respond_to do |format|
-      format.xml { haml :"blobs/show" }
-      format.html { haml :"blobs/show" }
-      format.json { convert_to_json(:blob, @blob) }
-    end
-  elsif(env["BLOB_FAIL"])
-    report_error(500) #OK?
-  else # small blobs - < 112kb dont hit the streaming monkey patch - use 'normal' create_blob
-       # also, if running under webrick don't hit the streaming patch (Thin specific)
-    bucket_id = params[:bucket]
-    blob_id = params[:blob]
-    temp_file = Tempfile.new("temp_blob_file")
-    temp_file.write(env['rack.input'].read)
-    temp_file.flush
-    content_type = env['CONTENT_TYPE'] || ""
-    blob_data = {:tempfile => temp_file, :type => content_type}
-    user_meta = BlobHelper::extract_blob_metadata_hash(request.env)
-    @blob = driver.create_blob(credentials, bucket_id, blob_id, blob_data, user_meta)
-    temp_file.delete
-    respond_to do |format|
-      format.xml { haml :"blobs/show" }
-      format.html { haml :"blobs/show"}
-    end
-  end
-end
-
 #get html form for creating a new blob
 
 # The URL for getting the new blob form for the HTML UI looks like the URL
@@ -801,107 +776,160 @@ get "#{Sinatra::UrlForHelper::DEFAULT_URI_PREFIX}/buckets/:bucket/#{NEW_BLOB_FOR
   end
 end
 
-#create a new blob using html interface - NON STREAMING (i.e. browser POST http form data)
-post "#{Sinatra::UrlForHelper::DEFAULT_URI_PREFIX}/buckets/:bucket" do
-  bucket_id = params[:bucket]
-  blob_id = params['blob_id'] || params['blob'] #keep 'blob' just in case
-  blob_data = params['blob_data']
-  user_meta = {}
-  #metadata from params (i.e., passed by http form post, e.g. browser)
-  max = params[:meta_params]
-  if(max)
-    (1..max.to_i).each do |i|
-      key = params[:"meta_name#{i}"]
-      key = "HTTP_X_Deltacloud_Blobmeta_#{key}"
-      value = params[:"meta_value#{i}"]
-      user_meta[key] = value
+collection :buckets do
+  description "Cloud Storage buckets - aka buckets|directories|folders"
+
+  collection :blobs do
+    description "Blobs associated with given bucket"
+
+    operation :show do
+      description "Display blob"
+      control do
+        @blob = driver.blob(credentials, { :id => params[:blob], 'bucket' => params[:bucket]})
+        if @blob
+          respond_to do |format|
+            format.xml { haml :"blobs/show" }
+            format.html { haml :"blobs/show" }
+            format.json { convert_to_json(:blob, @blob) }
+          end
+        else
+          report_error(404)
+        end
+      end
+
     end
-  end
-  @blob = driver.create_blob(credentials, bucket_id, blob_id, blob_data, user_meta)
-  respond_to do |format|
-    format.xml { haml :"blobs/show" }
-    format.html { haml :"blobs/show"}
-  end
-end
 
-#delete a blob
-delete "#{Sinatra::UrlForHelper::DEFAULT_URI_PREFIX}/buckets/:bucket/:blob" do
-  bucket_id = params[:bucket]
-  blob_id = params[:blob]
-  driver.delete_blob(credentials, bucket_id, blob_id)
-  status 204
-  respond_to do |format|
-    format.xml
-    format.json
-    format.html { redirect(bucket_url(bucket_id)) }
-  end
-end
+    operation :create do
+      description "Create new blob"
+      control do
+        bucket_id = params[:bucket]
+        blob_id = params['blob_id']
+        blob_data = params['blob_data']
+        user_meta = {}
+        #metadata from params (i.e., passed by http form post, e.g. browser)
+        max = params[:meta_params]
+        if(max)
+          (1..max.to_i).each do |i|
+            key = params[:"meta_name#{i}"]
+            key = "HTTP_X_Deltacloud_Blobmeta_#{key}"
+            value = params[:"meta_value#{i}"]
+            user_meta[key] = value
+          end
+        end
+        @blob = driver.create_blob(credentials, bucket_id, blob_id, blob_data, user_meta)
+        respond_to do |format|
+          format.xml { haml :"blobs/show" }
+          format.html { haml :"blobs/show"}
+        end
+      end
+    end
 
-#get blob metadata
-head "#{Sinatra::UrlForHelper::DEFAULT_URI_PREFIX}/buckets/:bucket/:blob" do
-  @blob_id = params[:blob]
-  @blob_metadata = driver.blob_metadata(credentials, {:id => params[:blob], 'bucket' => params[:bucket]})
-  if @blob_metadata
-      @blob_metadata.each do |k,v|
-        headers["X-Deltacloud-Blobmeta-#{k}"] = v
+    operation :destroy do
+      description "Destroy given blob"
+      control do
+        bucket_id = params[:bucket]
+        blob_id = params[:blob]
+        driver.delete_blob(credentials, bucket_id, blob_id)
+        status 204
+        respond_to do |format|
+          format.xml
+          format.json
+          format.html { redirect(bucket_url(bucket_id)) }
+        end
       end
-      status 204
-      respond_to do |format|
-        format.xml
-        format.json
+    end
+
+    operation :stream, :member => true, :standard => true, :method => :put do
+      description "Stream new blob data into the blob"
+      control do
+        if(env["BLOB_SUCCESS"]) #ie got a 200ok after putting blob
+          content_type = env["CONTENT_TYPE"]
+          content_type ||=  ""
+          @blob = driver.blob(credentials, {:id => params[:blob],
+                                            'bucket' => params[:bucket]})
+          respond_to do |format|
+            format.xml { haml :"blobs/show" }
+            format.html { haml :"blobs/show" }
+            format.json { convert_to_json(:blob, @blob) }
+          end
+        elsif(env["BLOB_FAIL"])
+          report_error(500) #OK?
+        else # small blobs - < 112kb dont hit the streaming monkey patch - use 'normal' create_blob
+          # also, if running under webrick don't hit the streaming patch (Thin specific)
+          bucket_id = params[:bucket]
+          blob_id = params[:blob]
+          temp_file = Tempfile.new("temp_blob_file")
+          temp_file.write(env['rack.input'].read)
+          temp_file.flush
+          content_type = env['CONTENT_TYPE'] || ""
+          blob_data = {:tempfile => temp_file, :type => content_type}
+          user_meta = BlobHelper::extract_blob_metadata_hash(request.env)
+          @blob = driver.create_blob(credentials, bucket_id, blob_id, blob_data, user_meta)
+          temp_file.delete
+          respond_to do |format|
+            format.xml { haml :"blobs/show" }
+            format.html { haml :"blobs/show"}
+          end
+        end
       end
-   else
-    report_error(404)
-  end
-end
+    end
 
-#update blob metadata
-post "#{Sinatra::UrlForHelper::DEFAULT_URI_PREFIX}/buckets/:bucket/:blob" do
-  meta_hash = BlobHelper::extract_blob_metadata_hash(request.env)
-  success = driver.update_blob_metadata(credentials, {'bucket'=>params[:bucket], :id =>params[:blob], 'meta_hash' => meta_hash})
-  if(success)
-    meta_hash.each do |k,v|
-      headers["X-Deltacloud-Blobmeta-#{k}"] = v
+    operation :metadata, :member => true, :standard => true, :method => :head do
+      description "Get blob metadata"
+      control do
+        @blob_id = params[:blob]
+        @blob_metadata = driver.blob_metadata(credentials, {:id => params[:blob], 'bucket' => params[:bucket]})
+        if @blob_metadata
+          @blob_metadata.each do |k,v|
+            headers["X-Deltacloud-Blobmeta-#{k}"] = v
+          end
+          status 204
+          respond_to do |format|
+            format.xml
+            format.json
+          end
+        else
+          report_error(404)
+        end
+      end
     end
-    status 204
-    respond_to do |format|
-      format.xml
-      format.json
+
+    operation :update, :member => true, :method => :post do
+      description "Update blob metadata"
+      control do
+        meta_hash = BlobHelper::extract_blob_metadata_hash(request.env)
+        success = driver.update_blob_metadata(credentials, {'bucket'=>params[:bucket], :id =>params[:blob], 'meta_hash' => meta_hash})
+        if(success)
+          meta_hash.each do |k,v|
+            headers["X-Deltacloud-Blobmeta-#{k}"] = v
+          end
+          status 204
+          respond_to do |format|
+            format.xml
+            format.json
+          end
+        else
+          report_error(404) #FIXME is this the right error code?
+        end
+      end
     end
-  else
-    report_error(404) #FIXME is this the right error code?
-  end
-end
 
-#Get a particular blob's particulars (not actual blob data)
-get "#{Sinatra::UrlForHelper::DEFAULT_URI_PREFIX}/buckets/:bucket/:blob" do
-  @blob = driver.blob(credentials, { :id => params[:blob], 'bucket' => params[:bucket]})
-  if @blob
-    respond_to do |format|
-      format.xml { haml :"blobs/show" }
-      format.html { haml :"blobs/show" }
-      format.json { convert_to_json(:blob, @blob) }
+    operation :content, :member => true, :method => :get do
+      description "Download blob content"
+      control do
+        @blob = driver.blob(credentials, { :id => params[:blob], 'bucket' => params[:bucket]})
+        if @blob
+          params['content_length'] = @blob.content_length
+          params['content_type'] = @blob.content_type
+          params['content_disposition'] = "attachment; filename=#{@blob.id}"
+          BlobStream.call(env, credentials, params)
+        else
+          report_error(404)
+        end
       end
-  else
-      report_error(404)
-  end
-end
+    end
 
-#get the content of a particular blob
-get "#{Sinatra::UrlForHelper::DEFAULT_URI_PREFIX}/buckets/:bucket/:blob/content" do
-  @blob = driver.blob(credentials, { :id => params[:blob], 'bucket' => params[:bucket]})
-  if @blob
-    params['content_length'] = @blob.content_length
-    params['content_type'] = @blob.content_type
-    params['content_disposition'] = "attachment; filename=#{@blob.id}"
-    BlobStream.call(env, credentials, params)
-  else
-    report_error(404)
   end
-end
-
-collection :buckets do
-  description "Cloud Storage buckets - aka buckets|directories|folders"
 
   operation :new do
     description "A form to create a new bucket resource"