scrivito_sdk 0.60.0 → 0.65.0.rc1

data/lib/scrivito/client_error.rb

@@ -1,11 +1,11 @@
 module Scrivito
 
   class ClientError < StandardError
-    attr_reader :http_code, :error_code
+    attr_reader :http_code, :backend_code
 
-    def initialize(message, http_code, error_code=nil)
+    def initialize(message, http_code, backend_code = nil)
       @http_code = http_code
-      @error_code = error_code
+      @backend_code = backend_code
       super(message)
     end
   end

data/lib/scrivito/cms_backend.rb

@@ -55,8 +55,11 @@ module Scrivito
       end
     end
 
+    attr_accessor :die_content_service
+
     def initialize
       @query_counter = 0
+      @caching = true
     end
 
     def begin_caching
@@ -68,6 +71,10 @@ module Scrivito
       @caching = false
     end
 
+    def clear_cache
+      CmsDataCache.cache.clear
+    end
+
     def caching?
       !!@caching
     end
@@ -82,6 +89,33 @@ module Scrivito
     end
 
     def find_workspace_data_by_id(id)
+      if die_content_service
+        from_csid  = CmsDataCache.read_workspace_csid(id)
+
+        changes = CmsRestApi.get("/workspaces/#{id}/changes", from: from_csid)
+
+        objs = changes["objs"]
+        if objs.present?
+          if objs != "*"
+            last_state = Backend::ContentStateNode.find(from_csid)
+
+            successor_state = changes["to"]
+            current_state = last_state.create_successor(successor_state, objs)
+          end
+
+          # TODO what if workspace data is missing?
+          # have the backend team include a new key `current`
+          current_csid = changes["workspace"]["content_state_id"]
+          CmsDataCache.write_workspace_csid(id, current_csid)
+        end
+
+        # TODO what if workspace data is missing?
+        # implement workspace data caching
+        workspace_data = changes["workspace"]
+
+        return WorkspaceData.new(workspace_data)
+      end
+
       workspace_data_from_cache = WorkspaceDataFromService.find_from_cache(id)
       from_content_state_id = workspace_data_from_cache.try(:content_state_id)
 
@@ -101,17 +135,37 @@ module Scrivito
 
       if raw_workspace_data = raw_data['workspace']
         workspace_data = WorkspaceDataFromService.new(raw_workspace_data)
-        workspace_data.store_in_cache if from_content_state_id != workspace_data.content_state_id
+        if from_content_state_id != workspace_data.content_state_id
+          workspace_data.store_in_cache_and_create_content_state
+        end
         workspace_data
       end
     end
 
     def find_obj_data_by(revision, index, keys)
-      find_obj_data_filtering_deleted_by(revision, index, keys, false)
-    end
+      index = index.to_s
+
+      if die_content_service
+        obj_datas =
+          if index == "id"
+            obj_datas = Backend::ObjLoad.load(revision, keys)
+            obj_datas.map { |obj_data| obj_data ? [obj_data] : [] }
+          else
+            index_implementation = Backend::Index.by_name(index)
+            Backend::ObjQuery.query(revision, index_implementation, keys)
+          end
+
+        return obj_datas
+      end
 
-    def find_obj_data_including_deleted_by(revision, index, keys)
-      find_obj_data_filtering_deleted_by(revision, index, keys, true)
+      assert_valid_index_name(index)
+      raw_data = find_raw_data_from_cache_or_database_by(revision, index, keys)
+
+      raw_data.map do |raw_result|
+        raw_result.each_with_object([]) do |raw_data, result|
+          result << ObjDataFromService.new(raw_data)
+        end
+      end
     end
 
     def find_blob_data(id, access, verb)
@@ -136,6 +190,11 @@ module Scrivito
     end
 
     def search_objs(workspace, params)
+      if die_content_service
+        # TODO caching
+        return request_search_result_from_backend(workspace, params)
+      end
+
       content_state = workspace.revision.content_state
       cache_index = 'search'
       cache_key = params.to_param
@@ -249,19 +308,6 @@ module Scrivito
       "blob_metadata/#{id}"
     end
 
-    def find_obj_data_filtering_deleted_by(revision, index, keys, include_deleted)
-      index = index.to_s
-      assert_valid_index_name(index)
-      raw_data = find_raw_data_from_cache_or_database_by(revision, index, keys)
-
-      raw_data.map do |raw_result|
-        raw_result.each_with_object([]) do |raw_data, result|
-          next if raw_data['_modification'] == ['deleted'] && !include_deleted
-          result << ObjDataFromService.new(raw_data)
-        end
-      end
-    end
-
     def find_raw_data_from_cache_or_database_by(revision, index, keys)
       keys_from_database = []
       # load results from cache

data/lib/scrivito/cms_data_cache.rb

@@ -26,36 +26,39 @@ module CmsDataCache
       @second_level_cache = cache_store
     end
 
