fogged 0.0.2

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 117c0db8e6eced45592f16bb7cbb19aadb026dba
+  data.tar.gz: 5e52387b1f5338038bf2c378d7b4a7ff9217f0a0
+SHA512:
+  metadata.gz: 29213f2ad1476ea58e24a488e8c2a422950b27008e596d497714f9d8f65e9ce1f73ead680b7d33ea0c2ce7ae1380ce05172b5777c71c49c4d40607c752643cd1
+  data.tar.gz: 3bff3cc1207dc3f9f28057044ed731cdec712ffed320a14de4896eb5cc0730571e91d70755d90f07b8fe2a3aecf638d4aa5468cf81f51dcf9b78460539debd47

data/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright 2014 Gatemedia.ch
+
+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/Rakefile

@@ -0,0 +1,34 @@
+begin
+  require 'bundler/setup'
+rescue LoadError
+  puts 'You must `gem install bundler` and `bundle install` to run rake tasks'
+end
+
+require 'rdoc/task'
+
+RDoc::Task.new(:rdoc) do |rdoc|
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title    = 'Fogged'
+  rdoc.options << '--line-numbers'
+  rdoc.rdoc_files.include('README.rdoc')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end
+
+APP_RAKEFILE = File.expand_path("../test/dummy/Rakefile", __FILE__)
+load 'rails/tasks/engine.rake'
+
+
+
+Bundler::GemHelper.install_tasks
+
+require 'rake/testtask'
+
+Rake::TestTask.new(:test) do |t|
+  t.libs << 'lib'
+  t.libs << 'test'
+  t.pattern = 'test/**/*_test.rb'
+  t.verbose = false
+end
+
+
+task default: :test

data/app/controllers/fogged/resources_controller.rb

