public RandomAmountInputStream(InputStream in, Random random) {
    super(checkNotNull(in));
    this.random = checkNotNull(random);
  }

  @Override
  public int read(byte[] b, int off, int len) throws IOException {
    return super.read(b, off, random.nextInt(len) + 1);
  }

root_access                     (boolean)   turn 'off' root credential access for all API calls including s3, admin operations (default: 'on')
sync_events                     (boolean)   set to enable synchronous bucket notifications (default: 'off')
object_max_versions             (number)    set max allowed number of versions per object (default: '9223372036854775807')
```

		for _, item := range cfgSubsysItems {
			off := item.Config.Get(config.Enable) == config.EnableOff
			switch hkv.Key {
			case config.EtcdSubSys:
				off = !etcd.Enabled(item.Config)
			case config.StorageClassSubSys:
				off = !storageclass.Enabled(item.Config)
			case config.PolicyPluginSubSys:
				off = !polplugin.Enabled(item.Config)
			case config.IdentityOpenIDSubSys:
				off = !openid.Enabled(item.Config)

./mc admin user add sitea foobar foo12345

./mc admin policy attach sitea/ consoleAdmin --user=foobar

./mc admin user info siteb foobar

killall -9 minio

echo "turning off root access, however site replication must continue"
export MINIO_API_ROOT_ACCESS=off

minio server --address 127.0.0.1:9001 "http://127.0.0.1:9001/tmp/multisitea/data/disterasure/xl{1...4}" \

     * @param off the start offset in array b at which the data is written
     * @param len the maximum number of bytes to read
     * @return the total number of bytes read into the buffer, or -1 if there is no more data
     * @throws IOException if an I/O error occurs
     */
    @Override
    public int read(final byte[] b, final int off, final int len) throws IOException {

     * @param b the byte array to read into
     * @param off the start offset in the array
     * @param len the number of bytes to read
     * @throws IOException if an I/O error occurs
     */
    public void readFully(final byte[] b, final int off, final int len) throws IOException {
        this.dis.readFully(b, off, len);
    }

    /**
     * Reads a 16-bit character value with proper alignment.

        "fe012443-6ba9-4ef2-bb94-b729d2060c78/test123/testw3c.pdf/xl.meta": {"Versions":[{"Type":1,"V2Obj":{"ID":"aGEA/ZUOR4ueRIZsAgfDqA==","DDir":"9MMwM47bS+K6KvQqN3hlDw==","EcAlgo":1,"EcM":2,"EcN":2,"EcBSize":1048576,"EcIndex":1,"EcDis...

    assertEquals(
        hashFunction.hashBytes(bytes), hashFunction.newHasher(size).putBytes(bytes).hash());
    int off = random.nextInt(size);
    int len = random.nextInt(size - off);
    assertEquals(
        hashFunction.hashBytes(bytes, off, len),
        hashFunction.newHasher(size).putBytes(bytes, off, len).hash());
  }

  private static void assertHashByteBufferEquivalence(HashFunction hashFunction, Random random) {

     *
     * @param b
     *            buffer
     * @param off
     *            offset into buffer
     * @param len
     *            read up to <code>len</code> bytes
     * @return number of bytes read
     * @throws SmbException if an I/O error occurs during read
     */
    int read(byte[] b, int off, int len) throws SmbException;

    /**
     * Current position in file
     *

        writeUShort(dest, offset + 2, length);
        return offset + 4;
    }

    static int writeSecurityBufferContent(final byte[] dest, final int pos, final int off, final byte[] src) {
        writeULong(dest, off, pos);
        if (src != null && src.length > 0) {
            System.arraycopy(src, 0, dest, pos, src.length);
            return src.length;
        }
        return 0;
    }