}
			if err == nil {
				if len(sctx.Layout.pools) != 2 {
					t.Error("expected parsed pools to be 2, not", len(sctx.Layout.pools))
				}
				if sctx.Layout.pools[0].cmdline != testcase.hash {
					t.Error("expected hash", testcase.hash, "got", sctx.Layout.pools[0].cmdline)
				}
			}
		})
	}
}

// Tests initializing new object layer.
func TestNewObjectLayer(t *testing.T) {
	ctx, cancel := context.WithCancel(t.Context())

	}

	var nmeta1 poolMeta
	nmeta1.Version = poolMetaVersion
	nmeta1.Pools = append(nmeta1.Pools, meta.Pools...)
	for i, pool := range nmeta1.Pools {
		if i == 0 {
			nmeta1.Pools[i] = PoolStatus{
				CmdLine:    pool.CmdLine,
				ID:         i,
				LastUpdate: UTCNow(),
				Decommission: &PoolDecommissionInfo{
					Complete: true,
				},
			}
		}
	}

	var nmeta2 poolMeta
	nmeta2.Version = poolMetaVersion

	ns2 := s2.NEndpoints
	if ns1 != ns2 {
		return fmt.Errorf("Expected number of endpoints %d, seen %d", ns1, ns2)
	}

	for i, cmdLine := range s1.CmdLines {
		if cmdLine != s2.CmdLines[i] {
			return fmt.Errorf("Expected command line argument %s, seen %s", cmdLine,
				s2.CmdLines[i])
		}
	}

	if reflect.DeepEqual(s1.MinioEnv, s2.MinioEnv) {
		return nil
	}

	// Report differences in environment variables.

		case "id":
			z.ID, err = dc.ReadInt()
			if err != nil {
				err = msgp.WrapError(err, "ID")
				return
			}
		case "cl":
			z.CmdLine, err = dc.ReadString()
			if err != nil {
				err = msgp.WrapError(err, "CmdLine")
				return
			}
		case "lu":
			z.LastUpdate, err = dc.ReadTime()
			if err != nil {
				err = msgp.WrapError(err, "LastUpdate")
				return
			}

			// Preserve any current pool status.
			if currentPool.CmdLine == pool.endpoints.CmdLine {
				newMeta.Pools = append(newMeta.Pools, currentPool)
				skip = true
				break
			}
		}
		if skip {
			continue
		}
		newMeta.Pools = append(newMeta.Pools, PoolStatus{
			CmdLine:    pool.endpoints.CmdLine,
			ID:         idx,
			LastUpdate: UTCNow(),
		})
	}
	return newMeta
}

			SetCount:     len(poolArgs[i].layout),
			DrivesPerSet: len(poolArgs[i].layout[0]),
			Endpoints:    endpointList,
			Platform:     fmt.Sprintf("OS: %s | Arch: %s", runtime.GOOS, runtime.GOARCH),
			CmdLine:      poolArgs[i].cmdline,
		}); err != nil {
			return nil, -1, err
		}
	}

	return endpointServerPools, setupType, nil

net.ipv6.conf.all.disable_ipv6=1
net.ipv6.conf.default.disable_ipv6=1
net.ipv6.conf.lo.disable_ipv6=1

[bootloader]
# Avoid firing timers for all CPUs at the same time. This is irrelevant for
# full nohz systems

			delete(m.ByHost, host)
		}
		return &m
	}

	anonymizeCmdLine := func(cmdLine string) string {
		if anonParam != anonymizeStrict {
			return cmdLine
		}

		if !globalIsDistErasure {
			// FS mode - single server - hard code to `server1`
			anonCmdLine := strings.ReplaceAll(cmdLine, globalLocalNodeName, "server1")
			if len(globalMinioConsoleHost) > 0 {

	tlsClientSessionCacheSize = 100
)

func init() {
	// Injected to prevent circular dependency.
	pubsub.GetByteBuffer = grid.GetByteBuffer
}

type poolDisksLayout struct {
	cmdline string
	layout  [][]string
}

type disksLayout struct {
	legacy bool
	pools  []poolDisksLayout
}

type serverCtxt struct {
	JSON, Quiet               bool
	Anonymous                 bool

type PoolEndpoints struct {
	// indicates if endpoints are provided in non-ellipses style
	Legacy       bool
	SetCount     int
	DrivesPerSet int
	Endpoints    Endpoints
	CmdLine      string
	Platform     string
}

// EndpointServerPools - list of list of endpoints
type EndpointServerPools []PoolEndpoints

// ESCount returns the total number of erasure sets in this cluster