httpimagestore 1.8.1 → 1.9.0

data/lib/httpimagestore/configuration/handler/source_store_base.rb

@@ -0,0 +1,37 @@
+require 'httpimagestore/configuration/handler/statement'
+
+module Configuration
+	class SourceStoreBase < HandlerStatement
+		include ImageName
+		include ConditionalInclusion
+		include LocalConfiguration
+		include GlobalConfiguration
+		include PathSpec
+
+		def initialize(global, image_name, path_spec)
+			with_global_configuration(global)
+			with_image_name(image_name)
+			with_path_spec(path_spec)
+		end
+
+		private
+
+		def put_sourced_named_image(request_state)
+			rendered_path = path_template.render(request_state.with_locals(local_configuration))
+
+			image = yield @image_name, rendered_path
+
+			image.source_path = rendered_path
+			request_state.images[@image_name] = image
+		end
+
+		def get_named_image_for_storage(request_state)
+			image = request_state.images[@image_name]
+			rendered_path = path_template.render(request_state.with_locals(local_configuration))
+			image.store_path = rendered_path
+
+			yield @image_name, image, rendered_path
+		end
+	end
+end
+

data/lib/httpimagestore/configuration/handler/statement.rb

@@ -0,0 +1,114 @@
+require 'httpimagestore/configuration'
+require 'httpimagestore/configuration/handler'
+
+module Configuration
+	class HandlerStatement < Scope
+		# Base class for all statements that are within get/post/put/delete handler
+		#
+		module LocalConfiguration
+			attr_reader :local_configuration
+			def config_local(name, value)
+				@local_configuration ||= {}
+				@local_configuration[name] = value
+			end
+		end
+
+		module ImageName
+			attr_reader :image_name
+
+			def with_image_name(image_name)
+				@image_name = image_name
+				config_local :imagename, @image_name # deprecated
+				config_local :image_name, @image_name
+				self
+			end
+		end
+
+		module GlobalConfiguration
+			attr_reader :global
+			def with_global_configuration(global)
+				@global = global
+			end
+
+			def path_template(path_spec)
+				@global.paths[path_spec]
+			end
+		end
+
+		module PathSpec
+			attr_reader :path_spec
+
+			def with_path_spec(path_spec)
+				@path_spec = path_spec
+				self
+			end
+
+			# this is more specific than GlobalConfiguration
+			def path_template
+				@global.paths[@path_spec]
+			end
+		end
+
+		module ConditionalInclusion
+			class ImageNameOn
+				def initialize(template)
+					@template = template.to_template
+				end
+
+				def included?(request_state)
+					image_name = request_state[:image_name]
+					@template.render(request_state).split(',').include? image_name
+				end
+			end
+
+			class VariableMatches
+				def initialize(value)
+					param_name, template = value.split(':', 2)
+					@param_name = param_name.to_sym if param_name
+					@template = template.to_template if template
+				end
+
+				def included?(request_state)
+					return false if not @param_name
+					return !request_state[@param_name].empty? if not @template
+					@template.render(request_state) == request_state[@param_name]
+				rescue Configuration::VariableNotDefinedError
+					false
+				end
+			end
+
+			def self.grab_conditions_with_remaining(attributes)
+				conditions = []
+				attributes = attributes.dup
+
+				if_image_name_on = attributes.delete('if-image-name-on')
+				conditions << ConditionalInclusion::ImageNameOn.new(if_image_name_on) if if_image_name_on
+
+				if_image_name_on = attributes.delete('if-variable-matches')
+				conditions << ConditionalInclusion::VariableMatches.new(if_image_name_on) if if_image_name_on
+
+				[conditions, attributes]
+			end
+
+			def with_conditions(conditions)
+				@conditions ||= []
+				@conditions.push(*conditions)
+				self
+			end
+
+			def included?(request_state)
+				return true if not @conditions or @conditions.empty?
+				# some conditions may use local_configuration vars
+				request_state = request_state.with_locals(local_configuration) if @local_configuration
+				@conditions.all? do |matcher|
+					matcher.included?(request_state)
+				end
+			end
+
+			def excluded?(request_state)
+				not included? request_state
+			end
+		end
+	end
+end
+

data/lib/httpimagestore/configuration/identify.rb

@@ -5,6 +5,11 @@ require 'httpimagestore/configuration/handler'
 module Configuration
 	class Identify < HandlerStatement
 		include ClassLogging
