swift-storage 0.0.1

data/lib/swift_storage/object.rb

@@ -0,0 +1,172 @@
+require "time"
+
+# @attr [String] content_length
+#  Content length of the Object, in bytes.
+#
+# @attr [String] content_type
+#  Content type of the Object, eg: `image/png`.
+#
+# @attr [String] expires
+#  When the object is set to expire.
+#
+# @attr [String] cache_control
+#  Object cache control header.
+#
+class SwiftStorage::Object < SwiftStorage::Node
+
+
+  parent_node                :container
+
+
+  header_attributes          :content_length,
+                             :content_type,
+                             :expires,
+                             :cache_control
+
+  # Read the object data
+  #
+  # This will always make a request to the API server and will not use cache
+  #
+  # @param output_stream [IO]
+  #  An optional stream to write the object's content to. This can be a `File` or and `IO` object.
+  #  This method will **NEVER** rewind `output_stream`, either before writing and after.
+  #
+  # @return [String, output_stream]
+  #  If `output_stream` is nil or ommited, it returns a string with the object content. If `output_stream`
+  #  is given, returns it.
+  #
+  def read(output_stream=nil)
+    response = request(relative_path, :method => :get, :output_stream => output_stream)
+    if output_stream
+      output_stream
+    else
+      response.body
+    end
+  end
+
+
+  # Write the object
+  #
+  # This will always make a request to the API server and will not use cache
+  #
+  # @note If you want to only update the metadata, you may omit `input_stream`
+  #  but you must specify all other options otherwise they will be overwritten.
+  #
+  # @note Some headers specified here may not work with a specific swift server
+  #  as they must be enabled in the server configuration.
+  #
+  # @param input_stream [String, IO]
+  #  The data to upload, if ommited, the write will not override the body and instead it will update
+  #  the metadata and other options. If `input_stream` is an `IO` object, it must
+  #  be seeked to the proper position, this method will **NEVER** seek or rewind the stream.
+  #
+  # @param content_type [String]
+  #  The content type, eg: `image/png`.
+  #
+  # @param attachment [Boolean]
+  #  If `true` the file will be served with `Content-Disposition: attachment`.
+  #
+  # @param delete_at [Time]
+  #  If set, the server will delete the object at the specified time.
+  #
+  # @param delete_after [Time]
+  #  If set, the server will delete the object after the specified time.
+  #
+  # @param cache_control [String]
+  #  The value for the 'Cache-Control' header when serving the object. The value
+  #  is not parsed and served unmodified as is. If you set max-age, it will
+  #  always be served with the same max-age value. To have the resource expire
+  #  at point of time, use the expires header.
+  #
+  # @param expires [Time]
+  #  Set the Expires header.
+  #
+  # @param object_manifest [String]
+  #  When set, this object acts as a large object manifest. The value should be
+  #  `<container>/<prefix>` where `<container>` is the container the object
+  #  segments are in and `<prefix>` is the common prefix for all the segments.
+  #
+  # @return [input_stream]
+  #   Return the `input_stream` argument, or `nil` if `input_stream` is ommited.
+  #
+  def write(input_stream=nil,
+            content_type: nil,
+            attachment: false,
+            delete_at: nil,
+            delete_after: nil,
+            cache_control: nil,
+            expires: nil,
+            object_manifest: nil,
+            metadata: nil)
+
+    h = {}
+
+    input_stream.nil? or content_type or raise ArgumentError, 'Content_type is required if input_stream is given'
+
+    object_manifest.nil? or input_stream.nil? or raise ArgumentError, 'Input must be nil on object manigest'
+
+    h[H::CONTENT_DISPOSITION] = attachment ? 'attachment' : 'inline'
+    h[H::OBJECT_MANIFEST] = object_manifest if object_manifest
+    h[H::CONTENT_TYPE] = content_type if content_type
+    h[H::EXPIRES] = expires.httpdate if expires
+    h[H::CACHE_CONTROL] = cache_control if cache_control
+
+    if delete_at
+      h[H::DELETE_AT] = delete_at.to_i.to_s
+    elsif delete_after
+      h[H::DELETE_AFTER] = delete_after.to_i.to_s
+    end
+
+    merge_metadata(h, metadata)
+
+    method =  input_stream || object_manifest ? :put : :post
+
+    request(relative_path,
+            :method => method,
+            :headers => h,
+            :input_stream => input_stream)
+    clear_cache
+    input_stream
+  end
+
+
+  # Generates a public URL with an expiration time
+  #
+  # @param expires [Time]
+  #  The absolute time when the URL will expire.
+  #
+  # @param method [Symbol]
+  #  The HTTP method to allow, can be `:get, :put, :head`.
+  #
+  # @return [String]
+  #  A temporary URL to the object.
+  #
+  # @!parse def temp_url(expires=Time.now + 3600, method: :get);end
+  def temp_url(expires=nil, method: :get)
+    expires ||= Time.now + 3600
+    service.create_temp_url(container.name, name, expires, method)
+  end
+
+  # Returns the object's URL
+  #
+  # @note This URL is unsigneds and the container authorization will apply. If
+  #  the container do not allow public access, this URL will require an
+  #  authentication token.
+  #
+  # @return [String]
+  #  The object URL.
+  #
+  def url
+    File.join(service.storage_url, relative_path)
+  end
+
+  private
+
+  H = SwiftStorage::Headers
+
+  def relative_path
+    File.join(container.name, name)
+  end
+
+end
+

