mrpin-sdk 0.3.141 → 1.0.2

data/lib/mrpin/core/uploaders/aws/aws_uploader.rb

@@ -0,0 +1,229 @@
+require 'open-uri'
+
+class AWSUploader
+
+  BUCKET_NAME_DEFAULT     = 'mrpin-static'
+  DOMAIN_NAME_CLOUD_FRONT = 'd3crzre36asem1.cloudfront.net'
+  DOMAIN_NAME_S3          = 's3.amazonaws.com'
+  AWS_REGION              = 'us-east-1'
+
+  CACHE_CONTROL_MAX_AGE_DEFAULT = 365 * 24 * 60 * 60
+
+  attr_reader :s3
+  attr_reader :cloud_front
+
+  def initialize(options = {})
+    credentials = {}
+
+    credentials[:access_key_id]     = get_var_from_env('AWS_ACCESS_KEY_ID')
+    credentials[:secret_access_key] = get_var_from_env('AWS_SECRET_ACCESS_KEY')
+    credentials[:region]            = AWS_REGION
+
+    @s3           = Aws::S3::Client.new(credentials)
+    @s3_resources = Aws::S3::Resource.new(credentials)
+    @cloud_front  = Aws::CloudFront::Client.new(credentials)
+  end
+
+  # upload files to s3 and returns urls map
+  public
+  def upload_files_to_s3(files_to_upload, bucket_name, keys)
+    bucket_name ||= BUCKET_NAME_DEFAULT
+
+    assert(!files_to_upload.nil?, 'aws:upload_files_to_s3. Files to upload must be non nil')
+    assert(!bucket_name.nil?, 'aws:upload_files_to_s3. Bucket name must be non nil')
+    assert(!keys.nil? && keys.size == files_to_upload.size, 'aws:upload_files_to_s3. Desired names must be non nil and its count must be equal count of files to upload')
+
+    result = []
+
+    begin
+
+      [0..files_to_upload.size - 1].each do |i|
+        file_to_upload = files_to_upload[i]
+
+        s3_key = keys[i]
+
+        result << upload_file_to_s3(file_to_upload, bucket_name, s3_key)
+      end
+
+    rescue Exception => e
+
+      result.each do |file_info|
+        delete_file_from_s3_by_uri(bucket_name, file_info.url_s3)
+      end
+
+      assert(false, e.to_s)
+    end
+
+    result
+  end
+
+  public
+  def upload_file_to_s3(file_to_upload, bucket_name, key)
+    result = nil
+
+    File.open(file_to_upload) do |data_to_upload|
+      result = upload_to_s3_internal(data_to_upload, bucket_name, key, file_to_upload)
+    end
+
+    result
+  end
+
+  # upload file to s3 and returns instance of AWSFileInfo
+  public
+  def upload_data_to_s3(data_to_upload, bucket_name, path, desired_name = nil)
+    upload_to_s3_internal(data_to_upload, bucket_name, path, desired_name)
+  end
+
+  public
+  def upload_url_file_to_s3(url_to_upload, bucket_name, key)
+    result = nil
+
+    open(url_to_upload) do |data_to_upload|
+      result = upload_to_s3_internal(data_to_upload, bucket_name, key, url_to_upload)
+    end
+
+    result.source = url_to_upload
+
+    result
+  end
+
+  # @source_type - possible values :file, :data
+  private
+  def upload_to_s3_internal(data_to_upload, bucket_name, s3_key, source = nil)
+    result = AWSFileInfo.new
+
+    bucket_name ||= BUCKET_NAME_DEFAULT
+
+    s3_object_options                 = {}
+    s3_object_options[:body]          = data_to_upload
+    s3_object_options[:acl]           = 'public-read'
+    s3_object_options[:cache_control] = "max-age=#{CACHE_CONTROL_MAX_AGE_DEFAULT}"
+
+    s3_object = @s3_resources.bucket(bucket_name).object(s3_key)
+
+    s3_object.put(s3_object_options)
+
+    result.source          = source
+    result.url_s3          = s3_object.public_url
+    result.url_cloud_front = get_cloud_front_url(result.url_s3)
+
+    result
+  end
+
+  public
+  def delete_file_from_s3_by_uri(bucket_name, url)
+    bucket_name ||= BUCKET_NAME_DEFAULT
+
+    key = get_key_from_url(url, bucket_name)
+
+    delete_file_from_s3(bucket_name, key)
+  end
+
+  # remove file from s3
+  public
+  def delete_file_from_s3(bucket_name, key)
+    bucket_name ||= BUCKET_NAME_DEFAULT
+
+    return unless check_s3_object_exists(key, bucket_name)
+
+    s3_object = @s3_resources.bucket(bucket_name).object(key)
+
+    s3_object.delete
+
+    nil
+  end
+
+
+  #
+  # CloudFront
+  #
+
+  public
+  def get_cloud_front_url(url, use_ssl = true)
+    result = url.sub URI.parse(url).host, DOMAIN_NAME_CLOUD_FRONT
+
+    if use_ssl
+      result.sub! 'http:/', 'https:/'
+    else
+      result.sub! 'https:/', 'http:/'
+    end
+
+    result
+  end
+
+
+  public
+  def get_distribution_id_by(bucket_name = BUCKET_NAME_DEFAULT)
+    result = nil
+
+    response = @cloud_front.list_distributions
+
+    list_distributions = response[:items]
+
+    list_distributions.each do |distribution|
+      origin_settings    = distribution[:origins]
+      origin_item_first  = origin_settings[:items].first
+      origin_domain_name = origin_item_first[:domain_name]
+      origin_name        = origin_domain_name.split('.s3.').first
+
+      if origin_name == bucket_name
+        result = distribution[:id]
+        break
+      end
+    end
+
+    result
+  end
+
+  public
+  def invalidate_distribution(distribution_id, keys)
+
+    assert(!distribution_id.nil?, 'aws:invalidate_distribution. distribution_id must be non nil')
+    assert(keys.is_a?(Array), 'aws:invalidate_distribution. distribution_id must be non nil')
+
+    keys = keys.map do |k|
+      k.start_with?('/') ? k : '/' + k
+    end
+
+    paths            = {}
+    paths[:items]    = keys
+    paths[:quantity] = keys.size
+
+    invalidation_batch                    = {}
+    invalidation_batch[:caller_reference] = Time.now.to_i.to_s
+    invalidation_batch[:paths]            = paths
+
+    options                      = {}
+    options[:distribution_id]    = distribution_id
+    options[:invalidation_batch] = invalidation_batch
+
+    response = @cloud_front.create_invalidation(options)
+  end
+
+  public
+  def get_s3_url(url, bucket_name = BUCKET_NAME_DEFAULT)
+    result = url.sub URI.parse(url).host, "#{bucket_name}.#{DOMAIN_NAME_S3}"
+
+    result.sub! 'http:/', 'https:/'
+
+    result
+  end
+
+  public
+  def check_s3_object_exists(url, bucket_name = BUCKET_NAME_DEFAULT)
+
+    key = get_key_from_url(url, bucket_name)
+
+    s3_object = @s3_resources.bucket(bucket_name).object(key)
+
+    s3_object.exists?
+  end
+
+  private
+  def get_key_from_url(url, bucket_name = nil)
+    bucket_name ||= BUCKET_NAME_DEFAULT
+
+    URI(url).path.gsub(bucket_name, '').gsub(/\/+/, '/').gsub(/^\/+/, '')
+  end
+
+end