+		include ImageName
+		include LocalConfiguration
+		include GlobalConfiguration
+		include ConditionalInclusion
+		include PerfStats
 
 		extend Stats
 		def_stats(
@@ -18,18 +23,19 @@ module Configuration
 
 		def self.parse(configuration, node)
 			image_name = node.grab_values('image name').first
-			if_image_name_on = node.grab_attributes('if-image-name-on').first
 
-			matcher = InclusionMatcher.new(image_name, if_image_name_on) if if_image_name_on
+			conditions, remaining = *ConditionalInclusion.grab_conditions_with_remaining(node.attributes)
+			remaining.empty? or raise UnexpectedAttributesError.new(node, remaining)
 
-			configuration.processors << self.new(configuration.global, image_name, matcher)
-		end
+			iden = self.new(configuration.global, image_name)
+			iden.with_conditions(conditions)
 
-		include ImageName
-		include ConditionalInclusion
+			configuration.processors << iden
+		end
 
-		def initialize(global, image_name, matcher = nil)
-			super(global, image_name, matcher)
+		def initialize(global, image_name)
+			with_global_configuration(global)
+			with_image_name(image_name)
 		end
 
 		def realize(request_state)
@@ -41,7 +47,9 @@ module Configuration
 			Identify.stats.incr_total_identify_requests
 			Identify.stats.incr_total_identify_requests_bytes image.data.bytesize
 
-			id = client.with_headers(request_state.headers).identify(image.data)
+			id = measure "identifying", @image_name do
+				client.with_headers(request_state.forward_headers).identify(image.data)
+			end
 
 			image.mime_type = id.mime_type if id.mime_type
 			image.width = id.width if id.width

data/lib/httpimagestore/configuration/output.rb

@@ -1,4 +1,4 @@
-require 'httpimagestore/configuration/handler'
+require 'httpimagestore/configuration/handler/statement'
 require 'httpimagestore/ruby_string_template'
 require 'addressable/uri'
 require 'base64'
@@ -16,61 +16,18 @@ module Configuration
 		end
 	end
 
-	class OutputText
-		def self.match(node)
-			node.name == 'output_text'
-		end
-
-		def self.parse(configuration, node)
-			configuration.output and raise StatementCollisionError.new(node, 'output')
-			text = node.grab_values('text').first
-			status, cache_control = *node.grab_attributes('status', 'cache-control')
-			configuration.output = OutputText.new(text, status || 200, cache_control)
-		end
-
-		def initialize(text, status, cache_control)
-			@text = RubyStringTemplate.new(text || fail("no text?!"))
-			@status = status || 200
-			@cache_control = cache_control
-		end
-
-		def realize(request_state)
-			# make sure variables are available in request context
-			status = @status
-			text = @text.render(request_state)
-			cache_control = @cache_control
-			request_state.output do
-				res['Cache-Control'] = cache_control if cache_control
-				write_plain status.to_i, text.to_s
-			end
-		end
-	end
-
-	class OutputOK < OutputText
-		def self.match(node)
-			node.name == 'output_ok'
-		end
-
-		def self.parse(configuration, node)
-			configuration.output and raise StatementCollisionError.new(node, 'output')
-			cache_control = node.grab_attributes('cache-control').first
-			configuration.output = OutputOK.new(cache_control)
-		end
-
-		def initialize(cache_control = nil)
-			super 'OK', 200, cache_control
-		end
-	end
-	Handler::register_node_parser OutputText
-
 	class OutputMultiBase
 		class OutputSpec < HandlerStatement
+			include GlobalConfiguration
 			include ImageName
 			include PathSpec
 			include ConditionalInclusion
+			include LocalConfiguration
 
-			def initialize(global, image_name, scheme, host, port, path_spec, matcher)
-				super(global, image_name, path_spec, matcher)
+			def initialize(global, image_name, scheme, host, port, path_spec)
+				with_global_configuration(global)
+				with_image_name(image_name)
+				with_path_spec(path_spec)
 				@scheme = scheme && scheme.to_template
 				@host = host && host.to_template
 				@port = port && port.to_template
@@ -80,7 +37,7 @@ module Configuration
 				store_path = request_state.images[@image_name].store_path or raise StorePathNotSetForImage.new(@image_name)
 				return store_path unless @path_spec
 
-				path_template.render(request_state.with_locals(config_locals, path: store_path))
+				path_template.render(request_state.with_locals(local_configuration, path: store_path))
 			end
 
 			def store_url(request_state)
@@ -96,7 +53,7 @@ module Configuration
 				request_locals[:host] = url.host if url.host
 				request_locals[:port] = url.port if url.port
 
-				request_state = request_state.with_locals(config_locals, request_locals)
+				request_state = request_state.with_locals(local_configuration, request_locals)
 
 				# optional rewrites
 				url.scheme = @scheme.render(request_state) if @scheme
@@ -112,9 +69,13 @@ module Configuration
 			nodes = node.values.empty? ? node.children : [node]
 			output_specs = nodes.map do |node|
 				image_name = node.grab_values('image name').first
-				scheme, host, port, path_spec, if_image_name_on = *node.grab_attributes('scheme', 'host', 'port', 'path', 'if-image-name-on')
-				matcher = InclusionMatcher.new(image_name, if_image_name_on)
-				OutputSpec.new(configuration.global, image_name, scheme, host, port, path_spec, matcher)
+				scheme, host, port, path_spec, remaining = *node.grab_attributes_with_remaining('scheme', 'host', 'port', 'path')
+				conditions, remaining = *HandlerStatement::ConditionalInclusion.grab_conditions_with_remaining(remaining)
+				remaining.empty? or raise UnexpectedAttributesError.new(node, remaining)
+
+				out = OutputSpec.new(configuration.global, image_name, scheme, host, port, path_spec)
+				out.with_conditions(conditions)
+				out
 			end
 
 			configuration.output and raise StatementCollisionError.new(node, 'output')
@@ -125,10 +86,12 @@ module Configuration
 			@output_specs = output_specs
 		end
 	end
-	Handler::register_node_parser OutputOK
 
-	class OutputImage
+	class OutputImage < HandlerStatement
 		include ClassLogging
+		include ImageName
+		include LocalConfiguration
+		include PerfStats
 
 		def self.match(node)
 			node.name == 'output_image'
@@ -144,6 +107,7 @@ module Configuration
 		def initialize(name, cache_control)
 			@name = name
 			@cache_control = cache_control
+			with_image_name(name)
 		end
 
 		def realize(request_state)
@@ -157,15 +121,20 @@ module Configuration
 				end
 
 			cache_control = @cache_control
+			_context = self
 			request_state.output do
-				res['Cache-Control'] = cache_control if cache_control
-				write 200, mime_type, image.data
+				_context.measure "sending response image data", "mime type: #{mime_type} (image #{image.data.bytesize} bytes)" do
+					res['Cache-Control'] = cache_control if cache_control
+					write 200, mime_type, image.data
+				end
 			end
 		end
 	end
 	Handler::register_node_parser OutputImage
 
 	class OutputDataURIImage < OutputImage
+		include PerfStats
+
 		def self.match(node)
 			node.name == 'output_data_uri_image'
 		end
@@ -175,9 +144,12 @@ module Configuration
 			fail "image '#{@name}' needs to be identified first to be used in data URI output" unless image.mime_type
 
 			cache_control = @cache_control
+			_context = self
 			request_state.output do
-				res['Cache-Control'] = cache_control if cache_control
-				write 200, 'text/uri-list', "data:#{image.mime_type};base64,#{Base64.strict_encode64(image.data)}"
+				_context.measure "sending response image data with data URI encoding", "mime type: #{image.mime_type} (image #{image.data.bytesize} bytes)" do
+					res['Cache-Control'] = cache_control if cache_control
+					write 200, 'text/uri-list', "data:#{image.mime_type};base64,#{Base64.strict_encode64(image.data)}"
+				end
 			end
 		end
 	end

data/lib/httpimagestore/configuration/path.rb

@@ -15,7 +15,7 @@ module Configuration
 		end
 	end
 
-	class NoValueForPathTemplatePlaceholerError < PathRenderingError
+	class NoValueForPathTemplatePlaceholderError < PathRenderingError
 		def initialize(path_name, template, placeholder)
 			super path_name, template, "no value for '\#{#{placeholder}}'"
 		end
@@ -56,7 +56,7 @@ module Configuration
 					locals[name]
 				rescue ConfigurationError => error
 					raise PathRenderingError.new(path_name, template, error.message)
-				end or raise NoValueForPathTemplatePlaceholerError.new(path_name, template, name)
+				end or raise NoValueForPathTemplatePlaceholderError.new(path_name, template, name)
 			end
 		end
 

data/lib/httpimagestore/configuration/request_state.rb

@@ -0,0 +1,131 @@
+require 'mime/types'
+require 'digest/sha2'
+require 'securerandom'
+
+module Configuration
+	class RequestState < Hash
+		include ClassLogging
+
+		class Images < Hash
+			def initialize(memory_limit)
+				@memory_limit = memory_limit
+				super
+			end
+
+			def []=(name, image)
+				if member?(name)
+					@memory_limit.return fetch(name).data.bytesize
+				end
+				super
+			end
+
+			def [](name)
+				fetch(name){|image_name| raise ImageNotLoadedError.new(image_name)}
+			end
+		end
+
+		def initialize(body, matches, path, query_string, request_uri, request_headers, memory_limit, forward_headers)
+			super() do |request_state, name|
+				# note that request_state may be different object when useing with_locals that creates duplicate
+				request_state[name] = request_state.generate_meta_variable(name) or raise VariableNotDefinedError.new(name)
+			end
+
+			# it is OK to overwrite path with a match
+			self[:path] = path
+
+			merge! matches
+
+			log.debug "processing request with body length: #{body.bytesize} bytes and variables: #{map{|k,v| "#{k}: '#{v}'"}.join(', ')}"
+
+			@body = body
+			@images = Images.new(memory_limit)
+			@query_string = query_string
+			@request_uri = request_uri
+			@request_headers = request_headers
+			@memory_limit = memory_limit
+			@output_callback = nil
+
+			@forward_headers = forward_headers
+		end
+
+		attr_reader :body
+		attr_reader :images
+		attr_reader :memory_limit
+		attr_reader :query_string
+		attr_reader :request_uri
+		attr_reader :request_headers
+		attr_reader :forward_headers
+
+		def with_locals(*locals)
+			locals = locals.reduce{|a, b| a.merge(b)}
+			log.debug "using additional local variables: #{locals}"
+			self.dup.merge!(locals)
+		end
+
+		def output(&callback)
+			@output_callback = callback
+		end
+
+		def output_callback
+			@output_callback or fail 'no output callback'
+		end
+
+		def fetch_base_variable(name, base_name)
+			fetch(base_name, nil) or generate_meta_variable(base_name) or raise NoVariableToGenerateMetaVariableError.new(base_name, name)
+		end
+
+		def generate_meta_variable(name)
+			val = case name
+			when :basename
+				path = Pathname.new(fetch_base_variable(name, :path))
+				path.basename(path.extname).to_s
+			when :dirname
+				Pathname.new(fetch_base_variable(name, :path)).dirname.to_s
+			when :extension
+				Pathname.new(fetch_base_variable(name, :path)).extname.delete('.')
+			when :digest # deprecated
+				@body.empty? and raise NoRequestBodyToGenerateMetaVariableError.new(name)
+				Digest::SHA2.new.update(@body).to_s[0,16]
+			when :input_digest
+				@body.empty? and raise NoRequestBodyToGenerateMetaVariableError.new(name)
+				Digest::SHA2.new.update(@body).to_s[0,16]
+			when :input_sha256
+				@body.empty? and raise NoRequestBodyToGenerateMetaVariableError.new(name)
+				Digest::SHA2.new.update(@body).to_s
+			when :input_image_width
+				@images['input'].width or raise NoImageDataForVariableError.new('input', name)
+			when :input_image_height
+				@images['input'].height or raise NoImageDataForVariableError.new('input', name)
+			when :input_image_mime_extension
+				@images['input'].mime_extension or raise NoImageDataForVariableError.new('input', name)
+			when :image_digest
+				Digest::SHA2.new.update(@images[fetch_base_variable(name, :image_name)].data).to_s[0,16]
+			when :image_sha256
+				Digest::SHA2.new.update(@images[fetch_base_variable(name, :image_name)].data).to_s
+			when :mimeextension # deprecated
+				image_name = fetch_base_variable(name, :image_name)
+				@images[image_name].mime_extension or raise NoImageDataForVariableError.new(image_name, name)
+			when :image_mime_extension
+				image_name = fetch_base_variable(name, :image_name)
+				@images[image_name].mime_extension or raise NoImageDataForVariableError.new(image_name, name)
+			when :image_width
+				image_name = fetch_base_variable(name, :image_name)
+				@images[image_name].width or raise NoImageDataForVariableError.new(image_name, name)
+			when :image_height
+				image_name = fetch_base_variable(name, :image_name)
+				@images[image_name].height or raise NoImageDataForVariableError.new(image_name, name)
+			when :uuid
+				SecureRandom.uuid
+			when :query_string_options
+				query_string.sort.map{|kv| kv.join(':')}.join(',')
+			end
+			if val
+				log.debug  "generated meta variable '#{name}': #{val}"
+			else
+				log.debug  "could not generated meta variable '#{name}'"
+			end
+			val
+		end
+	end
+end
+