return s
}

func (s *suiteImpl) Setup(fn resource.SetupFn) Suite {
	s.setupFns = append(s.setupFns, fn)
	return s
}

func (s *suiteImpl) Teardown(fn resource.TeardownFn) Suite {
	s.teardownFns = append(s.teardownFns, fn)
	return s
}

func (s *suiteImpl) SetupParallel(fns ...resource.SetupFn) Suite {
	s.setupFns = append(s.setupFns, func(ctx resource.Context) error {
		g := multierror.Group{}

func (t *T) SetupForServicePair(setupFn svcPairSetupFn) *T {
	t.deploymentPairSetup = append(t.deploymentPairSetup, setupFn)
	return t
}

// SetupForDestination is run each time the destination Service (but not destination cluster) changes.
func (t *T) SetupForDestination(setupFn dstSetupFn) *T {
	t.destinationDeploymentSetup = append(t.destinationDeploymentSetup, setupFn)
	return t
}

		s := setupSDS(t)
		c := s.Connect()
		s.Verify(c.RequestResponseAck(t, &discovery.DiscoveryRequest{ResourceNames: []string{rootResourceName}}), expectRoot)
		s.Verify(c.RequestResponseAck(t, &discovery.DiscoveryRequest{ResourceNames: []string{rootResourceName}}), expectRoot)
		c.ExpectNoResponse(t)
	})
	t.Run("parallel", func(t *testing.T) {
		s := setupSDS(t)
		cert := s.Connect()

// See the License for the specific language governing permissions and
// limitations under the License.

package resource

// SetupFn is a function used for performing setup actions.
type SetupFn func(ctx Context) error

// TeardownFn is a function used for performing tear-down actions.
type TeardownFn func(ctx Context)

	s, err := NewLocal(t, ns)
	if err != nil {
		t.Fatal(err)
	}
	return s
}

// Setup is a utility function for configuring a global authz Server.
func Setup(server *Server, ns namespace.Getter) resource.SetupFn {
	if ns == nil {
		ns = namespace.NilGetter
	}

	return func(ctx resource.Context) error {
		s, err := New(ctx, ns())
		if err != nil {
			return err
		}

		// Store the server.
		*server = s

apiVersion: release-notes/v2
kind: bug-fix
area: istioctl
releaseNotes:
  - |

	t.Helper()
	s, err := New(t, ns)
	if err != nil {
		t.Fatal(err)
	}
	return s
}

// Setup is a utility function for configuring a jwt Server.
func Setup(server *Server, ns namespace.Getter) resource.SetupFn {
	if ns == nil {
		ns = namespace.NilGetter
	}

	return func(ctx resource.Context) error {
		s, err := New(ctx, ns())
		if err != nil {
			return err
		}

		// Store the server.
		*server = s

```

- On baremetal setups, if you have `MINIO_VOLUMES="http://minio{1...2}/data{1...4} http://minio{3...4}/data{1...4}"`, you can remove the first argument `http://minio{1...2}/data{1...4}` to update your `MINIO_VOLUMES` setting, then restart all the servers in the setup in parallel using `systemctl restart minio`.

package base

import (
	"os"
	"os/signal"
	"sync"
)

// Interrupted is closed when the go command receives an interrupt signal.
var Interrupted = make(chan struct{})

// processSignals setups signal handler.
func processSignals() {
	sig := make(chan os.Signal, 1)
	signal.Notify(sig, signalsToIgnore...)
	go func() {
		<-sig
		close(Interrupted)
	}()
}

var onceProcessSignals sync.Once

# 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) |
|--------:|------------------:|------------:|------------------------:|------------------------------:|-------------------------------:|