public void testPackagePrivateBean() throws Exception {
        final MogeBean moge = MogeBeanFactory.create("moge");
        final BeanDesc beanDesc = new BeanDescImpl(moge.getClass());
        final PropertyDesc propDesc = beanDesc.getPropertyDesc("name");
        assertThat(propDesc, is(notNullValue()));
        assertThat((String) propDesc.getValue(moge), is("moge"));
    }

    /**
     *
     */

* IDE warnings become more accurate, reducing warnings fatigue.
* Public API nullability annotations become closer to reality.
* Java compilation of Gradle code suffers from small performance penalty (up to 10%).
* Time has to be allocated to clean up existing projects.
* One has to write NullAway-conformant code even when hacking.
* Some patterns used to satisfy NullAway can be slightly more verbose.

   */
  public static MappedByteBuffer map(File file, MapMode mode, long size) throws IOException {
    checkArgument(size >= 0, "size (%s) may not be negative", size);
    return mapInternal(file, mode, size);
  }

  private static MappedByteBuffer mapInternal(File file, MapMode mode, long size)
      throws IOException {
    checkNotNull(file);
    checkNotNull(mode);

    Closer closer = Closer.create();
    try {

     */
    int FLAGS2_UNICODE = 0x8000;

    /**
     * No capabilities.
     */
    int CAP_NONE = 0x0000;
    /**
     * Raw mode transfers are supported capability.
     */
    int CAP_RAW_MODE = 0x0001;
    /**
     * Multiplex mode is supported capability.
     */
    int CAP_MPX_MODE = 0x0002;
    /**
     * Unicode strings are supported capability.
     */

```

> NOTE: For Veeam Backup with Immutability, create the bucket with object lock enabled, e.g.,

```
mc mb -l myminio/veeambackup
```

> Object locking requires erasure coding enabled on the minio server. For more information see <https://docs.min.io/community/minio-object-store/operations/concepts/erasure-coding.html>.

### Add MinIO as an object store for Veeam

	ErrInvalidErasureEndpoints = newErrFn(
		"Invalid endpoint(s) in erasure mode",
		"Please provide correct combination of local/remote paths",
		"For more information, please refer to https://docs.min.io/community/minio-object-store/operations/concepts/erasure-coding.html",
	)

	ErrInvalidNumberOfErasureEndpoints = newErrFn(
		"Invalid total number of endpoints for erasure mode",
		"Please provide number of endpoints greater or equal to 2",

    }

    private int fid;
    private int mode;
    private long offset;

    /**
     * Sets the file identifier.
     *
     * @param fid
     *            the fid to set
     */
    public void setFid(final int fid) {
        this.fid = fid;
    }

    /**
     * Sets the seek mode.
     *
     * @param mode
     *            the mode to set
     */

MinIO in distributed mode lets you pool multiple drives (even on different machines) into a single object storage server. As drives are distributed across several nodes, distributed MinIO can withstand multiple node failures and yet ensure full data protection.

## Why distributed MinIO?

                deleted = true;
            } catch (SmbException e) {
                if (i < 2) {
                    log.debug("Retry delete in move, attempt {}", i + 1);
                    Thread.sleep(500);
                } else {
                    log.warn("Could not delete source after move, but continuing");
                    deleted = true; // Proceed anyway
                }
            }
        }

# FastAPI CLI { #fastapi-cli }

**FastAPI <abbr title="command line interface">CLI</abbr>** is a command line program that you can use to serve your FastAPI app, manage your FastAPI project, and more.

When you install FastAPI (e.g. with `pip install "fastapi[standard]"`), it comes with a command line program you can run in the terminal.

To run your FastAPI app for development, you can use the `fastapi dev` command:

<div class="termy">

```console