Separate common sharding metadata methods from sharding key methods

It would be more efficient to get sharding keys and
sharding functions from storage in one `fetch_on_storage`
function call. So, this function is common for sharding
keys and sharding functions support. As well as functions
for fetching on router. These methods are introduced
in `sharding_metadata` module. Methods for working
with sharding key structure are introduced in
sharding key module.

Part of #237

Author: AnaNek

crud/common/const.lua

@@ -2,6 +2,6 @@ local const = {}
 
 const.RELOAD_RETRIES_NUM = 1
 const.RELOAD_SCHEMA_TIMEOUT = 3 -- 3 seconds
-const.FETCH_SHARDING_KEY_TIMEOUT = 3 -- 3 seconds
+const.FETCH_SHARDING_METADATA_TIMEOUT = 3 -- 3 seconds
 
 return const

crud/common/sharding/init.lua

@@ -22,7 +22,7 @@ function sharding.tuple_get_bucket_id(tuple, space, specified_bucket_id)
     end
 
     local sharding_index_parts = space.index[0].parts
-    local sharding_key_as_index_obj, err = sharding_metadata_module.fetch_on_router(space.name)
+    local sharding_key_as_index_obj, err = sharding_metadata_module.fetch_sharding_key_on_router(space.name)
     if err ~= nil then
         return nil, err
     end

crud/common/sharding/sharding_key.lua

@@ -1,45 +1,14 @@
-local fiber = require('fiber')
 local errors = require('errors')
 
-local call = require('crud.common.call')
-local const = require('crud.common.const')
 local dev_checks = require('crud.common.dev_checks')
-local cache = require('crud.common.sharding_key_cache')
+local cache = require('crud.common.sharding.sharding_metadata_cache')
 local utils = require('crud.common.utils')
 
 local ShardingKeyError = errors.new_class("ShardingKeyError", {capture_stack = false})
-local FetchShardingKeyError = errors.new_class('FetchShardingKeyError', {capture_stack = false})
 local WrongShardingConfigurationError = errors.new_class('WrongShardingConfigurationError',  {capture_stack = false})
 
-local FETCH_FUNC_NAME = '_crud.fetch_on_storage'
-
 local sharding_key_module = {}
 
--- Function decorator that is used to prevent _fetch_on_router() from being
--- called concurrently by different fibers.
-local function locked(f)
-    dev_checks('function')
-
-    return function(timeout, ...)
-        local timeout_deadline = fiber.clock() + timeout
-        local ok = cache.fetch_lock:put(true, timeout)
-        -- channel:put() returns false in two cases: when timeout is exceeded
-        -- or channel has been closed. However error message describes only
-        -- first reason, I'm not sure we need to disclose to users such details
-        -- like problems with synchronization objects.
-        if not ok then
-            return FetchShardingKeyError:new(
-                "Timeout for fetching sharding key is exceeded")
-        end
-        local timeout = timeout_deadline - fiber.clock()
-        local status, err = pcall(f, timeout, ...)
-        cache.fetch_lock:get()
-        if not status or err ~= nil then
-            return err
-        end
-    end
-end
-
 -- Build a structure similar to index, but it is not a real index object,
 -- it contains only parts key with fieldno's.
 local function as_index_object(space_name, space_format, sharding_key_def)
@@ -59,104 +28,6 @@ local function as_index_object(space_name, space_format, sharding_key_def)
     return {parts = fieldnos}
 end
 
