storage: introduce schema_management_mode

The new option allows to turn off automatic creation and upgrade
of functions, users, and privileges of all sorts. For that the
mode has to be specified to 'manual_access'. The default value
'auto' makes vshard behave like before this option's introduction.

Note that the option is intentionally not documented so as not to
encourage people to use it. The best approach is to let the schema
to be maintained fully automatically.

Closes #435

NO_DOC=internal

Author: Gerold103

test/luatest_helpers/vtest.lua

@@ -221,6 +221,22 @@ local function cluster_new(g, cfg)
 
             local grant_range = cfg.test_user_grant_range
             ivtest.clear_test_cfg_options(cfg)
+
+            if cfg.schema_management_mode == 'manual_access' then
+                local vexports = require('vshard.storage.exports')
+                local username = 'storage'
+                box.schema.user.create(username, {
+                    password = username,
+                    -- Yes, intentionally false to ensure that the user wasn't
+                    -- created by vshard.
+                    if_not_exists = false,
+                })
+                local exports = vexports.log[#vexports.log]
+                exports = vexports.compile(exports)
+                vexports.deploy_funcs(exports)
+                vexports.deploy_privs(exports, username)
+                box.schema.user.grant(username, 'replication')
+            end
             ivshard.storage.cfg(cfg, box.info.uuid)
 
             if grant_range ~= nil then

test/storage-luatest/schema_management_mode_test.lua

@@ -0,0 +1,79 @@
+local t = require('luatest')
+local vtest = require('test.luatest_helpers.vtest')
+local vutil = require('vshard.util')
+
+local group_config = {{mode = 'auto'}, {mode = 'manual_access'}}
+
+if vutil.feature.memtx_mvcc then
+    table.insert(group_config, {
+        mode = 'auto', memtx_use_mvcc_engine = true
+    })
+    table.insert(group_config, {
+        mode = 'manual_access', memtx_use_mvcc_engine = true
+    })
+end
+
+local test_group = t.group('storage_schema_management_mode', group_config)
+
+local cfg_template = {
+    sharding = {
+        {
+            master = 'auto',
+            replicas = {
+                replica_1_a = {read_only = false},
+                replica_1_b = {read_only = true},
+            },
+        },
+        {
+            master = 'auto',
+            replicas = {
+                replica_2_a = {read_only = false},
+            },
+        },
+    },
+    bucket_count = 10,
+}
+
+test_group.before_all(function(g)
+    cfg_template.memtx_use_mvcc_engine = g.params.memtx_use_mvcc_engine
+    cfg_template.schema_management_mode = g.params.mode
+    local cfg = vtest.config_new(cfg_template)
+
+    vtest.cluster_new(g, cfg)
+    vtest.cluster_bootstrap(g, cfg)
+    vtest.cluster_rebalancer_disable(g)
+end)
+
+test_group.after_all(function(g)
+    g.cluster:drop()
+    g.cluster = nil
+end)
+
+test_group.test_boot_with_mode_manual_access = function(g)
+    local bid = g.replica_1_a:exec(function(uuid)
+        local bid = _G.get_first_bucket()
+        local ok, err = ivshard.storage.bucket_send(bid, uuid,
+                                                    {timeout = iwait_timeout})
+        ilt.assert_equals(err, nil)
+        ilt.assert(ok)
+        _G.bucket_gc_wait()
+        return bid
+    end, {g.replica_2_a:replicaset_uuid()})
+    --
+    -- Switch to another mode. Still works fine.
+    --
+    local test_template = table.deepcopy(cfg_template)
+    if test_template.schema_management_mode == 'auto' then
+        test_template.schema_management_mode = 'manual_access'
+    else
+        test_template.schema_management_mode = 'auto'
+    end
+    vtest.cluster_cfg(g, vtest.config_new(test_template))
+    g.replica_2_a:exec(function(bid, uuid)
+        local ok, err = ivshard.storage.bucket_send(bid, uuid,
+                                                    {timeout = iwait_timeout})
+        ilt.assert_equals(err, nil)
+        ilt.assert(ok)
+        _G.bucket_gc_wait()
+    end, {bid, g.replica_1_a:replicaset_uuid()})
+end

test/unit-luatest/config_test.lua

@@ -299,4 +299,14 @@ g.test_enum = function()
         "Box.cfg mode must be enum {'auto', 'manual', nil}",
         vcfg.check, config)
     config.box_cfg_mode = nil