data/lib/swift_storage/object_collection.rb

@@ -0,0 +1,34 @@
+class SwiftStorage::ObjectCollection < SwiftStorage::Node
+
+  parent_node          :container
+
+
+  # Return all objects
+  #
+  # @note This method will return only the first 1000 objects.
+  #
+  # @return [Array<SwiftStorage::Object>]
+  #  Objects in this collection
+  #
+  def all
+    get_lines(container.name).map { |name| SwiftStorage::Object.new(container, name)}
+  end
+
+  # Return a particular object
+  #
+  # @note This always return an object, regadeless of it's existence
+  #  on the server. This call do NOT contact the server.
+  #
+  # @param name [String]
+  #  The name (sometimes named key) of the object
+  #
+  # @return [SwiftStorage::Object]
+  #  Object with given name
+  #
+  def [](name)
+    SwiftStorage::Object.new(container, name)
+  end
+
+end
+
+

data/lib/swift_storage/service.rb

@@ -0,0 +1,201 @@
+require 'uri'
+
+class SwiftStorage::Service
+
+  include SwiftStorage::Utils
+  include SwiftStorage
+
+  attr_reader          :tenant,
+                       :endpoint,
+                       :storage_url,
+                       :auth_token,
+                       :storage_token,
+                       :storage_scheme,
+                       :storage_host,
+                       :storage_port,
+                       :storage_path,
+                       :temp_url_key
+
+  def initialize(tenant: ENV['SWIFT_STORAGE_TENANT'],
+                 username: ENV['SWIFT_STORAGE_USERNAME'],
+                 password: ENV['SWIFT_STORAGE_PASSWORD'],
+                 endpoint: ENV['SWIFT_STORAGE_ENDPOINT'],
+                 temp_url_key: ENV['SWIFT_STORAGE_TEMP_URL_KEY'])
+    @temp_url_key = temp_url_key
+
+    %w(tenant username password endpoint).each do |n|
+      eval("#{n} or raise ArgumentError, '#{n} is required'")
+      eval("@#{n} = #{n}")
+    end
+    self.storage_url = File.join(endpoint, 'v1', "AUTH_#{tenant}")
+
+    @sessions = {}
+  end
+
+  def authenticate!
+    headers = {
+      Headers::AUTH_USER => "#{tenant}:#{username}",
+      Headers::AUTH_KEY => password
+    }
+    res = request(auth_url, :headers => headers)
+
+    h = res.header
+    self.storage_url = h[Headers::STORAGE_URL]
+    @auth_token = h[Headers::AUTH_TOKEN]
+    @storage_token = h[Headers::STORAGE_TOKEN]
+  end
+
+  def authenticated?
+    !!(storage_url && auth_token)
+  end
+
+  def containers
+    @container_collection ||= SwiftStorage::ContainerCollection.new(self)
+  end
+
+  def account
+    @account ||= SwiftStorage::Account.new(self, tenant)
+  end
+
+  def storage_url=(new_url)
+    uri = URI.parse(new_url)
+    @storage_url = new_url
+    @storage_scheme = uri.scheme
+    @storage_host = uri.host
+    @storage_port = uri.port
+    @storage_path = uri.path
+  end
+
+  def create_temp_url(container, object, expires, method, options = {})
+
+    scheme = options[:scheme] || storage_scheme
+
+    method = method.to_s.upcase
+    # Limit methods
+    %w{GET PUT HEAD}.include?(method) or raise ArgumentError, "Only GET, PUT, HEAD supported"
+
+    expires = expires.to_i
+    object_path_escaped = File.join(storage_path, escape(container), escape(object,"/"))
+    object_path_unescaped = File.join(storage_path, escape(container), object)
+
+    string_to_sign = "#{method}\n#{expires}\n#{object_path_unescaped}"
+
+    sig  = sig_to_hex(hmac('sha1', temp_url_key, string_to_sign))
+
+    klass = scheme == 'http' ? URI::HTTP : URI::HTTPS
+
+    temp_url_options = {
+      :scheme => scheme,
+      :host => storage_host,
+      :port => storage_port,
+      :path => object_path_escaped,
+      :query => URI.encode_www_form(
+        :temp_url_sig => sig,
+        :temp_url_expires => expires
+      )
+    }
+    klass.build(temp_url_options).to_s
+  end
+
+
+  # CGI.escape, but without special treatment on spaces
+  def self.escape(str, extra_exclude_chars = '')
+    str.gsub(/([^a-zA-Z0-9_.-#{extra_exclude_chars}]+)/) do
+      '%' + $1.unpack('H2' * $1.bytesize).join('%').upcase
+    end
+  end
+
+  def escape(*args)
+    self.class.escape(*args)
+  end
+
+  def request(path_or_url,
+              method: :get,
+              headers: nil,
+              input_stream: nil,
+              output_stream: nil)
+    headers ||= {}
+    headers.merge!(Headers::AUTH_TOKEN => auth_token) if authenticated?
+    headers.merge!(Headers::CONNECTION => 'keep-alive', Headers::PROXY_CONNECTION => 'keep-alive')
+
+    if !(path_or_url =~ /^http/)
+      path_or_url = File.join(storage_url, path_or_url)
+    end
+
+    # Cache HTTP session as url with no path (scheme, host, port)
+    uri = URI.parse(path_or_url)
+    path = uri.path
+    uri.path = ''
+    key = uri.to_s
+
+    if sessions[key].nil?
+      s = sessions[key] = Net::HTTP.new(uri.host, uri.port)
+      s.use_ssl = uri.scheme == 'https'
+      #s.set_debug_output($stderr)
+      s.keep_alive_timeout = 30
+      s.start
+    end
+    s = sessions[key]
+
+    case method
+    when :get
+      req = Net::HTTP::Get.new(path, headers)
+    when :delete
+      req = Net::HTTP::Delete.new(path, headers)
+    when :head
+      req = Net::HTTP::Head.new(path, headers)
+    when :post
+      req = Net::HTTP::Post.new(path, headers)
+    when :put
+      req = Net::HTTP::Put.new(path, headers)
+    else
+      raise ArgumentError, "Method #{method} not supported"
+    end
+
+    if input_stream
+      if String === input_stream
+        input_stream = StringIO.new(input_stream)
+      end
+      req.body_stream = input_stream
+      req.content_length = input_stream.size
+    end
+
+    if output_stream
+      output_proc = proc do |response|
+        response.read_body do |chunk|
+          output_stream.write(chunk)
+        end
+      end
+    end
+
+    response = s.request(req, &output_proc)
+    check_response!(response)
+    response
+  end
+
+  private
+
+  attr_reader          :sessions,
+                       :username,
+                       :password
+
+  def auth_url
+    File.join(endpoint, 'auth/v1.0')
+  end
+
+  def check_response!(response)
+    case response.code
+    when /^2/
+      return true
+    when '401'
+      raise AuthError
+    when '403'
+      raise ForbiddenError
+    when '404'
+      raise NotFoundError
+    else
+      raise ServerError
+    end
+  end
+
+end

data/lib/swift_storage/utils.rb

@@ -0,0 +1,23 @@
+module SwiftStorage::Utils
+
+  include SwiftStorage::Errors
+
+  def hmac(type, key, data)
+    digest = OpenSSL::Digest.new(type)
+    OpenSSL::HMAC.digest(digest, key, data)
+  end
+
+  def sig_to_hex(str)
+    str.unpack("C*").map { |c|
+      c.to_s(16)
+    }.map { |h|
+      h.size == 1 ? "0#{h}" : h
+    }.join
+  end
+
+  def struct(h)
+    return nil if h.empty?
+    Struct.new(*h.keys.map(&:to_sym)).new(*h.values)
+  end
+
+end

data/lib/swift_storage/version.rb

@@ -0,0 +1,3 @@
+module SwiftStorage
+  VERSION = "0.0.1"
+end

data/spec/spec_helper.rb

@@ -0,0 +1,139 @@
+require "swift-storage"
+require_relative "support/local_server"
+
+module TestServerMixin
+
+  def h
+    SwiftStorage::Headers
+  end
+
+  def self.run
+    @server = LocalTestServer.new
+    @server.run
+  end
+
+  def self.server
+    @server
+  end
+
+  def self.reset
+    @server.app.reset
+  end
+
+  def server
+    TestServerMixin.server
+  end
+
+  def swift_service
+    service = SwiftStorage::Service.new(:tenant => 'test',
+                                        :username => 'testuser',
+                                        :password => 'testpassword',
+                                        :endpoint => server.base_url,
+                                        :temp_url_key => 'A1234'
+                                       )
+  end
+
+  def test_storage_url
+    File.join(server.base_url, 'v1/AUTH_test')
+  end
+
+  def headers(new_headers)
+    server.app.mock_headers = new_headers
+  end
+
+  def status(new_status)
+    server.app.mock_status = new_status
+  end
+
+  def body(new_body)
+    server.app.mock_body = new_body
+  end
+
+  def random_length
+    Random.rand(5000) + 1000
+  end
+
+
+end
+
+RSpec::Matchers.define :send_request do |method, path, headers, body|
+  match do |actual|
+    actual.call()
+    env = server.app.last_env
+
+    @actual_method = env['REQUEST_METHOD'].downcase
+    @actual_path = env['PATH_INFO']
+    @actual_body = env['rack.input'].read
+
+    @method_match = @actual_method == method.to_s.downcase
+
+    @path_match = @actual_path == path
+    @headers_match = true
+
+    headers.each_pair do |k,v|
+      k = k.gsub('-', '_').upcase
+      actual_value =  env[k] || env["HTTP_#{k}"]
+      if v.to_s != actual_value.to_s
+        @unatched_header = "Header #{k} should be #{v}, got #{actual_value||'null'}"
+        @headers_match = false
+        break
+      end
+    end if headers
+    @body_match = true
+    @body_match = @actual_body == body if body
+
+    @method_match && @path_match && @headers_match && @body_match
+  end
+
+  failure_message do
+    r = []
+    r << "Method should be #{method}, got #{@actual_method}" if !@method_match
+    r << "Path should be #{path}, got #{@actual_path}" if !@path_match
+    r << "Unmatched headers #{@unatched_header}" if !@headers_match
+    r << "Body doesn't match, for #{@actual_body} expected #{body}" if !@body_match
+    r.join("\n")
+  end
+
+  def supports_block_expectations?
+    true
+  end
+
+end
+
+RSpec.configure do |config|
+
+  config.expect_with :rspec do |expectations|
+    expectations.include_chain_clauses_in_custom_matcher_descriptions = true
+  end
+
+
+  config.mock_with :rspec do |mocks|
+    mocks.verify_partial_doubles = true
+  end
+
+  config.filter_run :focus
+  config.run_all_when_everything_filtered = true
+
+  config.disable_monkey_patching!
+
+  if config.files_to_run.one?
+    config.default_formatter = 'doc'
+  end
+
+  config.profile_examples = 10
+
+  config.order = :random
+
+  Kernel.srand(config.seed)
+
+  config.include(TestServerMixin)
+
+  config.before(:suite) do
+    TestServerMixin.run
+  end
+
+  config.before(:each) do
+    TestServerMixin.reset
+  end
+
+end