tus-server 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: ac1db8e0078cd0824caf54dc3c1993957ca90902
+  data.tar.gz: 032f12c4aaa676e7f55388f8af96d7a46cad42a7
+SHA512:
+  metadata.gz: 45aa99b75d86eb9197fa3edcb8fd4a140004e9e48bb955327e5e77dd7ac3fa3b407a5782f4bcf12fb2a7277704f4ea4cfd6a2972a35d3d69b5e3c778708dcb0f
+  data.tar.gz: b27487dc797127e1c51010e65e1ad44e22206bfcc8ff5dbecc4136eedf4c2197c6ae13b1d32bada612d614844f61e9780349748050559bb47c2ea386306bf31d

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2015-2016 Janko Marohnić
+
+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 above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+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.

data/README.md

@@ -0,0 +1,164 @@
+# tus-ruby-server
+
+A Ruby server for the [tus resumable upload protocol]. It implements the core
+1.0 protocol, along with the following extensions:
+
+* [`creation`][creation] (and `creation-defer-length`)
+* [`concatenation`][concatenation] (and `concatenation-unfinished`)
+* [`checksum`][checksum]
+* [`expiration`][expiration]
+* [`termination`][termination]
+
+## Installation
+
+```rb
+gem "tus-server"
+```
+
+## Usage
+
+You can run the `Tus::Server` in your `config.ru`:
+
+```rb
+# config.ru
+require "tus/server"
+
+map "/files" do
+  run Tus::Server
+end
+
+run YourApp
+```
+
+Now you can tell your tus client library (e.g. [tus-js-client]) to use this
+endpoint:
+
+```js
+// using tus-js-client
+new tus.Upload(file, {
+  endpoint: "http://localhost:9292/files",
+  chunkSize: 15*1024*1024, # 15 MB
+  // ...
+})
+```
+
+After upload is complete, you'll probably want to attach the uploaded files to
+database records. [Shrine] is one file attachment library that supports this,
+see [shrine-tus-demo] on how you can integrate the two.
+
+### Metadata
+
+As per tus protocol, you can assign custom metadata when creating a file using
+the `Upload-Metadata` header. When retrieving the file via a GET request,
+tus-server will use
+
+* `content_type` -- for setting the `Content-Type` header
+* `filename` -- for setting the `Content-Disposition` header
+
+Both of these are optional, and will be used if available.
+
+### Storage
+
+By default `Tus::Server` saves partial and complete files on the filesystem,
+inside the `data/` directory. You can easily change the directory:
+
+```rb
+require "tus/server"
+
+Tus::Server.opts[:storage] = Tus::Storage::Filesystem.new("public/cache")
+```
+
+The downside of storing files on the filesystem is that it isn't distributed,
+so for resumable uploads to work you have to host the tus application on a
+single server.
+
+However, tus-server also ships with MongoDB [GridFS] storage, which among other
+things is convenient for a multi-server setup. It requires the [Mongo] gem:
+
+```rb
+gem "mongo"
+```
+
+```rb
+require "tus/server"
+require "tus/storage/gridfs"
+
+client = Mongo::Client.new("mongodb://127.0.0.1:27017/mydb")
+Tus::Server.opts[:storage] = Tus::Storage::Gridfs.new(client: client)
+```
+
+You can also write your own storage, you just need to implement the same
+public interface that `Tus::Storage::Filesystem` and `Tus::Storage::Gridfs` do.
+
+### Maximum size
+
+By default the maximum size for an uploaded file is 1GB, but you can change
+that:
+
+```rb
+require "tus/server"
+
+Tus::Server.opts[:max_size] = 5 * 1024*1024*1024 # 5GB
+# or
+Tus::Server.opts[:max_size] = nil                # no limit
+```
+
+### Expiration
+
+By default both partially and fully uploaded files will get deleted after one
+week, and the interval of checking for expired files is 1 hour. You can change
+both of these:
+
+```rb
+require "tus/server"
+
+Tus::Server.opts[:expiration_time]     = 14*24*60*60 # 2 weeks
+Tus::Server.opts[:expiration_interval] = 24*60*60    # 1 day
+```
+
+### Checksum
+
+The following checksum algorithms are supported for the `checksum` extension:
+
+* SHA1
+* SHA256
+* SHA384
+* SHA512
+* MD5
+* CRC32
+
+## Limitations
+
+Since tus-server is built using a Rack-based web framework (Roda), if a PATCH
+request gets interrupted, none of the received data will be stored. It's
+recommended to configure your client tus library not to use a single PATCH
+request for large files, but rather to split it into multiple chunks. You can
+do that for [tus-js-client] by specifying a maximum chunk size:
+
+```js
+new tus.Upload(file, {
+  endpoint: "http://localhost:9292/files",
+  chunkSize: 15*1024*1024, # 15 MB
+  // ...
+})
+```
+
+Tus-server also currently doesn't support the `checksum-trailer` extension,
+which would allow sending the checksum header *after* the data has been sent,
+using [trailing headers].
+
+## License
+
+[MIT](/LICENSE.txt)
+
+[tus resumable upload protocol]: http://tus.io/
+[tus-js-client]: https://github.com/tus/tus-js-client
+[creation]: http://tus.io/protocols/resumable-upload.html#creation
+[concatenation]: http://tus.io/protocols/resumable-upload.html#concatenation
+[checksum]: http://tus.io/protocols/resumable-upload.html#checksum
+[expiration]: http://tus.io/protocols/resumable-upload.html#expiration
+[termination]: http://tus.io/protocols/resumable-upload.html#termination
+[GridFS]: https://docs.mongodb.org/v3.0/core/gridfs/ 
+[shrine-tus-demo]: https://github.com/janko-m/shrine-tus-demo
+[Shrine]: https://github.com/janko-m/shrine
+[trailing headers]: https://tools.ietf.org/html/rfc7230#section-4.1.2

