rubytus 0.1.0

data/lib/rubytus/info.rb

@@ -0,0 +1,31 @@
+require 'json'
+
+module Rubytus
+  class Info < Hash
+    def initialize(args = {})
+      self['Offset']      = args[:offset]       || 0
+      self['FinalLength'] = args[:final_length] || 0
+      self['Meta']        = args[:meta]         || nil
+    end
+
+    def offset=(value)
+      self['Offset'] = value.to_i
+    end
+
+    def offset
+      self['Offset']
+    end
+
+    def final_length=(value)
+      self['FinalLength'] = value.to_i
+    end
+
+    def final_length
+      self['FinalLength']
+    end
+
+    def remaining_length
+      final_length - offset
+    end
+  end
+end

data/lib/rubytus/middlewares/storage_barrier.rb

@@ -0,0 +1,36 @@
+require 'rubytus/error'
+
+module Rubytus
+  module Middlewares
+    class StorageBarrier
+      include Rubytus::Constants
+      include Goliath::Rack::AsyncMiddleware
+
+      def post_process(env, status, headers, body)
+        status  = STATUS_OK
+        action  = env['api.action']
+        storage = env['api.options'][:storage]
+
+        begin
+          case action
+          when :create
+            status = STATUS_CREATED
+            headers['Location'] = env['api.resource_url']
+            storage.create_file(env['api.uid'], env['api.final_length'])
+
+          when :head
+            info = storage.read_info(env['api.uid'])
+            headers['Offset'] = info.offset.to_s
+
+          when :get
+            body = storage.read_file(env['api.uid'])
+          end
+        rescue PermissionError => e
+          raise Goliath::Validation::Error.new(500, e.message)
+        end
+
+        [status, headers, body]
+      end
+    end
+  end
+end

data/lib/rubytus/middlewares/tus_barrier.rb

@@ -0,0 +1,36 @@
+module Rubytus
+  module Middlewares
+    class TusBarrier
+      include Rubytus::Constants
+      include Goliath::Rack::AsyncMiddleware
+
+      def post_process(env, status, headers, body)
+        request = Rubytus::Request.new(env)
+
+        if request.collection?
+          unless request.options? || request.post?
+            status = STATUS_NOT_ALLOWED
+            body   = "#{request.request_method} used against file creation url. Only POST is allowed."
+            headers['Allow'] = 'POST'
+          end
+        end
+
+        if request.resource?
+          unless request.options? || request.head? || request.patch? || request.get?
+            status  = STATUS_NOT_ALLOWED
+            allowed = 'HEAD,PATCH'
+            body    = "#{request.request_method} used against file creation url. Allowed: #{allowed}"
+            headers['Allow'] = allowed
+          end
+        end
+
+        if request.unknown?
+          status = STATUS_NOT_FOUND
+          body   = "Unknown url: #{request.path_info} - does not match file pattern"
+        end
+
+        [status, headers, body]
+      end
+    end
+  end
+end

data/lib/rubytus/request.rb