@@ -0,0 +1,259 @@
+# The Resource API. This API has only 3 methods: create, confirm and destroy.
+#
+# To create a new resource, call the create method with a filename and a
+# content_type, you will get a resource as a result. This resource has an
+# upload_url you can use to put your content. Caution, this url is valid only
+# for 2 minutes.
+#
+# When uploading a resource, two http headers are *mandatory*:
+# * Content-Type, which *must* be the same value as the one used to create the
+#   resource
+# * Set the acl to public read. Eg. on AWS send the x-amz-acl header set to
+#   "public-read". This ensures that the resource is publicly readable.
+#
+# The upload can fail if these two flags/settings are missing.
+#
+# Once you finished uploading the resource, you can confirm it with the method
+# confirm. You MUST confirm a resource in order to use it elsewhere (eg. in the
+# Event api). Once confirmed, a resource can't be updated. For example, if you
+# want to update the resource content, create a new one. A resource has these
+# fields:
+#
+# id - the resource's id
+# name - the resource's name
+# upload_url - the secured url where you can upload your content. This link has
+#              already all the correct parameters for S3. Do not change them.
+# url - the public url where you can read the content
+# h264_url - the url of the h264 file. Only for video resources
+# mpeg_url - the url of the mpeg file. Only for video resources
+# webm_url - the url of the webm file. Only for video resources
+# thumbnail_urls - the urls of the thumbnails. Only for video resources
+# encoding_progress - the progress of the encoding in %. Only for video
+#                     resources
+#
+# Examples
+#
+# {
+#   "resource": {
+#     "id": 1,
+#     "upload_url": "https:...",
+#     "url": "https:..."
+#   }
+# }
+#
+# {
+#   "resource": {
+#     "id": 42145,
+#     "name": "Resource 6",
+#     "url": "https://...",
+#     "h264_url": "https://...",
+#     "mpeg_url": "https://...",
+#     "webm_url": "https://...",
+#     "thumbnail_urls": [
+#       "https://...",
+#       "https://...",
+#       "https://...",
+#       "https://...",
+#       "https://..."
+#     ],
+#     "encoding_progress": 0
+#   }
+# }
+module Fogged
+  class ResourcesController < Fogged.parent_controller.constantize
+    before_action :select_resourceables, :only => :index
+    before_action :select_resource, :only => %i(confirm destroy show update)
+
+    # List all resources. Parameter type is mandatory. It indicates in which
+    # "context" you want all resources. You can refine the search, using
+    # using parameters type_id or type_ids, which will select the context
+    # objects before retrieving the resources. Pagination options are
+    # available. Search options are available.
+    #
+    # type - the context/type in which the resources search is done. Mandatory
+    # type_id - the specific type id
+    # type_ids - the specific type ids
+    # query - text search (insensitive) on the resource's name
+    #
+    # Example
+    #
+    # GET /api/v1/resources?type=group&ids[]=2&ids[]=3
+    # GET /api/v1/resources?type=group
+    #
+    # Returns an array of Resources found
+    # Raises 400 if the given type is unknown
+    # Raises 500 if an error occurs
+    def index
+      resources = @resourceables.map do |resourceable|
+        resourceable.resources.search(params)
+      end
+
+      render :json => paginate(resources.flatten.uniq),
+             :meta => @meta,
+             :each_serializer => ResourceSerializer
+    end
+
+    # Get the resource.
+    #
+    # id - the resource's id
+    #
+    # Example
+    #
+    # GET /api/v1/resources/123
+    #
+    # Returns the Resource
+    # Raises 404 if the Resource is not found
+    # Raises 500 if an error occurs
+    def show
+      render :json => @resource,
+             :serializer => ResourceSerializer
+    end
+
+    # Create a new resource. You must provide a filename (example: foo.png)
+    # and a content_type (example: "image/png"). This content_type must be the
+    # same as the one used with the upload_url.
+    #
+    # resource - a hash with a name (optional), a filename and a content_type
+    #
+    #
+    # Examples
+    #
+    # POST /api/v1/resources
+    # {
+    #   "resource": {
+    #     "name": "The ultimate ruby"
+    #     "filename": "ruby.png"
+    #     "content_type": "image/png"
+    #   }
+    # }
+    #
+    # Return the created resource which will be marked as uploading.
+    # Raises 400 if resource params are not valid.
+    # Raises 500 if an error occurs.
+    def create
+      resource = Resource.create!(
+        :name => resource_params.require(:name),
+        :extension => extension(resource_params.require(:filename)),
+        :content_type => resource_params.require(:content_type),
+        :uploading => true
+      )
+
+      render :json => resource,
+             :serializer => ResourceSerializer,
+             :include_upload_url => true
+    end
+
+    # Update a Resource. You can update the name of a Resource or its context
+    # object
+    #
+    # id - the resource's id
+    # resource - the resource params
+    #
+    # Example
+    #
+    # PUT /api/v1/resources/1
+    # {
+    #   "resource": {
+    #     "name": "Updated"
+    #   }
+    # }
+    #
+    # Returns the updated Resource
+    # Raises 400 if the parameters are invalid
+    # Raises 404 if the resource or the context object can't be found
+    # Raises 500 if an error occurs
+    def update
+      @resource.update!(resource_params.permit(:name))
+
+      show
+    end
+
+    # Confirm a resource. You MUST confirm a resource before using it.
+    #
+    # id - the resource id
+    #
+    # Examples
+    #
+    # PUT /api/v1/resources/1/confirm
+    #
+    # Return the confirmed resource. Note that the upload_url will not be
+    # present in the response.
+    # Raises 500 if a server errors occurs
+    def confirm
+      @resource.process!
+      @resource.update!(:uploading => false)
+      show
+    end
+
+    # Destroy a resource. You can choose to destroy a resource. This
+    # will also destroy the content on S3.
+    #
+    # id - the resource id
+    #
+    # Examples
+    #
+    # DELETE /api/v1/resources/1
+    #
+    # Return an empty response with 204(No content)
+    # Raises 500 if a server errors occurs
+    def destroy
+      @resource.destroy!
+      head :no_content
+    end
+
+    private
+
+    def select_resourceables
+      ids = params[:type_id] || params[:type_ids]
+      ids = [ids] unless ids.respond_to?(:to_ary)
+      @resourceables = resourceable_clazz.all
+      @resourceables = resourceable_clazz.where(:id => ids) if ids.try(:any?)
+    end
+
+    def resourceable_clazz
+      @_resourceable_clazz ||= resource_type_param.try(:classify)
+                                                  .try(:safe_constantize)
+      unless @_resourceable_clazz
+        fail(ArgumentError, "Unknown resourceable type: #{params[:type]}")
+      end
+      @_resourceable_clazz
+    end
+
+    def resource_type_param
+      params.require(:type)
+    end
+
+    def select_resource
+      @resource = Resource.find(params[:id])
+    end
+
+    def resource_params
+      params.require(:resource).permit(:name, :filename, :content_type)
+    end
+
+    def extension(filename)
+      extension = File.extname(filename)
+      extension.tap { |e| e.slice!(0) }
+    end
+
+    def paginate(result)
+      page = Integer(params[:page] || 1)
+      count = Integer(params[:count] || 50).to_i
+      offset = (page - 1) * count
+      total = result.size
+      @meta = {
+        :pagination => {
+          :total => total,
+          :remaining => [total - offset - count, 0].max
+        }
+      }
+
+      case result
+      when Array
+        result.slice(offset, count)
+      else
+        result.limit(count).offset(offset)
+      end
+    end
+  end
+end

data/app/jobs/fogged/resources/zencoder_poll_job.rb

