infopark_cloud_connector 6.8.3.115.227021242 → 6.8.3.174.51542603

data/lib/rails_connector/obj_data_from_database.rb

@@ -1,109 +0,0 @@
-module RailsConnector
-
-  class ObjDataFromDatabase < ObjData
-
-    def initialize(data, revision)
-      @rtc_ref = data["rtc_ref"]
-      @values = data["values"]
-      @ext_ref = data["ext_ref"]
-      @revision = revision
-    end
-
-    def value_and_type_of(attribute_name)
-      if internal_attribute?(attribute_name)
-        attribute_type = type_of_internal(attribute_name)
-
-        attribute_value = read_value(attribute_name)
-        if attribute_name == '_text_links'
-          attribute_value = attribute_value && attribute_value.values
-        elsif attribute_name == '_path'
-          attribute_value = PathConversion.path_from_list(attribute_value)
-        end
-      else
-        attribute_type = current_attribute_type(attribute_name)
-        if legacy_attribute_type(attribute_name) == attribute_type
-          attribute_value = read_value(attribute_name)
-        else
-          attribute_value = default_attribute_value(attribute_type)
-        end
-      end
-
-      [attribute_value, attribute_type]
-    end
-
-    def has_custom_attribute?(name)
-      obj_class_attributes.include?(name)
-    end
-
-    def all_custom_attributes
-      obj_class_attributes
-    end
-
-    private
-
-    attr_reader :values, :rtc_ref, :revision
-
-    def current_attribute_type(name)
-      revision.attributes[name]["type"]
-    end
-
-    def obj_class_attributes
-      @obj_class_attributes ||=
-        begin
-          name = values["_obj_class"]
-          if data = revision.obj_classes[name]
-            Set.new(data["attributes"]) || Set.new
-          else
-            raise "Could not find ObjClass with name #{name} in Revision #{revision.id}!"
-          end
-        end
-    end
-
-    def read_value(attribute_name)
-      return values[attribute_name] if values.key?(attribute_name)
-      if @ext_ref && (attribute_name == "_text_links" || attribute_name[0] != ?_)
-        extend_values_with_dict_storage_values
-      end
-      values[attribute_name]
-    end
-
-    def extend_values_with_dict_storage_values
-      return unless @ext_ref
-
-      # may raise Kvom::Storage::NotFound
-      ext_values = DictStorage.get(@ext_ref)
-      values.reverse_merge!(ext_values)
-      @ext_ref = nil
-    end
-
-    SPECIAL_INTERNAL_ATTRIBUTES = Set.new(%w[title body blob])
-
-    def internal_attribute?(attribute_name)
-      ?_ == attribute_name[0] || SPECIAL_INTERNAL_ATTRIBUTES.include?(attribute_name)
-    end
-
-    def legacy_attribute_type(name)
-      if attr_def = legacy_attributes[name]
-        attr_def["type"]
-      end
-    end
-
-    def legacy_attributes
-      @attributes ||=
-        begin
-          rtc = DictStorage.get(rtc_ref)
-          if rtc['obj_classes'] && rtc['attributes'] && oc = rtc['obj_classes'][values['_obj_class']]
-            rtc['attributes'].inject({}) do |attrs, (name, value)|
-              attrs[name] = value if oc['attributes'] && oc['attributes'].include?(name)
-              attrs
-            end
-          else
-            {}
-          end
-        end
-    end
-
-  end
-
-end
-

data/lib/rails_connector/path_conversion.rb

@@ -1,21 +0,0 @@
-module RailsConnector
-
-  module PathConversion
-
-    def self.path_from_list(components)
-      if components
-        "/#{components.join("/")}"
-      else
-        "/"
-      end
-    end
-
-    private
-
-    def path_from_list(components)
-      PathConversion.path_from_list(components)
-    end
-
-  end
-
-end

data/lib/rails_connector/permission.rb

