scrivito_sdk 0.12.0

data/lib/scrivito/client_error.rb

@@ -0,0 +1,12 @@
+module Scrivito
+
+  class ClientError < StandardError
+    attr_reader :http_code
+
+    def initialize(message, http_code)
+      @http_code = http_code
+      super(message)
+    end
+  end
+
+end

data/lib/scrivito/cms_accessible.rb

@@ -0,0 +1,30 @@
+module Scrivito
+
+  # @api public
+  module CmsAccessible
+
+  protected
+
+    # Filter method to load a CMS object.
+    #
+    # To require the loading for all actions, use this in your controllers:
+    #   before_filter :load_object
+    def load_object
+      CmsEnv.new(request.env).load
+      loaded_obj = request.env[CmsEnv::OBJ_ENV_KEY]
+      raise loaded_obj if loaded_obj.is_a?(StandardError)
+      @obj = loaded_obj
+    end
+
+    # Deliver a binary @obj by redirecting to it's `body_data_url`.
+    # Will respond with 404 if the @obj has no blob.
+    # @api public
+    def deliver_file
+      if @obj.body_data_url
+        redirect_to enforce_protocol_from_request(@obj.body_data_url)
+      else
+        render text: "Empty Blob", status: 404
+      end
+    end
+  end
+end

data/lib/scrivito/cms_backend.rb

@@ -0,0 +1,238 @@
+require 'rest_client'
+
+module Scrivito
+
+  class ContentServiceObjQueries
+    def initialize(queries)
+      @queries = queries
+      @open_queries = queries.dup
+      @results = {}
+    end
+
+    def open_queries
+      @open_queries[0..99]
+    end
+
+    def handle_response(response)
+      objs = {}
+      response["objs"].each do |obj|
+        objs[obj["_id"].first] = obj
+      end
+
+      queries_to_delete = []
+      response["results"].each_with_index do |response, i|
+        query = @open_queries[i]
+        if response["continuation_handle"]
+          query[:continuation_handle] = response["continuation_handle"]
+        else
+          queries_to_delete << i
+        end
+        result = (@results[query.__id__] ||= [])
+        response["refs"].each do |obj_ref|
+          id = obj_ref["id"]
+          # TODO fetch missing ObjData from Service
+          result << (objs[id] or raise "Data for Obj with id #{id} missing!")
+        end
+      end
+      queries_to_delete.reverse_each {|i| @open_queries.delete_at(i) }
+    end
+
+    def results
+      @queries.map {|query| @results[query.__id__] || [] }
+    end
+
+    def finished?
+      open_queries.empty?
+    end
+  end
+
+  class CmsBackend
+    BLOB_DATA_CACHE_PREFIX = 'blob_data'.freeze
+    VALID_INDEX_NAMES = %w[id path ppath permalink].freeze
+
+    class << self
+      def instance
+        @instance ||= new
+      end
+    end
+
+    def initialize
+      @query_counter = 0
+    end
+
+    def begin_caching
+      @caching = true
+    end
+
+    def end_caching
+      CmsCacheStorage.cache.clear
+      @caching = false
+    end
+
+    def caching?
+      !!@caching
+    end
+
+    def query_counter
+      @query_counter
+    end
+
+    def find_workspace_data_by_id(id)
+      workspace_data_from_cache = WorkspaceDataFromService.find_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
+
+      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
+        workspace_data
+      end
+    end
+
+    def find_obj_data_by(revision, index, keys)
+      find_obj_data_filtering_deleted_by(revision, index, keys, false)
+    end
+
+    def find_obj_data_including_deleted_by(revision, index, keys)
+      find_obj_data_filtering_deleted_by(revision, index, keys, true)
+    end
+
+    def find_blob_data_by_id(id)
+      cache_key = "#{BLOB_DATA_CACHE_PREFIX}/#{id}"
+      if data_from_cache = CmsCacheStorage.cache.read(cache_key)
+        data_from_cache
+      else
+        data_from_database = find_blob_data_from_database_by(id)
+        if maxage = data_from_database['maxage']
+          CmsCacheStorage.cache.write(cache_key, data_from_database, :expires_in => maxage)
+        end
+        data_from_database
+      end
+    end
+
+    private
+
+    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
+      results_from_cache = keys.map do |key|
+        find_raw_data_from_cache_by(revision, index, key).tap do |objs|
+          keys_from_database << key unless objs
+        end
+      end
+
+      # load cache misses from database and store them in cache
+      results_from_database =
+          find_raw_data_from_database_by(revision, index, keys_from_database)
+      keys_from_database.each_with_index do |key, key_number|
+        store_raw_data_list_in_cache(revision, index, key, results_from_database[key_number])
+      end
+
+      # combine the results
+      results_from_cache.map do |objs_from_cache|
+        objs_from_cache || results_from_database.shift
+      end
+    end
+
+    def find_raw_data_from_cache_by(revision, index, key)
+      ContentStateCaching.find_obj_data(revision.content_state, index, key) if caching?
+    end
+
+    def find_raw_data_from_database_by(revision, index, keys)
+      return [] if keys.blank?
+      instrumenter = ActiveSupport::Notifications.instrumenter
+      instrumenter.instrument(
+        "cms_load.scrivito", :name => "Obj Load", :index => index, :keys => keys
+      ) do
+        @query_counter += 1
+        queries = ContentServiceObjQueries.new(keys.map {|key| {:type => index, :param => key} })
+        queries.handle_response(request_content_service(queries, revision)) until queries.finished?
+        queries.results
+      end
+    end
+
+    def request_content_service(queries, revision)
+      ContentService.query('objs/query', content_service_request_params(queries, revision))
+    end
+
+    def content_service_request_params(queries, revision)
+      params = {
+        queries: queries.open_queries,
+        revision_id: revision.id,
+        include_deleted: true
+      }
+
+      # Not every revision has a workspace,
+      # e.g. when requesting with the base revision of the current workspace.
+      params[:workspace_id] = revision.workspace.id if revision.workspace
+
+      params
+    end
+
+    UNIQUE_INDICES = [:id, :path, :permalink].freeze
+
+    def store_raw_data_list_in_cache(revision, index, key, raw_data_list)
+      raw_data_list.each do |values|
+        UNIQUE_INDICES.each do |unique_index|
+          unique_index_values = values["_#{unique_index}"]
+          if unique_index_values.present?
+            store_item_in_cache(revision, unique_index, unique_index_values.first, [values])
+          end
+        end
+      end
+      unless UNIQUE_INDICES.include?(index)
+        store_item_in_cache(revision, index, key, raw_data_list)
+      end
+    end
+
+    def store_item_in_cache(revision, index, key, item)
+      ContentStateCaching.store_obj_data(revision.content_state, index, key, item)
+    end
+
+    def find_blob_data_from_database_by(id)
+      @query_counter += 1
+      ContentService.query('blobs/query', :blob_ids => [id])['blobs'][id]
+    end
+
+    def assert_valid_index_name(index)
+      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_cache_storage.rb