@@ -0,0 +1,39 @@
+module Fogged
+  module Resources
+    class ZencoderPollJob < Struct.new(:resource_id)
+      def perform
+        @resource = Fogged::Resource.find(resource_id)
+        update_encoding_progress
+
+        return if @resource.encoding_progress == 100
+
+        frequency = Fogged.zencoder_polling_frequency
+        Delayed::Job.enqueue(self, :run_at => frequency.seconds.from_now)
+      end
+
+      private
+
+      def update_encoding_progress
+        job = Zencoder::Job.progress(@resource.encoding_job_id)
+
+        case job.body["state"]
+        when "finished"
+          job = Zencoder::Job.details(@resource.encoding_job_id)
+          f = job.body["job"]["output_media_files"][0]
+          @resource.update!(
+            :encoding_progress => 100,
+            :width => f["width"],
+            :height => f["height"],
+            :duration => f["duration_in_ms"].to_f / 1000.0
+          )
+        when "processing", "waiting"
+          @resource.update!(
+            :encoding_progress => job.body["progress"].to_i
+          )
+        else
+          fail(ArgumentError, "Unknown Zencoder job state #{job.body["state"]}")
+        end
+      end
+    end
+  end
+end

data/app/models/fogged/resource.rb

@@ -0,0 +1,153 @@
+module Fogged
+  class Resource < ActiveRecord::Base
+    validates :extension, :content_type, :presence => true
+
+    before_save :ensure_token
+    after_destroy :destroy_fogged_file
+
+    def self.search(params)
+      results = all
+
+      if params[:query]
+        results = results.where(
+          "#{table_name}.name LIKE :query",
+          :query => "%#{params[:query].to_s.downcase}%"
+        )
+      end
+
+      results
+    end
+
+    def upload_url
+      fogged_file.service.put_object_url(
+        Fogged.resources.key,
+        fogged_file.key,
+        2.minutes.from_now,
+        "Content-Type" => content_type,
+        "x-amz-acl" => "public-read"
+      )
+    end
+
+    def url
+      storage = Fogged.resources
+      storage.service.try(
+        :request_url,
+        :bucket_name => storage.key,
+        :object_name => fogged_name
+      )
+    end
+
+    def h264_url
+      return unless video?
+      url.gsub(fogged_name, fogged_name_for(:h264))
+    end
+
+    def mpeg_url
+      return unless video?
+      url.gsub(fogged_name, fogged_name_for(:mpeg))
+    end
+
+    def webm_url
+      return unless video?
+      url.gsub(fogged_name, fogged_name_for(:webm))
+    end
+
+    def thumbnail_urls
+      return unless video?
+      5.times.map do |n|
+        url.gsub(fogged_name, fogged_name_for(:thumbnails, n))
+      end
+    end
+
+    def video?
+      content_type.start_with?("video/")
+    end
+
+    def image?
+      content_type.start_with?("image/")
+    end
+
+    def encoding?
+      return false unless video? && encoding_progress.present?
+      encoding_progress < 100
+    end
+
+    def process!
+      find_size! if image?
+      encode! if video?
+    end
+
+    def write(content)
+      fogged_file.body = content
+      fogged_file.save
+    end
+
+    private
+
+    def find_size!
+      if Fogged.test_enabled
+        update!(
+          :width => 800,
+          :height => 600
+        )
+      else
+        size = FastImage.size(url)
+        update!(
+          :width => size.first,
+          :height => size.second
+        ) unless size.blank?
+      end
+    end
+
+    def encode!
+      return unless Fogged.zencoder_enabled
+      Resources::Encoder.for(self).encode!
+    end
+
+    def ensure_token
+      self.token = generate_token if token.blank?
+    end
+
+    def generate_token
+      loop do
+        a_token = SecureRandom.hex(16)
+        break a_token unless Resource.find_by(:token => a_token)
+      end
+    end
+
+    def fogged_file
+      return @fogged_file if defined?(@fogged_file)
+
+      files = Fogged.resources.files
+      @fogged_file = files.get(fogged_name) || files.create(
+        :key => fogged_name,
+        :body => "",
+        :public => true,
+        :content_type => content_type
+      )
+    end
+
+    def fogged_name
+      "#{token}.#{extension}"
+    end
+
+    def fogged_name_for(type, number = 0)
+      case type
+      when :h264
+        "#{token}-h264.mp4"
+      when :mpeg
+        "#{token}-mpeg.mp4"
+      when :webm
+        "#{token}-webm.webm"
+      when :thumbnails
+        "#{token}-thumbnail-#{number}.png"
+      else
+        fail(ArgumentError, "Can't get fogged name of #{type}")
+      end
+    end
+
+    def destroy_fogged_file
+      fogged_file.destroy
+    end
+  end
+end