data/lib/mrpin/core/uploaders/carrierwave/file_uploader.rb

@@ -0,0 +1,7 @@
+# encoding: utf-8
+
+class FileUploader < CarrierWave::Uploader::Base
+
+  storage :file
+
+end

data/lib/mrpin/core/uploaders/carrierwave/file_uploader_helpers_base.rb

@@ -0,0 +1,66 @@
+#todo: fix extension
+module FileUploaderHelpersBase
+
+  #
+  # properties
+  #
+
+  # key - url field
+  # value - uploader field
+  protected
+  def url_uploaders_map
+    {}
+  end
+
+  #
+  # methods
+  #
+
+  protected
+  def delete_uploaded_files
+  end
+
+  protected
+  def try_update_uploaded_files
+  end
+
+  protected
+  def delete_uploaded_files_if_error
+    if self.new_record? && !errors.empty?
+
+      delete_uploaded_files
+
+      url_uploaders_map.each_key do |url_field|
+        self.send("#{url_field}=", nil)
+      end
+
+    end
+  end
+
+  #
+  # commons methods
+  #
+
+  protected
+  def get_upload_file_name(url_field, file_path)
+    result = "#{self.id.to_s}_#{url_field}_#{Time.now.to_i}"
+
+    extension = File.extname file_path
+
+    unless extension.nil?
+      result += extension.downcase
+    end
+
+    result
+  end
+
+  private
+  def upload_file_full_path(url_field)
+    game_name = AppInfo.instance.server_name
+    path      = upload_file_path(url_field)
+
+    File.join(game_name, path)
+  end
+
+
+end