-    def read_workspace_data(workspace_id)
-      cache.read("workspace/#{workspace_id}")
-    end
-
-    def write_workspace_data(workspace_id, workspace_data)
-      cache.write("workspace/#{workspace_id}", workspace_data)
-    end
-
-    def read_content_state(content_state_id)
-      cache.read("content/#{content_state_id}")
-    end
-
-    def write_content_state(content_state_id, content_state)
-      cache.write("content/#{content_state_id}", content_state)
-    end
-
-    def read_obj_data(content_state_id, index, key)
-      cache.read("content/#{content_state_id}/obj/#{index}/#{key}")
-    end
-
-    def write_obj_data(content_state_id, index, key, data)
-      cache.write("content/#{content_state_id}/obj/#{index}/#{key}", data)
-    end
-
-    def read_obj_classes_data(content_state_id)
-      cache.read("content/#{content_state_id}/obj_classes")
-    end
-
-    def write_obj_classes_data(content_state_id, data)
-      cache.write("content/#{content_state_id}/obj_classes", data)
+    SCHEMA = {
+      workspace_data:     'workspace/#{workspace_id}',
+
+      # CONTENT SERVICE
+      content_state:      'content/#{content_state_id}',
+      obj_data:           'content/#{content_state_id}/obj/#{index}/#{key}',
+      obj_classes_data:   'content/#{content_state_id}/obj_classes',
+
+      # REST API
+      obj_data_rest:      'obj/#{cache_id}/#{index}/#{key}',
+      content_state_node: 'csn/#{content_state_id}',
+      workspace_csid:     'wscsid/#{workspace_id}'
+    }
+
+    SCHEMA.each do |name, schema|
+      params = schema.scan(/\#{([^}]+)}/).map(&:first)
+      params_code = params.map(&:to_s).join(",")
+
+      # using eval instead of define_method for performance reasons
+      class_eval(<<-END, __FILE__, __LINE__ + 1)
+        def read_#{name}(#{params_code})
+          cache.read("#{schema}")
+        end
+      END
+
+      class_eval(<<-END, __FILE__, __LINE__ + 1)
+        def write_#{name}(#{params_code}, data)
+          if data == nil
+            raise InternalError, "tried to write nil into #{schema}"
+          end
+          cache.write("#{schema}", data)
+        end
+      END
     end
 
     private

data/lib/scrivito/cms_dispatch_controller.rb

@@ -1,8 +1,22 @@
 module Scrivito
 
   class CmsDispatchController < ActionController::Metal
+    include ActionController::Redirecting
+    include Rails.application.routes.url_helpers
+    include Scrivito::RoutingHelper
+
     def process(action)
       CmsEnv.new(env).load
+
+      if !obj_not_found? && action == 'legacy'
+        if Scrivito::Configuration.legacy_routing
+          action = 'index'
+        else
+          redirect_to scrivito_path(loaded_obj)
+          return self.response
+        end
+      end
+
       controller = target_controller(env)
       env["action_dispatch.request.path_parameters"]["controller"] = controller.controller_path
 
@@ -17,6 +31,10 @@ module Scrivito
 
     private
 
+    def main_app
+      Rails.application.routes.url_helpers
+    end
+
     def target_controller(env)
       return default_controller if obj_not_found?
       controller = "#{loaded_obj.controller_name}Controller".constantize

data/lib/scrivito/cms_field_tag.rb

@@ -1,7 +1,7 @@
 module Scrivito
 
 # this class is the server-side equivalent of the JavaScript class `cms_field_element`
-class CmsFieldTag < Struct.new(:view, :tag_name, :obj_or_widget, :field_name)
+class CmsFieldTag < Struct.new(:view, :tag_name, :obj_or_widget, :field_name, :widget_template_name)
   FIELD_TYPES_WITH_ORIGINAL_CONTENT = %w[
     binary
     date
@@ -21,7 +21,7 @@ class CmsFieldTag < Struct.new(:view, :tag_name, :obj_or_widget, :field_name)
       raise ArgumentError, 'No block allowed for widgetlist fields' if block_given?
       modifications = modification_info || []
       rendered_widgets = default_content.each_with_index.map do |widget, index|
-        WidgetTag.new(view, widget, modifications[index]).render
+        WidgetTag.new(view, widget, modifications[index], widget_template_name).render
       end
       view.safe_join(rendered_widgets)
     else
@@ -60,6 +60,7 @@ class CmsFieldTag < Struct.new(:view, :tag_name, :obj_or_widget, :field_name)
 
     if field_type == 'widgetlist'
       options['private-field-widget-allowed-classes'] = build_valid_widget_classes.to_json
+      options['private-field-widget-template'] = widget_template_name
     end
 
     options

data/lib/scrivito/cms_rest_api.rb

@@ -32,6 +32,8 @@ module Scrivito
       :delete => Net::HTTP::Delete,
     }.freeze
 
+    MAX_RATE_LIMIT_RETRY_DURATION = 20.seconds.freeze
+
     def self.get(resource_path, payload = nil, options = nil)
       request_cms_api(:get, resource_path, payload, options)
     end
@@ -100,9 +102,12 @@ module Scrivito
 
         response = nil
         retried = false
+        wait_until = Time.now + MAX_RATE_LIMIT_RETRY_DURATION
         begin
-          # lower timeout back to DEFAULT_TIMEOUT once the backend has been fixed
-          response = connection_manager.request(request, 25)
+          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
@@ -112,11 +117,11 @@ module Scrivito
           end
         end
 
-        handle_response(response)
+        handle_response(resource_path, response)
       end
 
-      def handle_response(response)
-        code = response.code.to_i
+      def handle_response(resource_path, response)
+        http_code = response.code.to_i
         if response.code.start_with?('2')
           MultiJson.load(response.body)
         elsif response.code == '403'
@@ -127,15 +132,16 @@ module Scrivito
             specific_output = error_body['error']
 
             if response.code.start_with?('4')
-              error_code = error_body['code']
-              raise ClientError.new(specific_output, code, error_code)
+              backend_code = error_body['code']
+              message = "'#{specific_output}' on '#{resource_path}'"
+              raise ClientError.new(specific_output, http_code, backend_code)
             elsif response.code == '500' && specific_output
-              raise BackendError.new(specific_output, code)
+              raise BackendError.new(specific_output, http_code)
             else # 3xx and >500 are treated as NetworkErrors
-              raise NetworkError.new(response.body, code)
+              raise NetworkError.new(response.body, http_code)
             end
           rescue MultiJson::DecodeError
-            raise NetworkError.new(response.body, code)
+            raise NetworkError.new(response.body, http_code)
           end
         end
       end
@@ -151,8 +157,8 @@ module Scrivito
         end
         return task_data["result"] if task_data["status"] == "success"
         message = task_data["message"] || "Missing error message in task response #{task_data}"
-        error_code = task_data['code']
-        raise ClientError.new(message, 400, error_code)
+        backend_code = task_data['code']
+        raise ClientError.new(message, 400, backend_code)
       end
 
       def set_headers(request)

data/lib/scrivito/cms_rest_api/rate_limit.rb

@@ -0,0 +1,40 @@
+module Scrivito
+class CmsRestApi
+module RateLimit
+  class << self
+    def retry_on_rate_limit(try_until, &block)
+      internal_retry(block, try_until, 0)
+    end
+
+    private
+
+    def internal_retry(request_proc, try_until, 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
+          sleep time_to_sleep
+          internal_retry(request_proc, try_until, retry_count + 1)
+        else
+          raise Scrivito::RateLimitExceeded.new('rate limit exceeded', 429)
+        end
+      else
+        response
+      end
+    end
+
+
+    def calculate_time_to_sleep(retry_after, retry_count)
+      backoff_wait_time = 2 ** retry_count * 0.5
+      [backoff_wait_time, retry_after].max
+    end
+
+    def failed_because_of_rate_limit?(response)
+      response.code == '429'
+    end
+  end
+end
+end
+end

data/lib/scrivito/cms_routing.rb

@@ -89,18 +89,19 @@ class CmsRouting < Struct.new(:request, :main_app)
         LINK_TO_EMPTY_BLOB
       end
     else
-      id_path_or_url_for_objs(obj, path_or_url, options)
+      slug = obj.slug.present? ? obj.slug.sub(/^\//, '') : nil
+      id_path_or_url_for_objs(obj, path_or_url, options.merge(slug: slug))
     end
   end
 
   def id_path_or_url_for_objs(obj, path_or_url, options)
-    main_app.public_send(
-      "cms_id_#{path_or_url}",
-      options.merge(
-        id: obj.id,
-        slug: obj.slug.presence
-      )
-    )
+    method_name = if Scrivito::Configuration.legacy_routing
+      "cms_legacy_id_#{path_or_url}"
+    else
+      "cms_id_#{path_or_url}"
+    end
+
+    main_app.public_send(method_name, options.merge(id: obj.id))
   end
 
   def editor_authenticated?

data/lib/scrivito/configuration.rb

@@ -176,7 +176,6 @@ module Scrivito
 
       def to_prepare
         unless Rails.configuration.cache_classes
-          NamedLink.reset_cache
           BasicObj.reset_type_computer!
           BasicWidget.reset_type_computer!
         end
@@ -207,6 +206,7 @@ module Scrivito
         self.ca_file = DEFAULT_CA_FILE
         self.endpoint = 'api.scrivito.com'
         self.check_batch_size = 100
+        self.legacy_routing = false
       end
 
       #
@@ -225,6 +225,13 @@ module Scrivito
       #
       attr_accessor :ui_locale
 
+
+      # @api public
+      #
+      # Scrivito changed its routing to a slug first url scheme. This configuration option
+      # allows you to switch back to the old id first url scheme.
+      attr_accessor :legacy_routing
+
       attr_accessor :choose_homepage_callback, :check_batch_size
 
       # Configure a callback to be invoked when the Scrivito SDK delivers the homepage.