scrivito_sdk 0.66.0 → 0.70.0.rc1

data/lib/scrivito/cms_backend.rb

@@ -60,6 +60,7 @@ module Scrivito
     def initialize
       @query_counter = 0
       @caching = true
+      @die_content_service = true
     end
 
     def begin_caching
@@ -88,7 +89,25 @@ module Scrivito
       @query_counter = 0
     end
 
-    def find_workspace_data_by_id(id)
+    def find_workspace_data_from_cache(id)
+      if die_content_service
+        cached_workspace_state = CmsDataCache.read_workspace_state(id)
+        cached_data_tag = cached_workspace_state.try(:second)
+        cached_content_state_id = cached_workspace_state.try(:first)
+
+        if cached_data_tag && cached_content_state_id
+          if raw_workspace_data = fetch_cached_data_by_tag(cached_data_tag)
+            build_workspace_data(raw_workspace_data, cached_content_state_id)
+          end
+        end
+      else
+        WorkspaceDataFromService.find_from_cache(id)
+      end
+    end
+
+    def find_workspace_data_by_id(id, timeout=nil)
+      options = timeout ? {timeout: timeout} : {}
+
       if die_content_service
         begin
           cached_workspace_state = CmsDataCache.read_workspace_state(id)
@@ -96,12 +115,12 @@ module Scrivito
           cached_csid = cached_workspace_state.try(:first)
           cached_workspace_data_tag = cached_workspace_state.try(:second)
 
-          changes = CmsRestApi.get("/workspaces/#{id}/changes", from: cached_csid)
+          changes = CmsRestApi.get("/workspaces/#{id}/changes", {from: cached_csid}, options)
 
           update_obj_cache(id, cached_csid, changes)
 
-          workspace_data, workspace_data_tag = update_workspace_cache(
-              id, cached_workspace_data_tag, changes["workspace"])
+          raw_workspace_data, workspace_data_tag = update_workspace_cache(
+              id, cached_workspace_data_tag, changes["workspace"], options)
 
           current_csid = changes["current"]
           current_workspace_state = [current_csid, workspace_data_tag]
@@ -110,8 +129,7 @@ module Scrivito
             CmsDataCache.write_workspace_state(id, current_workspace_state)
           end
 
-          return WorkspaceData.new(workspace_data.merge(
-              "content_state_id" => current_csid))
+          return build_workspace_data(raw_workspace_data, current_csid)
 
         rescue Scrivito::ClientError => client_error
           if client_error.http_code == 404
@@ -122,22 +140,13 @@ module Scrivito
         end
       end
 
-      workspace_data_from_cache = WorkspaceDataFromService.find_from_cache(id)
+      workspace_data_from_cache = find_workspace_data_from_cache(id)
       from_content_state_id = workspace_data_from_cache.try(:content_state_id)
 
       request_params = {:workspace_id => id}
       request_params[:content_state_id] = from_content_state_id if from_content_state_id
 
-      raw_data = if id == 'published' && workspace_data_from_cache
-        begin
-          ContentService.query('workspaces/query', request_params, timeout: 1)
-        rescue CommunicationError => e
-          warn_backend_not_available(id, from_content_state_id, e.message)
-          return workspace_data_from_cache
-        end
-      else
-        ContentService.query('workspaces/query', request_params)
-      end
+      raw_data = ContentService.query('workspaces/query', request_params, options)
 
       if raw_workspace_data = raw_data['workspace']
         workspace_data = WorkspaceDataFromService.new(raw_workspace_data)
@@ -200,6 +209,18 @@ module Scrivito
       end
     end
 
+    def find_binary_meta_data(blob_id)
+      blob_id = normalize_blob_id(blob_id)
+      cache_key = "binary_meta_data/#{blob_id}"
+      if meta_data = CmsDataCache.cache.read(cache_key)
+        meta_data
+      else
+        meta_data = CmsRestApi.get("blobs/#{blob_id}/meta_data")['meta_data']
+        CmsDataCache.cache.write(cache_key, meta_data)
+        meta_data
+      end
+    end
+
     def search_objs(workspace, params)
       cache_index = 'search'
       cache_key = params.to_param