@@ -0,0 +1,102 @@
+require 'rubytus/constants'
+require 'rubytus/common'
+
+module Rubytus
+  class Request
+    include Rubytus::Constants
+    include Rubytus::Common
+
+    def initialize(env)
+      @env = env
+    end
+
+    def get?;     request_method == 'GET'; end
+    def post?;    request_method == 'POST'; end
+    def head?;    request_method == 'HEAD'; end
+    def patch?;   request_method == 'PATCH'; end
+    def options?; request_method == 'OPTIONS'; end
+
+    def resumable_content_type?
+      content_type == RESUMABLE_CONTENT_TYPE
+    end
+
+    def unknown?
+      !collection? && !resource?
+    end
+
+    def collection?
+      path_info.chomp('/') == base_path.chomp('/')
+    end
+
+    def resource?
+      !!(resource_uid =~ RESOURCE_UID_REGEX)
+    end
+
+    def resource_uid
+      rpath = path_info.dup
+      rpath.slice!(base_path)
+      rpath
+    end
+
+    def resource_url(uid)
+      "#{scheme}://#{host_with_port}#{base_path}#{uid}"
+    end
+
+    def final_length
+      fetch_positive_header('HTTP_FINAL_LENGTH')
+    end
+
+    def offset
+      fetch_positive_header('HTTP_OFFSET')
+    end
+
+    def base_path
+      @env['api.options'][:base_path]
+    end
+
+    def scheme
+      @env['HTTPS'] ? 'https' : 'http'
+    end
+
+    def path_info
+      @env['PATH_INFO']
+    end
+
+    def host_with_port
+      @env['HTTP_HOST'] || "#{@env['SERVER_NAME']}:#{@env['SERVER_PORT']}"
+    end
+
+    def request_method
+      @env['REQUEST_METHOD']
+    end
+
+    def content_type
+      @env['CONTENT_TYPE']
+    end
+
+    def content_length
+      @env['CONTENT_LENGTH'].to_i
+    end
+
+    protected
+    def fetch_positive_header(header_name)
+      header_val  = @env[header_name] || ''
+      value       = header_val.to_i
+      header_orig = normalize_header_name(header_name)
+
+      if header_val.empty?
+        error!(STATUS_BAD_REQUEST, "#{header_orig} header must not be empty")
+      end
+
+      if value < 0
+        error!(STATUS_BAD_REQUEST, "#{header_orig} header must be > 0")
+      end
+
+      value
+    end
+
+    def normalize_header_name(header_name)
+      header_name.gsub('HTTP_', '').split('_').map(&:capitalize).join('-')
+    end
+  end
+end

data/lib/rubytus/storage.rb

@@ -0,0 +1,117 @@
+require 'json'
+require 'rubytus/info'
+require 'rubytus/error'
+require 'pathname'
+
+module Rubytus
+  module StorageHelper
+    def validates_data_dir(data_dir)
+      if Pathname.new(data_dir).relative?
+        data_dir = File.join(ENV['PWD'], data_dir)
+      end
+
+      begin
+        unless File.directory?(data_dir)
+          Dir.mkdir(data_dir)
+        end
+      rescue SystemCallError => _
+        raise PermissionError, "Couldn't create `data_dir` in #{data_dir}"
+      end
+
+      unless File.world_writable?(data_dir)
+        begin
+          File.chmod(0777, data_dir)
+        rescue Errno::EPERM
+          raise PermissionError, "Couldn't make `data_dir` in #{data_dir} writable"
+        end
+      end
+
+      data_dir
+    end
+
+    def file_path(uid)
+      File.join(@options[:data_dir], "#{uid}.bin")
+    end
+
+    def info_path(uid)
+      File.join(@options[:data_dir], "#{uid}.info")
+    end
+  end
+
+  class Storage
+    include StorageHelper
+
+    def initialize(options)
+      @options = options
+    end
+
+    def create_file(uid, final_length)
+      fpath = file_path(uid)
+      ipath = info_path(uid)
+      info  = Rubytus::Info.new
+      info.final_length = final_length
+
+      begin
+        File.open(fpath, 'w') {}
+        File.open(ipath, 'w') do |f|
+          f.write(info.to_json)
+        end
+      rescue SystemCallError => e
+        raise(PermissionError, e.message) if e.class.name.start_with?('Errno::')
+      end
+    end
+
+    def read_file(uid)
+      fpath = file_path(uid)
+
+      begin
+        f = File.open(fpath, 'rb')
+        f.read
+      rescue SystemCallError => e
+        raise(PermissionError, e.message) if e.class.name.start_with?('Errno::')
+      ensure
+        f.close unless f.nil?
+      end
+    end
+
+    def patch_file(uid, data, offset = nil)
+      fpath = file_path(uid)
+      begin
+        f = File.open(fpath, 'r+b')
+        f.sync = true
+        f.seek(offset) unless offset.nil?
+        f.write(data)
+        size = f.size
+        f.close
+        update_info(uid, size)
+      rescue SystemCallError => e
+        raise(PermissionError, e.message) if e.class.name.start_with?('Errno::')
+      end
+    end
+
+    def read_info(uid)
+      ipath = info_path(uid)
+
+      begin
+        data = File.open(ipath, 'r') { |f| f.read }
+        JSON.parse(data, :object_class => Rubytus::Info)
+      rescue SystemCallError => e
+        raise(PermissionError, e.message) if e.class.name.start_with?('Errno::')
+      end
+    end
+
+    def update_info(uid, offset)
+      ipath = info_path(uid)
+      info = read_info(uid)
+      info.offset = offset
+
+      begin
+        File.open(ipath, 'w') do |f|
+          f.write(info.to_json)
+        end
+      rescue SystemCallError => e
+        raise(PermissionError, e.message) if e.class.name.start_with?('Errno::')
+      end
+    end
+  end
+end