data/lib/mrpin/core/uploaders/carrierwave/file_uploader_helpers_local.rb

@@ -0,0 +1,111 @@
+module FileUploaderHelpersLocal
+
+  extend ActiveSupport::Concern
+
+  included do
+    after_destroy :delete_uploaded_files
+    before_validation :try_update_uploaded_files
+    after_validation :delete_uploaded_files_if_error
+  end
+
+  include FileUploaderHelpersBase
+
+  #
+  # properties
+  #
+
+  #
+  # methods
+  #
+
+  # default constructor
+  protected
+  def try_update_uploaded_files
+    url_uploaders_map.each do |url_field, uploader_field|
+
+      next unless self.send(uploader_field).present?
+
+      begin
+        file_to_upload = self.send(uploader_field).file.file.to_s
+
+        # delete old file if was uploaded
+        old_url        = self.send(url_field)
+
+        delete_file_local(old_url)
+
+        # upload new file
+        path = upload_file_full_path(url_field)
+        name = get_upload_file_name(url_field, file_to_upload)
+
+        file_path = File.join(path, name)
+
+        file_path_local = UtilsIO.to_local_path(file_path)
+
+        upload_file(url_field, file_to_upload, file_path_local)
+
+      rescue Exception => e
+        errors[:base] << e.to_s
+      ensure
+        file_path = File.dirname(file_to_upload)
+
+        FileUtils.rm_rf(file_path) if File.exists?(file_path)
+      end
+
+    end
+
+    nil
+  end
+
+  private
+  def upload_file(url_field, file_to_upload, file_path_local)
+    file_dir = File.dirname(file_path_local)
+
+    FileUtils.mkdir_p(file_dir)
+
+    FileUtils.copy(file_to_upload, file_path_local)
+
+    file_path_domain = UtilsIO.to_domain_path(file_path_local)
+
+    self.send("#{url_field}=", file_path_domain)
+
+    nil
+  end
+
+
+  protected
+  def get_upload_file_name(url_field, file_path)
+    file_name = File.basename(file_path)
+
+    result = "#{file_name}_#{url_field}_#{Time.now.to_i}"
+
+    extension = File.extname file_path
+
+    unless extension.nil?
+      result += extension.downcase
+    end
+
+    result
+  end
+
+  protected
+  def delete_uploaded_files
+    url_uploaders_map.each do |url_field, uploader_field|
+      url = self.send(url_field)
+      delete_file_local(url)
+    end
+
+    nil
+  end
+
+  private
+  def delete_file_local(url)
+    return if url.nil? || url.blank?
+
+    local_path = UtilsIO.to_local_path(url)
+
+    FileUtils.rm_rf(local_path) if File.exists?(local_path)
+
+    nil
+  end
+
+end