@@ -213,7 +234,7 @@ module Scrivito
 
         result = request_search_result_from_backend(workspace, params)
 
-        cache.write_index(cache_index, cache_key, result)
+        cache.write_index_not_updatable(cache_index, cache_key, result)
 
         return result
       end
@@ -231,17 +252,15 @@ module Scrivito
 
     private
 
-    def update_workspace_cache(id, cached_data_tag, changed_workspace)
+    def update_workspace_cache(id, cached_data_tag, changed_workspace, options)
       if changed_workspace
         workspace_data = changed_workspace
       else
-        cached_workspace_data = CmsDataCache.read_data_from_tag(cached_data_tag)
-
-        if cached_workspace_data
+        if cached_workspace_data = fetch_cached_data_by_tag(cached_data_tag)
           workspace_data = cached_workspace_data
           workspace_data_tag = cached_data_tag
         else
-          workspace_data = CmsRestApi.get("/workspaces/#{id}")
+          workspace_data = CmsRestApi.get("/workspaces/#{id}", nil, options)
         end
       end
 
@@ -250,6 +269,14 @@ module Scrivito
       [workspace_data, workspace_data_tag]
     end
 
+    def fetch_cached_data_by_tag(data_tag)
+      data_tag && CmsDataCache.read_data_from_tag(data_tag)
+    end
+
+    def build_workspace_data(raw_data, content_state_id)
+      WorkspaceData.new(raw_data.merge('content_state_id' => content_state_id))
+    end
+
     def update_obj_cache(workspace_id, cached_csid, changes)
       objs = changes["objs"]
       if objs.present? && objs != "*"
@@ -302,7 +329,7 @@ module Scrivito
     end
 
     def normalize_blob_id(id)
-      Addressable::URI.normalize_component(id, Addressable::URI::CharacterClasses::UNRESERVED)
+      CmsRestApi.normalize_path_component(id)
     end
 
     def fetch_blob_metadata_from_cache(id)
@@ -422,15 +449,6 @@ module Scrivito
       raise ArgumentError, "invalid index name '#{index}'" unless VALID_INDEX_NAMES.include?(index)
     end
 
-    def warn_backend_not_available(workspace_id, content_state_id, error_message)
-      message = <<-EOS
-        Couldn't connect to content service for workspace with id=#{workspace_id} and content_state_id=#{content_state_id}.
-        #{error_message}
-        Serving from cache.
-      EOS
-      Rails.logger.warn(message)
-    end
-
   end
 
 end

data/lib/scrivito/cms_data_cache.rb

@@ -75,6 +75,7 @@ module CmsDataCache
     end
 
     def read_data_from_tag(tag)
+      raise ArgumentError, 'tag can not be nil' if tag.nil?
       read_tag_data(tag)
     end
 

data/lib/scrivito/cms_dispatch_controller.rb

@@ -18,7 +18,7 @@ module Scrivito
       end
 
       if obj_not_found? && editing_context.workspace_changed?
-        redirect_to scrivito_path(Obj.homepage)
+        redirect_to :scrivito_root
         return self.response
       end
 

data/lib/scrivito/cms_env.rb

@@ -33,17 +33,7 @@ module Scrivito
         elsif params[:permalink].present?
           self.class.find_permalink_by_param(params[:permalink])
         else
-          if callback = Scrivito::Configuration.choose_homepage_callback
-            callback_result = callback.call(env)
-            if callback_result.is_a?(Obj)
-              callback_result
-            else
-              raise "choose_homepage callback did not return an Obj. "\
-                "Instead saw #{callback_result.class}."
-            end
-          else
-            Obj.homepage
-          end
+          Scrivito::RequestHomepage.call(env)
         end
 
       found_obj

data/lib/scrivito/cms_field_tag.rb

@@ -1,6 +1,6 @@
 module Scrivito
 
