infopark_cloud_connector 6.8.3.115.227021242 → 6.8.3.174.51542603

data/lib/rails_connector/chain.rb

@@ -1,175 +0,0 @@
-module RailsConnector
-
-class Chain
-  # the id of the content cache to use, or nil
-  attr_reader :content_cache
-
-  # a chain of patch operations that can be used to construct the target revision
-  # each chain member is an array with two elements.
-  # the first element denotes the patch type (-1, 1), where
-  # 1 => apply the revision
-  # -1 => revert the revision
-  # and the second element is the revision.
-  attr_reader :patches
-
-  def self.build_for(revision, content_cache = nil)
-    if content_cache && content_cache.revision
-      patches = patches_to(revision, content_cache.revision)
-
-      if content_cache.transfer_target
-        if patches.present? && patches.first.second == content_cache.transfer_target
-          # the transfer target is already included in the chain - no extra patch needed!
-        else
-          patches.unshift([-1, content_cache.transfer_target])
-        end
-      end
-
-      new(content_cache, patches)
-    else
-      new(nil, patches_to(revision))
-    end
-  end
-
-  def self.query_counter
-    @query_counter || 0
-  end
-
-  def self.count_query
-    @query_counter = query_counter + 1
-  end
-
-  def initialize(content_cache, patches)
-    @content_cache = content_cache
-    @patches = patches
-  end
-
-  # performs a revision aware query on the cms database.
-  #
-  # returns a hash of results from the query.
-  # the keys are the criterion by which the query results are grouped (typically the OBJ ID).
-  # the values are tuples where
-  # - the first element denotes the diff type and
-  # - the second the document rows
-  def query(index, key)
-    self.class.count_query
-    result_map = perform_queries(index, key)
-    version_map = result_map.merge(result_map) do |ignore, results|
-      results.map {|row| Version.new(row) }
-    end
-    revision_aware_results(version_map)
-  end
-
-  private
-
-  # calculate a list of patches to get to the destionation revision.
-  # if origin is given, the list will start at origin.
-  # otherwise the list will start at the initial revision.
-  def self.patches_to(destination, origin = nil)
-    if destination.nil? && origin.nil?
-      []
-    elsif origin.nil? || origin.generation < destination.generation
-      patches_to(destination.base_revision, origin) + [[1, destination]]
-    elsif destination.nil? || origin.generation > destination.generation
-      [[-1, origin]] + patches_to(destination, origin.base_revision)
-    elsif origin != destination
-      [[-1, origin]] + patches_to(destination.base_revision, origin.base_revision) + [[1, destination]]
-    else # origin == destination
-      []
-    end
-  end
-
-  def perform_queries(index, key)
-    result_map = {}
-
-    query_options = {
-      :hash_value => key,
-    }
-
-    if content_cache.present?
-      result_map[:content_cache] = CmsBaseModel.query_index(:obj, index, query_options.merge({
-        :range_value => "cc/#{content_cache.id}",
-      }))
-    end
-    if patches.present?
-      result_map[:patches] = CmsBaseModel.query_index(:obj, index, query_options.merge({
-        :range_value => revision_range,
-      }))
-    end
-
-    result_map
-  end
-
-  # filter out those results that aren't on the chain.
-  # order the remaining results according to their chain position
-  def order_results_by_chain(result_map)
-    results = []
-
-    if result_map[:content_cache].present?
-      results << [1, result_map[:content_cache]]
-    end
-    if result_map[:patches].present?
-      results_by_revision = result_map[:patches].group_by do |version|
-        version.revision_id
-      end
-      patches.each do |(patch_diff_type, revision)|
-        results_for_revision = results_by_revision[revision.id]
-        results << [patch_diff_type, results_for_revision] if results_for_revision
-      end
-    end
-
-    results
-  end
-
-  # group the results by obj id
-  # i.e. calculate a separate chain for each obj
-  def group_results(result_map)
-    results_by_chain = order_results_by_chain(result_map)
-
-    result_index = {}
-    results_by_chain.each do |(patch_diff_type, versions)|
-      versions.each do |version|
-        id = version.obj_id
-        result_index[id] ||= []
-        result_index[id] << [patch_diff_type, version]
-      end
-    end
-
-    result_index
-  end
-
-  # apply the diff chain for each of obj
-  # to determine which of them are included in the final revision
-  def revision_aware_results(result_map)
-    result_index = {}
-
-    # note: using merge as a map function for hashes
-    group_results(result_map).each do |id, apply_chain|
-      final_existance = apply_chain.inject(0) do |temp_existance, (patch_diff_type, version)|
-        # remember: -1 (revert) multiplied with -1 (revert) equals 1 (apply)
-        # and: +1 (create) added to -1 (delete) equals 0 (not existant)
-        temp_existance + patch_diff_type * version.diff
-      end
-      if final_existance > 0
-        patch_diff, version = apply_chain.last
-        result_index[id] = version.obj_data(patch_diff)
-      end
-    end
-
-    result_index
-  end
-
-  private
-
-  def revision_range
-    @revision_range ||=
-      begin
-        sorted_keys = patches.map do |(type, revision)|
-          "#{"%010d" % revision.generation}/#{revision.id}"
-        end.sort
-        Range.new(sorted_keys.first, sorted_keys.last)
-      end
-  end
-
-end
-
-end # module RailsConnector