data/lib/tus/checksum.rb

@@ -0,0 +1,48 @@
+require "base64"
+require "digest"
+require "zlib"
+
+module Tus
+  class Checksum
+    attr_reader :algorithm
+
+    def initialize(algorithm)
+      @algorithm = algorithm
+    end
+
+    def match?(checksum, content)
+      checksum = Base64.decode64(checksum)
+      generate(content) == checksum
+    end
+
+    def generate(content)
+      send("generate_#{algorithm}", content)
+    end
+
+    private
+
+    def generate_sha1(content)
+      Digest::SHA1.hexdigest(content)
+    end
+
+    def generate_sha256(content)
+      Digest::SHA256.hexdigest(content)
+    end
+
+    def generate_sha384(content)
+      Digest::SHA384.hexdigest(content)
+    end
+
+    def generate_sha512(content)
+      Digest::SHA512.hexdigest(content)
+    end
+
+    def generate_md5(content)
+      Digest::MD5.hexdigest(content)
+    end
+
+    def generate_crc32(content)
+      Zlib.crc32(content).to_s
+    end
+  end
+end

data/lib/tus/expirator.rb

@@ -0,0 +1,58 @@
+require "tus/info"
+require "time"
+
+module Tus
+  class Expirator
+    attr_reader :storage, :interval
+
+    def initialize(storage, interval: 60)
+      @storage  = storage
+      @interval = interval
+    end
+
+    def expire_files!
+      return unless expiration_due?
+      update_last_expiration
+
+      Thread.new do
+        thread = Thread.current
+        thread.abort_on_exception = false
+        thread.report_on_exception = true if thread.respond_to?(:report_on_exception) # Ruby 2.4
+
+        _expire_files!
+      end
+    end
+
+    def expiration_due?
+      Time.now - interval > last_expiration
+    end
+
+    private
+
+    def _expire_files!
+      storage.list_files.each do |uid|
+        next if uid == "expirator"
+        begin
+          info = Info.new(storage.read_info(uid))
+          storage.delete_file(uid) if Time.now > info.expires
+        rescue
+        end
+      end
+    end
+
+    def last_expiration
+      info = storage.read_info("expirator")
+      Time.parse(info["Last-Expiration"])
+    rescue
+      Time.new(0)
+    end
+
+    def update_last_expiration
+      if storage.file_exists?("expirator")
+        storage.update_info("expirator", {"Last-Expiration" => Time.now.httpdate})
+      else
+        storage.create_file("expirator", {"Last-Expiration" => Time.now.httpdate})
+      end
+    end
+  end
+end

data/lib/tus/info.rb