data/lib/rubytus/version.rb

@@ -0,0 +1,3 @@
+module Rubytus
+  VERSION = '0.1.0'
+end

data/rubytus.gemspec

@@ -0,0 +1,31 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'rubytus/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "rubytus"
+  spec.version       = Rubytus::VERSION
+  spec.authors       = ["Alif Rachmawadi"]
+  spec.email         = ["subosito@gmail.com"]
+  spec.description   = %q{Resumable upload protocol implementation in Ruby}
+  spec.summary       = %q{Resumable upload protocol implementation in Ruby}
+  spec.homepage      = ""
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files`.split($/)
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler", "~> 1.3"
+  spec.add_development_dependency "rake"
+  spec.add_development_dependency "minitest"
+  spec.add_development_dependency "rr"
+  spec.add_development_dependency "simplecov"
+  spec.add_development_dependency "em-http-request"
+  spec.add_development_dependency "pry"
+  spec.add_development_dependency "coveralls"
+
+  spec.add_runtime_dependency "goliath", "~> 1.0.3"
+end

data/test/rubytus/test_command.rb

@@ -0,0 +1,249 @@
+require 'test_helper'
+require 'rubytus/command'
+require 'rubytus/info'
+
+class TestRubytusCommand < MiniTest::Test
+  include Rubytus::Mock
+  include Rubytus::StorageHelper
+  include Goliath::TestHelper
+
+  def setup
+    @err = Proc.new { assert false, 'API request failed' }
+  end
+
+  def test_get_request_for_root
+    params = { :path => '/' }
+
+    with_api(Rubytus::Command, default_options) do
+      get_request(params, @err) do |c|
+        assert_equal 404, c.response_header.status
+      end
+    end
+  end
+
+  def test_options_request_for_collection
+    params = { :path => '/uploads/' }
+
+    with_api(Rubytus::Command, default_options) do
+      options_request(params, @err) do |c|
+        assert_equal 200, c.response_header.status
+        assert_equal '', c.response
+      end
+    end
+  end
+
+  def test_get_request_for_collection
+    params = { :path => '/uploads/' }
+
+    with_api(Rubytus::Command, default_options) do
+      get_request(params, @err) do |c|
+        assert_equal 405, c.response_header.status
+        assert_equal 'POST', c.response_header['ALLOW']
+      end
+    end
+  end
+
+  def test_post_request_for_collection_without_final_length
+    params = { :path => '/uploads/' }
+
+    with_api(Rubytus::Command, default_options) do
+      post_request(params, @err) do |c|
+        assert_equal 400, c.response_header.status
+      end
+    end
+  end
+
+  def test_post_request_for_collection_with_negative_final_length
+    params = {
+      :path => '/uploads/',
+      :head => { 'Final-Length' => '-1'}
+    }
+
+    with_api(Rubytus::Command, default_options) do
+      post_request(params, @err) do |c|
+        assert_equal 400, c.response_header.status
+      end
+    end
+  end
+
+  def test_post_request_for_collection
+    params = {
+      :path => '/uploads/',
+      :head => { 'Final-Length' => '10' }
+    }
+
+    with_api(Rubytus::Command, default_options) do
+      post_request(params, @err) do |c|
+        assert_equal 201, c.response_header.status
+        assert c.response_header.location
+      end
+    end
+  end
+
+  def test_put_request_for_resource
+    with_api(Rubytus::Command, default_options) do
+      put_request({ :path => "/uploads/#{uid}" }, @err) do |c|
+        assert_equal 405, c.response_header.status
+        assert_equal 'HEAD,PATCH', c.response_header['ALLOW']
+      end
+    end
+  end
+
+  def test_patch_request_for_resource_without_valid_content_type
+    params = {
+      :path => "/uploads/#{uid}",
+      :body => 'abc',
+      :head => {
+        'Offset' => '0',
+        'Content-Type' => 'plain/text'
+      }
+    }
+
+    with_api(Rubytus::Command, default_options) do
+      patch_request(params, @err) do |c|
+        assert_equal 400, c.response_header.status
+      end
+    end
+  end
+
+  def test_patch_request_for_resource
+    options = default_options
+    ruid    = uid
+
+    validates_data_dir(options[:data_dir])
+
+    storage = Rubytus::Storage.new(options)
+    storage.create_file(ruid, 3)
+
+    params = {
+      :path => "/uploads/#{ruid}",
+      :body => 'abc',
+      :head => {
+        'Offset' => '0',
+        'Content-Type' => 'application/offset+octet-stream'
+      }
+    }
+
+    with_api(Rubytus::Command, options) do
+      patch_request(params, @err) do |c|
+        assert_equal 200, c.response_header.status
+      end
+    end
+  end
+
+  def test_patch_request_for_resource_exceed_offset
+    ruid = uid
+    info = Rubytus::Info.new(:offset => 0)
+
+    any_instance_of(Rubytus::Storage) do |klass|
+      stub(klass).read_info(ruid) { info }
+    end
+
+    params = {
+      :path => "/uploads/#{ruid}",
+      :body => 'abc',
+      :head => {
+        'Offset' => '3',
+        'Content-Type' => 'application/offset+octet-stream'
+      }
+    }
+
+    with_api(Rubytus::Command, default_options) do
+      patch_request(params, @err) do |c|
+        assert_equal 403, c.response_header.status
+      end
+    end
+  end
+
+  def test_patch_request_for_resource_exceed_remaining_length
+    ruid = uid
+    info = Rubytus::Info.new(:offset => 0, :final_length => 2)
+
+    any_instance_of(Rubytus::Storage) do |klass|
+      stub(klass).read_info(ruid) { info }
+    end
+
+    params = {
+      :path => "/uploads/#{ruid}",
+      :body => 'abcdef',
+      :head => {
+        'Offset' => '0',
+        'Content-Type' => 'application/offset+octet-stream'
+      }
+    }
+
+    with_api(Rubytus::Command, default_options) do
+      patch_request(params, @err) do |c|
+        assert_equal 403, c.response_header.status
+      end
+    end
+  end
+
+  def test_patch_request_for_resource_failure
+    options = read_only_options
+    params  = {
+      :path => "/uploads/#{uid}",
+      :body => 'abc',
+      :head => {
+        'Offset' => '0',
+        'Content-Type' => 'application/offset+octet-stream'
+      }
+    }
+
+    any_instance_of(Rubytus::Command) do |klass|
+      stub(klass).setup { true }
+      stub(klass).storage { Rubytus::Storage.new(options) }
+    end
+
+    with_api(Rubytus::Command, options) do
+      patch_request(params, @err) do |c|
+        assert_equal 500, c.response_header.status
+      end
+    end
+  end
+
+  def test_head_request_for_resource
+    ruid = uid
+    info = Rubytus::Info.new(:offset => 3)
+
+    any_instance_of(Rubytus::Storage) do |klass|
+      stub(klass).read_info(ruid) { info }
+    end
+
+    with_api(Rubytus::Command, default_options) do
+      head_request({ :path => "/uploads/#{ruid}" }, @err) do |c|
+        assert_equal 200, c.response_header.status
+        assert_equal '3', c.response_header['OFFSET']
+      end
+    end
+  end
+
+  def test_get_request_for_resource_failure
+    ruid = uid
+
+    any_instance_of(Rubytus::Storage) do |klass|
+      stub(klass).read_file(ruid) { raise Rubytus::PermissionError }
+    end
+
+    with_api(Rubytus::Command, default_options) do
+      get_request({ :path => "/uploads/#{ruid}" }, @err) do |c|
+        assert_equal 500, c.response_header.status
+      end
+    end
+  end
+
+  def test_get_request_for_resource
+    ruid = uid
+
+    any_instance_of(Rubytus::Storage) do |klass|
+      stub(klass).read_file(ruid) { 'abc' }
+    end
+
+    with_api(Rubytus::Command, default_options) do
+      get_request({ :path => "/uploads/#{ruid}" }, @err) do |c|
+        assert_equal 200, c.response_header.status
+        assert_equal 'abc', c.response
+      end
+    end
+  end
+end