data/lib/rails_connector/cms_base_model.rb

@@ -1,55 +0,0 @@
-require "kvom"
-
-module RailsConnector
-
-  # This is the abstract class from which all CMS models derive.
-  class CmsBaseModel < Kvom::Model::Base
-    class << self
-      def instance_name=(ignore)
-        # this method is here only for compatibility with the fiona connector.
-      end
-
-      def adapter
-        @@cms_database_adapter
-      end
-
-      def configure_database(connection_spec)
-        @@cms_database_adapter =
-            case connection_spec["type"]
-            when "dynamo"
-              Kvom::Adapter::DynamodbAdapter.new(connection_spec)
-            when "file"
-              Kvom::Adapter::FilesystemAdapter.new(connection_spec)
-            else
-              raise "Unexpected database type #{connection_spec["type"]}"
-            end
-      end
-
-      def query_index(model, index, params = {}, query_options={})
-        hash_value = "#{model}/#{index}/#{params[:hash_value]}"
-        range_value = params[:range_value] || ""
-
-        # up to this point: backend independent
-
-        # this may be backend dependent (suffix character)
-        start_key, end_key =
-            case range_value
-            when Range
-              [range_value.begin, range_value.end]
-            else
-              [range_value, range_value]
-            end
-        range_value = Range.new(start_key, end_key + "~")
-
-        adapter.query(hash_value, range_value, query_options)
-      end
-
-    end
-
-    def save
-      raise "CmsBaseModel is read-only"
-    end
-
-  end
-
-end

data/lib/rails_connector/content_cache.rb

@@ -1,23 +0,0 @@
-module RailsConnector
-
-class ContentCache < CmsBaseModel
-  self.key_prefix = "cc"
-
-  property :revision_id
-  property :transferring_to
-
-  # returns the revision that is represented by this content cache.
-  # returns nil if the revision cannot be found.
-  def revision
-    @revision ||= Revision.find_by_id(revision_id)
-  end
-
-  # returns the revision that this content cache is currently transferring to.
-  # returns nil if no transfer is taking place or if the revision cannot be found.
-  def transfer_target
-    @transfer_target ||= transferring_to ? Revision.find_by_id(transferring_to) : nil
-  end
-end
-
-end # module RailsConnector
-

data/lib/rails_connector/dict_storage.rb

@@ -1,66 +0,0 @@
-module RailsConnector
-
-  class DictStorage
-
-    class << self
-
-      def configure(config)
-        @config = config.present? ? config.symbolize_keys : {}
-        @storage = nil
-      end
-
-      def get(key)
-        cache.fetch(key) { storage.get(key) }
-      end
-
-      # clears the in-memory cache.
-      # does not affect a potential second level cache present in the underlying storage.
-      def clear_first_level_cache
-        @cache = nil
-      end
-
-      attr_reader :config
-
-      def storage
-        @storage ||=
-            case config[:type]
-            when "s3"
-              s3_storage(config)
-            when "file"
-              file_storage(config)
-            else
-              raise "Unsupported dict storage type #{config[:type]}"
-            end
-      end
-
-      private
-
-      def cache
-        @cache ||= Cache.new
-      end
-
-      def s3_storage(config)
-        if config && !config.key?("s3_endpoint") && !config.key?(:s3_endpoint)
-          config = config.merge(:s3_endpoint => "s3-eu-west-1.amazonaws.com")
-        end
-
-        bucket = AWS::S3.new(config).buckets[config[:bucket_name]]
-        Kvom::Storage::S3Storage.new({
-          :bucket => bucket,
-          :bucket_prefix => "dict",
-          :cache => s3_storage_cache,
-          :cache_prefix => "dict.",
-        })
-      end
-
-      def s3_storage_cache
-        Rails.cache
-      end
-
-      def file_storage(config)
-        Kvom::Storage::FileSystemStorage.new(config)
-      end
-
-    end
-  end
-end