+
+    for _, v in pairs({'auto', 'manual_access'}) do
+        config.schema_management_mode = v
+        t.assert(vcfg.check(config))
+    end
+    config.schema_management_mode = 'bad'
+    t.assert_error_msg_content_equals(
+        "Schema management mode must be enum {'auto', 'manual_access', nil}",
+        vcfg.check, config)
+    config.schema_management_mode = nil
 end

vshard/cfg.lua

@@ -410,7 +410,11 @@ local cfg_template = {
     box_cfg_mode = {
         name = 'Box.cfg mode', type = 'enum', is_optional = true,
         default = 'auto', enum = {'auto', 'manual'},
-    }
+    },
+    schema_management_mode = {
+        name = 'Schema management mode', type = 'enum',
+        is_optional = true, default = 'auto', enum = {'auto', 'manual_access'},
+    },
 }
 
 --

vshard/storage/schema.lua

@@ -19,6 +19,9 @@ if not M then
         -- and be not nullable. Values in this part are considered as bucket
         -- identifiers.
         shard_index = nil,
+        -- How to manage the schema. Auto - do everything automatically,
+        -- manual - expect some things to be done externally outside of vshard.
+        management_mode = 'auto',
         errinj = {
             ERRINJ_UPGRADE = false,
         },
@@ -78,12 +81,6 @@ end
 --
 local function schema_init_0_1_15_0(username, password)
     llog.info("Initializing schema %s", schema_version_make({0, 1, 15, 0}))
-    box.schema.user.create(username, {
-        password = password,
-        if_not_exists = true,
-    })
-    box.schema.user.grant(username, 'replication', nil, nil,
-                          {if_not_exists = true})
 
     local bucket = box.schema.space.create('_bucket')
     bucket:format({
@@ -94,11 +91,19 @@ local function schema_init_0_1_15_0(username, password)
     bucket:create_index('pk', {parts = {'id'}})
     bucket:create_index('status', {parts = {'status'}, unique = false})
 
-    local exports = lvexports.log[1]
-    assert(exports.version == '0.1.15.0')
-    exports = lvexports.compile(exports)
-    lvexports.deploy_funcs(exports)
-    lvexports.deploy_privs(exports, username)
+    if M.management_mode == 'auto' then
+        box.schema.user.create(username, {
+            password = password,
+            if_not_exists = true,
+        })
+        box.schema.user.grant(username, 'replication', nil, nil,
+                              {if_not_exists = true})
+        local exports = lvexports.log[1]
+        assert(exports.version == '0.1.15.0')
+        exports = lvexports.compile(exports)
+        lvexports.deploy_funcs(exports)
+        lvexports.deploy_privs(exports, username)
+    end
     box.space._schema:replace({'vshard_version', 0, 1, 15, 0})
 end
 
@@ -130,7 +135,7 @@ end
 -- to a certain vshard version.
 --
 local function schema_upgrade_core_features()
-    if M.is_core_up_to_date then
+    if M.is_core_up_to_date or M.management_mode ~= 'auto' then
         return
     end
     local version = schema_current_version()
@@ -186,8 +191,10 @@ local function schema_upgrade(target_version, username, password)
                         next_version)
                     exports = lvexports.compile(exports)
                     handler.upgrade()
-                    lvexports.deploy_funcs(exports)
-                    lvexports.deploy_privs(exports, username)
+                    if M.management_mode == 'auto' then
+                        lvexports.deploy_funcs(exports)
+                        lvexports.deploy_privs(exports, username)
+                    end
                 end)
                 if ok and errinj == 'end' then
                     ok, err1 = false, 'Errinj in end'
@@ -204,8 +211,10 @@ local function schema_upgrade(target_version, username, password)
                         prev_version)
                     exports = lvexports.compile(exports)
                     handler.downgrade()
-                    lvexports.deploy_funcs(exports)
-                    lvexports.deploy_privs(exports, username)
+                    if M.management_mode == 'auto' then
+                        lvexports.deploy_funcs(exports)
+                        lvexports.deploy_privs(exports, username)
+                    end
                 end)
                 if not ok then
                     llog.info("Couldn't downgrade schema to %s - fatal error: "..
@@ -259,6 +268,7 @@ end
 
 local function schema_cfg(cfg)
     M.shard_index = cfg.shard_index
+    M.management_mode = cfg.schema_management_mode
 end
 
 M.current_version = schema_current_version