data/lib/mrpin/core/uploaders/carrierwave/file_uploader_helpers_s3.rb

@@ -0,0 +1,87 @@
+module FileUploaderHelpersS3
+
+  extend ActiveSupport::Concern
+
+  included do
+    after_destroy :delete_uploaded_files
+    before_validation :try_update_uploaded_files
+    after_validation :delete_uploaded_files_if_error
+  end
+
+  include FileUploaderHelpersBase
+
+  #
+  # Properties
+  #
+
+
+
+
+  protected
+  def upload_file_path(url_field)
+    assert(false, 'Please override')
+  end
+
+  private
+  def aws_uploader
+    @aws_uploader ||= AppInfo.instance.aws_uploader
+  end
+
+
+  #
+  # Methods
+  #
+
+  protected
+  def try_update_uploaded_files
+    url_uploaders_map.each do |url_field, uploader_field|
+
+      next unless self.send(uploader_field).present?
+
+      begin
+        file_to_upload = self.send(uploader_field).file.file.to_s
+
+        # delete old file if was uploaded
+        old_url        = self.send(url_field)
+
+        delete_file_from_s3(old_url)
+
+        # upload new file
+        path = upload_file_full_path(url_field)
+        name = get_upload_file_name(url_field, file_to_upload)
+
+        s3_key = File.join(path, name)
+
+        s3_file_info = aws_uploader.upload_file_to_s3(file_to_upload, AWSUploader::BUCKET_NAME_DEFAULT, s3_key)
+
+        self.send("#{url_field}=", s3_file_info.url_cloud_front)
+
+      rescue Exception => e
+        errors[:base] << e.to_s
+
+      ensure
+        file_path = File.dirname(file_to_upload)
+
+        FileUtils.rm_rf(file_path) if File.exists?(file_path)
+      end
+
+    end
+  end
+
+  protected
+  def delete_uploaded_files
+    url_uploaders_map.each do |url_field, uploader_field|
+      url = self.send(url_field)
+      delete_file_from_s3(url)
+    end
+  end
+
+  private
+  def delete_file_from_s3(url)
+    unless url.nil? || url.blank?
+      s3_url = aws_uploader.get_s3_url(url)
+      aws_uploader.delete_file_from_s3_by_uri(AWSUploader::BUCKET_NAME_DEFAULT, s3_url)
+    end
+  end
+
+end

data/lib/mrpin/core/uploaders/carrierwave/zip_uploader.rb

@@ -0,0 +1,10 @@
+# encoding: utf-8
+
+class ZipUploader < CarrierWave::Uploader::Base
+
+  storage :file
+
+  def extension_white_list
+    %w(zip)
+  end
+end

data/lib/mrpin/core/utils/mongo.rb

@@ -0,0 +1,41 @@
+module Utils
+  module Mongo
+
+    class << self
+
+      def create_capped_collection(collection, size, max = 10_000_000)
+        Mongoid::Clients.default.command(create: collection, capped: true, size: size, max: max)
+      end
+
+      def get_collection_stats(collection)
+        Mongoid::Clients.default.command(collStats: collection) rescue nil
+      end
+
+      def get_database_stats
+        Mongoid::Clients.default.command(dbStats: 1) rescue nil
+      end
+
+      def get_collection_storage_size(collection)
+        get_collection_stats_property(collection, 'storageSize')
+      end
+
+      def get_collection_data_size(collection)
+        get_collection_stats_property(collection, 'size')
+      end
+
+      def get_collection_stats_property(collection, property)
+        result = nil
+
+        stats = get_collection_stats(collection)
+
+        if !stats.nil? && !stats.first.nil?
+          result = stats.first[property]
+        end
+
+        result
+      end
+
+    end
+
+  end
+end