--- Return a map with metadata or nil when space box.space._ddl_sharding_key is
--- not available on storage.
-function sharding_key_module.fetch_on_storage()
-    local sharding_key_space = box.space._ddl_sharding_key
-    if sharding_key_space == nil then
-        return nil
-    end
-
-    local SPACE_NAME_FIELDNO = 1
-    local SPACE_SHARDING_KEY_FIELDNO = 2
-    local metadata_map = {}
-    for _, tuple in sharding_key_space:pairs() do
-        local space_name = tuple[SPACE_NAME_FIELDNO]
-        local sharding_key_def = tuple[SPACE_SHARDING_KEY_FIELDNO]
-        local space_format = box.space[space_name]:format()
-        metadata_map[space_name] = {
-            sharding_key_def = sharding_key_def,
-            space_format = space_format,
-        }
-    end
-
-    return metadata_map
-end
-
--- Under high load we may get a case when more than one fiber will fetch
--- metadata from storages. It is not good from performance point of view.
--- locked() wraps a _fetch_on_router() to limit a number of fibers that fetches
--- a sharding metadata by a single one, other fibers will wait while
--- cache.fetch_lock become unlocked during timeout passed to
--- _fetch_on_router().
-local _fetch_on_router = locked(function(timeout)
-    dev_checks('number')
-
-    if cache.sharding_key_as_index_obj_map ~= nil then
-        return
-    end
-
-    local metadata_map, err = call.any(FETCH_FUNC_NAME, {}, {
-        timeout = timeout
-    })
-    if err ~= nil then
-        return err
-    end
-    if metadata_map == nil then
-        cache.sharding_key_as_index_obj_map = {}
-        return
-    end
-
-    cache.sharding_key_as_index_obj_map = {}
-    for space_name, metadata in pairs(metadata_map) do
-        local sharding_key_as_index_obj, err = as_index_object(space_name,
-                                                    metadata.space_format,
-                                                    metadata.sharding_key_def)
-        if err ~= nil then
-            return err
-        end
-        cache.sharding_key_as_index_obj_map[space_name] = sharding_key_as_index_obj
-    end
-end)
-
--- Get sharding index for a certain space.
---
--- Return:
---  - sharding key as index object, when sharding key definition found on
---  storage.
---  - nil, when sharding key definition was not found on storage. Pay attention
---  that nil without error is a successfull return value.
---  - nil and error, when something goes wrong on fetching attempt.
---
-function sharding_key_module.fetch_on_router(space_name, timeout)
-    dev_checks('string', '?number')
-
-    if cache.sharding_key_as_index_obj_map ~= nil then
-        return cache.sharding_key_as_index_obj_map[space_name]
-    end
-
-    local timeout = timeout or const.FETCH_SHARDING_KEY_TIMEOUT
-    local err = _fetch_on_router(timeout)
-    if err ~= nil then
-        if cache.sharding_key_as_index_obj_map ~= nil then
-            return cache.sharding_key_as_index_obj_map[space_name]
-        end
-        return nil, err
-    end
-
-    if cache.sharding_key_as_index_obj_map ~= nil then
-        return cache.sharding_key_as_index_obj_map[space_name]
-    end
-
-    return nil, FetchShardingKeyError:new(
-        "Fetching sharding key for space '%s' is failed", space_name)
-end
-
-function sharding_key_module.update_cache(space_name)
-    cache.drop_caches()
-    return sharding_key_module.fetch_on_router(space_name)
-end
-
 -- Make sure sharding key definition is a part of primary key.
 local function is_part_of_pk(space_name, primary_index_parts, sharding_key_as_index_obj)
     dev_checks('string', 'table', 'table')
@@ -204,13 +75,9 @@ end
 
 -- Extract sharding key from pk.
 -- Returns a table with sharding key or pair of nil and error.
-function sharding_key_module.extract_from_pk(space_name, primary_index_parts, primary_key, timeout)
-    dev_checks('string', 'table', '?', '?number')
+function sharding_key_module.extract_from_pk(space_name, sharding_key_as_index_obj, primary_index_parts, primary_key)
+    dev_checks('string', '?table', 'table', '?')
 
-    local sharding_key_as_index_obj, err = sharding_key_module.fetch_on_router(space_name, timeout)
-    if err ~= nil then
-        return nil, err
-    end
     if sharding_key_as_index_obj == nil then
         return primary_key
     end
@@ -229,8 +96,22 @@ function sharding_key_module.extract_from_pk(space_name, primary_index_parts, pr
     return extract_from_index(primary_key, primary_index_parts, sharding_key_as_index_obj)
 end
 
-function sharding_key_module.init()
-   _G._crud.fetch_on_storage = sharding_key_module.fetch_on_storage
+function sharding_key_module.construct_as_index_obj_cache(metadata_map)
+    dev_checks('table')
+
+    cache.sharding_key_as_index_obj_map = {}
+    for space_name, metadata in pairs(metadata_map) do
+        if metadata.sharding_key_def ~= nil then
+            local sharding_key_as_index_obj, err = as_index_object(space_name,
+                                                                   metadata.space_format,
+                                                                   metadata.sharding_key_def)
+            if err ~= nil then
+                return err
+            end
+
+            cache.sharding_key_as_index_obj_map[space_name] = sharding_key_as_index_obj
+        end
+    end
 end
 
 sharding_key_module.internal = {