"hide": false,
          "instant": true,
          "legendFormat": ".",
          "range": false,
          "refId": "B"
        }
      ],
      "title": "Total Online/Offline Drives",
      "type": "gauge"
    },
    {
      "datasource": {
        "type": "prometheus",
        "uid": "${DS_PROMETHEUS}"
      },
      "description": "",
      "fieldConfig": {

public final class Longs {
  private Longs() {}

  /**
   * The number of bytes required to represent a primitive {@code long} value.
   *
   * <p>Prefer {@link Long#BYTES} instead.
   */
  // The constants value gets inlined here.
  @SuppressWarnings("AndroidJdkLibsChecker")
  public static final int BYTES = Long.BYTES;

  /**
   * The largest power of two that can be represented as a {@code long}.
   *
   * @since 10.0
   */

 * is a basic description of the algorithm. For a more complete description
 * we recommend reading the section on Access Control in Keith Brown's
 * "The .NET Developer's Guide to Windows Security" (which is also
 * available online).
 * <p>
 * Direct ACEs are evaluated first in order. The SID of the user performing
 * the operation and the desired access bits are compared to the SID
 * and access mask of each ACE. If the SID matches, the allow/deny flags

	"github.com/minio/madmin-go/v3"
)

// StorageAPI interface.
type StorageAPI interface {
	// Stringified version of disk.
	String() string

	// Storage operations.

	// Returns true if disk is online and its valid i.e valid format.json.
	// This has nothing to do with if the drive is hung or not responding.
	// For that individual storage API calls will fail properly. The purpose

          </description>
        </field>
        <field>
          <name>provides</name>
          <version>1.1.0+</version>
          <type>Properties</type>
          <association xml.mapStyle="inline">
            <type>String</type>
            <multiplicity>*</multiplicity>
          </association>
          <!-- <identifier>true</identifier> -->
          <description>

			retries++
			// after 20 retries start logging that servers are not reachable yet
			if retries >= 20 {
				logger.Info(fmt.Sprintf("Waiting for at least %d remote servers with valid configuration to be online", len(clnts)/2))
				if len(offlineEndpoints) > 0 {
					logger.Info(fmt.Sprintf("Following servers are currently offline or unreachable %s", offlineEndpoints))
				}
				if len(incorrectConfigs) > 0 {

          <name>properties</name>
          <description>Extended configuration specific to this profile goes
            here.</description>
          <type>Properties</type>
          <association xml.mapStyle="inline">
            <type>String</type>
            <multiplicity>*</multiplicity>
          </association>
        </field>
        <field>
          <name>repositories</name>
          <version>1.0.0</version>

			z.Checksum, bts, err = msgp.ReadBytesBytes(bts, z.Checksum)
			if err != nil {
				err = msgp.WrapError(err, "Checksum")
				return
			}
		case "Inlined":
			z.Inlined, bts, err = msgp.ReadBoolBytes(bts)
			if err != nil {
				err = msgp.WrapError(err, "Inlined")
				return
			}
		case "DataBlocks":
			z.DataBlocks, bts, err = msgp.ReadIntBytes(bts)
			if err != nil {

### Metadata for object replication - on source

```
...
  "MetaSys": {
      "x-minio-internal-inline-data": "dHJ1ZQ==",

 * is a basic description of the algorithm. For a more complete description
 * we recommend reading the section on Access Control in Keith Brown's
 * "The .NET Developer's Guide to Windows Security" (which is also
 * available online).
 * <p>
 * Direct ACEs are evaluated first in order. The SID of the user performing
 * the operation and the desired access bits are compared to the SID
 * and access mask of each ACE. If the SID matches, the allow/deny flags