s3_media_server_api 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 49178c41050a932cd11ba20ab661e0e3353e64d4
+  data.tar.gz: bf5572843932b79e5424b649b1fa3db92432be50
+SHA512:
+  metadata.gz: 415b6b8a82653c15cd62d9bbca6b0f4cabd12cd44951d9c5bc954fa55ab29dd302bf1fe7845bdb084d6ce2b3b4987d7f402ba9d1782f657307436cd26603d50e
+  data.tar.gz: 0e2df36585d3c516f74a322de409580c2c07da68a2ea1386b8b02760b4543786504fee4ffc2e524806f00e8ca70ec03ad47ef50596f224383bc0fa3f111ff7d6

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in s3_media_server_api.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2016 Ayrat Badykov
+
+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,188 @@
+# S3MediaServerApi - - a Ruby client for the S3 Media Server
+
+S3MediaServerApi helps you write apps that need to interact with S3 Media Server.
+
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 's3_media_server_api'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install s3_media_server_api
+
+## Usage
+### Available resources
+
+#### S3MediaServerApi::Media::Document
+Use S3MediaServerApi::Media::Document to interact Document resource
+```ruby
+# if you want create document from file path, use create method
+created_document = S3MediaServerApi::Media::Document.create('/Users/ayrat/Development/s3_media_server_api/tmp/sample_mpeg4.mp4')
+
+
+# to resolve document, use resolve method
+resolved_document = S3MediaServerApi::Media::Document.resolve(created_document.uuid)
+
+# both methods create and resolve return document object
+
+resolved_document.uuid # uuid of document
+resolved_document.url  # url of document
+resolved_document.size # size of document
+resolved_document.name  # url of document
+
+# use destroy method, to destroy document
+# this method is asynchronous, so it doesn't return anything
+S3MediaServerApi::Media::Document.destroy(created_document.uuid)
+```
+#### S3MediaServerApi::Media::Image
+Use S3MediaServerApi::Media::Image to interact Image resource
+```ruby
+# if you want create image from file path, use create method
+created_image = S3MediaServerApi::Media::Image.create('/Users/ayrat/Development/s3_media_server_api/tmp/test_image.jpg')
+
+# to resolve image, use resolve method
+resolved_image = S3MediaServerApi::Media::Image.resolve(created_image.uuid)
+
+# both methods create and resolve return document object
+resolved_image.size
+resolved_image.name
+resolved_image.uuid
+resolved_image.source.url
+resolved_image.source.width
+resolved_image.source.height
+
+# to create thumb of image, use resize method.
+# this method is asynchronous
+S3MediaServerApi::Media::Image.resize(created_image.uuid)
+
+# after thumb is created, new attributes will be available
+thumbed_image = S3MediaServerApi::Media::Image.resolve(created_image.uuid)
+thumbed_image.thumb.url
+thumbed_image.thumb.width
+thumbed_image.thumb.height
+
+# to copy image, use copy method
+copied_image = S3MediaServerApi::Media::Image.copy(created_image.uuid)
+
+# to destroy image, use destroy method
+# this method is asynchronous
+S3MediaServerApi::Media::Image.destroy(created_image.uuid)
+```
+#### S3MediaServerApi::Media::Audio
+Use S3MediaServerApi::Media::Audio to interact Audio resource
+```ruby
+# to create audio file from its path, use create method
+created_audio = S3MediaServerApi::Media::Audio.create('/Users/ayrat/Development/s3_media_server_api/tmp/music_test.mp3')
+# to resolve image, use resolve method
+resolved_audio = S3MediaServerApi::Media::Audio.resolve(created_audio.uuid)
+
+# both methods create and resolve return audio object
+resolved_audio.url
+resolved_audio.uuid
+resolved_audio.name
+resolved_audio.size
+
+# cut method sends request to create audio sampel
+# parameters: uuid - uuid of file
+#             audio_url - url of audio file
+#             duration  - duration of cutted file
+#             start_position - position where cut wil be made
+# this method is asynchronous
+cut_params = { audio_url: created_audio.url,
+               duration: 20,
+               start_position: 40}
+S3MediaServerApi::Media::Audio.cut(created_audio.uuid, cut_params)
+
+# after audio is cutted, new attributes will be available
+cutted_audio = S3MediaServerApi::Media::Audio.resolve(created_audio.uuid)
+
+cutted_audio.sample_url
+cutted_audio.duration
+cutted_audio.sample_duration
+
+# destroys audio file
+# this method is asynchronous
+S3MediaServerApi::Media::Audio.destroy(created_audio.uuid)
+```
+#### S3MediaServerApi::Media::Video
+Use S3MediaServerApi::Media::Video to interact Video resource
+```ruby
+# to create video from its path, use create method
+video = S3MediaServerApi::Media::Video.create('/Users/ayrat/Development/s3_media_server_api/tmp/sample_mpeg4.mp4')
+
+# to resolve video, use resolve method
+video = S3MediaServerApi::Media::Video.resolve(video.uuid)
+
+# both methods create and resolve return video object
+video.
+
+video.name
+video.embed_url
+video.transcoded # true if video has all versions
+                 # false otherwise
+
+# after screenshots are made, screenshots attributes will be available with 3 screenshots
+video = S3MediaServerApi::Media::Video.resolve(video.uuid)
+video.screenshots[0].source.url
+video.screenshots[0].source.width
+video.screenshots[0].source.height
+video.screenshots[0].thumb.url
+video.screenshots[0].thumb.width
+video.screenshots[0].thumb.height
+
+# you can get available video versions in version attribute
+
+video.versions[0].format
+video.versions[0].resolution
+video.versions[0].url
+video.versions[0].size
+
+# to destroy video, use destroy method
+# this method is asynchronous
+S3MediaServerApi::Media::Video.destroy(video.uuid)
+```
+
+#### AwsFile
+```ruby
+# to create aws file from its path, use upload method from S3MediaServerApi::Uploader module
+aws_file = S3MediaServerApi::Uploader.upload('/Users/ayrat/Development/s3_media_server_api/tmp/test_image.jpg')
+
+# to resolve aws file, use resolve method
+resolved_aws_file =  S3MediaServerApi::AwsFile.resolve(aws_file.uuid)
+
+# both S3MediaServerApi::Uploader.upload and S3MediaServerApi::AwsFile.resolve return aws file object
+aws_file.uuid
+aws_file.size
+aws_file.mime_type
+aws_file.uploads_count
+aws_file.default_part_size
+aws_file.state
+aws_file.public_url
+aws_file.name
+
+```
+NOTE: you can't remove aws file without creating media resource
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake test` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+
+To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and tags, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/[USERNAME]/s3_media_server_api.
+
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](http://opensource.org/licenses/MIT).

data/Rakefile

@@ -0,0 +1,10 @@
+require "bundler/gem_tasks"
+require "rake/testtask"
+
+Rake::TestTask.new(:test) do |t|
+  t.libs << "test"
+  t.libs << "lib"
+  t.test_files = FileList['test/**/*_test.rb']
+end
+
+task :default => :spec

data/lib/s3_media_server_api.rb

@@ -0,0 +1,24 @@
+require "s3_media_server_api/version"
+require "s3_media_server_api/error"
+require "s3_media_server_api/config"
+require "s3_media_server_api/uploader"
+require "s3_media_server_api/file_part"
+require "s3_media_server_api/aws_file"
+require "s3_media_server_api/media"
+require "s3_media_server_api/asynk_request"
+
+module S3MediaServerApi
+
+  class << self
+
+    def upload_thread_count
+      config.upload_thread_count
+    end
+
+    private
+
+      def config
+        @@config ||= Config.new
+      end
+  end
+end

data/lib/s3_media_server_api/asynk_request.rb

@@ -0,0 +1,30 @@
+module S3MediaServerApi
+  module AsynkRequest
+    class << self
+      #
+      # sends asynchronous request using Asynk gem - https://github.com/konalegi/asynk
+      # parameters: path - base path of consumer
+      #             action - consumer action
+      #             params - parametes that will be passed to consumer
+      #
+      def async_request(path, action, params)
+        Asynk::Publisher.publish("#{server}.#{path}.#{action}", params)
+      end
+      #
+      # sends synchronous request using Asynk gem - https://github.com/konalegi/asynk
+      # parameters: path - base path of consumer
+      #             action - consumer action
+      #             params - parametes that will be passed to consumer
+      #
+      def sync_request(path, action, params)
+        Asynk::Publisher.sync_publish("#{server}.#{path}.#{action}", params)
+      end
+
+      private
+
+        def server
+          's3_media_server'
+        end
+    end
+  end
+end

data/lib/s3_media_server_api/aws_file.rb

@@ -0,0 +1,106 @@
+module S3MediaServerApi
+  class AwsFile
+
+    def initialize(response)
+      @params = response[:data]
+    end
+
+    def uuid
+      @params[:uuid]
+    end
+
+    def size
+      @params[:size]
+    end
+
+    def mime_type
+      @params[:mime_type]
+    end
+
+    def uploads_count
+      @params[:uploads_count]
+    end
+
+    def default_part_size
+      @params[:default_part_size]
+    end
+
+    def state
+      @params[:state]
+    end
+
+    def public_url
+      @params[:public_url]
+    end
+
+    def name
+      @params[:name]
+    end
+
+    def as_hash
+      @params
+    end
+
+    class << self
+      class AwsFileError < S3MediaServerApiError; end
+      class FileCreationError < AwsFileError; end
+      class CompleteUploadError < AwsFileError; end
+      #
+      # creates file on s3_media_server
+      # parameters: file_path - path on file system to file
+      #
+      # returns: response with created file
+      #
+      def create_from_path(file_path)
+        params = {
+                   size: File.size(file_path),
+                   mime_type: file_mime_type(file_path),
+                   name: File.basename(file_path)
+                 }
+        response = AsynkRequest.sync_request(base_path, :create, params)
+        raise FileCreationError.message_from_asynk_response(response) unless response.success?
+        AwsFile.new(response)
+      end
+      #
+      # fetches media file
+      # parameters: uuid - uuid of file
+      #
+      # returns: response with file information
+      #
+      def resolve(uuid)
+        AsynkRequest.sync_request(base_path, :resolve, uuid: uuid)
+      end
+      #
+      # fetches signed upload url to upload specified part number
+      # parameters: uuid - file uuid
+      #             part_numer - part number that will be uploaded
+      #
+      # returns:  signed upload url
+      #
+      def get_signed_upload_url(uuid, part_number)
+        response = AsynkRequest.sync_request(:uploads, :show, aws_file_uuid: uuid, uuid: part_number)
+        response[:data][:upload_url]
+      end
+      #
+      # completes multipart upload
+      # parameters: uuid - file uuid
+      #
+      def complete_upload(uuid)
+        response = AsynkRequest.sync_request(base_path, :complete_upload, uuid: uuid)
+        raise CompleteUploadError.message_from_asynk_response(response) unless response.success?
+        AwsFile.new(response)
+      end
+
+      private
+
+        def file_mime_type(file_source_path)
+          mime_magic = MimeMagic.by_magic(File.open(file_source_path))
+          mime_magic ? mime_magic.type : 'application/octet-stream'
+        end
+
+        def base_path
+          'aws_file'
+        end
+    end
+  end
+end

data/lib/s3_media_server_api/config.rb

@@ -0,0 +1,26 @@
+require 'yaml'
+
+module S3MediaServerApi
+  class ConfigError < S3MediaServerApiError; end
+  #
+  # By default 4 threads is used for file uploading. To change
+  # this value you can create config/s3_media_server_api.yml and specify
+  # upload_thread_count
+  #
+  # Example
+  #   prosuction:
+  #     upload_thread_count: 10
+  #
+  class Config
+    attr_reader :upload_thread_count
+
+    def initialize
+      @upload_thread_count = nil
+      environment = ENV['RUBY_ENV'] || ENV['RAILS_ENV']
+      if File.exists?('config/s3_media_server_api.yml')
+        @attributes = YAML.load_file('config/s3_media_server_api.yml')[environment][:upload_thread_count]
+      end
+      @upload_thread_count ||= 4
+    end
+  end
+end

data/lib/s3_media_server_api/error.rb

@@ -0,0 +1,9 @@
+module S3MediaServerApi
+  class S3MediaServerApiError < RuntimeError
+    class<<self
+      def message_from_asynk_response(asynk_response)
+        self.new("body: #{asynk_response.body}, message: #{asynk_response.error_message}")
+      end
+    end
+  end
+end

data/lib/s3_media_server_api/file_part.rb

@@ -0,0 +1,69 @@
+module S3MediaServerApi
+  module Uploader
+
+      class FilePart
+        # @option options [required,String,Pathname,File,Tempfile] :source
+        # @option options [required,Integer] :offset The file part will read
+        #   starting at this byte offset.
+        # @option options [required,Integer] :size The maximum number of bytes to
+        #   read from the `:offset`.
+        def initialize(options = {})
+          @source = options[:source]
+          @first_byte = options[:offset]
+          @last_byte = @first_byte + options[:size]
+          @size = options[:size]
+        end
+
+        # @return [String,Pathname,File,Tempfile]
+        attr_reader :source
+
+        # @return [Integer]
+        attr_reader :first_byte
+
+        # @return [Integer]
+        attr_reader :last_byte
+
+        # @return [Integer]
+        attr_reader :size
+
+        def read(bytes = nil, output_buffer = nil)
+          open_file unless @file
+          read_from_file(bytes, output_buffer)
+        end
+
+        def rewind
+          if @file
+            @file.seek(@first_byte)
+            @position = @first_byte
+          end
+          0
+        end
+
+        def close
+          @file.close if @file
+        end
+
+        private
+
+          def open_file
+            @file = File.open(@source, 'rb')
+            rewind
+          end
+
+          def read_from_file(bytes, output_buffer)
+            if bytes
+              data = @file.read([remaining_bytes, bytes].min)
+              data = nil if data == ''
+            else
+              data = @file.read(remaining_bytes)
+            end
+            @position += data ? data.bytesize : 0
+            output_buffer ? output_buffer.replace(data || '') : data
+          end
+
+          def remaining_bytes
+            @last_byte - @position
+          end
+      end
+    end
+end

data/lib/s3_media_server_api/media.rb

@@ -0,0 +1,11 @@
+require 's3_media_server_api/media/common_media_api'
+require 's3_media_server_api/media/image'
+require 's3_media_server_api/media/video'
+require 's3_media_server_api/media/audio'
+require 's3_media_server_api/media/document'
+
+
+module S3MediaServerApi
+  module Media
+  end
+end

data/lib/s3_media_server_api/media/audio.rb

@@ -0,0 +1,56 @@
+module S3MediaServerApi
+  module Media
+    class Audio < CommonMediaApi
+      AUDIO = 'audio'
+
+      def sample_url
+        @params[:sample_url]
+      end
+
+      def url
+        @params[:url]
+      end
+
+      def sample_url
+        @params[:sample_url]
+      end
+
+      def duration
+        @params[:duration]
+      end
+
+      def sample_duration
+        @params[:sample_duration]
+      end
+
+      class << self
+        def create(path)
+          Audio.new(super(path))
+        end
+
+        def resolve(uuid)
+          Audio.new(super(uuid))
+        end
+        #
+        # sends request to cut audio file
+        # parameters: uuid - uuid of file
+        #             audio_url - url of audio file
+        #             duration  - duration of audio file
+        #             start_position - position where cut wil be made
+        #
+        def cut(uuid, audio_url: audio_url, duration: duration, start_position: start_position)
+          params = {
+                     uuid: uuid,
+                     audio_url: audio_url,
+                     duration: duration,
+                     start_position: start_position
+                    }
+          custom_async_request(:cut, params)
+        end
+
+        private
+          def media_type; AUDIO; end
+      end
+    end
+  end
+end

data/lib/s3_media_server_api/media/common_media_api.rb

@@ -0,0 +1,98 @@
+module S3MediaServerApi
+  module Media
+    class CommonMediaApiError < S3MediaServerApiError; end
+    class CreationError < CommonMediaApiError ; end
+    #
+    # Parent module for all media api, implements common methods for all media files
+    # To use methods from this module new module must be inherited from this module and
+    # media_type method with existing media type must be overwritten
+    #
+    class CommonMediaApi
+
+      def initialize(response)
+        @params = response[:data]
+      end
+
+      def uuid
+        @params[:uuid]
+      end
+
+      def name
+        @params[:name]
+      end
+
+      def size
+        @params[:size]
+      end
+
+      def as_hash
+        @params
+      end
+
+      class << self
+        #
+        # creates media file
+        # parameters: path - file path in file system
+        #
+        # returns: response with created AwsFile information
+        #
+        def create(path)
+          aws_file = Uploader.upload(path)
+          uuid = aws_file.uuid
+          params = (media_type == 'video') ? { uuid: uuid } : { aws_file_uuid: uuid }
+          response = AsynkRequest.sync_request(base_path, :create, params)
+          raise CreationError.message_from_asynk_response(response) unless response.success?
+          response
+        end
+        #
+        # destroys media file
+        # parameters: uuid - uuid of file
+        #
+        def destroy(uuid)
+          AsynkRequest.async_request(base_path, :destroy, uuid: uuid)
+        end
+        #
+        # fetches media file
+        # parameters: uuid - uuid of file
+        #
+        # returns: response with file information
+        #
+        def resolve(uuid)
+          AsynkRequest.sync_request(base_path, :resolve, uuid: uuid)
+        end
+        #
+        # this method should be used to send custom synchronous request to
+        # s3_media_server. For example, to copy image file
+        # parameters: action - method that should be called
+        #             params - parameters for specified method
+        # Example:
+        #          custom_sync_request (:copy, 'image')
+        #
+        def custom_sync_request(action, params)
+          AsynkRequest.sync_request(base_path, action, params)
+        end
+        #
+        # this method should be used to send custom asynchronous request to
+        # s3_media_server. For example, to cut audio file
+        # parameters: action - method that should be called
+        #             params - parameters for specified method
+        # Example:
+        #          custom_async_request (:cut, 'image')
+        #
+        def custom_async_request(action, params)
+          AsynkRequest.async_request(base_path, action, params)
+        end
+
+        private
+          #
+          # specifies media type which methods will be called
+          #
+          def media_type; end
+          #
+          # base path of media consumers on s3_media_server
+          #
+          def base_path; "media.#{media_type}"; end
+      end
+    end
+  end
+end

data/lib/s3_media_server_api/media/document.rb

@@ -0,0 +1,26 @@
+module S3MediaServerApi
+  module Media
+    class Document< CommonMediaApi
+      DOCUMENT = 'document'
+
+      def url
+        @params[:url]
+      end
+
+      class << self
+
+        def create(path)
+          Document.new(super(path))
+        end
+
+        def resolve(uuid)
+          Document.new(super(uuid))
+        end
+
+        private
+
+          def media_type; DOCUMENT; end
+      end
+    end
+  end
+end

data/lib/s3_media_server_api/media/image.rb

@@ -0,0 +1,69 @@
+module S3MediaServerApi
+  module Media
+    class Image< CommonMediaApi
+      IMAGE = 'image'
+
+      class ImageObject
+
+        def initialize(params)
+          @params = params
+        end
+
+        def url
+          @params[:url]
+        end
+
+        def width
+          @params[:width]
+        end
+
+        def height
+          @params[:height]
+        end
+
+        def as_hash
+          @params
+        end
+      end
+
+      def source
+        ImageObject.new(@params[:source])
+      end
+
+      def thumb
+        ImageObject.new(@params[:thumb])
+      end
+
+      class << self
+
+        def create(path)
+          Image.new(super(path))
+        end
+
+        def resolve(uuid)
+          Image.new(super(uuid))
+        end
+        #
+        # copies image file
+        # parameters: uuid - uuid of file
+        #             aduio - url of image file
+        # returns: response with copied image
+        #
+        def copy(uuid)
+          Image.new(custom_sync_request(:copy, uuid: uuid))
+        end
+        #
+        # sends request to make thumb of image
+        # parameters: uuid - uuid of file
+        #
+        def resize(uuid)
+          custom_async_request(:resize, uuid: uuid)
+        end
+
+        private
+
+          def media_type; IMAGE; end
+      end
+    end
+  end
+end

data/lib/s3_media_server_api/media/video.rb

@@ -0,0 +1,72 @@
+module S3MediaServerApi
+  module Media
+    class Video< CommonMediaApi
+      VIDEO = 'video'
+
+      class Version
+        def initialize(params)
+          @params = params
+        end
+
+        def url
+          @params[:url]
+        end
+
+        def format
+          @params[:format]
+        end
+
+        def resolution
+          @params[:resolution]
+        end
+
+        def size
+          @params[:size]
+        end
+      end
+
+      def preview
+        @params[:preview]
+      end
+
+      def duration
+        @params[:duration]
+      end
+
+      def transcoded
+        @params[:transcoded]
+      end
+
+      def embed_url
+        @params[:embed_url]
+      end
+
+      def provider
+        @params[:provider]
+      end
+
+      def screenshots
+        @params[:screenshots].map { |screenshot| Image::ImageObject.new(screenshot) }
+      end
+
+      def versions
+        @params[:versions].map { |version| Version.new(version) }
+      end
+
+      class << self
+
+        def create(path)
+          Video.new(super(path))
+        end
+
+        def resolve(uuid)
+          Video.new(super(uuid))
+        end
+
+        private
+
+          def media_type; VIDEO; end
+      end
+    end
+  end
+end

data/lib/s3_media_server_api/uploader.rb

@@ -0,0 +1,107 @@
+require 'mimemagic'
+require 'asynk'
+require 'parallel'
+require 'faraday'
+
+module S3MediaServerApi
+
+  # Module with file uplod finctionality implementation
+
+  module Uploader
+
+    class << self
+
+      class UploaderError < S3MediaServerApiError; end
+      class PartUploadError < UploaderError; end
+      #
+      # uploads file to amazon s3 and create AwsFile object
+      # parameter : filepath - file path in file system
+      # returns: [AwsFile object]
+      #
+      # Example
+      #
+      # file = S3MediaServerApi::Uploader.upload(/home/vasya/my_awesome_file.awesome)
+      #
+      def upload(file_path)
+        parts = []
+        file = AwsFile.create_from_path(file_path)
+        default_part_size = file.default_part_size
+        aws_file_uuid = file.uuid
+        uploads_count = file.uploads_count
+        parts = compute_parts(file_path, default_part_size)
+        Parallel.each(parts, in_threads: S3MediaServerApi.upload_thread_count) do |part|
+          signed_upload_url = AwsFile.get_signed_upload_url(aws_file_uuid, part[:part_number])
+
+          raise PartUploadError.new("Part #{part[:part_number]} wasn't uploaded") unless upload_part(signed_upload_url, part[:body].read)
+        end
+
+        AwsFile.complete_upload(aws_file_uuid)
+      ensure
+        close_all_parts(parts)
+      end
+
+      private
+        #
+        # closes all parts of file that were used in multipart upload to prevent memory leak
+        #
+        def close_all_parts(parts)
+          parts.each do |part|
+            part[:body].close
+          end
+        end
+        #
+        # divides file into parts for multipart upload
+        # parameter:
+        #            source            - path of source file
+        #            default_part_size -  wanted part size (in bytes)
+        # returns:   [ array of parts ]
+        #
+        def compute_parts(source, default_part_size)
+          size = File.size(source)
+          offset, part_number, parts = 0, 1, []
+          while offset < size
+            parts << {
+              part_number: part_number,
+              body: FilePart.new(source: source, offset: offset, size: part_size(size, default_part_size, offset))
+            }
+
+            part_number += 1
+            offset += default_part_size
+          end
+          parts
+        end
+        #
+        # calculates size of one part - last part often has smaller size than other parts
+        # parameters: total_size - totol size of file (in bytes)
+        #             part_size  - default size of one part (in bytes)
+        #             offset     - offset from beginning of file (in bytes)
+        # returns: part size
+        #
+        def part_size(total_size, part_size, offset)
+          if offset + part_size > total_size
+            total_size - offset
+          else
+            part_size
+          end
+        end
+        #
+        # uploads data to specified url
+        # parameters: url - upload url
+        #             data  - data to upload
+        # returns: true if upload was successful
+        #          false otherwise
+        #
+        def upload_part(url, data)
+          conn = Faraday.new(url: url) do |faraday|
+            faraday.adapter :net_http
+          end
+          resp = conn.put do |req|
+            req.body = data
+            # to prevent Faraday from adding garbage header
+            req.headers['Content-Type'] = ''
+          end
+          resp.success?
+        end
+    end
+  end
+end

data/lib/s3_media_server_api/version.rb

@@ -0,0 +1,3 @@
+module S3MediaServerApi
+  VERSION = "0.1.0"
+end

data/s3_media_server_api.gemspec

@@ -0,0 +1,27 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 's3_media_server_api/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "s3_media_server_api"
+  spec.version       = S3MediaServerApi::VERSION
+  spec.authors       = ["Ayrat Badykov"]
+  spec.email         = ["ayratin555@gmail.com"]
+
+  spec.summary       = 'S3MediaServerApi helps you write apps that need to interact with S3 Media Server.'
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
+  spec.bindir        = "exe"
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler", "~> 1.11"
+  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency "minitest", "~> 5.0"
+  spec.add_dependency 'asynk', '>= 0.0.1'
+  spec.add_dependency 'parallel'
+  spec.add_dependency 'mimemagic'
+  spec.add_dependency 'faraday'
+end

metadata

@@ -0,0 +1,162 @@
+--- !ruby/object:Gem::Specification
+name: s3_media_server_api
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Ayrat Badykov
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2016-07-11 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.11'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.11'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.0'
+- !ruby/object:Gem::Dependency
+  name: asynk
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.0.1
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.0.1
+- !ruby/object:Gem::Dependency
+  name: parallel
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: mimemagic
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: faraday
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: 
+email:
+- ayratin555@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- lib/s3_media_server_api.rb
+- lib/s3_media_server_api/asynk_request.rb
+- lib/s3_media_server_api/aws_file.rb
+- lib/s3_media_server_api/config.rb
+- lib/s3_media_server_api/error.rb
+- lib/s3_media_server_api/file_part.rb
+- lib/s3_media_server_api/media.rb
+- lib/s3_media_server_api/media/audio.rb
+- lib/s3_media_server_api/media/common_media_api.rb
+- lib/s3_media_server_api/media/document.rb
+- lib/s3_media_server_api/media/image.rb
+- lib/s3_media_server_api/media/video.rb
+- lib/s3_media_server_api/uploader.rb
+- lib/s3_media_server_api/version.rb
+- s3_media_server_api.gemspec
+homepage: 
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.4.5.1
+signing_key: 
+specification_version: 4
+summary: S3MediaServerApi helps you write apps that need to interact with S3 Media
+  Server.
+test_files: []