@@ -0,0 +1,70 @@
+require "base64"
+require "time"
+
+module Tus
+  class Info
+    def initialize(hash)
+      @hash = hash
+    end
+
+    def [](key)
+      @hash[key]
+    end
+
+    def []=(key, value)
+      @hash[key] = value
+    end
+
+    def to_h
+      @hash.reject { |key, value| value.nil? }
+    end
+
+    def length
+      Integer(@hash["Upload-Length"])
+    end
+
+    def offset
+      Integer(@hash["Upload-Offset"])
+    end
+
+    def metadata
+      parse_metadata(@hash["Upload-Metadata"])
+    end
+
+    def expires
+      Time.parse(@hash["Upload-Expires"])
+    end
+
+    def final_upload?
+      @hash["Upload-Concat"].to_s.start_with?("final")
+    end
+
+    def defer_length?
+      @hash["Upload-Defer-Length"] == "1"
+    end
+
+    def partial_uploads
+      urls = @hash["Upload-Concat"].split(";").last.split(" ")
+      urls.map { |url| url.split("/").last }
+    end
+
+    def remaining_length
+      length - offset
+    end
+
+    private
+
+    def parse_metadata(string)
+      return {} if string == nil || string == ""
+
+      pairs = string.split(",").map { |s| s.split(" ") }
+
+      hash = Hash[pairs]
+      hash.each do |key, value|
+        hash[key] = Base64.decode64(value)
+      end
+
+      hash
+    end
+  end
+end

data/lib/tus/server.rb