data/lib/rails_connector/dynamo_cms_backend.rb

@@ -1,136 +0,0 @@
-module RailsConnector
-
-  class DynamoCmsBackend
-    CACHE_PREFIX = 'revision'
-
-    def initialize
-      @query_counter = 0
-    end
-
-    def begin_caching
-      @editable_cache = Configuration.cache_editable_workspaces ? persistent_cache : Cache.new
-      @read_only_cache = persistent_cache
-    end
-
-    def end_caching
-      @editable_cache = @read_only_cache = nil
-    end
-
-    def find_workspace_data_by_id(id)
-      WorkspaceDataFromDatabase.find(id)
-    rescue Kvom::NotFound
-    end
-
-    def find_obj_data_by(workspace_data, index, keys)
-      revision = workspace_data.revision
-      raw_data =
-        if caching?
-          find_obj_data_from_cache_or_database_by(revision, index, keys)
-        else
-          find_obj_data_from_database_by(revision, index, keys)
-        end
-
-      raw_data.map do |raw_list|
-        raw_list.map do |raw_obj_data|
-          ObjDataFromDatabase.new(raw_obj_data, revision)
-        end
-      end
-    end
-
-    def caching?
-      @read_only_cache && @editable_cache
-    end
-
-    def query_counter
-      @query_counter
-    end
-
-    private
-
-    def persistent_cache
-      Cache.new(:fallback_backend => Rails.cache, :cache_prefix => CACHE_PREFIX)
-    end
-
-    def find_obj_data_from_database_by(revision, index, keys)
-      return [] if keys.blank?
-      @query_counter += 1
-      instrumenter = ActiveSupport::Notifications.instrumenter
-      instrumenter.instrument(
-        "cms_load.rails_connector", :name => "Obj Load", :index => index.to_s, :keys => keys
-      ) do
-        keys.map do |key|
-          results = revision.chain.query(index, key)
-          results.values.map { |row| extract_obj_data(row) }
-        end
-      end
-    end
-
-    def find_obj_data_from_cache_or_database_by(revision, index, keys)
-      keys_from_database = []
-      # load results from cache
-      results_from_cache = keys.map do |key|
-        cache_for(revision).read(cache_key_for(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_obj_data_from_database_by(revision, index, keys_from_database)
-      keys_from_database.each_with_index do |key, key_number|
-        store_obj_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
-
-    UNIQUE_INDICES = [:id, :path, :permalink].freeze
-    OBJ_PROPERTY_VALUE_TO_RANGE_VALUE_CONVERSIONS = {
-      :path => PathConversion.method(:path_from_list)
-    }.freeze
-
-    def store_obj_data_list_in_cache(revision, index, key, obj_data_list)
-      obj_data_list.each do |obj_data|
-        values = obj_data["values"]
-        UNIQUE_INDICES.each do |unique_index|
-          index_value = values["_#{unique_index}"]
-          if (converter = OBJ_PROPERTY_VALUE_TO_RANGE_VALUE_CONVERSIONS[unique_index])
-            index_value = converter.call(index_value)
-          end
-          store_item_in_cache(revision, unique_index, index_value, [obj_data])
-        end
-      end
-      unless UNIQUE_INDICES.include?(index)
-        store_item_in_cache(revision, index, key, obj_data_list)
-      end
-    end
-
-    def store_item_in_cache(revision, index, key, item)
-      cache_for(revision).write(cache_key_for(revision, index, key), item) if caching?
-    end
-
-    def cache_key_for(revision, index, key)
-      "#{revision.id}/obj/#{index}/#{key}"
-    end
-
-    def extract_obj_data(data)
-      {
-        "values" => data["values"].merge(
-          "_id" => data["obj_id"],
-          "_obj_type" => data["obj_type"],
-          "_obj_class" => data["obj_class_name"]
-        ),
-        "rtc_ref" => data["rtc_ref"],
-        "ext_ref" => data["ext_ref"],
-      }
-    end
-
-    def cache_for(revision)
-      revision.editable ? @editable_cache : @read_only_cache
-    end
-
-  end
-
-end