@@ -0,0 +1,51 @@
+module Scrivito
+
+# This module manages storage of different kind of cache data.
+module CmsCacheStorage
+  VERSION = 'v2'.freeze
+
+  class << self
+    attr_writer :cache
+
+    def cache
+      @cache ||= begin
+        Cache.new(fallback_backend: backend_cache, cache_prefix: VERSION)
+      end
+    end
+
+    def backend_cache=(new_cache)
+      @backend_cache = new_cache
+      @cache = nil
+    end
+
+    def backend_cache
+      @backend_cache || ActiveSupport::Cache::FileStore.new(Rails.root + 'tmp/scrivito_cache')
+    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
+  end
+end
+
+end

data/lib/scrivito/cms_dispatch_controller.rb

@@ -0,0 +1,46 @@
+module Scrivito
+
+  class CmsDispatchController < ActionController::Metal
+    def process(action)
+      CmsEnv.new(env).load
+      controller = target_controller(env)
+      env["action_dispatch.request.path_parameters"]["controller"] = controller.controller_path
+
+      if !obj_not_found? && action == 'index'
+        action = loaded_obj.controller_action_name
+      end
+
+      env["action_dispatch.request.path_parameters"]["action"] = action
+
+      self.response = controller.action(action).call(env)
+    end
+
+    private
+
+    def target_controller(env)
+      return default_controller if obj_not_found?
+      controller = "#{loaded_obj.controller_name}Controller".constantize
+
+      if controller.respond_to?(:use_for_obj_dispatch?) && controller.use_for_obj_dispatch?
+        controller
+      else
+        default_controller
+      end
+    rescue NameError
+      default_controller
+    end
+
+    def loaded_obj
+      env[CmsEnv::OBJ_ENV_KEY]
+    end
+
+    def obj_not_found?
+      loaded_obj.is_a?(StandardError)
+    end
+
+    def default_controller
+      CmsController
+    end
+  end
+
+end

data/lib/scrivito/cms_env.rb

@@ -0,0 +1,63 @@
+module Scrivito
+
+  class CmsEnv
+
+    OBJ_ENV_KEY = "SCRIVITO_OBJ"
+
+    def initialize(env)
+      @env = env
+    end
+
+    def load
+      return if env[OBJ_ENV_KEY]
+      load_object
+    end
+
+    protected
+
+    attr_reader :env
+
+    def load_object
+      env[OBJ_ENV_KEY] =
+        begin
+          find_obj
+        rescue StandardError => e
+          e
+        end
+    end
+
+    def find_obj
+      found_obj =
+        if params[:id]
+          Obj.find(params[:id])
+        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
+        end
+
+      found_obj
+    end
+
+    def params
+      env["action_dispatch.request.path_parameters"]
+    end
+
+    def self.find_permalink_by_param(permalink_param)
+      permalink =  Array(permalink_param).join("/")
+      Obj.find_by_permalink!(permalink)
+    end
+
+  end
+
+end