Allow to lock a replicaset's buckets from rebalancing

[Gerold103]

Add a method like

vshard.storage.lock_buckets()

This method must protect active buckets of this replicaset from rebalancing, and must forbid to receive new buckets. In other words, rebalancer must consider such replicaset as balanced, even if it contradicts with weights.

[Gerold103]

And allow to lock a concrete bucket. For example, by:

vshard.storage.bucket_pin(bucket_id)

[Gerold103]

Why?

1. Replicaset lock allows, for example, to separate a replicaset for testsing
   from production replicasets. Or to fix some application metadata, that must not
   be sharded for a while.

2. Bucket pin allows the same, but in the smaller scope.

How it works?

Replicaset lock is not the same as pinning all of its buckets. When a replicaset
is locked, it can neither receive new buckets nor send its own ones.
When a bucket is individually pinned, then it can not be sent, but its
replicaset can receive new buckets.

Replicaset lock and rebalancing

When a replicaset is locked, it does not participate in rebalancing. It means,
that even if its ethalon bucket count is not equal to an actual one, this
disbalance can not be fixed due to lock. When a rebalancer detects that one of
replicasets appears to be locked, it recalculates ethalon bucket count of
non-locked replicasets as if the locked replicaset and its buckets does not
exist.

Bucket pin and rebalancing

It is the much more complex case.

1. A rebalancer calculates ethalon bucket count as if all buckets are not
   pinned. Then it looks at each replicaset and compares its new ethalon bucket
   count against pinned bucket count. If the pinned one is less, then it is ok. A
   non-locked replicaset with pinned buckets can receive new ones.

2. If ethalon bucket count is less, than pinned one, this disbalance can not be
   fixed - the rebalancer can not move pinned buckets out of this replicaset. In
   such a case ethalon bucket count of this replicasets are set to exactly the
   pinned one. These replicasets are not considered by a rebalancer then, and their
   pinned count is subtracted from a total bucket count.

3. The described procecure is restarted from the step one with new total
   bucket count and with replicasets, those ethalon bucket count >= pinned one,
   until it appears, that on all replicasets ethalon bucket count >= pinned one.

Pseudocode:

function cluster_calculate_ethalon_balance(replicasets, bucket_count)
	-- spread buckets over replicasets using weights --
end;

cluster = <all of non-locked replicasets>;
bucket_count = <total bucket count in the cluster>;
next_cluster = <empty>;
while next_cluster != cluster do
	cluster_calculate_ethalon_balance(cluster, bucket_count);
	foreach replicaset in cluster do
		if replicaset.ethalon_bucket_count <
		   replicaset.pinned_bucket_count then
			bucket_count -= replicaset.pinned_bucket_count;
			replicaset.ethalon_bucket_count =
				replicaset.pinned_bucket_count;
		else
			new_cluster.add(replicaset);
		end;
	end;
end;
cluster_calculate_ethalon_balance(cluster, bucket_count);