@@ -1,39 +0,0 @@
-module RailsConnector
-
-  # The permissions assigned to an Obj.
-  class Permission < CmsBaseModel
-    # Returns the Array of the names of the user groups to which read permission has been granted.
-    def self.read
-      user_groups_for_permission_type(1)
-    end
-
-    # Returns the Array of the names of the user groups to which write permission has been granted
-    def self.write
-      user_groups_for_permission_type(2)
-    end
-
-    # Returns the Array of the names of the user groups to which root permission has been granted
-    def self.root
-      user_groups_for_permission_type(3)
-    end
-
-    # Returns the Array of the names of the user groups to which the children creation permission has been granted.
-    def self.create_children
-      user_groups_for_permission_type(4)
-    end
-
-    # Returns the Array of the names of the user groups to which live read permission has been granted.
-    def self.live
-      user_groups_for_permission_type(5)
-    end
-
-    private
-
-    def self.user_groups_for_permission_type(permission_type)
-      # Field name "user_login" is a legacy from CM tables.
-      # Actually the field contains the user group.
-      select(:user_login).where(:permission_type => permission_type).map(&:user_login)
-    end
-  end
-
-end

data/lib/rails_connector/revision.rb

@@ -1,75 +0,0 @@
-module RailsConnector
-
-  class Revision < CmsBaseModel
-    self.key_prefix = "rev"
-
-    property :generation
-    property :base_revision_id
-    property :title
-    property :content_cache_id
-    property :editable
-
-    def self.current=(revision_or_proc)
-      raise "Do not use Revision.current=, use Workspace.current= instead."
-    end
-
-    def self.current
-      raise "Do not use Revision.current, use Workspace.current instead."
-    end
-
-    def self.find_by_label(label_name)
-      workspace = Workspace.find(label_name)
-      find(workspace.revision_id)
-    end
-
-    def chain
-      @chain ||= Chain.build_for(self, content_cache)
-    end
-
-    def invalidate_chain
-      @chain = nil
-    end
-
-    # returns the base revision or nil for an initial revision
-    def base_revision
-      @base_revision ||= base_revision_id ? Revision.find(base_revision_id) : nil
-    end
-
-    # returns the content cache to be used with this revision or nil if not available
-    def content_cache
-      if content_cache_id
-        if @content_cache && content_cache_id == @content_cache.id
-          @content_cache
-        else
-          @content_cache = ContentCache.find_by_id(content_cache_id)
-        end
-      end
-    end
-
-    def inspect
-      "<#{self.class} id=\"#{id}\" title=\"#{title}\">"
-    end
-
-    def obj_classes
-      rtc['obj_classes']
-    end
-
-    def attributes
-      rtc['attributes']
-    end
-
-    def rtc_id
-      rtc_ref['id']
-    end
-
-    private
-
-    def rtc
-      @rtc ||= DictStorage.get(rtc_ref)
-    end
-
-    def rtc_ref
-      read_attribute('rtc_ref')
-    end
-  end
-end

data/lib/rails_connector/s3_blob.rb

@@ -1,89 +0,0 @@
-module RailsConnector
-
-class S3Blob
-  class << self
-
-    def s3_objects
-      @s3_objects ||= bucket.objects
-    end
-
-    def bucket_url
-      @cached_bucket_url ||= bucket.url
-    end
-
-    def configure(spec)
-      @spec = spec.symbolize_keys
-
-      # invalidate cache
-      @cached_bucket_url = nil
-      @s3_objects = nil
-    end
-
-    def find(id)
-      new(id)
-    end
-
-    private
-
-    attr_reader :spec
-
-    def s3_api
-      AWS::S3.new(
-        :access_key_id => access_key_id,
-        :secret_access_key => secret_access_key
-      )
-    end
-
-    def bucket
-      s3_api.buckets[bucket_name]
-    end
-
-    def bucket_name
-      spec[:bucket_name]
-    end
-
-    def access_key_id
-      spec[:access_key_id]
-    end
-
-    def secret_access_key
-      spec[:secret_access_key]
-    end
-
-  end
-
-  attr_reader :id
-
-  def initialize(id)
-    @id = id
-  end
-
-  def s3_object
-    @s3_object ||= self.class.s3_objects[id]
-  end
-
-  def url
-    # the 'official' way to calculate an s3 url is as follows:
-    # s3_object.public_url.to_s
-    #
-    # this is about 25x faster:
-    # assumption: 'id' does not contain any characters that need escaping.
-    # the assumptions is valid for cms blobs.
-    "#{self.class.bucket_url}#{@id}"
-  end
-
-  def meta_url
-    url
-  end
-
-  def content_type
-    s3_object.content_type
-  end
-
-  def length
-    s3_object.content_length
-  end
-
-end
-
-end # module RailsConnector

