discourse/app/models/optimized_image.rb

377 lines
10 KiB
Ruby
Raw Normal View History

# frozen_string_literal: true
2013-06-16 04:39:48 -04:00
class OptimizedImage < ActiveRecord::Base
include HasUrl
2013-06-16 04:39:48 -04:00
belongs_to :upload
# BUMP UP if optimized image algorithm changes
VERSION = 2
URL_REGEX ||= /(\/optimized\/\dX[\/\.\w]*\/([a-zA-Z0-9]+)[\.\w]*)/
def self.lock(upload_id, width, height)
@hostname ||= `hostname`.strip rescue "unknown"
# note, the extra lock here ensures we only optimize one image per machine on webs
# this can very easily lead to runaway CPU so slowing it down is beneficial and it is hijacked
#
# we can not afford this blocking in Sidekiq cause it can lead to starvation
if Sidekiq.server?
DistributedMutex.synchronize("optimized_image_#{upload_id}_#{width}_#{height}") do
yield
end
else
DistributedMutex.synchronize("optimized_image_host_#{@hostname}") do
DistributedMutex.synchronize("optimized_image_#{upload_id}_#{width}_#{height}") do
yield
end
end
end
end
2017-07-27 21:20:09 -04:00
def self.create_for(upload, width, height, opts = {})
2013-11-05 13:04:47 -05:00
return unless width > 0 && height > 0
return if upload.try(:sha1).blank?
2013-07-07 19:39:08 -04:00
# no extension so try to guess it
if (!upload.extension)
upload.fix_image_extension
end
if !upload.extension.match?(IM_DECODERS) && upload.extension != "svg"
if !opts[:raise_on_error]
# nothing to do ... bad extension, not an image
return
else
raise InvalidAccess
end
end
# prefer to look up the thumbnail without grabbing any locks
thumbnail = find_by(upload_id: upload.id, width: width, height: height)
# correct bad thumbnail if needed
if thumbnail && (thumbnail.url.blank? || thumbnail.version != VERSION)
thumbnail.destroy!
thumbnail = nil
end
return thumbnail if thumbnail
lock(upload.id, width, height) do
# may have been generated since we got the lock
thumbnail = find_by(upload_id: upload.id, width: width, height: height)
# return the previous thumbnail if any
return thumbnail if thumbnail
# create the thumbnail otherwise
original_path = Discourse.store.path_for(upload)
if original_path.blank?
external_copy = Discourse.store.download(upload) rescue nil
original_path = external_copy.try(:path)
2015-02-03 12:44:18 -05:00
end
if original_path.blank?
Rails.logger.error("Could not find file in the store located at url: #{upload.url}")
else
# create a temp file with the same extension as the original
extension = ".#{opts[:format] || upload.extension}"
if extension.length == 1
return nil
end
temp_file = Tempfile.new(["discourse-thumbnail", extension])
temp_path = temp_file.path
if upload.extension == "svg"
FileUtils.cp(original_path, temp_path)
resized = true
elsif opts[:crop]
resized = crop(original_path, temp_path, width, height, opts)
2013-11-05 13:04:47 -05:00
else
resized = resize(original_path, temp_path, width, height, opts)
2013-11-05 13:04:47 -05:00
end
if resized
thumbnail = OptimizedImage.create!(
upload_id: upload.id,
sha1: Upload.generate_digest(temp_path),
extension: extension,
width: width,
height: height,
url: "",
filesize: File.size(temp_path),
version: VERSION
)
# store the optimized image and update its url
File.open(temp_path) do |file|
url = Discourse.store.store_optimized_image(file, thumbnail)
if url.present?
thumbnail.url = url
thumbnail.save
end
end
end
# close && remove temp file
temp_file.close!
2013-11-05 13:04:47 -05:00
end
# make sure we remove the cached copy from external stores
if Discourse.store.external?
external_copy&.close
end
thumbnail
end
2013-06-16 19:00:25 -04:00
end
def destroy
OptimizedImage.transaction do
Discourse.store.remove_optimized_image(self) if self.upload
super
end
end
def local?
2017-07-27 21:20:09 -04:00
!(url =~ /^(https?:)?\/\//)
end
def calculate_filesize
path =
if local?
Discourse.store.path_for(self)
else
Discourse.store.download(self).path
end
File.size(path)
end
def filesize
if size = read_attribute(:filesize)
size
else
# we may have a bad optimized image so just skip for now
# and do not break here
size = calculate_filesize rescue nil
write_attribute(:filesize, size)
if !new_record?
update_columns(filesize: size)
end
size
end
end
def self.safe_path?(path)
# this matches instructions which call #to_s
path = path.to_s
return false if path != File.expand_path(path)
return false if path !~ /\A[\w\-\.\/]+\z/m
true
end
def self.ensure_safe_paths!(*paths)
paths.each do |path|
raise Discourse::InvalidAccess unless safe_path?(path)
end
end
IM_DECODERS ||= /\A(jpe?g|png|ico|gif)\z/i
def self.prepend_decoder!(path, ext_path = nil, opts = nil)
2018-12-18 14:55:09 -05:00
opts ||= {}
# This logic is a little messy but the result of using mocks for most
# of the image tests. The idea here is you shouldn't trust the "original"
# path of a file to figure out its extension. However, in certain cases
# such as generating the loading upload thumbnail, we force the format,
# and this allows us to use the forced format in that case.
extension = nil
if (opts[:format] && path != ext_path)
extension = File.extname(path)[1..-1]
else
extension = File.extname(opts[:filename] || ext_path || path)[1..-1]
end
raise Discourse::InvalidAccess if !extension || !extension.match?(IM_DECODERS)
"#{extension}:#{path}"
end
def self.thumbnail_or_resize
SiteSetting.strip_image_metadata ? "thumbnail" : "resize"
end
2017-07-27 21:20:09 -04:00
def self.resize_instructions(from, to, dimensions, opts = {})
ensure_safe_paths!(from, to)
# note FROM my not be named correctly
from = prepend_decoder!(from, to, opts)
to = prepend_decoder!(to, to, opts)
instructions = ['convert', "#{from}[0]"]
if opts[:colors]
instructions << "-colors" << opts[:colors].to_s
end
# NOTE: ORDER is important!
instructions.concat(%W{
-auto-orient
-gravity center
-background transparent
-#{thumbnail_or_resize} #{dimensions}^
-extent #{dimensions}
2018-07-17 03:48:59 -04:00
-interpolate catrom
-unsharp 2x0.5+0.7+0
-interlace none
-quality 98
-profile #{File.join(Rails.root, 'vendor', 'data', 'RT_sRGB.icm')}
#{to}
})
2015-02-20 11:24:37 -05:00
end
2017-07-27 21:20:09 -04:00
def self.resize_instructions_animated(from, to, dimensions, opts = {})
ensure_safe_paths!(from, to)
%W{
gifsicle
--colors=#{opts[:colors] || 256}
--resize-fit #{dimensions}
--optimize=3
--output #{to}
2016-07-27 12:48:02 -04:00
#{from}
}
end
2017-07-27 21:20:09 -04:00
def self.crop_instructions(from, to, dimensions, opts = {})
ensure_safe_paths!(from, to)
from = prepend_decoder!(from, to, opts)
to = prepend_decoder!(to, to, opts)
%W{
convert
#{from}[0]
-auto-orient
-gravity north
-background transparent
-#{thumbnail_or_resize} #{opts[:width]}
-crop #{dimensions}+0+0
-unsharp 2x0.5+0.7+0
-interlace none
-quality 98
-profile #{File.join(Rails.root, 'vendor', 'data', 'RT_sRGB.icm')}
#{to}
}
end
2017-07-27 21:20:09 -04:00
def self.crop_instructions_animated(from, to, dimensions, opts = {})
ensure_safe_paths!(from, to)
2016-07-27 12:48:02 -04:00
%W{
gifsicle
--crop 0,0+#{dimensions}
--colors=#{opts[:colors] || 256}
2016-07-27 12:48:02 -04:00
--optimize=3
--output #{to}
#{from}
}
end
2017-07-27 21:20:09 -04:00
def self.downsize_instructions(from, to, dimensions, opts = {})
ensure_safe_paths!(from, to)
from = prepend_decoder!(from, to, opts)
to = prepend_decoder!(to, to, opts)
%W{
convert
#{from}[0]
-auto-orient
-gravity center
-background transparent
-interlace none
-resize #{dimensions}
-profile #{File.join(Rails.root, 'vendor', 'data', 'RT_sRGB.icm')}
#{to}
}
end
2017-07-27 21:20:09 -04:00
def self.downsize_instructions_animated(from, to, dimensions, opts = {})
resize_instructions_animated(from, to, dimensions, opts)
end
2017-07-27 21:20:09 -04:00
def self.resize(from, to, width, height, opts = {})
optimize("resize", from, to, "#{width}x#{height}", opts)
2015-02-20 11:24:37 -05:00
end
2017-07-27 21:20:09 -04:00
def self.crop(from, to, width, height, opts = {})
opts[:width] = width
optimize("crop", from, to, "#{width}x#{height}", opts)
end
2017-07-27 21:20:09 -04:00
def self.downsize(from, to, dimensions, opts = {})
optimize("downsize", from, to, dimensions, opts)
end
2017-07-27 21:20:09 -04:00
def self.optimize(operation, from, to, dimensions, opts = {})
method_name = "#{operation}_instructions"
2019-05-06 21:27:05 -04:00
if !!opts[:allow_animation] && (from =~ /\.GIF$/i)
method_name += "_animated"
end
2019-05-06 21:27:05 -04:00
instructions = self.public_send(method_name.to_sym, from, to, dimensions, opts)
2018-07-25 22:17:38 -04:00
convert_with(instructions, to, opts)
end
MAX_PNGQUANT_SIZE = 500_000
2018-07-25 22:17:38 -04:00
def self.convert_with(instructions, to, opts = {})
Discourse::Utils.execute_command("nice", "-n", "10", *instructions)
allow_pngquant = to.downcase.ends_with?(".png") && File.size(to) < MAX_PNGQUANT_SIZE
FileHelper.optimize_image!(to, allow_pngquant: allow_pngquant)
2015-02-20 11:24:37 -05:00
true
rescue => e
2018-07-25 22:17:38 -04:00
if opts[:raise_on_error]
raise e
else
error = +"Failed to optimize image:"
if e.message =~ /^convert:([^`]+)/
error << $1
else
error << " unknown reason"
end
Discourse.warn(error, location: to, error_message: e.message)
false
end
2015-02-20 11:24:37 -05:00
end
2013-06-16 04:39:48 -04:00
end
2013-06-16 20:48:58 -04:00
# == Schema Information
#
# Table name: optimized_images
#
# id :integer not null, primary key
# sha1 :string(40) not null
# extension :string(10) not null
2013-06-16 20:48:58 -04:00
# width :integer not null
# height :integer not null
# upload_id :integer not null
2019-01-11 14:29:56 -05:00
# url :string not null
# filesize :integer
2019-01-11 12:19:23 -05:00
# etag :string
# version :integer
2013-06-16 20:48:58 -04:00
#
# Indexes
#
2019-01-11 12:19:23 -05:00
# index_optimized_images_on_etag (etag)
2013-06-16 20:48:58 -04:00
# index_optimized_images_on_upload_id (upload_id)
# index_optimized_images_on_upload_id_and_width_and_height (upload_id,width,height) UNIQUE
#