return kstatus.CreateCondition(conditions, condition, cond.setOnce)
			}
		}
		// A condition can be "negative polarity" (ex: ListenerInvalid) or "positive polarity" (ex:
		// ListenerValid), so in order to determine the status we should set each `condition` defines its
		// default positive status. When there is an error, we will invert that. Example: If we have

      return failure();
    }

    // The input tensors x and y are 2-D or higher with shape:
    //       [..., r_x == 1, c_x] and [..., c_y, r_y].
    // The position of r_* and c_* are determined by the polarity of
    // the adj(X|Y) attribute, respectively.
    // So adjX == True indicates [..., c_x, r_x == 1].
    llvm::ArrayRef<int64_t> lhs_shape =
        mlir::cast<RankedTensorType>(bmm_op.getX().getType()).getShape();

* Update to fluentd-gcp:1.28.3, rebased on ubuntu-slim:0.8 ([#43928](https://github.com/kubernetes/kubernetes/pull/43928), [@ixdy](https://github.com/ixdy))
* Fix polarity of NodePort logic to avoid leaked ports ([#43259](https://github.com/kubernetes/kubernetes/pull/43259), [@thockin](https://github.com/thockin))

### Allowed values for STANDARD storage class

`STANDARD` storage class implies more parity than `REDUCED_REDUNDANCY` class. So, `STANDARD` parity drives should be

- Greater than or equal to 2, if `REDUCED_REDUNDANCY` parity is not set.
- Greater than `REDUCED_REDUNDANCY` parity, if it is set.

Parity blocks can not be higher than data blocks, so `STANDARD` storage class parity can not be higher than N/2. (N being total number of drives)

	if err != nil {
		return err
	}
	sc.Parity = s.Parity
	return nil
}

// MarshalText - marshals storage class string.
func (sc *StorageClass) MarshalText() ([]byte, error) {
	if sc.Parity != 0 {
		return []byte(fmt.Sprintf("%s:%d", schemePrefix, sc.Parity)), nil
	}
	return []byte{}, nil
}

func (sc *StorageClass) String() string {
	if sc.Parity != 0 {

# Erasure code sizing guide

## Toy Setups

Capacity constrained environments, MinIO will work but not recommended for production.

| servers | drives (per node) | stripe_size | parity chosen (default) | tolerance for reads (servers) | tolerance for writes (servers) |
|--------:|------------------:|------------:|------------------------:|------------------------------:|-------------------------------:|

			Standard: StorageClass{
				Parity: 8,
			},
			RRS: StorageClass{
				Parity: 2,
			},
			initialized: true,
		}
		// Set env var for test case 4
		if i+1 == 4 {
			scfg.RRS.Parity = 7
		}
		// Set env var for test case 5
		if i+1 == 5 {
			scfg.Standard.Parity = 6
		}
		// Set env var for test case 6
		if i+1 == 6 {
			scfg.Standard.Parity = 7
		}

	}

	Help = config.HelpKVS{
		config.HelpKV{
			Key:         ClassStandard,
			Description: `set the parity count for default standard storage class` + defaultHelpPostfix(ClassStandard),
			Optional:    true,
			Type:        "string",
		},
		config.HelpKV{
			Key:         ClassRRS,
			Description: `set the parity count for reduced redundancy storage class` + defaultHelpPostfix(ClassRRS),
			Optional:    true,

)

var (
	configRRSParityMD = NewGaugeMD(configRRSParity,
		"Reduced redundancy storage class parity")
	configStandardParityMD = NewGaugeMD(configStandardParity,
		"Standard storage class parity")
)

// loadClusterConfigMetrics - `MetricsLoaderFn` for cluster config
// such as standard and RRS parity.
func loadClusterConfigMetrics(ctx context.Context, m MetricValues, c *metricsCache) error {

	for _, disk := range diskInfo {
		// Ignore invalid.
		if disk.PoolIndex < 0 || len(s.Backend.StandardSCData) <= disk.PoolIndex {
			// https://github.com/minio/minio/issues/16500
			continue
		}
		// Ignore parity disks
		if disk.DiskIndex < s.Backend.StandardSCData[disk.PoolIndex] {
			capacity += disk.TotalSpace
		}
	}
	return
}

// GetTotalCapacityFree gets the total capacity free in the cluster.