data/lib/rails_connector/service_blob.rb

@@ -1,48 +0,0 @@
-module RailsConnector
-
-# TODO Caching:
-# unlimited urls: ewig
-# limited urls: zeitlimit - x (x fuer mindestverwendbarkeitszeit)
-class ServiceBlob
-
-  class << self
-
-    def configure(config)
-    end
-
-    def find(id)
-      new(id)
-    end
-
-  end
-
-  attr_reader :id
-
-  def initialize(id)
-    @id = id
-  end
-
-  def url
-    raw_data["url"]
-  end
-
-  def content_type
-    meta_data[:content_type]
-  end
-
-  def length
-    meta_data[:content_length].to_i
-  end
-
-  private
-
-  def raw_data
-    @raw_data ||= CmsBackend.find_blob_data_by_id(id)
-  end
-
-  def meta_data
-    @meta_data ||= RestClient.head(raw_data["meta_url"]).headers
-  end
-end
-
-end

data/lib/rails_connector/service_cms_backend.rb

@@ -1,194 +0,0 @@
-require 'rest_client'
-
-module RailsConnector
-
-  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
-
-  # connects the cloud connector to the connector service
-  class ServiceCmsBackend < CmsBackend
-    BLOB_DATA_CACHE_PREFIX = 'blob_data'.freeze
-    VALID_INDEX_NAMES = %w[id path ppath permalink].freeze
-
-    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)
-      from_content_state_id = ContentStateCaching.find_content_state_id(id)
-      request_params = {:workspace_id => id}
-      request_params[:content_state_id] = from_content_state_id if from_content_state_id
-      raw_data = ContentService.query('workspaces/query', request_params)
-      if raw_workspace_data = raw_data['workspace']
-        workspace_data = WorkspaceDataFromService.new(raw_workspace_data)
-        if from_content_state_id != workspace_data.content_state_id
-          ContentStateCaching.store_content_state(workspace_data)
-          ContentStateCaching.store_content_state_id(workspace_data.id,
-              workspace_data.content_state_id)
-        end
-        workspace_data
-      end
-    end
-
-    def find_obj_data_by(workspace_data, index, keys)
-      index = index.to_s
-      assert_valid_index_name(index)
-      raw_data = find_raw_data_from_cache_or_database_by(workspace_data, index, keys)
-      raw_data.map do |raw_list|
-        raw_list.map do |raw_obj_data|
-          ObjDataFromService.new(raw_obj_data)
-        end
-      end
-    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_raw_data_from_cache_or_database_by(workspace_data, index, keys)
-      keys_from_database = []
-      # load results from cache
-      results_from_cache = keys.map do |key|
-        find_raw_data_from_cache_by(workspace_data, 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(workspace_data, index, keys_from_database)
-      keys_from_database.each_with_index do |key, key_number|
-        store_raw_data_list_in_cache(workspace_data, 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(workspace_data, index, key)
-      ContentStateCaching.find_obj_data(workspace_data, index, key) if caching?
-    end
-
-    def find_raw_data_from_database_by(workspace_data, index, keys)
-      return [] if keys.blank?
-      instrumenter = ActiveSupport::Notifications.instrumenter
-      instrumenter.instrument(
-        "cms_load.rails_connector", :name => "Obj Load", :index => index, :keys => keys
-      ) do
-        @query_counter += 1
-        queries = ContentServiceObjQueries.new(keys.map {|key| {:type => index, :param => key} })
-        until queries.finished?
-          queries.handle_response(ContentService.query(
-            "objs/query",
-            :queries => queries.open_queries,
-            :workspace_id => workspace_data.id,
-            :revision_id => workspace_data.revision_id
-          ))
-        end
-        queries.results
-      end
-    end
-
-    UNIQUE_INDICES = [:id, :path, :permalink].freeze
-
-    def store_raw_data_list_in_cache(workspace_data, 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(workspace_data, unique_index, unique_index_values.first, [values])
-          end
-        end
-      end
-      unless UNIQUE_INDICES.include?(index)
-        store_item_in_cache(workspace_data, index, key, raw_data_list)
-      end
-    end
-
-    def store_item_in_cache(workspace_data, index, key, item)
-      ContentStateCaching.store_obj_data(workspace_data, 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
-
-  end
-
-end