@@ -0,0 +1,310 @@
+require "roda"
+
+require "tus/storage/filesystem"
+require "tus/info"
+require "tus/expirator"
+require "tus/checksum"
+
+require "securerandom"
+
+module Tus
+  class Server < Roda
+    SUPPORTED_VERSIONS = ["1.0.0"]
+    SUPPORTED_EXTENSIONS = [
+      "creation", "creation-defer-length",
+      "termination",
+      "expiration",
+      "concatenation", "concatenation-unfinished",
+      "checksum",
+    ]
+    SUPPORTED_CHECKSUM_ALGORITHMS = %w[sha1 sha256 sha384 sha512 md5 crc32]
+    RESUMABLE_CONTENT_TYPE = "application/offset+octet-stream"
+
+    opts[:max_size]            = 1024*1024*1024
+    opts[:expiration_time]     = 7*24*60*60
+    opts[:expiration_interval] = 60*60
+
+    plugin :all_verbs
+    plugin :delete_empty_headers
+    plugin :request_headers
+    plugin :default_headers, "Content-Type" => ""
+    plugin :not_allowed
+
+    route do |r|
+      expire_files
+
+      if request.headers["X-HTTP-Method-Override"]
+        request.env["REQUEST_METHOD"] = request.headers["X-HTTP-Method-Override"]
+      end
+
+      response.headers.update(
+        "Tus-Resumable" => SUPPORTED_VERSIONS.first,
+      )
+
+      handle_cors!
+      validate_tus_resumable! unless request.options? || request.get?
+
+      r.is ['', true] do
+        r.options do
+          response.headers.update(
+            "Tus-Version"            => SUPPORTED_VERSIONS.join(","),
+            "Tus-Extension"          => SUPPORTED_EXTENSIONS.join(","),
+            "Tus-Max-Size"           => max_size.to_s,
+            "Tus-Checksum-Algorithm" => SUPPORTED_CHECKSUM_ALGORITHMS.join(","),
+          )
+
+          no_content!
+        end
+
+        r.post do
+          validate_upload_concat! if request.headers["Upload-Concat"]
+          validate_upload_length! unless request.headers["Upload-Concat"].to_s.start_with?("final") || request.headers["Upload-Defer-Length"] == "1"
+          validate_upload_metadata! if request.headers["Upload-Metadata"]
+
+          uid = SecureRandom.hex
+          info = Info.new(
+            "Upload-Length"       => request.headers["Upload-Length"],
+            "Upload-Offset"       => "0",
+            "Upload-Defer-Length" => request.headers["Upload-Defer-Length"],
+            "Upload-Metadata"     => request.headers["Upload-Metadata"],
+            "Upload-Concat"       => request.headers["Upload-Concat"],
+            "Upload-Expires"      => (Time.now + expiration_time).httpdate,
+          )
+
+          storage.create_file(uid, info.to_h)
+
+          if info.final_upload?
+            length = info.partial_uploads.inject(0) do |length, partial_uid|
+              content = storage.read_file(partial_uid)
+              storage.patch_file(uid, content)
+              storage.delete_file(partial_uid)
+              length += content.length
+            end
+
+            info["Upload-Length"] = length.to_s
+            info["Upload-Offset"] = length.to_s
+
+            storage.update_info(uid, info.to_h)
+          end
+
+          response.headers.update(info.to_h)
+
+          file_url = "#{request.url.chomp("/")}/#{uid}"
+          created!(file_url)
+        end
+      end
+
+      r.is ":uid" do |uid|
+        not_found! unless storage.file_exists?(uid)
+
+        r.options do
+          response.headers.update(
+            "Tus-Version"            => SUPPORTED_VERSIONS.join(","),
+            "Tus-Extension"          => SUPPORTED_EXTENSIONS.join(","),
+            "Tus-Max-Size"           => max_size.to_s,
+            "Tus-Checksum-Algorithm" => SUPPORTED_CHECKSUM_ALGORITHMS.join(","),
+          )
+
+          no_content!
+        end
+
+        r.get do
+          path = storage.download_file(uid)
+          info = Info.new(storage.read_info(uid))
+
+          file = Rack::File.new(File.dirname(path))
+
+          result = file.serving(request, path)
+
+          response.status = result[0]
+          response.headers.update(result[1])
+
+          metadata = info.metadata
+          response.headers["Content-Disposition"] = "attachment; filename=\"#{metadata["filename"]}\"" if metadata["filename"]
+          response.headers["Content-Type"] = metadata["content_type"] if metadata["content_type"]
+
+          request.halt response.finish_with_body(result[2])
+        end
+
+        r.head do
+          info = storage.read_info(uid)
+
+          response.headers.update(info.to_h)
+          response.headers["Cache-Control"] = "no-store"
+
+          no_content!
+        end
+
+        r.patch do
+          validate_content_type!
+
+          content = request.body.read
+          info = Info.new(storage.read_info(uid))
+
+          if info.defer_length?
+            validate_upload_length!
+            info["Upload-Length"] = request.headers["Upload-Length"]
+            info["Upload-Defer-Length"] = nil
+          end
+
+          validate_upload_checksum!(content) if request.headers["Upload-Checksum"]
+          validate_upload_offset!(info.offset)
+          validate_content_length!(content, info.remaining_length)
+
+          storage.patch_file(uid, content)
+
+          info["Upload-Offset"] = (info.offset + content.length).to_s
+          storage.update_info(uid, info.to_h)
+
+          response.headers.update(info.to_h)
+
+          no_content!
+        end
+
+        r.delete do
+          storage.delete_file(uid)
+
+          no_content!
+        end
+      end
+    end
+
+    def expire_files
+      expirator = Expirator.new(storage, interval: expiration_interval)
+      expirator.expire_files!
+    end
+
+    def validate_content_type!
+      content_type = request.headers["Content-Type"]
+      error!(415, "Invalid Content-Type header") if content_type != RESUMABLE_CONTENT_TYPE
+    end
+
+    def validate_tus_resumable!
+      client_version = request.headers["Tus-Resumable"]
+
+      unless SUPPORTED_VERSIONS.include?(client_version)
+        response.headers["Tus-Version"] = SUPPORTED_VERSIONS.join(",")
+        error!(412, "Unsupported version")
+      end
+    end
+
+    def validate_upload_length!
+      upload_length = request.headers["Upload-Length"]
+
+      error!(400, "Missing Upload-Length header") if upload_length.to_s == ""
+      error!(400, "Invalid Upload-Length header") if upload_length =~ /\D/
+      error!(400, "Invalid Upload-Length header") if upload_length.to_i < 0
+
+      if max_size && upload_length.to_i > max_size
+        error!(413, "Upload-Length header too large")
+      end
+    end
+
+    def validate_upload_offset!(current_offset)
+      upload_offset = request.headers["Upload-Offset"]
+
+      error!(400, "Missing Upload-Offset header") if upload_offset.to_s == ""
+      error!(400, "Invalid Upload-Offset header") if upload_offset =~ /\D/
+      error!(400, "Invalid Upload-Offset header") if upload_offset.to_i < 0
+
+      if upload_offset.to_i != current_offset
+        error!(409, "Upload-Offset header doesn't match current offset")
+      end
+    end
+
+    def validate_content_length!(content, remaining_length)
+      error!(403, "Cannot modify completed upload") if remaining_length == 0
+      error!(413, "Size of this chunk surpasses Upload-Length") if content.length > remaining_length
+    end
+
+    def validate_upload_metadata!
+      upload_metadata = request.headers["Upload-Metadata"]
+
+      upload_metadata.split(",").each do |string|
+        key, value = string.split(" ")
+
+        error!(400, "Invalid Upload-Metadata header") if key.nil? || value.nil?
+        error!(400, "Invalid Upload-Metadata header") if key.ord > 127
+        error!(400, "Invalid Upload-Metadata header") if key =~ /,| /
+
+        error!(400, "Invalid Upload-Metadata header") if value =~ /[^a-zA-Z0-9+\/=]/
+      end
+    end
+
+    def validate_upload_concat!
+      upload_concat = request.headers["Upload-Concat"]
+
+      error!(400, "Invalid Upload-Concat header") if upload_concat !~ /^(partial|final)/
+
+      if upload_concat.start_with?("final")
+        string = upload_concat.split(";").last
+        string.split(" ").each do |url|
+          error!(400, "Invalid Upload-Concat header") if url !~ %r{^#{request.script_name}/\w+$}
+        end
+      end
+    end
+
+    def validate_upload_checksum!(content)
+      algorithm, checksum = request.headers["Upload-Checksum"].split(" ")
+
+      error!(400, "Invalid Upload-Checksum header") if algorithm.nil? || checksum.nil?
+      error!(400, "Invalid Upload-Checksum header") unless SUPPORTED_CHECKSUM_ALGORITHMS.include?(algorithm)
+
+      unless Checksum.new(algorithm).match?(checksum, content)
+        error!(460, "Checksum from Upload-Checksum header doesn't match generated")
+      end
+    end
+
+    def handle_cors!
+      origin = request.headers["Origin"]
+
+      return if origin.to_s == ""
+
+      response.headers["Access-Control-Allow-Origin"] = origin
+
+      if request.options?
+        response.headers["Access-Control-Allow-Methods"] = "POST, GET, HEAD, PATCH, DELETE, OPTIONS"
+        response.headers["Access-Control-Allow-Headers"] = "Origin, X-Requested-With, Content-Type, Upload-Length, Upload-Offset, Tus-Resumable, Upload-Metadata"
+        response.headers["Access-Control-Max-Age"]       = "86400"
+      else
+        response.headers["Access-Control-Expose-Headers"] = "Upload-Offset, Location, Upload-Length, Tus-Version, Tus-Resumable, Tus-Max-Size, Tus-Extension, Upload-Metadata"
+      end
+    end
+
+    def no_content!
+      response.status = 204
+      response.headers["Content-Length"] = ""
+    end
+
+    def created!(location)
+      response.status = 201
+      response.headers["Location"] = location
+    end
+
+    def not_found!(message = "Upload not found")
+      error!(404, message)
+    end
+
+    def error!(status, message)
+      response.status = status
+      response.write(message) unless request.head?
+      request.halt
+    end
+
+    def storage
+      opts[:storage] || Tus::Storage::Filesystem.new("data")
+    end
+
+    def max_size
+      opts[:max_size]
+    end
+
+    def expiration_time
+      opts[:expiration_time]
+    end
+
+    def expiration_interval
+      opts[:expiration_interval]
+    end
+  end
+end

data/lib/tus/storage/filesystem.rb

@@ -0,0 +1,78 @@
+require "pathname"
+require "json"
+
+module Tus
+  module Storage
+    class Filesystem
+      attr_reader :directory
+
+      def initialize(directory)
+        @directory = Pathname(directory)
+
+        create_directory! unless @directory.exist?
+      end
+
+      def create_file(uid, info = {})
+        write(file_path(uid), "")
+        write(info_path(uid), info.to_json)
+      end
+
+      def file_exists?(uid)
+        file_path(uid).exist? && info_path(uid).exist?
+      end
+
+      def read_file(uid)
+        file_path(uid).binread
+      end
+
+      def patch_file(uid, content)
+        write(file_path(uid), content, mode: "ab")
+      end
+
+      def download_file(uid)
+        file_path(uid).to_s
+      end
+
+      def delete_file(uid)
+        file_path(uid).delete
+        info_path(uid).delete
+      end
+
+      def read_info(uid)
+        data = info_path(uid).binread
+        JSON.parse(data)
+      end
+
+      def update_info(uid, info)
+        write(info_path(uid), info.to_json)
+      end
+
+      def list_files
+        paths = Dir[directory.join("*.file")]
+        paths.map { |path| File.basename(path, ".file") }
+      end
+
+      private
+
+      def write(pathname, content, mode: "wb")
+        pathname.open(mode) do |file|
+          file.sync = true
+          file.write(content)
+        end
+      end
+
+      def file_path(uid)
+        directory.join("#{uid}.file")
+      end
+
+      def info_path(uid)
+        directory.join("#{uid}.info")
+      end
+
+      def create_directory!
+        directory.mkpath
+        directory.chmod(0755)
+      end
+    end
+  end
+end

data/lib/tus/storage/gridfs.rb

@@ -0,0 +1,73 @@
+require "mongo"
+require "stringio"
+require "tempfile"
+
+module Tus
+  module Storage
+    class Gridfs
+      attr_reader :client, :prefix, :bucket
+
+      def initialize(client:, prefix: "fs")
+        @client = client
+        @prefix = prefix
+        @bucket = @client.database.fs(bucket_name: @prefix)
+        @bucket.send(:ensure_indexes!)
+      end
+
+      def create_file(uid, metadata = {})
+        file = Mongo::Grid::File.new("", filename: uid, metadata: metadata)
+        bucket.insert_one(file)
+      end
+
+      def file_exists?(uid)
+        !!bucket.files_collection.find(filename: uid).first
+      end
+
+      def read_file(uid)
+        file = bucket.find_one(filename: uid)
+        file.data
+      end
+
+      def patch_file(uid, content)
+        file_info = bucket.files_collection.find(filename: uid).first
+        file_info["md5"] = Digest::MD5.new # hack around not able to update digest
+        file_info = Mongo::Grid::File::Info.new(file_info)
+        offset = bucket.chunks_collection.find(files_id: file_info.id).count
+        chunks = Mongo::Grid::File::Chunk.split(content, file_info, offset)
+        bucket.chunks_collection.insert_many(chunks)
+      end
+
+      def download_file(uid)
+        tempfile = Tempfile.new("tus", binmode: true)
+        tempfile.sync = true
+        bucket.download_to_stream_by_name(uid, tempfile)
+        tempfile.path
+      end
+
+      def delete_file(uid)
+        file_info = bucket.files_collection.find(filename: uid).first
+        bucket.delete(file_info.fetch("_id"))
+      end
+
+      def read_info(uid)
+        info = bucket.files_collection.find(filename: uid).first
+        info.fetch("metadata")
+      end
+
+      def update_info(uid, info)
+        bucket.files_collection.find(filename: uid).update_one("$set" => {metadata: info})
+      end
+
+      def list_files
+        infos = bucket.files_collection.find.to_a
+        infos.map { |info| info.fetch("filename") }
+      end
+
+      private
+
+      def bson_id(uid)
+        BSON::ObjectId(uid)
+      end
+    end
+  end
+end

data/lib/tus-server.rb

@@ -0,0 +1 @@
+require "tus/server"

data/tus-server.gemspec

@@ -0,0 +1,24 @@
+Gem::Specification.new do |gem|
+  gem.name         = "tus-server"
+  gem.version      = "0.1.0"
+
+  gem.required_ruby_version = ">= 2.1"
+
+  gem.summary      = "Ruby server implementation of the Open Protocol for Resumable File Uploads."
+
+  gem.homepage     = "https://github.com/janko-m/tus-ruby-server"
+  gem.authors      = ["Janko Marohnić"]
+  gem.email        = ["janko.marohnic@gmail.com"]
+  gem.license      = "MIT"
+
+  gem.files        = Dir["README.md", "LICENSE.txt", "lib/**/*.rb", "*.gemspec"]
+  gem.require_path = "lib"
+
+  gem.add_dependency "roda", "~> 2.17"
+  gem.add_dependency "rack", "~> 2.0"
+
+  gem.add_development_dependency "rake", "~> 11.1"
+  gem.add_development_dependency "minitest", "~> 5.8"
+  gem.add_development_dependency "rack-test_app"
+  gem.add_development_dependency "mongo"
+end

metadata

@@ -0,0 +1,138 @@
+--- !ruby/object:Gem::Specification
+name: tus-server
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Janko Marohnić
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2016-08-22 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: roda
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.17'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.17'
+- !ruby/object:Gem::Dependency
+  name: rack
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '11.1'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '11.1'
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.8'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.8'
+- !ruby/object:Gem::Dependency
+  name: rack-test_app
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: mongo
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: 
+email:
+- janko.marohnic@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- LICENSE.txt
+- README.md
+- lib/tus-server.rb
+- lib/tus/checksum.rb
+- lib/tus/expirator.rb
+- lib/tus/info.rb
+- lib/tus/server.rb
+- lib/tus/storage/filesystem.rb
+- lib/tus/storage/gridfs.rb
+- tus-server.gemspec
+homepage: https://github.com/janko-m/tus-ruby-server
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '2.1'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.5.1
+signing_key: 
+specification_version: 4
+summary: Ruby server implementation of the Open Protocol for Resumable File Uploads.
+test_files: []