-# this class is the server-side equivalent of the JavaScript class `cms_field_element`
+# This class is the server-side equivalent of the JavaScript +cms_field_element+ class.
 class CmsFieldTag < Struct.new(:view, :tag_name, :obj_or_widget, :editing_options)
   FIELD_TYPES_WITH_ORIGINAL_CONTENT = %w[
     binary
@@ -135,12 +135,15 @@ class CmsFieldTag < Struct.new(:view, :tag_name, :obj_or_widget, :editing_option
   end
 
   def original_content(field_type, field_value, raw_value)
-    case field_type
-    when 'binary'        then field_value && {}
-    when 'date'          then raw_value.try(:utc).try(:iso8601)
-    when 'reference'     then field_value.try(:id)
-    when 'referencelist' then field_value.map(&:id)
-    else field_value
+    if %w[
+      binary
+      date
+      reference
+      referencelist
+    ].include?(field_type)
+      ClientAttributeSerializer.serialize_custom_attr_value(field_type, raw_value)
+    else
+      ClientAttributeSerializer.serialize_custom_attr_value(field_type, field_value)
     end
   end
 

data/lib/scrivito/cms_rest_api/rate_limit.rb

@@ -2,21 +2,21 @@ module Scrivito
 class CmsRestApi
 module RateLimit
   class << self
-    def retry_on_rate_limit(try_until, &block)
-      internal_retry(block, try_until, 0)
+    def retry_on_rate_limit(request_timer, &block)
+      internal_retry(block, request_timer, 0)
     end
 
     private
 
-    def internal_retry(request_proc, try_until, retry_count)
+    def internal_retry(request_proc, request_timer, retry_count)
       response = request_proc.call
 
       if failed_because_of_rate_limit?(response)
         time_to_sleep = calculate_time_to_sleep(response['Retry-After'].to_f, retry_count)
 
-        if (Time.now + time_to_sleep.seconds) <= try_until
+        if request_timer.cover?(Time.now + time_to_sleep.seconds)
           sleep time_to_sleep
-          internal_retry(request_proc, try_until, retry_count + 1)
+          internal_retry(request_proc, request_timer, retry_count + 1)
         else
           raise Scrivito::RateLimitExceeded.new('rate limit exceeded', 429)
         end

data/lib/scrivito/cms_rest_api/request_timer.rb

@@ -0,0 +1,27 @@
+module Scrivito
+class CmsRestApi
+  class RequestTimer
+    MIN_REQUEST_TIME = 0.005
+
+    def initialize(max_duration)
+      @finish_before = Time.now + max_duration
+    end
+
+    def finished?
+      remaining_time <= MIN_REQUEST_TIME
+    end
+
+    def remaining_time
+      [finish_before - Time.now, 0].max
+    end
+
+    def cover?(point_in_time)
+      point_in_time <= finish_before
+    end
+
+    private
+
+    attr_reader :finish_before
+  end
+end
+end

data/lib/scrivito/cms_rest_api/widget_extractor.rb

@@ -2,9 +2,11 @@ module Scrivito
   class CmsRestApi
     class WidgetExtractor
 
-      # Extract widgets from a given attribute tree and return them as a flat
-      # hash of widget_like => updated_attributes
-      def self.call(updated_attributes, obj=nil)
+      # Extract widgets from a given attribute tree
+      # first return param: a flat hash of widget_like => updated widget attributes
+      # second return param: the updated attributes
+      def self.call(attributes, obj=nil)
+        updated_attributes = attributes.dup
         extracted_widgets = {}
 
         (updated_attributes.delete(:_widget_pool) || {}).each do |widget, widget_properties|
@@ -12,7 +14,7 @@ module Scrivito
             raise ScrivitoError, 'new top-level widgets are not allowed in the _widget_pool'
           end
           extracted_widgets[widget] = widget_properties
-          extracted_widgets.merge!(call(widget_properties, obj))
+          extracted_widgets.merge!(call(widget_properties, obj).first)
         end
 
         updated_attributes.each do |attribute_name, value|
@@ -21,13 +23,13 @@ module Scrivito
               unless widget.persisted?
                 attach_widget_to_obj(widget, obj)
                 extracted_widgets[widget] = widget.attributes_to_be_saved
-                extracted_widgets.merge!(call(widget.attributes_to_be_saved, obj))
+                extracted_widgets.merge!(call(widget.attributes_to_be_saved, obj).first)
               end
             end
           end
         end
 
-        extracted_widgets
+        return extracted_widgets, updated_attributes
       end
 
       def self.attach_widget_to_obj(widget, obj)

data/lib/scrivito/cms_rest_api.rb

@@ -32,27 +32,28 @@ module Scrivito
       :delete => Net::HTTP::Delete,
     }.freeze
 
-    MAX_RATE_LIMIT_RETRY_DURATION = 20.seconds.freeze
+    DEFAULT_TIMEOUT = 25.seconds.freeze
+    MAX_REQUEST_TIME = 10.seconds.freeze
 
-    def self.get(resource_path, payload = nil, options = nil)
+    def self.get(resource_path, payload = nil, options = {})
       request_cms_api(:get, resource_path, payload, options)
     end
 
-    def self.put(resource_path, payload, options = nil)
+    def self.put(resource_path, payload, options = {})
       request_cms_api(:put, resource_path, payload, options)
     end
 
-    def self.post(resource_path, payload, options = nil)
+    def self.post(resource_path, payload, options = {})
       request_cms_api(:post, resource_path, payload, options)
     end
 
-    def self.delete(resource_path, payload = nil, options = nil)
+    def self.delete(resource_path, payload = nil, options = {})
       request_cms_api(:delete, resource_path, payload, options)
     end
 
     def self.task_unaware_request(method, resource_path, payload = nil)
       raise "Unexpected method #{method}" unless [:delete, :get, :post, :put].include?(method)
-      response_for_request_cms_api(method, resource_path, payload)
+      response_for_request_cms_api(method, resource_path, payload, build_timer)
     end
 
     def self.count_requests(path)
@@ -63,21 +64,19 @@ module Scrivito
       @number_of_requests
     end
 
-    def self.upload_file(file)
+    def self.upload_file(file, obj_id)
       upload_permission = get('blobs/upload_permission')
-      uri = URI.parse(upload_permission['url'])
-      File.open(file) do |open_file|
-        content_type = MIME::Types.type_for(file.path).first.content_type
-        upload_io = UploadIO.new(open_file, content_type, File.basename(file))
-        params = upload_permission['fields'].merge('file' => upload_io)
-        request = Net::HTTP::Post::Multipart.new(uri.path, params)
-        response = ConnectionManager.request(uri, request)
-        if response.code.starts_with?('2')
-          upload_permission['blob'].merge('filename' => File.basename(file.path))
-        else
-          raise ScrivitoError, "File upload failed with code #{response.code}"
-        end
-      end
+      upload = perform_file_upload(file, upload_permission)
+      activate_upload(upload: upload, obj_id: obj_id)
+    end
+
+    def self.activate_upload(params)
+      put('blobs/activate_upload', params)
+    end
+
+    def self.normalize_path_component(component)
+      Addressable::URI.normalize_component(component,
+        Addressable::URI::CharacterClasses::UNRESERVED)
     end
 
     class << self
@@ -85,35 +84,47 @@ module Scrivito
       private
 
       def request_cms_api(action, resource_path, payload, options)
-        @number_of_requests += 1 if resource_path == @count_requests
-        decoded = response_for_request_cms_api(action, resource_path, payload)
-        return decoded unless Hash === decoded
-        return decoded unless decoded.keys == ["task"]
-        task_data = decoded["task"]
-        return decoded unless Hash === task_data
-        task_path = "tasks/#{task_data["id"]}"
-        final_response(task_path, options)
+        log_api_request(action, resource_path, payload) do
+          @number_of_requests += 1 if resource_path == @count_requests
+
+          timer = build_timer(options)
+          response = response_for_request_cms_api(action, resource_path, payload, timer)
+
+          if task_response?(response)
+            task_path = "tasks/#{response['task']['id']}"
+            poll_interval = options[:interval].presence.try(:to_f) || 2
+            wait_for_tasks_final_response(task_path, poll_interval)
+          else
+            response
+          end
+        end
+      end
+
+      def log_api_request(action, resource_path, payload, &block)
+        ActiveSupport::Notifications.instrumenter.instrument(
+          "backend_request.scrivito",
+          {
+            :path => resource_path,
+            :verb => action,
+            :params => action == :get ? payload : nil
+          },
+          &block
+        )
       end
 
-      def response_for_request_cms_api(method, resource_path, payload = nil)
+      def task_response?(response)
+        response.is_a?(Hash) && response.keys == ['task'] && response['task'].is_a?(Hash)
+      end
+
+      def response_for_request_cms_api(method, resource_path, payload, timer)
         request = method_to_net_http_class(method).new(path(resource_path))
         set_headers(request)
         request.body = MultiJson.encode(payload) if payload.present?
 
-        response = nil
-        retried = false
-        wait_until = Time.now + MAX_RATE_LIMIT_RETRY_DURATION
-        begin
-          response = CmsRestApi::RateLimit.retry_on_rate_limit(wait_until) do
-            # lower timeout back to DEFAULT_TIMEOUT once the backend has been fixed
-            connection_manager.request(request, 25)
-          end
-        rescue NetworkError => e
-          if method == :post || retried
-            raise e
-          else
-            retried = true
-            retry
+        response = retry_once_on_network_error(method, timer) do
+          CmsRestApi::RateLimit.retry_on_rate_limit(timer) do
+            request_timeout = [timer.remaining_time, MAX_REQUEST_TIME].min
+            connection_manager.request(request, request_timeout)
           end
         end
 
@@ -146,19 +157,57 @@ module Scrivito
         end
       end
 
-      def final_response(task_path, options)
-        options ||= {}
-        wait = options[:interval].presence.try(:to_f) || 2
-        task_data = response = nil
+      def wait_for_tasks_final_response(task_path, poll_interval)
+        task_data = fetch_final_response(task_path, poll_interval)
+
+        if task_data['status'] == 'success'
+          task_data['result']
+        else
+          message = task_data["message"] ||
+            "Missing error message in task response #{task_data}"
+
+          backend_code = task_data['code']
+          raise ClientError.new(message, 400, backend_code)
+        end
+      end
+
+      def perform_file_upload(file, upload_permission)
+        uri = URI.parse(upload_permission['url'])
+        File.open(file) do |open_file|
+          content_type = MIME::Types.type_for(file.path).first.content_type
+          upload_io = UploadIO.new(open_file, content_type, File.basename(file))
+          params = upload_permission['fields'].merge('file' => upload_io)
+          request = Net::HTTP::Post::Multipart.new(uri.path, params)
+          response = ConnectionManager.request(uri, request)
+          if response.code.starts_with?('2')
+            upload_permission['blob'].merge('filename' => File.basename(file.path))
+          else
+            raise ScrivitoError, "File upload failed with code #{response.code}"
+          end
+        end
+      end
+
+      def fetch_final_response(task_path, poll_interval)
         loop do
-          sleep wait
-          task_data = response_for_request_cms_api(:get, task_path, nil)
-          break unless task_data["status"] == "open"
+          sleep poll_interval
+          task_data = response_for_request_cms_api(:get, task_path, nil, build_timer)
+
+          return task_data if task_data['status'] != 'open'
+        end
+      end
+
+      def retry_once_on_network_error(method, timer)
+        return yield if method == :post
+
+        begin
+          yield
+        rescue NetworkError => e
+          if timer.finished?
+            raise e
+          else
+            yield
+          end
         end
-        return task_data["result"] if task_data["status"] == "success"
-        message = task_data["message"] || "Missing error message in task response #{task_data}"
-        backend_code = task_data['code']
-        raise ClientError.new(message, 400, backend_code)
       end
 
       def set_headers(request)
@@ -175,6 +224,10 @@ module Scrivito
         ConnectionManager.instance
       end
 
+      def build_timer(options={})
+        CmsRestApi::RequestTimer.new(options.fetch(:timeout, DEFAULT_TIMEOUT))
+      end
+
       def method_to_net_http_class(method)
         METHOD_TO_NET_HTTP_CLASS.fetch(method)
       end

data/lib/scrivito/cms_routing.rb

@@ -18,7 +18,7 @@ class CmsRouting < Struct.new(:request, :main_app, :scrivito_engine, :image_opti
 
   def convert_links(html)
     if html
-      html.gsub(%r{\bobjid:([a-f0-9]{16})\b([^"']*)}) do
+      html.to_str.gsub(%r{\bobjid:([a-f0-9]{16})\b([^"']*)}) do
         if obj = Obj.find_by_id($1)
           options = {}
 
@@ -62,7 +62,7 @@ class CmsRouting < Struct.new(:request, :main_app, :scrivito_engine, :image_opti
         return LINK_TO_EMPTY_LINKLIST
       end
     elsif target.is_a?(Binary)
-      binary_url(target, path_or_url)
+      binary_url(target)
     else
       raise "scrivito_path or scrivito_url was called with an instance of #{target.class}. "+
         "It must only be called with an Obj or a Link or a non-empty LinkList."
@@ -81,14 +81,10 @@ class CmsRouting < Struct.new(:request, :main_app, :scrivito_engine, :image_opti
     if permalink
       main_app
         .public_send("scrivito_permalink_#{path_or_url}", options.merge(:permalink => permalink))
-    elsif obj.homepage?
+    elsif homepage?(obj)
       main_app.public_send("scrivito_root_#{path_or_url}", options)
     elsif obj.binary?
-      if binary = obj.binary
-        binary_url(binary, path_or_url)
-      else
-        LINK_TO_EMPTY_BLOB
-      end
+      binary_obj_url(obj) || LINK_TO_EMPTY_BLOB
     else
       slug = obj.slug.present? ? obj.slug.sub(/^\//, '') : nil
       id_path_or_url_for_objs(obj, path_or_url, options.merge(slug: slug))
@@ -105,6 +101,10 @@ class CmsRouting < Struct.new(:request, :main_app, :scrivito_engine, :image_opti
     main_app.public_send(method_name, options.merge(id: obj.id))
   end
 
+  def homepage?(obj)
+    RequestHomepage.call(request.env) == obj
+  end
+
   def editor_authenticated?
     editing_context.authenticated_editor?
   end
@@ -141,27 +141,15 @@ class CmsRouting < Struct.new(:request, :main_app, :scrivito_engine, :image_opti
     Rack::Utils.parse_query(uri.query)
   end
 
-  def binary_url(binary, path_or_url)
-    binary = transform_binary(binary)
-    if url_from_cache = binary.url_from_cache
-      BinaryRewrite.call(request, url_from_cache)
-    else
-      encrypted_params = BinaryParamVerifier.generate(binary)
-      scrivito_engine.public_send("binary_#{path_or_url}", encrypted_params: encrypted_params)
-    end
+  def binary_url(binary)
+    BinaryRouting.new(request, scrivito_engine).binary_url(binary)
   end
 
-  def transform_binary(binary)
-    if transformation_definition = image_options[:transform]
-      binary.transform(transformation_definition)
-    else
-      binary
+  def binary_obj_url(obj)
+    if binary = obj.binary
+      BinaryRouting.new(request, scrivito_engine).binary_obj_url(obj, binary, image_options || {})
     end
   end
-
-  def image_options
-    super || {}
-  end
 end
 
 end

data/lib/scrivito/configuration.rb

@@ -208,6 +208,9 @@ module Scrivito
         self.check_batch_size = 100
         self.legacy_routing = false
         self.default_image_transformation = {}
+        self.choose_homepage_callback = -> (env) { Obj.root }
+        self.find_user_proc = nil
+        reset_editing_auth_callback!
       end
 
       #
@@ -238,7 +241,7 @@ module Scrivito
       #
       # Set the default {Scrivito::Binary#transform image transformation}.
       #
-      # @api beta
+      # @api public
       #
       # When delivering binary Objs, the default image transformation will be applied if
       # {Scrivito::BasicObj#apply_image_transformation? Obj#apply_image_transformation?} returns
@@ -259,7 +262,7 @@ module Scrivito
       # Configure a callback to be invoked when the Scrivito SDK delivers the homepage.
       # The given callback will receive the rack env
       # and must return an {BasicObj Obj} to be used as the homepage.
-      # If no callback is configured, {BasicObj.homepage Obj.homepage} will be used as the default.
+      # If no callback is configured, {BasicObj.root Obj.root} will be used as the default.
       # @api public
       def choose_homepage(&block)
         self.choose_homepage_callback = block