Refactor health data structure (#11914)

This feature comes with simplified data structures and versioning support. Signed-off-by: Bala.FA <bala.gluster@gmail.com>
2021-06-01 21:25:49 +05:30 · 2021-06-01 21:25:49 +05:30 · 120951d9e9
parent 8347db8be3
commit 120951d9e9
9 changed files with 368 additions and 829 deletions
--- a/cmd/admin-handlers.go
+++ b/cmd/admin-handlers.go
@ -1366,6 +1366,105 @@ func (a adminAPIHandlers) KMSKeyStatusHandler(w http.ResponseWriter, r *http.Req
 	writeSuccessResponseJSON(w, resp)
 }

+func getServerInfo(ctx context.Context, r *http.Request) madmin.InfoMessage {
+	kmsStat := fetchKMSStatus()
+
+	ldap := madmin.LDAP{}
+	if globalLDAPConfig.Enabled {
+		ldapConn, err := globalLDAPConfig.Connect()
+		if err != nil {
+			ldap.Status = string(madmin.ItemOffline)
+		} else if ldapConn == nil {
+			ldap.Status = "Not Configured"
+		} else {
+			// Close ldap connection to avoid leaks.
+			ldapConn.Close()
+			ldap.Status = string(madmin.ItemOnline)
+		}
+	}
+
+	log, audit := fetchLoggerInfo()
+
+	// Get the notification target info
+	notifyTarget := fetchLambdaInfo()
+
+	local := getLocalServerProperty(globalEndpoints, r)
+	servers := globalNotificationSys.ServerInfo()
+	servers = append(servers, local)
+
+	assignPoolNumbers(servers)
+
+	var backend interface{}
+	mode := madmin.ItemInitializing
+
+	buckets := madmin.Buckets{}
+	objects := madmin.Objects{}
+	usage := madmin.Usage{}
+
+	objectAPI := newObjectLayerFn()
+	if objectAPI != nil {
+		mode = madmin.ItemOnline
+
+		// Load data usage
+		dataUsageInfo, err := loadDataUsageFromBackend(ctx, objectAPI)
+		if err == nil {
+			buckets = madmin.Buckets{Count: dataUsageInfo.BucketsCount}
+			objects = madmin.Objects{Count: dataUsageInfo.ObjectsTotalCount}
+			usage = madmin.Usage{Size: dataUsageInfo.ObjectsTotalSize}
+		} else {
+			buckets = madmin.Buckets{Error: err.Error()}
+			objects = madmin.Objects{Error: err.Error()}
+			usage = madmin.Usage{Error: err.Error()}
+		}
+
+		// Fetching the backend information
+		backendInfo := objectAPI.BackendInfo()
+		if backendInfo.Type == madmin.Erasure {
+			// Calculate the number of online/offline disks of all nodes
+			var allDisks []madmin.Disk
+			for _, s := range servers {
+				allDisks = append(allDisks, s.Disks...)
+			}
+			onlineDisks, offlineDisks := getOnlineOfflineDisksStats(allDisks)
+
+			backend = madmin.ErasureBackend{
+				Type:             madmin.ErasureType,
+				OnlineDisks:      onlineDisks.Sum(),
+				OfflineDisks:     offlineDisks.Sum(),
+				StandardSCParity: backendInfo.StandardSCParity,
+				RRSCParity:       backendInfo.RRSCParity,
+			}
+		} else {
+			backend = madmin.FSBackend{
+				Type: madmin.FsType,
+			}
+		}
+	}
+
+	domain := globalDomainNames
+	services := madmin.Services{
+		KMS:           kmsStat,
+		LDAP:          ldap,
+		Logger:        log,
+		Audit:         audit,
+		Notifications: notifyTarget,
+	}
+
+	return madmin.InfoMessage{
+		Mode:         string(mode),
+		Domain:       domain,
+		Region:       globalServerRegion,
+		SQSARN:       globalNotificationSys.GetARNList(false),
+		DeploymentID: globalDeploymentID,
+		Buckets:      buckets,
+		Objects:      objects,
+		Usage:        usage,
+		Services:     services,
+		Backend:      backend,
+		Servers:      servers,
+	}
+}
+
 // HealthInfoHandler - GET /minio/admin/v3/healthinfo
 // ----------
 // Get server health info
@ -1380,7 +1479,7 @@ func (a adminAPIHandlers) HealthInfoHandler(w http.ResponseWriter, r *http.Reque
 	}

 	query := r.URL.Query()
-	healthInfo := madmin.HealthInfo{}
+	healthInfo := madmin.HealthInfo{Version: madmin.HealthInfoVersion}
 	healthInfoCh := make(chan madmin.HealthInfo)

 	enc := json.NewEncoder(w)
@ -1402,7 +1501,7 @@ func (a adminAPIHandlers) HealthInfoHandler(w http.ResponseWriter, r *http.Reque
 		logger.LogIf(ctx, enc.Encode(healthInfo))
 	}

-	deadline := 3600 * time.Second
+	deadline := 1 * time.Hour
 	if dstr := r.URL.Query().Get("deadline"); dstr != "" {
 		var err error
 		deadline, err = time.ParseDuration(dstr)
@ -1426,86 +1525,67 @@ func (a adminAPIHandlers) HealthInfoHandler(w http.ResponseWriter, r *http.Reque
 	go func() {
 		defer close(healthInfoCh)

-		if cpu := query.Get("syscpu"); cpu == "true" {
-			cpuInfo := getLocalCPUInfo(deadlinedCtx, r)
+		partialWrite(healthInfo) // Write first message with only version populated

-			healthInfo.Sys.CPUInfo = append(healthInfo.Sys.CPUInfo, cpuInfo)
-			healthInfo.Sys.CPUInfo = append(healthInfo.Sys.CPUInfo, globalNotificationSys.CPUInfo(deadlinedCtx)...)
+		if query.Get("syscpu") == "true" {
+			healthInfo.Sys.CPUInfo = append(healthInfo.Sys.CPUInfo, madmin.GetCPUs(deadlinedCtx, r.Host))
+			healthInfo.Sys.CPUInfo = append(healthInfo.Sys.CPUInfo, globalNotificationSys.GetCPUs(deadlinedCtx)...)
 			partialWrite(healthInfo)
 		}

-		if diskHw := query.Get("sysdiskhw"); diskHw == "true" {
-			diskHwInfo := getLocalDiskHwInfo(deadlinedCtx, r)
-
-			healthInfo.Sys.DiskHwInfo = append(healthInfo.Sys.DiskHwInfo, diskHwInfo)
-			healthInfo.Sys.DiskHwInfo = append(healthInfo.Sys.DiskHwInfo, globalNotificationSys.DiskHwInfo(deadlinedCtx)...)
+		if query.Get("sysdrivehw") == "true" {
+			healthInfo.Sys.Partitions = append(healthInfo.Sys.Partitions, madmin.GetPartitions(deadlinedCtx, r.Host))
+			healthInfo.Sys.Partitions = append(healthInfo.Sys.Partitions, globalNotificationSys.GetPartitions(deadlinedCtx)...)
 			partialWrite(healthInfo)
 		}

-		if osInfo := query.Get("sysosinfo"); osInfo == "true" {
-			osInfo := getLocalOsInfo(deadlinedCtx, r)
-
-			healthInfo.Sys.OsInfo = append(healthInfo.Sys.OsInfo, osInfo)
-			healthInfo.Sys.OsInfo = append(healthInfo.Sys.OsInfo, globalNotificationSys.OsInfo(deadlinedCtx)...)
+		if query.Get("sysosinfo") == "true" {
+			healthInfo.Sys.OSInfo = append(healthInfo.Sys.OSInfo, madmin.GetOSInfo(deadlinedCtx, r.Host))
+			healthInfo.Sys.OSInfo = append(healthInfo.Sys.OSInfo, globalNotificationSys.GetOSInfo(deadlinedCtx)...)
 			partialWrite(healthInfo)
 		}

-		if mem := query.Get("sysmem"); mem == "true" {
-			memInfo := getLocalMemInfo(deadlinedCtx, r)
-
-			healthInfo.Sys.MemInfo = append(healthInfo.Sys.MemInfo, memInfo)
-			healthInfo.Sys.MemInfo = append(healthInfo.Sys.MemInfo, globalNotificationSys.MemInfo(deadlinedCtx)...)
+		if query.Get("sysmem") == "true" {
+			healthInfo.Sys.MemInfo = append(healthInfo.Sys.MemInfo, madmin.GetMemInfo(deadlinedCtx, r.Host))
+			healthInfo.Sys.MemInfo = append(healthInfo.Sys.MemInfo, globalNotificationSys.GetMemInfo(deadlinedCtx)...)
 			partialWrite(healthInfo)
 		}

-		if proc := query.Get("sysprocess"); proc == "true" {
-			procInfo := getLocalProcInfo(deadlinedCtx, r)
-
-			healthInfo.Sys.ProcInfo = append(healthInfo.Sys.ProcInfo, procInfo)
-			healthInfo.Sys.ProcInfo = append(healthInfo.Sys.ProcInfo, globalNotificationSys.ProcInfo(deadlinedCtx)...)
+		if query.Get("sysprocess") == "true" {
+			healthInfo.Sys.ProcInfo = append(healthInfo.Sys.ProcInfo, madmin.GetProcInfo(deadlinedCtx, r.Host))
+			healthInfo.Sys.ProcInfo = append(healthInfo.Sys.ProcInfo, globalNotificationSys.GetProcInfo(deadlinedCtx)...)
 			partialWrite(healthInfo)
 		}

-		if config := query.Get("minioconfig"); config == "true" {
-			cfg, err := readServerConfig(ctx, objectAPI)
-			logger.LogIf(ctx, err)
-			healthInfo.Minio.Config = cfg
-			partialWrite(healthInfo)
-		}
-
-		if drive := query.Get("perfdrive"); drive == "true" {
-			// Get drive perf details from local server's drive(s)
-			drivePerfSerial := getLocalDrives(deadlinedCtx, false, globalEndpoints, r)
-			drivePerfParallel := getLocalDrives(deadlinedCtx, true, globalEndpoints, r)
-
-			errStr := ""
-			if drivePerfSerial.Error != "" {
-				errStr = "serial: " + drivePerfSerial.Error
-			}
-			if drivePerfParallel.Error != "" {
-				errStr = errStr + " parallel: " + drivePerfParallel.Error
+		if query.Get("minioconfig") == "true" {
+			config, err := readServerConfig(ctx, objectAPI)
+			if err != nil {
+				healthInfo.Minio.Config = madmin.MinioConfig{
+					Error: err.Error(),
+				}
+			} else {
+				healthInfo.Minio.Config = madmin.MinioConfig{
+					Config: config,
+				}
 			}
+			partialWrite(healthInfo)
+		}

-			driveInfo := madmin.ServerDrivesInfo{
-				Addr:     drivePerfSerial.Addr,
-				Serial:   drivePerfSerial.Serial,
-				Parallel: drivePerfParallel.Parallel,
-				Error:    errStr,
-			}
-			healthInfo.Perf.DriveInfo = append(healthInfo.Perf.DriveInfo, driveInfo)
+		if query.Get("perfdrive") == "true" {
+			healthInfo.Perf.Drives = append(healthInfo.Perf.Drives, getDrivePerfInfos(deadlinedCtx, r.Host))
 			partialWrite(healthInfo)

-			// Notify all other MinIO peers to report drive perf numbers
-			driveInfos := globalNotificationSys.DrivePerfInfoChan(deadlinedCtx)
-			for obd := range driveInfos {
-				healthInfo.Perf.DriveInfo = append(healthInfo.Perf.DriveInfo, obd)
+			perfCh := globalNotificationSys.GetDrivePerfInfos(deadlinedCtx)
+			for perfInfo := range perfCh {
+				healthInfo.Perf.Drives = append(healthInfo.Perf.Drives, perfInfo)
 				partialWrite(healthInfo)
 			}
+
 			partialWrite(healthInfo)
 		}

-		if net := query.Get("perfnet"); net == "true" && globalIsDistErasure {
-			healthInfo.Perf.Net = append(healthInfo.Perf.Net, globalNotificationSys.NetInfo(deadlinedCtx))
+		if globalIsDistErasure && query.Get("perfnet") == "true" {
+			healthInfo.Perf.Net = append(healthInfo.Perf.Net, globalNotificationSys.GetNetPerfInfo(deadlinedCtx))
 			partialWrite(healthInfo)

 			netInfos := globalNotificationSys.DispatchNetPerfChan(deadlinedCtx)
@ -1515,10 +1595,47 @@ func (a adminAPIHandlers) HealthInfoHandler(w http.ResponseWriter, r *http.Reque
 			}
 			partialWrite(healthInfo)

-			healthInfo.Perf.NetParallel = globalNotificationSys.NetPerfParallelInfo(deadlinedCtx)
+			healthInfo.Perf.NetParallel = globalNotificationSys.GetParallelNetPerfInfo(deadlinedCtx)
 			partialWrite(healthInfo)
 		}

+		if query.Get("minioinfo") == "true" {
+			infoMessage := getServerInfo(ctx, r)
+			servers := []madmin.ServerInfo{}
+			for _, server := range infoMessage.Servers {
+				servers = append(servers, madmin.ServerInfo{
+					State:      server.State,
+					Endpoint:   server.Endpoint,
+					Uptime:     server.Uptime,
+					Version:    server.Version,
+					CommitID:   server.CommitID,
+					Network:    server.Network,
+					Drives:     server.Disks,
+					PoolNumber: server.PoolNumber,
+					MemStats: madmin.MemStats{
+						Alloc:      server.MemStats.Alloc,
+						TotalAlloc: server.MemStats.TotalAlloc,
+						Mallocs:    server.MemStats.Mallocs,
+						Frees:      server.MemStats.Frees,
+						HeapAlloc:  server.MemStats.HeapAlloc,
+					},
+				})
+			}
+			healthInfo.Minio.Info = madmin.MinioInfo{
+				Mode:         infoMessage.Mode,
+				Domain:       infoMessage.Domain,
+				Region:       infoMessage.Region,
+				SQSARN:       infoMessage.SQSARN,
+				DeploymentID: infoMessage.DeploymentID,
+				Buckets:      infoMessage.Buckets,
+				Objects:      infoMessage.Objects,
+				Usage:        infoMessage.Usage,
+				Services:     infoMessage.Services,
+				Backend:      infoMessage.Backend,
+				Servers:      servers,
+			}
+			partialWrite(healthInfo)
+		}
 	}()

 	ticker := time.NewTicker(5 * time.Second)
@ -1616,105 +1733,8 @@ func (a adminAPIHandlers) ServerInfoHandler(w http.ResponseWriter, r *http.Reque
 		return
 	}

-	kmsStat := fetchKMSStatus()
-
-	ldap := madmin.LDAP{}
-	if globalLDAPConfig.Enabled {
-		ldapConn, err := globalLDAPConfig.Connect()
-		if err != nil {
-			ldap.Status = string(madmin.ItemOffline)
-		} else if ldapConn == nil {
-			ldap.Status = "Not Configured"
-		} else {
-			// Close ldap connection to avoid leaks.
-			ldapConn.Close()
-			ldap.Status = string(madmin.ItemOnline)
-		}
-	}
-
-	log, audit := fetchLoggerInfo()
-
-	// Get the notification target info
-	notifyTarget := fetchLambdaInfo()
-
-	local := getLocalServerProperty(globalEndpoints, r)
-	servers := globalNotificationSys.ServerInfo()
-	servers = append(servers, local)
-
-	assignPoolNumbers(servers)
-
-	var backend interface{}
-	mode := madmin.ItemInitializing
-
-	buckets := madmin.Buckets{}
-	objects := madmin.Objects{}
-	usage := madmin.Usage{}
-
-	objectAPI := newObjectLayerFn()
-	if objectAPI != nil {
-		mode = madmin.ItemOnline
-
-		// Load data usage
-		dataUsageInfo, err := loadDataUsageFromBackend(ctx, objectAPI)
-		if err == nil {
-			buckets = madmin.Buckets{Count: dataUsageInfo.BucketsCount}
-			objects = madmin.Objects{Count: dataUsageInfo.ObjectsTotalCount}
-			usage = madmin.Usage{Size: dataUsageInfo.ObjectsTotalSize}
-		} else {
-			buckets = madmin.Buckets{Error: err.Error()}
-			objects = madmin.Objects{Error: err.Error()}
-			usage = madmin.Usage{Error: err.Error()}
-		}
-
-		// Fetching the backend information
-		backendInfo := objectAPI.BackendInfo()
-		if backendInfo.Type == madmin.Erasure {
-			// Calculate the number of online/offline disks of all nodes
-			var allDisks []madmin.Disk
-			for _, s := range servers {
-				allDisks = append(allDisks, s.Disks...)
-			}
-			onlineDisks, offlineDisks := getOnlineOfflineDisksStats(allDisks)
-
-			backend = madmin.ErasureBackend{
-				Type:             madmin.ErasureType,
-				OnlineDisks:      onlineDisks.Sum(),
-				OfflineDisks:     offlineDisks.Sum(),
-				StandardSCParity: backendInfo.StandardSCParity,
-				RRSCParity:       backendInfo.RRSCParity,
-			}
-		} else {
-			backend = madmin.FSBackend{
-				Type: madmin.FsType,
-			}
-		}
-	}
-
-	domain := globalDomainNames
-	services := madmin.Services{
-		KMS:           kmsStat,
-		LDAP:          ldap,
-		Logger:        log,
-		Audit:         audit,
-		Notifications: notifyTarget,
-	}
-
-	infoMsg := madmin.InfoMessage{
-		Mode:         string(mode),
-		Domain:       domain,
-		Region:       globalServerRegion,
-		SQSARN:       globalNotificationSys.GetARNList(false),
-		DeploymentID: globalDeploymentID,
-		Buckets:      buckets,
-		Objects:      objects,
-		Usage:        usage,
-		Services:     services,
-		Backend:      backend,
-		Servers:      servers,
-	}
-
 	// Marshal API response
-	jsonBytes, err := json.Marshal(infoMsg)
+	jsonBytes, err := json.Marshal(getServerInfo(ctx, r))
 	if err != nil {
 		writeErrorResponseJSON(ctx, w, toAdminAPIErr(ctx, err), r.URL)
 		return
--- a/cmd/healthinfo.go
+++ b/cmd/healthinfo.go
@ -19,329 +19,95 @@ package cmd

 import (
 	"context"
-	"fmt"
-	"net/http"
+	"math"
 	"os"
 	"sync"
-	"syscall"

 	"github.com/minio/madmin-go"
 	"github.com/minio/minio/pkg/disk"
-	cpuhw "github.com/shirou/gopsutil/v3/cpu"
-	memhw "github.com/shirou/gopsutil/v3/mem"
-	"github.com/shirou/gopsutil/v3/process"
 )

-func getLocalCPUInfo(ctx context.Context, r *http.Request) madmin.ServerCPUInfo {
-	addr := r.Host
-	if globalIsDistErasure {
-		addr = globalLocalNodeName
-	}
-
-	info, err := cpuhw.InfoWithContext(ctx)
-	if err != nil {
-		return madmin.ServerCPUInfo{
-			Addr:  addr,
-			Error: fmt.Sprintf("info: %v", err),
-		}
-	}
-
-	time, err := cpuhw.TimesWithContext(ctx, false)
-	if err != nil {
-		return madmin.ServerCPUInfo{
-			Addr:  addr,
-			Error: fmt.Sprintf("times: %v", err),
-		}
-	}
-
-	return madmin.ServerCPUInfo{
-		Addr:     addr,
-		CPUStat:  info,
-		TimeStat: time,
+// round returns value rounding to specified decimal places.
+func round(f float64, n int) float64 {
+	if n <= 0 {
+		return math.Round(f)
 	}

+	p := math.Pow10(n)
+	return math.Round(f*p) / p
 }

-func getLocalDrives(ctx context.Context, parallel bool, endpointServerPools EndpointServerPools, r *http.Request) madmin.ServerDrivesInfo {
-	var drivesPerfInfo []madmin.DrivePerfInfo
+func getDrivePerfInfo(ctx context.Context, parallel bool) []madmin.DrivePerfInfo {
+	pools := globalEndpoints
+	info := []madmin.DrivePerfInfo{}
 	var wg sync.WaitGroup
-	for _, ep := range endpointServerPools {
-		for _, endpoint := range ep.Endpoints {
-			// Only proceed for local endpoints
-			if endpoint.IsLocal {
-				if _, err := os.Stat(endpoint.Path); err != nil {
-					// Since this drive is not available, add relevant details and proceed
-					drivesPerfInfo = append(drivesPerfInfo, madmin.DrivePerfInfo{
-						Path:  endpoint.Path,
-						Error: fmt.Sprintf("stat: %v", err),
-					})
-					continue
-				}
-				measurePath := pathJoin(minioMetaTmpBucket, mustGetUUID())
-				measure := func(path string) {
-					defer wg.Done()
-					driveInfo := madmin.DrivePerfInfo{
-						Path: path,
-					}
-					latency, throughput, err := disk.GetHealthInfo(ctx, path, pathJoin(path, measurePath))
-					if err != nil {
-						driveInfo.Error = fmt.Sprintf("health-info: %v", err)
-					} else {
-						driveInfo.Latency = latency
-						driveInfo.Throughput = throughput
-					}
-					drivesPerfInfo = append(drivesPerfInfo, driveInfo)
-				}
-				wg.Add(1)
+	for _, pool := range pools {
+		for _, endpoint := range pool.Endpoints {
+			if !endpoint.IsLocal {
+				continue
+			}

-				if parallel {
-					go measure(endpoint.Path)
+			if _, err := os.Stat(endpoint.Path); err != nil {
+				info = append(info, madmin.DrivePerfInfo{
+					Path:  endpoint.Path,
+					Error: err.Error(),
+				})
+				continue
+			}
+
+			getHealthInfo := func(path string) {
+				defer wg.Done()
+
+				latency, throughput, err := disk.GetHealthInfo(
+					ctx, path, pathJoin(path, minioMetaTmpBucket, mustGetUUID()),
+				)
+				if err != nil {
+					info = append(info, madmin.DrivePerfInfo{
+						Path:  path,
+						Error: err.Error(),
+					})
 				} else {
-					measure(endpoint.Path)
+					info = append(info, madmin.DrivePerfInfo{
+						Path: path,
+						Latency: madmin.Latency{
+							Avg:          round(latency.Avg, 3),
+							Max:          round(latency.Max, 3),
+							Min:          round(latency.Min, 3),
+							Percentile50: round(latency.Percentile50, 3),
+							Percentile90: round(latency.Percentile90, 3),
+							Percentile99: round(latency.Percentile99, 3),
+						},
+						Throughput: madmin.Throughput{
+							Avg:          uint64(round(throughput.Avg, 0)),
+							Max:          uint64(round(throughput.Max, 0)),
+							Min:          uint64(round(throughput.Min, 0)),
+							Percentile50: uint64(round(throughput.Percentile50, 0)),
+							Percentile90: uint64(round(throughput.Percentile90, 0)),
+							Percentile99: uint64(round(throughput.Percentile99, 0)),
+						},
+					})
 				}
 			}
+
+			wg.Add(1)
+			if parallel {
+				go getHealthInfo(endpoint.Path)
+			} else {
+				getHealthInfo(endpoint.Path)
+			}
 		}
 	}
+
 	wg.Wait()
-
-	addr := r.Host
-	if globalIsDistErasure {
-		addr = globalLocalNodeName
-	}
-	if parallel {
-		return madmin.ServerDrivesInfo{
-			Addr:     addr,
-			Parallel: drivesPerfInfo,
-		}
-	}
-	return madmin.ServerDrivesInfo{
-		Addr:   addr,
-		Serial: drivesPerfInfo,
-	}
+	return info
 }

-func getLocalMemInfo(ctx context.Context, r *http.Request) madmin.ServerMemInfo {
-	addr := r.Host
-	if globalIsDistErasure {
-		addr = globalLocalNodeName
-	}
-
-	swap, err := memhw.SwapMemoryWithContext(ctx)
-	if err != nil {
-		return madmin.ServerMemInfo{
-			Addr:  addr,
-			Error: fmt.Sprintf("swap: %v", err),
-		}
-	}
-
-	vm, err := memhw.VirtualMemoryWithContext(ctx)
-	if err != nil {
-		return madmin.ServerMemInfo{
-			Addr:  addr,
-			Error: fmt.Sprintf("virtual-mem: %v", err),
-		}
-	}
-
-	return madmin.ServerMemInfo{
-		Addr:       addr,
-		SwapMem:    swap,
-		VirtualMem: vm,
-	}
-}
-
-func getLocalProcInfo(ctx context.Context, r *http.Request) madmin.ServerProcInfo {
-	addr := r.Host
-	if globalIsDistErasure {
-		addr = globalLocalNodeName
-	}
-
-	errProcInfo := func(tag string, err error) madmin.ServerProcInfo {
-		return madmin.ServerProcInfo{
-			Addr:  addr,
-			Error: fmt.Sprintf("%s: %v", tag, err),
-		}
-	}
-
-	selfPid := int32(syscall.Getpid())
-	self, err := process.NewProcess(selfPid)
-	if err != nil {
-		return errProcInfo("new-process", err)
-	}
-
-	processes := []*process.Process{self}
-
-	sysProcs := []madmin.SysProcess{}
-	for _, proc := range processes {
-		sysProc := madmin.SysProcess{}
-		sysProc.Pid = proc.Pid
-
-		bg, err := proc.BackgroundWithContext(ctx)
-		if err != nil {
-			return errProcInfo("background", err)
-		}
-		sysProc.Background = bg
-
-		cpuPercent, err := proc.CPUPercentWithContext(ctx)
-		if err != nil {
-			return errProcInfo("cpu-percent", err)
-		}
-		sysProc.CPUPercent = cpuPercent
-
-		children, _ := proc.ChildrenWithContext(ctx)
-
-		for _, c := range children {
-			sysProc.Children = append(sysProc.Children, c.Pid)
-		}
-		cmdLine, err := proc.CmdlineWithContext(ctx)
-		if err != nil {
-			return errProcInfo("cmdline", err)
-		}
-		sysProc.CmdLine = cmdLine
-
-		conns, err := proc.ConnectionsWithContext(ctx)
-		if err != nil {
-			return errProcInfo("conns", err)
-		}
-		sysProc.ConnectionCount = len(conns)
-
-		createTime, err := proc.CreateTimeWithContext(ctx)
-		if err != nil {
-			return errProcInfo("create-time", err)
-		}
-		sysProc.CreateTime = createTime
-
-		cwd, err := proc.CwdWithContext(ctx)
-		if err != nil {
-			return errProcInfo("cwd", err)
-		}
-		sysProc.Cwd = cwd
-
-		exe, err := proc.ExeWithContext(ctx)
-		if err != nil {
-			return errProcInfo("exe", err)
-		}
-		sysProc.Exe = exe
-
-		gids, err := proc.GidsWithContext(ctx)
-		if err != nil {
-			return errProcInfo("gids", err)
-		}
-		sysProc.Gids = gids
-
-		ioCounters, err := proc.IOCountersWithContext(ctx)
-		if err != nil {
-			return errProcInfo("iocounters", err)
-		}
-		sysProc.IOCounters = ioCounters
-
-		isRunning, err := proc.IsRunningWithContext(ctx)
-		if err != nil {
-			return errProcInfo("is-running", err)
-		}
-		sysProc.IsRunning = isRunning
-
-		memInfo, err := proc.MemoryInfoWithContext(ctx)
-		if err != nil {
-			return errProcInfo("mem-info", err)
-		}
-		sysProc.MemInfo = memInfo
-
-		memMaps, err := proc.MemoryMapsWithContext(ctx, true)
-		if err != nil {
-			return errProcInfo("mem-maps", err)
-		}
-		sysProc.MemMaps = memMaps
-
-		memPercent, err := proc.MemoryPercentWithContext(ctx)
-		if err != nil {
-			return errProcInfo("mem-percent", err)
-		}
-		sysProc.MemPercent = memPercent
-
-		name, err := proc.NameWithContext(ctx)
-		if err != nil {
-			return errProcInfo("name", err)
-		}
-		sysProc.Name = name
-
-		// Refer for more information on NetIOCounters
-		// is useless https://github.com/shirou/gopsutil/issues/429
-
-		nice, err := proc.NiceWithContext(ctx)
-		if err != nil {
-			return errProcInfo("nice", err)
-		}
-		sysProc.Nice = nice
-
-		numCtxSwitches, err := proc.NumCtxSwitchesWithContext(ctx)
-		if err != nil {
-			return errProcInfo("num-ctx-switches", err)
-		}
-		sysProc.NumCtxSwitches = numCtxSwitches
-
-		numFds, err := proc.NumFDsWithContext(ctx)
-		if err != nil {
-			return errProcInfo("num-fds", err)
-		}
-		sysProc.NumFds = numFds
-
-		numThreads, err := proc.NumThreadsWithContext(ctx)
-		if err != nil {
-			return errProcInfo("num-threads", err)
-		}
-		sysProc.NumThreads = numThreads
-
-		pageFaults, err := proc.PageFaultsWithContext(ctx)
-		if err != nil {
-			return errProcInfo("page-faults", err)
-		}
-		sysProc.PageFaults = pageFaults
-
-		parent, err := proc.ParentWithContext(ctx)
-		if err == nil {
-			sysProc.Parent = parent.Pid
-		}
-
-		ppid, err := proc.PpidWithContext(ctx)
-		if err == nil {
-			sysProc.Ppid = ppid
-		}
-
-		status, err := proc.StatusWithContext(ctx)
-		if err != nil {
-			return errProcInfo("status", err)
-		}
-		sysProc.Status = status[0]
-
-		tgid, err := proc.Tgid()
-		if err != nil {
-			return errProcInfo("tgid", err)
-		}
-		sysProc.Tgid = tgid
-
-		times, err := proc.TimesWithContext(ctx)
-		if err != nil {
-			return errProcInfo("times", err)
-		}
-		sysProc.Times = times
-
-		uids, err := proc.UidsWithContext(ctx)
-		if err != nil {
-			return errProcInfo("uids", err)
-		}
-		sysProc.Uids = uids
-
-		username, err := proc.UsernameWithContext(ctx)
-		if err != nil {
-			return errProcInfo("username", err)
-		}
-		sysProc.Username = username
-
-		sysProcs = append(sysProcs, sysProc)
-	}
-
-	return madmin.ServerProcInfo{
-		Addr:      addr,
-		Processes: sysProcs,
+func getDrivePerfInfos(ctx context.Context, addr string) madmin.DrivePerfInfos {
+	serialPerf := getDrivePerfInfo(ctx, false)
+	parallelPerf := getDrivePerfInfo(ctx, true)
+	return madmin.DrivePerfInfos{
+		Addr:         addr,
+		SerialPerf:   serialPerf,
+		ParallelPerf: parallelPerf,
 	}
 }
--- a/cmd/healthinfo_linux.go
+++ b/cmd/healthinfo_linux.go
@ -1,138 +0,0 @@
-// +build linux
-
-// Copyright (c) 2015-2021 MinIO, Inc.
-//
-// This file is part of MinIO Object Storage stack
-//
-// This program is free software: you can redistribute it and/or modify
-// it under the terms of the GNU Affero General Public License as published by
-// the Free Software Foundation, either version 3 of the License, or
-// (at your option) any later version.
-//
-// This program is distributed in the hope that it will be useful
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-// GNU Affero General Public License for more details.
-//
-// You should have received a copy of the GNU Affero General Public License
-// along with this program.  If not, see <http://www.gnu.org/licenses/>.
-
-package cmd
-
-import (
-	"context"
-	"fmt"
-	"net/http"
-	"strings"
-
-	"github.com/minio/madmin-go"
-	"github.com/minio/minio/pkg/smart"
-	diskhw "github.com/shirou/gopsutil/v3/disk"
-	"github.com/shirou/gopsutil/v3/host"
-)
-
-func getLocalOsInfo(ctx context.Context, r *http.Request) madmin.ServerOsInfo {
-	addr := r.Host
-	if globalIsDistErasure {
-		addr = globalLocalNodeName
-	}
-
-	srvrOsInfo := madmin.ServerOsInfo{Addr: addr}
-	var err error
-
-	srvrOsInfo.Info, err = host.InfoWithContext(ctx)
-	if err != nil {
-		return madmin.ServerOsInfo{
-			Addr:  addr,
-			Error: fmt.Sprintf("info: %v", err),
-		}
-	}
-
-	srvrOsInfo.Sensors, err = host.SensorsTemperaturesWithContext(ctx)
-	if err != nil {
-		// Set error only when it's not of WARNINGS type
-		if _, isWarning := err.(*host.Warnings); !isWarning {
-			srvrOsInfo.Error = fmt.Sprintf("sensors-temp: %v", err)
-		}
-	}
-
-	// ignore user err, as it cannot be obtained reliably inside containers
-	srvrOsInfo.Users, _ = host.UsersWithContext(ctx)
-
-	return srvrOsInfo
-}
-
-func getLocalDiskHwInfo(ctx context.Context, r *http.Request) madmin.ServerDiskHwInfo {
-	addr := r.Host
-	if globalIsDistErasure {
-		addr = globalLocalNodeName
-	}
-
-	parts, err := diskhw.PartitionsWithContext(ctx, true)
-	if err != nil {
-		return madmin.ServerDiskHwInfo{
-			Addr:  addr,
-			Error: fmt.Sprintf("partitions: %v", err),
-		}
-	}
-
-	drives := []string{}
-	paths := []string{}
-	partitions := []madmin.PartitionStat{}
-
-	for _, part := range parts {
-		device := part.Device
-		path := part.Mountpoint
-		if strings.Index(device, "/dev/") == 0 {
-			if strings.Contains(device, "loop") {
-				continue
-			}
-
-			if strings.Contains(device, "/dev/fuse") {
-				continue
-			}
-
-			drives = append(drives, device)
-			paths = append(paths, path)
-			smartInfo, err := smart.GetInfo(device)
-			if err != nil {
-				smartInfo.Error = fmt.Sprintf("smart: %v", err)
-			}
-			partition := madmin.PartitionStat{
-				Device:     part.Device,
-				Mountpoint: part.Mountpoint,
-				Fstype:     part.Fstype,
-				Opts:       strings.Join(part.Opts, ","),
-				SmartInfo:  smartInfo,
-			}
-			partitions = append(partitions, partition)
-		}
-	}
-
-	ioCounters, err := diskhw.IOCountersWithContext(ctx, drives...)
-	if err != nil {
-		return madmin.ServerDiskHwInfo{
-			Addr:  addr,
-			Error: fmt.Sprintf("iocounters: %v", err),
-		}
-	}
-	usages := []*diskhw.UsageStat{}
-	for _, path := range paths {
-		usage, err := diskhw.UsageWithContext(ctx, path)
-		if err != nil {
-			return madmin.ServerDiskHwInfo{
-				Addr:  addr,
-				Error: fmt.Sprintf("usage: %v", err),
-			}
-		}
-		usages = append(usages, usage)
-	}
-
-	return madmin.ServerDiskHwInfo{
-		Addr:       addr,
-		Usage:      usages,
-		Partitions: partitions,
-		Counters:   ioCounters,
-		Error:      "",
-	}
-}
--- a/cmd/healthinfo_nonlinux.go
+++ b/cmd/healthinfo_nonlinux.go
@ -1,52 +0,0 @@
-// +build !linux
-
-// Copyright (c) 2015-2021 MinIO, Inc.
-//
-// This file is part of MinIO Object Storage stack
-//
-// This program is free software: you can redistribute it and/or modify
-// it under the terms of the GNU Affero General Public License as published by
-// the Free Software Foundation, either version 3 of the License, or
-// (at your option) any later version.
-//
-// This program is distributed in the hope that it will be useful
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-// GNU Affero General Public License for more details.
-//
-// You should have received a copy of the GNU Affero General Public License
-// along with this program.  If not, see <http://www.gnu.org/licenses/>.
-
-package cmd
-
-import (
-	"context"
-	"net/http"
-	"runtime"
-
-	"github.com/minio/madmin-go"
-)
-
-func getLocalDiskHwInfo(ctx context.Context, r *http.Request) madmin.ServerDiskHwInfo {
-	addr := r.Host
-	if globalIsDistErasure {
-		addr = globalLocalNodeName
-	}
-
-	return madmin.ServerDiskHwInfo{
-		Addr:  addr,
-		Error: "unsupported platform: " + runtime.GOOS,
-	}
-}
-
-func getLocalOsInfo(ctx context.Context, r *http.Request) madmin.ServerOsInfo {
-	addr := r.Host
-	if globalIsDistErasure {
-		addr = globalLocalNodeName
-	}
-
-	return madmin.ServerOsInfo{
-		Addr:  addr,
-		Error: "unsupported platform: " + runtime.GOOS,
-	}
-}
--- a/cmd/notification.go
+++ b/cmd/notification.go
@ -831,8 +831,8 @@ func (sys *NotificationSys) Send(args eventArgs) {
 	sys.targetList.Send(args.ToEvent(true), targetIDSet, sys.targetResCh)
 }

-// NetInfo - Net information
-func (sys *NotificationSys) NetInfo(ctx context.Context) madmin.ServerNetHealthInfo {
+// GetNetPerfInfo - Net information
+func (sys *NotificationSys) GetNetPerfInfo(ctx context.Context) madmin.NetPerfInfo {
 	var sortedGlobalEndpoints []string

 	/*
@ -889,14 +889,14 @@ func (sys *NotificationSys) NetInfo(ctx context.Context) madmin.ServerNetHealthI
 		}
 	}

-	netInfos := make([]madmin.NetPerfInfo, len(remoteTargets))
+	netInfos := make([]madmin.PeerNetPerfInfo, len(remoteTargets))

 	for index, client := range remoteTargets {
 		if client == nil {
 			continue
 		}
 		var err error
-		netInfos[index], err = client.NetInfo(ctx)
+		netInfos[index], err = client.GetNetPerfInfo(ctx)

 		addr := client.host.String()
 		reqInfo := (&logger.ReqInfo{}).AppendTags("remotePeer", addr)
@ -907,15 +907,15 @@ func (sys *NotificationSys) NetInfo(ctx context.Context) madmin.ServerNetHealthI
 			netInfos[index].Error = err.Error()
 		}
 	}
-	return madmin.ServerNetHealthInfo{
-		Net:  netInfos,
-		Addr: globalLocalNodeName,
+	return madmin.NetPerfInfo{
+		Addr:        globalLocalNodeName,
+		RemotePeers: netInfos,
 	}
 }

 // DispatchNetPerfInfo - Net perf information from other nodes
-func (sys *NotificationSys) DispatchNetPerfInfo(ctx context.Context) []madmin.ServerNetHealthInfo {
-	serverNetInfos := []madmin.ServerNetHealthInfo{}
+func (sys *NotificationSys) DispatchNetPerfInfo(ctx context.Context) []madmin.NetPerfInfo {
+	serverNetInfos := []madmin.NetPerfInfo{}

 	for index, client := range sys.peerClients {
 		if client == nil {
@ -932,8 +932,8 @@ func (sys *NotificationSys) DispatchNetPerfInfo(ctx context.Context) []madmin.Se
 }

 // DispatchNetPerfChan - Net perf information from other nodes
-func (sys *NotificationSys) DispatchNetPerfChan(ctx context.Context) chan madmin.ServerNetHealthInfo {
-	serverNetInfos := make(chan madmin.ServerNetHealthInfo)
+func (sys *NotificationSys) DispatchNetPerfChan(ctx context.Context) chan madmin.NetPerfInfo {
+	serverNetInfos := make(chan madmin.NetPerfInfo)
 	wg := sync.WaitGroup{}

 	wg.Add(1)
@ -960,9 +960,9 @@ func (sys *NotificationSys) DispatchNetPerfChan(ctx context.Context) chan madmin
 	return serverNetInfos
 }

-// NetPerfParallelInfo - Performs Net parallel tests
-func (sys *NotificationSys) NetPerfParallelInfo(ctx context.Context) madmin.ServerNetHealthInfo {
-	netInfos := []madmin.NetPerfInfo{}
+// GetParallelNetPerfInfo - Performs Net parallel tests
+func (sys *NotificationSys) GetParallelNetPerfInfo(ctx context.Context) madmin.NetPerfInfo {
+	netInfos := []madmin.PeerNetPerfInfo{}
 	wg := sync.WaitGroup{}

 	for index, client := range sys.peerClients {
@ -972,7 +972,7 @@ func (sys *NotificationSys) NetPerfParallelInfo(ctx context.Context) madmin.Serv

 		wg.Add(1)
 		go func(index int) {
-			netInfo, err := sys.peerClients[index].NetInfo(ctx)
+			netInfo, err := sys.peerClients[index].GetNetPerfInfo(ctx)
 			netInfo.Addr = sys.peerClients[index].host.String()
 			if err != nil {
 				netInfo.Error = err.Error()
@ -982,46 +982,15 @@ func (sys *NotificationSys) NetPerfParallelInfo(ctx context.Context) madmin.Serv
 		}(index)
 	}
 	wg.Wait()
-	return madmin.ServerNetHealthInfo{
-		Net:  netInfos,
-		Addr: globalLocalNodeName,
+	return madmin.NetPerfInfo{
+		Addr:        globalLocalNodeName,
+		RemotePeers: netInfos,
 	}
-
 }

-// DrivePerfInfo - Drive perf information
-func (sys *NotificationSys) DrivePerfInfo(ctx context.Context) []madmin.ServerDrivesInfo {
-	reply := make([]madmin.ServerDrivesInfo, len(sys.peerClients))
-
-	g := errgroup.WithNErrs(len(sys.peerClients))
-	for index, client := range sys.peerClients {
-		if client == nil {
-			continue
-		}
-		index := index
-		g.Go(func() error {
-			var err error
-			reply[index], err = sys.peerClients[index].DriveInfo(ctx)
-			return err
-		}, index)
-	}
-
-	for index, err := range g.Wait() {
-		if err != nil {
-			addr := sys.peerClients[index].host.String()
-			reqInfo := (&logger.ReqInfo{}).AppendTags("remotePeer", addr)
-			ctx := logger.SetReqInfo(GlobalContext, reqInfo)
-			logger.LogIf(ctx, err)
-			reply[index].Addr = addr
-			reply[index].Error = err.Error()
-		}
-	}
-	return reply
-}
-
-// DrivePerfInfoChan - Drive perf information
-func (sys *NotificationSys) DrivePerfInfoChan(ctx context.Context) chan madmin.ServerDrivesInfo {
-	updateChan := make(chan madmin.ServerDrivesInfo)
+// GetDrivePerfInfos - Drive performance information
+func (sys *NotificationSys) GetDrivePerfInfos(ctx context.Context) chan madmin.DrivePerfInfos {
+	updateChan := make(chan madmin.DrivePerfInfos)
 	wg := sync.WaitGroup{}

 	for _, client := range sys.peerClients {
@ -1030,7 +999,7 @@ func (sys *NotificationSys) DrivePerfInfoChan(ctx context.Context) chan madmin.S
 		}
 		wg.Add(1)
 		go func(client *peerRESTClient) {
-			reply, err := client.DriveInfo(ctx)
+			reply, err := client.GetDrivePerfInfos(ctx)

 			addr := client.host.String()
 			reqInfo := (&logger.ReqInfo{}).AppendTags("remotePeer", addr)
@ -1055,9 +1024,9 @@ func (sys *NotificationSys) DrivePerfInfoChan(ctx context.Context) chan madmin.S
 	return updateChan
 }

-// CPUInfo - CPU information
-func (sys *NotificationSys) CPUInfo(ctx context.Context) []madmin.ServerCPUInfo {
-	reply := make([]madmin.ServerCPUInfo, len(sys.peerClients))
+// GetCPUs - Get all CPU information.
+func (sys *NotificationSys) GetCPUs(ctx context.Context) []madmin.CPUs {
+	reply := make([]madmin.CPUs, len(sys.peerClients))

 	g := errgroup.WithNErrs(len(sys.peerClients))
 	for index, client := range sys.peerClients {
@ -1067,7 +1036,7 @@ func (sys *NotificationSys) CPUInfo(ctx context.Context) []madmin.ServerCPUInfo
 		index := index
 		g.Go(func() error {
 			var err error
-			reply[index], err = sys.peerClients[index].CPUInfo(ctx)
+			reply[index], err = sys.peerClients[index].GetCPUs(ctx)
 			return err
 		}, index)
 	}
@ -1085,9 +1054,9 @@ func (sys *NotificationSys) CPUInfo(ctx context.Context) []madmin.ServerCPUInfo
 	return reply
 }

-// DiskHwInfo - Disk HW information
-func (sys *NotificationSys) DiskHwInfo(ctx context.Context) []madmin.ServerDiskHwInfo {
-	reply := make([]madmin.ServerDiskHwInfo, len(sys.peerClients))
+// GetPartitions - Disk partition information
+func (sys *NotificationSys) GetPartitions(ctx context.Context) []madmin.Partitions {
+	reply := make([]madmin.Partitions, len(sys.peerClients))

 	g := errgroup.WithNErrs(len(sys.peerClients))
 	for index, client := range sys.peerClients {
@ -1097,7 +1066,7 @@ func (sys *NotificationSys) DiskHwInfo(ctx context.Context) []madmin.ServerDiskH
 		index := index
 		g.Go(func() error {
 			var err error
-			reply[index], err = sys.peerClients[index].DiskHwInfo(ctx)
+			reply[index], err = sys.peerClients[index].GetPartitions(ctx)
 			return err
 		}, index)
 	}
@ -1115,9 +1084,9 @@ func (sys *NotificationSys) DiskHwInfo(ctx context.Context) []madmin.ServerDiskH
 	return reply
 }

-// OsInfo - Os information
-func (sys *NotificationSys) OsInfo(ctx context.Context) []madmin.ServerOsInfo {
-	reply := make([]madmin.ServerOsInfo, len(sys.peerClients))
+// GetOSInfo - Get operating system's information
+func (sys *NotificationSys) GetOSInfo(ctx context.Context) []madmin.OSInfo {
+	reply := make([]madmin.OSInfo, len(sys.peerClients))

 	g := errgroup.WithNErrs(len(sys.peerClients))
 	for index, client := range sys.peerClients {
@ -1127,7 +1096,7 @@ func (sys *NotificationSys) OsInfo(ctx context.Context) []madmin.ServerOsInfo {
 		index := index
 		g.Go(func() error {
 			var err error
-			reply[index], err = sys.peerClients[index].OsInfo(ctx)
+			reply[index], err = sys.peerClients[index].GetOSInfo(ctx)
 			return err
 		}, index)
 	}
@ -1145,9 +1114,9 @@ func (sys *NotificationSys) OsInfo(ctx context.Context) []madmin.ServerOsInfo {
 	return reply
 }

-// MemInfo - Mem information
-func (sys *NotificationSys) MemInfo(ctx context.Context) []madmin.ServerMemInfo {
-	reply := make([]madmin.ServerMemInfo, len(sys.peerClients))
+// GetMemInfo - Memory information
+func (sys *NotificationSys) GetMemInfo(ctx context.Context) []madmin.MemInfo {
+	reply := make([]madmin.MemInfo, len(sys.peerClients))

 	g := errgroup.WithNErrs(len(sys.peerClients))
 	for index, client := range sys.peerClients {
@ -1157,7 +1126,7 @@ func (sys *NotificationSys) MemInfo(ctx context.Context) []madmin.ServerMemInfo
 		index := index
 		g.Go(func() error {
 			var err error
-			reply[index], err = sys.peerClients[index].MemInfo(ctx)
+			reply[index], err = sys.peerClients[index].GetMemInfo(ctx)
 			return err
 		}, index)
 	}
@ -1175,9 +1144,9 @@ func (sys *NotificationSys) MemInfo(ctx context.Context) []madmin.ServerMemInfo
 	return reply
 }

-// ProcInfo - Process information
-func (sys *NotificationSys) ProcInfo(ctx context.Context) []madmin.ServerProcInfo {
-	reply := make([]madmin.ServerProcInfo, len(sys.peerClients))
+// GetProcInfo - Process information
+func (sys *NotificationSys) GetProcInfo(ctx context.Context) []madmin.ProcInfo {
+	reply := make([]madmin.ProcInfo, len(sys.peerClients))

 	g := errgroup.WithNErrs(len(sys.peerClients))
 	for index, client := range sys.peerClients {
@ -1187,7 +1156,7 @@ func (sys *NotificationSys) ProcInfo(ctx context.Context) []madmin.ServerProcInf
 		index := index
 		g.Go(func() error {
 			var err error
-			reply[index], err = sys.peerClients[index].ProcInfo(ctx)
+			reply[index], err = sys.peerClients[index].GetProcInfo(ctx)
 			return err
 		}, index)
 	}
--- a/cmd/peer-rest-client.go
+++ b/cmd/peer-rest-client.go
@ -125,7 +125,7 @@ func (r *nullReader) Read(b []byte) (int, error) {
 	return len(b), nil
 }

-func (client *peerRESTClient) doNetTest(ctx context.Context, dataSize int64, threadCount uint) (info madmin.NetPerfInfo, err error) {
+func (client *peerRESTClient) doNetTest(ctx context.Context, dataSize int64, threadCount uint) (info madmin.PeerNetPerfInfo, err error) {
 	var mu sync.Mutex // mutex used to protect these slices in go-routines
 	latencies := []float64{}
 	throughputs := []float64{}
@ -228,12 +228,24 @@ func (client *peerRESTClient) doNetTest(ctx context.Context, dataSize int64, thr
 	}

 	latency, throughput, err := xnet.ComputePerfStats(latencies, throughputs)
-	info = madmin.NetPerfInfo{
-		Latency:    latency,
-		Throughput: throughput,
-	}
-	return info, err
-
+	return madmin.PeerNetPerfInfo{
+		Latency: madmin.Latency{
+			Avg:          round(latency.Avg, 3),
+			Max:          round(latency.Max, 3),
+			Min:          round(latency.Min, 3),
+			Percentile50: round(latency.Percentile50, 3),
+			Percentile90: round(latency.Percentile90, 3),
+			Percentile99: round(latency.Percentile99, 3),
+		},
+		Throughput: madmin.Throughput{
+			Avg:          uint64(round(throughput.Avg, 0)),
+			Max:          uint64(round(throughput.Max, 0)),
+			Min:          uint64(round(throughput.Min, 0)),
+			Percentile50: uint64(round(throughput.Percentile50, 0)),
+			Percentile90: uint64(round(throughput.Percentile90, 0)),
+			Percentile99: uint64(round(throughput.Percentile99, 0)),
+		},
+	}, nil
 }

 func maxLatencyForSizeThreads(size int64, threadCount uint) float64 {
@ -275,8 +287,8 @@ func maxLatencyForSizeThreads(size int64, threadCount uint) float64 {
 	return math.MaxFloat64
 }

-// NetInfo - fetch Net information for a remote node.
-func (client *peerRESTClient) NetInfo(ctx context.Context) (info madmin.NetPerfInfo, err error) {
+// GetNetPerfInfo - fetch network information for a remote node.
+func (client *peerRESTClient) GetNetPerfInfo(ctx context.Context) (info madmin.PeerNetPerfInfo, err error) {

 	// 100 Gbit ->  256 MiB  *  50 threads
 	// 40 Gbit  ->  256 MiB  *  20 threads
@ -330,7 +342,7 @@ func (client *peerRESTClient) NetInfo(ctx context.Context) (info madmin.NetPerfI
 }

 // DispatchNetInfo - dispatch other nodes to run Net info.
-func (client *peerRESTClient) DispatchNetInfo(ctx context.Context) (info madmin.ServerNetHealthInfo, err error) {
+func (client *peerRESTClient) DispatchNetInfo(ctx context.Context) (info madmin.NetPerfInfo, err error) {
 	respBody, err := client.callWithContext(ctx, peerRESTMethodDispatchNetInfo, nil, nil, -1)
 	if err != nil {
 		return
@ -344,8 +356,8 @@ func (client *peerRESTClient) DispatchNetInfo(ctx context.Context) (info madmin.
 	return
 }

-// DriveInfo - fetch Drive information for a remote node.
-func (client *peerRESTClient) DriveInfo(ctx context.Context) (info madmin.ServerDrivesInfo, err error) {
+// GetDrivePerfInfos - fetch all disk's serial/parallal performance information for a remote node.
+func (client *peerRESTClient) GetDrivePerfInfos(ctx context.Context) (info madmin.DrivePerfInfos, err error) {
 	respBody, err := client.callWithContext(ctx, peerRESTMethodDriveInfo, nil, nil, -1)
 	if err != nil {
 		return
@ -355,8 +367,8 @@ func (client *peerRESTClient) DriveInfo(ctx context.Context) (info madmin.Server
 	return info, err
 }

-// CPUInfo - fetch CPU information for a remote node.
-func (client *peerRESTClient) CPUInfo(ctx context.Context) (info madmin.ServerCPUInfo, err error) {
+// GetCPUs - fetch CPU information for a remote node.
+func (client *peerRESTClient) GetCPUs(ctx context.Context) (info madmin.CPUs, err error) {
 	respBody, err := client.callWithContext(ctx, peerRESTMethodCPUInfo, nil, nil, -1)
 	if err != nil {
 		return
@ -366,8 +378,8 @@ func (client *peerRESTClient) CPUInfo(ctx context.Context) (info madmin.ServerCP
 	return info, err
 }

-// DiskHwInfo - fetch Disk HW information for a remote node.
-func (client *peerRESTClient) DiskHwInfo(ctx context.Context) (info madmin.ServerDiskHwInfo, err error) {
+// GetPartitions - fetch disk partition information for a remote node.
+func (client *peerRESTClient) GetPartitions(ctx context.Context) (info madmin.Partitions, err error) {
 	respBody, err := client.callWithContext(ctx, peerRESTMethodDiskHwInfo, nil, nil, -1)
 	if err != nil {
 		return
@ -377,8 +389,8 @@ func (client *peerRESTClient) DiskHwInfo(ctx context.Context) (info madmin.Serve
 	return info, err
 }

-// OsInfo - fetch OS information for a remote node.
-func (client *peerRESTClient) OsInfo(ctx context.Context) (info madmin.ServerOsInfo, err error) {
+// GetOSInfo - fetch OS information for a remote node.
+func (client *peerRESTClient) GetOSInfo(ctx context.Context) (info madmin.OSInfo, err error) {
 	respBody, err := client.callWithContext(ctx, peerRESTMethodOsInfo, nil, nil, -1)
 	if err != nil {
 		return
@ -388,8 +400,8 @@ func (client *peerRESTClient) OsInfo(ctx context.Context) (info madmin.ServerOsI
 	return info, err
 }

-// MemInfo - fetch Memory information for a remote node.
-func (client *peerRESTClient) MemInfo(ctx context.Context) (info madmin.ServerMemInfo, err error) {
+// GetMemInfo - fetch memory information for a remote node.
+func (client *peerRESTClient) GetMemInfo(ctx context.Context) (info madmin.MemInfo, err error) {
 	respBody, err := client.callWithContext(ctx, peerRESTMethodMemInfo, nil, nil, -1)
 	if err != nil {
 		return
@ -399,8 +411,8 @@ func (client *peerRESTClient) MemInfo(ctx context.Context) (info madmin.ServerMe
 	return info, err
 }

-// ProcInfo - fetch Process information for a remote node.
-func (client *peerRESTClient) ProcInfo(ctx context.Context) (info madmin.ServerProcInfo, err error) {
+// GetProcInfo - fetch MinIO process information for a remote node.
+func (client *peerRESTClient) GetProcInfo(ctx context.Context) (info madmin.ProcInfo, err error) {
 	respBody, err := client.callWithContext(ctx, peerRESTMethodProcInfo, nil, nil, -1)
 	if err != nil {
 		return
--- a/cmd/peer-rest-server.go
+++ b/cmd/peer-rest-server.go
@ -402,15 +402,15 @@ func (s *peerRESTServer) DispatchNetInfoHandler(w http.ResponseWriter, r *http.R
 	done := keepHTTPResponseAlive(w)

 	ctx := newContext(r, w, "DispatchNetInfo")
-	info := globalNotificationSys.NetInfo(ctx)
+	info := globalNotificationSys.GetNetPerfInfo(ctx)

 	done(nil)
 	logger.LogIf(ctx, gob.NewEncoder(w).Encode(info))
 	w.(http.Flusher).Flush()
 }

-// DriveInfoHandler - returns Drive info.
-func (s *peerRESTServer) DriveInfoHandler(w http.ResponseWriter, r *http.Request) {
+// GetDrivePerfInfosHandler - returns all disk's serial/parallal performance information.
+func (s *peerRESTServer) GetDrivePerfInfosHandler(w http.ResponseWriter, r *http.Request) {
 	if !s.IsValid(w, r) {
 		s.writeErrorResponse(w, errors.New("Invalid request"))
 		return
@ -418,28 +418,15 @@ func (s *peerRESTServer) DriveInfoHandler(w http.ResponseWriter, r *http.Request

 	ctx, cancel := context.WithCancel(newContext(r, w, "DriveInfo"))
 	defer cancel()
-	infoSerial := getLocalDrives(ctx, false, globalEndpoints, r)
-	infoParallel := getLocalDrives(ctx, true, globalEndpoints, r)

-	errStr := ""
-	if infoSerial.Error != "" {
-		errStr = "serial: " + infoSerial.Error
-	}
-	if infoParallel.Error != "" {
-		errStr = errStr + " parallel: " + infoParallel.Error
-	}
-	info := madmin.ServerDrivesInfo{
-		Addr:     infoSerial.Addr,
-		Serial:   infoSerial.Serial,
-		Parallel: infoParallel.Parallel,
-		Error:    errStr,
-	}
+	info := getDrivePerfInfos(ctx, r.Host)
+
 	defer w.(http.Flusher).Flush()
 	logger.LogIf(ctx, gob.NewEncoder(w).Encode(info))
 }

-// CPUInfoHandler - returns CPU info.
-func (s *peerRESTServer) CPUInfoHandler(w http.ResponseWriter, r *http.Request) {
+// GetCPUsHandler - returns CPU info.
+func (s *peerRESTServer) GetCPUsHandler(w http.ResponseWriter, r *http.Request) {
 	if !s.IsValid(w, r) {
 		s.writeErrorResponse(w, errors.New("Invalid request"))
 		return
@ -448,14 +435,14 @@ func (s *peerRESTServer) CPUInfoHandler(w http.ResponseWriter, r *http.Request)
 	ctx, cancel := context.WithCancel(r.Context())
 	defer cancel()

-	info := getLocalCPUInfo(ctx, r)
+	info := madmin.GetCPUs(ctx, r.Host)

 	defer w.(http.Flusher).Flush()
 	logger.LogIf(ctx, gob.NewEncoder(w).Encode(info))
 }

-// DiskHwInfoHandler - returns Disk HW info.
-func (s *peerRESTServer) DiskHwInfoHandler(w http.ResponseWriter, r *http.Request) {
+// GetPartitionsHandler - returns disk partition information.
+func (s *peerRESTServer) GetPartitionsHandler(w http.ResponseWriter, r *http.Request) {
 	if !s.IsValid(w, r) {
 		s.writeErrorResponse(w, errors.New("Invalid request"))
 		return
@ -464,14 +451,14 @@ func (s *peerRESTServer) DiskHwInfoHandler(w http.ResponseWriter, r *http.Reques
 	ctx, cancel := context.WithCancel(r.Context())
 	defer cancel()

-	info := getLocalDiskHwInfo(ctx, r)
+	info := madmin.GetPartitions(ctx, r.Host)

 	defer w.(http.Flusher).Flush()
 	logger.LogIf(ctx, gob.NewEncoder(w).Encode(info))
 }

-// OsInfoHandler - returns Os info.
-func (s *peerRESTServer) OsInfoHandler(w http.ResponseWriter, r *http.Request) {
+// GetOSInfoHandler - returns operating system's information.
+func (s *peerRESTServer) GetOSInfoHandler(w http.ResponseWriter, r *http.Request) {
 	if !s.IsValid(w, r) {
 		s.writeErrorResponse(w, errors.New("Invalid request"))
 		return
@ -480,14 +467,14 @@ func (s *peerRESTServer) OsInfoHandler(w http.ResponseWriter, r *http.Request) {
 	ctx, cancel := context.WithCancel(r.Context())
 	defer cancel()

-	info := getLocalOsInfo(ctx, r)
+	info := madmin.GetOSInfo(ctx, r.Host)

 	defer w.(http.Flusher).Flush()
 	logger.LogIf(ctx, gob.NewEncoder(w).Encode(info))
 }

-// ProcInfoHandler - returns Proc info.
-func (s *peerRESTServer) ProcInfoHandler(w http.ResponseWriter, r *http.Request) {
+// GetProcInfoHandler - returns this MinIO process information.
+func (s *peerRESTServer) GetProcInfoHandler(w http.ResponseWriter, r *http.Request) {
 	if !s.IsValid(w, r) {
 		s.writeErrorResponse(w, errors.New("Invalid request"))
 		return
@ -496,14 +483,14 @@ func (s *peerRESTServer) ProcInfoHandler(w http.ResponseWriter, r *http.Request)
 	ctx, cancel := context.WithCancel(r.Context())
 	defer cancel()

-	info := getLocalProcInfo(ctx, r)
+	info := madmin.GetProcInfo(ctx, r.Host)

 	defer w.(http.Flusher).Flush()
 	logger.LogIf(ctx, gob.NewEncoder(w).Encode(info))
 }

-// MemInfoHandler - returns Memory info.
-func (s *peerRESTServer) MemInfoHandler(w http.ResponseWriter, r *http.Request) {
+// GetMemInfoHandler - returns memory information.
+func (s *peerRESTServer) GetMemInfoHandler(w http.ResponseWriter, r *http.Request) {
 	if !s.IsValid(w, r) {
 		s.writeErrorResponse(w, errors.New("Invalid request"))
 		return
@ -512,7 +499,7 @@ func (s *peerRESTServer) MemInfoHandler(w http.ResponseWriter, r *http.Request)
 	ctx, cancel := context.WithCancel(r.Context())
 	defer cancel()

-	info := getLocalMemInfo(ctx, r)
+	info := madmin.GetMemInfo(ctx, r.Host)

 	defer w.(http.Flusher).Flush()
 	logger.LogIf(ctx, gob.NewEncoder(w).Encode(info))
@ -1117,12 +1104,12 @@ func registerPeerRESTHandlers(router *mux.Router) {
 	subrouter.Methods(http.MethodPost).Path(peerRESTVersionPrefix + peerRESTMethodHealth).HandlerFunc(httpTraceHdrs(server.HealthHandler))
 	subrouter.Methods(http.MethodPost).Path(peerRESTVersionPrefix + peerRESTMethodGetLocks).HandlerFunc(httpTraceHdrs(server.GetLocksHandler))
 	subrouter.Methods(http.MethodPost).Path(peerRESTVersionPrefix + peerRESTMethodServerInfo).HandlerFunc(httpTraceHdrs(server.ServerInfoHandler))
-	subrouter.Methods(http.MethodPost).Path(peerRESTVersionPrefix + peerRESTMethodProcInfo).HandlerFunc(httpTraceHdrs(server.ProcInfoHandler))
-	subrouter.Methods(http.MethodPost).Path(peerRESTVersionPrefix + peerRESTMethodMemInfo).HandlerFunc(httpTraceHdrs(server.MemInfoHandler))
-	subrouter.Methods(http.MethodPost).Path(peerRESTVersionPrefix + peerRESTMethodOsInfo).HandlerFunc(httpTraceHdrs(server.OsInfoHandler))
-	subrouter.Methods(http.MethodPost).Path(peerRESTVersionPrefix + peerRESTMethodDiskHwInfo).HandlerFunc(httpTraceHdrs(server.DiskHwInfoHandler))
-	subrouter.Methods(http.MethodPost).Path(peerRESTVersionPrefix + peerRESTMethodCPUInfo).HandlerFunc(httpTraceHdrs(server.CPUInfoHandler))
-	subrouter.Methods(http.MethodPost).Path(peerRESTVersionPrefix + peerRESTMethodDriveInfo).HandlerFunc(httpTraceHdrs(server.DriveInfoHandler))
+	subrouter.Methods(http.MethodPost).Path(peerRESTVersionPrefix + peerRESTMethodProcInfo).HandlerFunc(httpTraceHdrs(server.GetProcInfoHandler))
+	subrouter.Methods(http.MethodPost).Path(peerRESTVersionPrefix + peerRESTMethodMemInfo).HandlerFunc(httpTraceHdrs(server.GetMemInfoHandler))
+	subrouter.Methods(http.MethodPost).Path(peerRESTVersionPrefix + peerRESTMethodOsInfo).HandlerFunc(httpTraceHdrs(server.GetOSInfoHandler))
+	subrouter.Methods(http.MethodPost).Path(peerRESTVersionPrefix + peerRESTMethodDiskHwInfo).HandlerFunc(httpTraceHdrs(server.GetPartitionsHandler))
+	subrouter.Methods(http.MethodPost).Path(peerRESTVersionPrefix + peerRESTMethodCPUInfo).HandlerFunc(httpTraceHdrs(server.GetCPUsHandler))
+	subrouter.Methods(http.MethodPost).Path(peerRESTVersionPrefix + peerRESTMethodDriveInfo).HandlerFunc(httpTraceHdrs(server.GetDrivePerfInfosHandler))
 	subrouter.Methods(http.MethodPost).Path(peerRESTVersionPrefix + peerRESTMethodNetInfo).HandlerFunc(httpTraceHdrs(server.NetInfoHandler))
 	subrouter.Methods(http.MethodPost).Path(peerRESTVersionPrefix + peerRESTMethodDispatchNetInfo).HandlerFunc(httpTraceHdrs(server.DispatchNetInfoHandler))
 	subrouter.Methods(http.MethodPost).Path(peerRESTVersionPrefix + peerRESTMethodCycleBloom).HandlerFunc(httpTraceHdrs(server.CycleServerBloomFilterHandler))
--- a/go.mod
+++ b/go.mod
@ -44,7 +44,7 @@ require (
 	github.com/minio/csvparser v1.0.0
 	github.com/minio/highwayhash v1.0.2
 	github.com/minio/kes v0.14.0
-	github.com/minio/madmin-go v1.0.2
+	github.com/minio/madmin-go v1.0.8
 	github.com/minio/minio-go/v7 v7.0.11-0.20210302210017-6ae69c73ce78
 	github.com/minio/parquet-go v1.0.0
 	github.com/minio/pkg v1.0.3
@ -56,6 +56,7 @@ require (
 	github.com/mitchellh/go-homedir v1.1.0
 	github.com/montanaflynn/stats v0.5.0
 	github.com/nats-io/nats-server/v2 v2.1.9
+	github.com/nats-io/nats-streaming-server v0.21.2 // indirect
 	github.com/nats-io/nats.go v1.10.0
 	github.com/nats-io/stan.go v0.8.3
 	github.com/ncw/directio v1.0.5
@ -69,7 +70,6 @@ require (
 	github.com/prometheus/procfs v0.6.0
 	github.com/rs/cors v1.7.0
 	github.com/secure-io/sio-go v0.3.1
-	github.com/shirou/gopsutil/v3 v3.21.3
 	github.com/streadway/amqp v1.0.0
 	github.com/tinylib/msgp v1.1.6-0.20210521143832-0becd170c402
 	github.com/valyala/bytebufferpool v1.0.0
--- a/go.sum
+++ b/go.sum
@ -1,6 +1,5 @@
 cloud.google.com/go v0.34.0/go.mod h1:aQUYkXzVsufM+DwF1aE+0xfcU+56JwCaLick0ClmMTw=
 cloud.google.com/go v0.38.0/go.mod h1:990N+gfupTy94rShfmMCWGDn0LpTmnzTp2qbd1dvSRU=
-cloud.google.com/go v0.39.0/go.mod h1:rVLT6fkc8chs9sfPtFc1SBH6em7n+ZoXaG+87tDISts=
 cloud.google.com/go v0.44.1/go.mod h1:iSa0KzasP4Uvy3f1mN/7PiObzGgflwredwwASm/v6AU=
 cloud.google.com/go v0.44.2/go.mod h1:60680Gw3Yr4ikxnPRS/oxxkBccT6SA1yMk63TGekxKY=
 cloud.google.com/go v0.45.1/go.mod h1:RpBamKRgapWJb87xiFSdk4g1CME7QZg3uwTez+TSTjc=
@ -39,26 +38,21 @@ github.com/Azure/azure-pipeline-go v0.2.2 h1:6oiIS9yaG6XCCzhgAgKFfIWyo4LLCiDhZot
 github.com/Azure/azure-pipeline-go v0.2.2/go.mod h1:4rQ/NZncSvGqNkkOsNpOU1tgoNuIlp9AfUH5G1tvCHc=
 github.com/Azure/azure-storage-blob-go v0.10.0 h1:evCwGreYo3XLeBV4vSxLbLiYb6e0SzsJiXQVRGsRXxs=
 github.com/Azure/azure-storage-blob-go v0.10.0/go.mod h1:ep1edmW+kNQx4UfWM9heESNmQdijykocJ0YOxmMX8SE=
-github.com/Azure/go-autorest v14.2.0+incompatible h1:V5VMDjClD3GiElqLWO7mz2MxNAK/vTfRHdAubSIPRgs=
-github.com/Azure/go-autorest v14.2.0+incompatible/go.mod h1:r+4oMnoxhatjLLJ6zxSWATqVooLgysK6ZNox3g/xq24=
 github.com/Azure/go-autorest/autorest v0.9.0 h1:MRvx8gncNaXJqOoLmhNjUAKh33JJF8LyxPhomEtOsjs=
 github.com/Azure/go-autorest/autorest v0.9.0/go.mod h1:xyHB1BMZT0cuDHU7I0+g046+BFDTQ8rEZB0s4Yfa6bI=
 github.com/Azure/go-autorest/autorest/adal v0.5.0/go.mod h1:8Z9fGy2MpX0PvDjB1pEgQTmVqjGhiHBW7RJJEciWzS0=
+github.com/Azure/go-autorest/autorest/adal v0.8.3 h1:O1AGG9Xig71FxdX9HO5pGNyZ7TbSyHaVg+5eJO/jSGw=
 github.com/Azure/go-autorest/autorest/adal v0.8.3/go.mod h1:ZjhuQClTqx435SRJ2iMlOxPYt3d2C/T/7TiQCVZSn3Q=
-github.com/Azure/go-autorest/autorest/adal v0.9.1 h1:xjPqigMQe2+0DAJ5A6MLUPp5D2r2Io8qHCuCMMI/yJU=
-github.com/Azure/go-autorest/autorest/adal v0.9.1/go.mod h1:/c022QCutn2P7uY+/oQWWNcK9YU+MH96NgK+jErpbcg=
 github.com/Azure/go-autorest/autorest/date v0.1.0/go.mod h1:plvfp3oPSKwf2DNjlBjWF/7vwR+cUD/ELuzDCXwHUVA=
+github.com/Azure/go-autorest/autorest/date v0.2.0 h1:yW+Zlqf26583pE43KhfnhFcdmSWlm5Ew6bxipnr/tbM=
 github.com/Azure/go-autorest/autorest/date v0.2.0/go.mod h1:vcORJHLJEh643/Ioh9+vPmf1Ij9AEBM5FuBIXLmIy0g=
-github.com/Azure/go-autorest/autorest/date v0.3.0 h1:7gUk1U5M/CQbp9WoqinNzJar+8KY+LPI6wiWrP/myHw=
-github.com/Azure/go-autorest/autorest/date v0.3.0/go.mod h1:BI0uouVdmngYNUzGWeSYnokU+TrmwEsOqdt8Y6sso74=
 github.com/Azure/go-autorest/autorest/mocks v0.1.0/go.mod h1:OTyCOPRA2IgIlWxVYxBee2F5Gr4kF2zd2J5cFRaIDN0=
 github.com/Azure/go-autorest/autorest/mocks v0.2.0/go.mod h1:OTyCOPRA2IgIlWxVYxBee2F5Gr4kF2zd2J5cFRaIDN0=
 github.com/Azure/go-autorest/autorest/mocks v0.3.0/go.mod h1:a8FDP3DYzQ4RYfVAxAN3SVSiiO77gL2j2ronKKP0syM=
-github.com/Azure/go-autorest/autorest/mocks v0.4.0/go.mod h1:LTp+uSrOhSkaKrUy935gNZuuIPPVsHlr9DSOxSayd+k=
+github.com/Azure/go-autorest/logger v0.1.0 h1:ruG4BSDXONFRrZZJ2GUXDiUyVpayPmb1GnWeHDdaNKY=
 github.com/Azure/go-autorest/logger v0.1.0/go.mod h1:oExouG+K6PryycPJfVSxi/koC6LSNgds39diKLz7Vrc=
+github.com/Azure/go-autorest/tracing v0.5.0 h1:TRn4WjSnkcSy5AEG3pnbtFSwNtwzjr4VYyQflFE619k=
 github.com/Azure/go-autorest/tracing v0.5.0/go.mod h1:r/s2XiOKccPW3HrqB+W0TQzfbtp2fGCgRFtBroKn4Dk=
-github.com/Azure/go-autorest/tracing v0.6.0 h1:TYi4+3m5t6K48TGI9AUdb+IzbnSxvnvUMfuitfgcfuo=
-github.com/Azure/go-autorest/tracing v0.6.0/go.mod h1:+vhtPC754Xsa23ID7GlGsrdKBpUA79WCAKPPZVC2DeU=
 github.com/Azure/go-ntlmssp v0.0.0-20200615164410-66371956d46c h1:/IBSNwUN8+eKzUzbJPqhK839ygXJ82sde8x3ogr6R28=
 github.com/Azure/go-ntlmssp v0.0.0-20200615164410-66371956d46c/go.mod h1:chxPXzSsl7ZWRAuOIE23GDNzjWuZquvFlgA8xmpunjU=
 github.com/BurntSushi/toml v0.3.1/go.mod h1:xHWCNGjB5oqiDr8zfno3MHue2Ht5sIBksp03qcyfWMU=
@ -177,7 +171,6 @@ github.com/envoyproxy/go-control-plane v0.9.4/go.mod h1:6rpuAdCZL397s3pYoYcLgu1m
 github.com/envoyproxy/protoc-gen-validate v0.1.0/go.mod h1:iSmxcyjqTsJpI2R4NaDN7+kN2VEUnK/pcBlmesArF7c=
 github.com/fatih/color v1.7.0/go.mod h1:Zm6kSWBoL9eyXnKyktHP6abPY2pDugNf5KwzbycvMj4=
 github.com/fatih/color v1.9.0/go.mod h1:eQcE1qtQxscV5RaZvpXrrb8Drkc3/DdQ+uUYCNjL+zU=
-github.com/fatih/color v1.10.0/go.mod h1:ELkj/draVOlAH/xkhN6mQ50Qd0MPOk5AAr3maGEBuJM=
 github.com/fatih/color v1.12.0 h1:mRhaKNwANqRgUBGKmnI5ZxEk7QXmjQeCcuYFMX2bfcc=
 github.com/fatih/color v1.12.0/go.mod h1:ELkj/draVOlAH/xkhN6mQ50Qd0MPOk5AAr3maGEBuJM=
 github.com/fatih/structs v1.1.0 h1:Q7juDM0QtcnhCpeyLGQKyg4TOIghuNXrkL32pHAUMxo=
@ -259,7 +252,6 @@ github.com/golang/snappy v0.0.0-20180518054509-2e65f85255db/go.mod h1:/XxbfmMg8l
 github.com/golang/snappy v0.0.1/go.mod h1:/XxbfmMg8lxefKM7IXC3fBNl/7bRcc72aCRzEWrmP2Q=
 github.com/golang/snappy v0.0.3 h1:fHPg5GQYlCeLIPB9BZqMVR5nR9A+IM5zcgeTdjMYmLA=
 github.com/golang/snappy v0.0.3/go.mod h1:/XxbfmMg8lxefKM7IXC3fBNl/7bRcc72aCRzEWrmP2Q=
-github.com/gomodule/redigo v1.8.3/go.mod h1:P9dn9mFrCBvWhGE1wpxx6fgq7BAeLBk+UUUzlpkBYO0=
 github.com/gomodule/redigo v2.0.0+incompatible h1:K/R+8tc58AaqLkqG2Ol3Qk+DR/TlNuhuh457pBFPtt0=
 github.com/gomodule/redigo v2.0.0+incompatible/go.mod h1:B4C85qUVwatsJoIUNIfCRsp7qO0iAmpGFZ4EELWSbC4=
 github.com/google/btree v0.0.0-20180813153112-4030bb1f1f0c/go.mod h1:lNA+9X1NB3Zf8V7Ke586lFgjr2dZNuvo3lPJSGZ5JPQ=
@ -409,7 +401,6 @@ github.com/kisielk/errcheck v1.5.0/go.mod h1:pFxgyoBC7bSaBwPgfKdkLd5X25qrDl4LWUI
 github.com/kisielk/gotool v1.0.0/go.mod h1:XhKaO+MFFWcvkIS/tQcRk01m1F5IRFswLeQ+oQHNcck=
 github.com/klauspost/compress v1.11.0/go.mod h1:aoV0uJVorq1K+umq18yTdKaF57EivdYsUV+/s2qKfXs=
 github.com/klauspost/compress v1.11.7/go.mod h1:aoV0uJVorq1K+umq18yTdKaF57EivdYsUV+/s2qKfXs=
-github.com/klauspost/compress v1.11.12/go.mod h1:aoV0uJVorq1K+umq18yTdKaF57EivdYsUV+/s2qKfXs=
 github.com/klauspost/compress v1.12.2 h1:2KCfW3I9M7nSc5wOqXAlW2v2U6v+w6cbjvbfp+OykW8=
 github.com/klauspost/compress v1.12.2/go.mod h1:8dP1Hq4DHOhN9w426knH3Rhby4rFm6D8eO+e+Dq5Gzg=
 github.com/klauspost/cpuid v1.2.3/go.mod h1:Pj4uuM528wm8OyEC2QMXAi2YiTZ96dNQPGgoMS4s3ek=
@ -463,9 +454,8 @@ github.com/mattn/go-colorable v0.1.2/go.mod h1:U0ppj6V5qS13XJ6of8GYAs25YV2eR4EVc
 github.com/mattn/go-colorable v0.1.4/go.mod h1:U0ppj6V5qS13XJ6of8GYAs25YV2eR4EVcfRqFIhoBtE=
 github.com/mattn/go-colorable v0.1.8 h1:c1ghPdyEDarC70ftn0y+A/Ee++9zz8ljHG1b13eJ0s8=
 github.com/mattn/go-colorable v0.1.8/go.mod h1:u6P/XSegPjTcexA+o6vUJrdnUu04hMope9wVRipJSqc=
+github.com/mattn/go-ieproxy v0.0.0-20190702010315-6dee0af9227d h1:oNAwILwmgWKFpuU+dXvI6dl9jG2mAWAZLX3r9s0PPiw=
 github.com/mattn/go-ieproxy v0.0.0-20190702010315-6dee0af9227d/go.mod h1:31jz6HNzdxOmlERGGEc4v/dMssOfmp2p5bT/okiKFFc=
-github.com/mattn/go-ieproxy v0.0.1 h1:qiyop7gCflfhwCzGyeT0gro3sF9AIg9HU98JORTkqfI=
-github.com/mattn/go-ieproxy v0.0.1/go.mod h1:pYabZ6IHcRpFh7vIaLfK7rdcWgFEb3SFJ6/gNWuh88E=
 github.com/mattn/go-isatty v0.0.3/go.mod h1:M+lRXTBqGeGNdLjl/ufCoiOlB5xdOkqRJdNxMWT7Zi4=
 github.com/mattn/go-isatty v0.0.4/go.mod h1:M+lRXTBqGeGNdLjl/ufCoiOlB5xdOkqRJdNxMWT7Zi4=
 github.com/mattn/go-isatty v0.0.8/go.mod h1:Iq45c/XA43vh69/j3iqttzPXn0bhXyGjM0Hdxcsrc5s=
@ -493,12 +483,10 @@ github.com/minio/highwayhash v1.0.2 h1:Aak5U0nElisjDCfPSG79Tgzkn2gl66NxOMspRrKnA
 github.com/minio/highwayhash v1.0.2/go.mod h1:BQskDq+xkJ12lmlUUi7U0M5Swg3EWR+dLTk+kldvVxY=
 github.com/minio/kes v0.14.0 h1:plCGm4LwR++T1P1sXsJbyFRX54CE1WRuo9PAPj6MC3Q=
 github.com/minio/kes v0.14.0/go.mod h1:OUensXz2BpgMfiogslKxv7Anyx/wj+6bFC6qA7BQcfA=
-github.com/minio/madmin-go v1.0.2 h1:ttwuuN6AopJNcikazBEwnXnw45BxQ74GZFqlJvcKOXc=
-github.com/minio/madmin-go v1.0.2/go.mod h1:6Hox3cho6WUdTzFt3GjA4Y0abFOs11Axn25sZXiyR9M=
+github.com/minio/madmin-go v1.0.8 h1:/hbeP6VqHNAk6syR8HMVVrUE0Uu1tmkDVdeY2z2WaA4=
+github.com/minio/madmin-go v1.0.8/go.mod h1:BK+z4XRx7Y1v8SFWXsuLNqQqnq5BO/axJ8IDJfgyvfs=
+github.com/minio/md5-simd v1.1.0 h1:QPfiOqlZH+Cj9teu0t9b1nTBfPbyTl16Of5MeuShdK4=
 github.com/minio/md5-simd v1.1.0/go.mod h1:XpBqgZULrMYD3R+M28PcmP0CkI7PEMzB3U77ZrKZ0Gw=
-github.com/minio/md5-simd v1.1.1 h1:9ojcLbuZ4gXbB2sX53MKn8JUZ0sB/2wfwsEcRw+I08U=
-github.com/minio/md5-simd v1.1.1/go.mod h1:XpBqgZULrMYD3R+M28PcmP0CkI7PEMzB3U77ZrKZ0Gw=
-github.com/minio/minio v0.0.0-20210422165109-3455f786faf0/go.mod h1:nFVEfjWoCj2KxWymJnQuVPolrE3/gvFCYm0wZkCIdXw=
 github.com/minio/minio-go/v7 v7.0.10/go.mod h1:td4gW1ldOsj1PbSNS+WYK43j+P1XVhX/8W8awaYlBFo=
 github.com/minio/minio-go/v7 v7.0.11-0.20210302210017-6ae69c73ce78 h1:v7OMbUnWkyRlO2MZ5AuYioELhwXF/BgZEznrQ1drBEM=
 github.com/minio/minio-go/v7 v7.0.11-0.20210302210017-6ae69c73ce78/go.mod h1:mTh2uJuAbEqdhMVl6CMIIZLUeiMiWtJR4JB8/5g2skw=
@ -550,16 +538,15 @@ github.com/nats-io/jwt v1.1.0/go.mod h1:n3cvmLfBfnpV4JJRN7lRYCyZnw48ksGsbThGXEk4
 github.com/nats-io/nats-server/v2 v2.1.2/go.mod h1:Afk+wRZqkMQs/p45uXdrVLuab3gwv3Z8C4HTBu8GD/k=
 github.com/nats-io/nats-server/v2 v2.1.9 h1:Sxr2zpaapgpBT9ElTxTVe62W+qjnhPcKY/8W5cnA/Qk=
 github.com/nats-io/nats-server/v2 v2.1.9/go.mod h1:9qVyoewoYXzG1ME9ox0HwkkzyYvnlBDugfR4Gg/8uHU=
-github.com/nats-io/nats-streaming-server v0.21.1 h1:jb/osnXmFJtKDS9DFghDjX82v1NT9IhaoR/r6s6toNg=
-github.com/nats-io/nats-streaming-server v0.21.1/go.mod h1:2W8QfNVOtcFpmf0bRiwuLtRb0/hkX4NuOxPOFNOThVQ=
+github.com/nats-io/nats-streaming-server v0.21.2 h1:chyaVdWlPdBcSbLq3cpyCYcuXA+7bVXJmM4yWrdqL/8=
+github.com/nats-io/nats-streaming-server v0.21.2/go.mod h1:2W8QfNVOtcFpmf0bRiwuLtRb0/hkX4NuOxPOFNOThVQ=
 github.com/nats-io/nats.go v1.9.1/go.mod h1:ZjDU1L/7fJ09jvUSRVBR2e7+RnLiiIQyqyzEE/Zbp4w=
 github.com/nats-io/nats.go v1.10.0 h1:L8qnKaofSfNFbXg0C5F71LdjPRnmQwSsA4ukmkt1TvY=
 github.com/nats-io/nats.go v1.10.0/go.mod h1:AjGArbfyR50+afOUotNX2Xs5SYHf+CoOa5HH1eEl2HE=
 github.com/nats-io/nkeys v0.1.0/go.mod h1:xpnFELMwJABBLVhffcfd1MZx6VsNRFpEugbxziKVo7w=
 github.com/nats-io/nkeys v0.1.3/go.mod h1:xpnFELMwJABBLVhffcfd1MZx6VsNRFpEugbxziKVo7w=
+github.com/nats-io/nkeys v0.1.4 h1:aEsHIssIk6ETN5m2/MD8Y4B2X7FfXrBAUdkyRvbVYzA=
 github.com/nats-io/nkeys v0.1.4/go.mod h1:XdZpAbhgyyODYqjTawOnIOI7VlbKSarI9Gfy1tqEu/s=
-github.com/nats-io/nkeys v0.2.0 h1:WXKF7diOaPU9cJdLD7nuzwasQy9vT1tBqzXZZf3AMJM=
-github.com/nats-io/nkeys v0.2.0/go.mod h1:XdZpAbhgyyODYqjTawOnIOI7VlbKSarI9Gfy1tqEu/s=
 github.com/nats-io/nuid v1.0.1 h1:5iA8DT8V7q8WK2EScv2padNa/rTESc1KdnPw4TC2paw=
 github.com/nats-io/nuid v1.0.1/go.mod h1:19wcPz3Ph3q0Jbyiqsd0kePYG7A95tJPxeL+1OSON2c=
 github.com/nats-io/stan.go v0.8.3 h1:XyemjL9vAeGHooHn5RQy+ngljd8AVSM2l65Jdnpv4rI=
@ -665,9 +652,8 @@ github.com/sean-/seed v0.0.0-20170313163322-e2103e2c3529/go.mod h1:DxrIzT+xaE7yg
 github.com/secure-io/sio-go v0.3.0/go.mod h1:D3KmXgKETffyYxBdFRN+Hpd2WzhzqS0EQwT3XWsAcBU=
 github.com/secure-io/sio-go v0.3.1 h1:dNvY9awjabXTYGsTF1PiCySl9Ltofk9GA3VdWlo7rRc=
 github.com/secure-io/sio-go v0.3.1/go.mod h1:+xbkjDzPjwh4Axd07pRKSNriS9SCiYksWnZqdnfpQxs=
-github.com/shirou/gopsutil/v3 v3.21.1/go.mod h1:igHnfak0qnw1biGeI2qKQvu0ZkwvEkUcCLlYhZzdr/4=
-github.com/shirou/gopsutil/v3 v3.21.3 h1:wgcdAHZS2H6qy4JFewVTtqfiYxFzCeEJod/mLztdPG8=
-github.com/shirou/gopsutil/v3 v3.21.3/go.mod h1:ghfMypLDrFSWN2c9cDYFLHyynQ+QUht0cv/18ZqVczw=
+github.com/shirou/gopsutil/v3 v3.21.4 h1:XB/+p+kVnyYLuPHCfa99lxz2aJyvVhnyd+FxZqH/k7M=
+github.com/shirou/gopsutil/v3 v3.21.4/go.mod h1:ghfMypLDrFSWN2c9cDYFLHyynQ+QUht0cv/18ZqVczw=
 github.com/shurcooL/sanitized_anchor_name v1.0.0/go.mod h1:1NzhyTcUVG4SuEtjjoZeVRXNmyL/1OwPU0+IJeTBvfc=
 github.com/sirupsen/logrus v1.2.0/go.mod h1:LxeOpSwHxABJmUn/MG1IvRgCAasNZTLOkJPxbbu5VWo=
 github.com/sirupsen/logrus v1.4.2/go.mod h1:tLMulIdttU9McNUspp0xgXVQah82FyeX6MwdIuYE2rE=
@ -700,25 +686,24 @@ github.com/stretchr/testify v1.5.1/go.mod h1:5W2xD1RspED5o8YsWQXVCued0rvSQ+mT+I5
 github.com/stretchr/testify v1.6.1/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg=
 github.com/stretchr/testify v1.7.0 h1:nwc3DEeHmmLAfoZucVR881uASk0Mfjw8xYJ99tb5CcY=
 github.com/stretchr/testify v1.7.0/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg=
-github.com/tidwall/gjson v1.6.8/go.mod h1:zeFuBCIqD4sN/gmqBzZ4j7Jd6UcA2Fc56x7QFsv+8fI=
 github.com/tidwall/gjson v1.7.4/go.mod h1:5/xDoumyyDNerp2U36lyolv46b3uF/9Bu6OfyQ9GImk=
 github.com/tidwall/gjson v1.7.5 h1:zmAN/xmX7OtpAkv4Ovfso60r/BiCi5IErCDYGNJu+uc=
 github.com/tidwall/gjson v1.7.5/go.mod h1:5/xDoumyyDNerp2U36lyolv46b3uF/9Bu6OfyQ9GImk=
 github.com/tidwall/match v1.0.3 h1:FQUVvBImDutD8wJLN6c5eMzWtjgONK9MwIBCOrUJKeE=
 github.com/tidwall/match v1.0.3/go.mod h1:eRSPERbgtNPcGhD8UCthc6PmLEQXEWd3PRB5JTxsfmM=
-github.com/tidwall/pretty v1.0.2/go.mod h1:XNkn88O1ChpSDQmQeStsy+sBenx6DDtFZJxhVysOjyk=
 github.com/tidwall/pretty v1.1.0 h1:K3hMW5epkdAVwibsQEfR/7Zj0Qgt4DxtNumTq/VloO8=
 github.com/tidwall/pretty v1.1.0/go.mod h1:XNkn88O1ChpSDQmQeStsy+sBenx6DDtFZJxhVysOjyk=
-github.com/tidwall/sjson v1.0.4/go.mod h1:bURseu1nuBkFpIES5cz6zBtjmYeOQmEESshn7VpF15Y=
 github.com/tidwall/sjson v1.1.6 h1:8fDdlahON04OZBlTQCIatW8FstSFJz8oxidj5h0rmSQ=
 github.com/tidwall/sjson v1.1.6/go.mod h1:KN3FZ7odvXIHPbJdhNorK/M9lWweVUbXsXXhrJ/kGOA=
 github.com/tinylib/msgp v1.1.3/go.mod h1:+d+yLhGm8mzTaHzB+wgMYrodPfmZrzkirds8fDWklFE=
 github.com/tinylib/msgp v1.1.6-0.20210521143832-0becd170c402 h1:x5VlSgDgIGXNegkO4gigpYmb/RFkKGgy12Kkrbif7XE=
 github.com/tinylib/msgp v1.1.6-0.20210521143832-0becd170c402/go.mod h1:75BAfg2hauQhs3qedfdDZmWAPcFMAvJE5b9rGOMufyw=
-github.com/tklauser/go-sysconf v0.3.4 h1:HT8SVixZd3IzLdfs/xlpq0jeSfTX57g1v6wB1EuzV7M=
 github.com/tklauser/go-sysconf v0.3.4/go.mod h1:Cl2c8ZRWfHD5IrfHo9VN+FX9kCFjIOyVklgXycLB6ek=
-github.com/tklauser/numcpus v0.2.1 h1:ct88eFm+Q7m2ZfXJdan1xYoXKlmwsfP+k88q05KvlZc=
+github.com/tklauser/go-sysconf v0.3.5 h1:uu3Xl4nkLzQfXNsWn15rPc/HQCJKObbt1dKJeWp3vU4=
+github.com/tklauser/go-sysconf v0.3.5/go.mod h1:MkWzOF4RMCshBAMXuhXJs64Rte09mITnppBXY/rYEFI=
 github.com/tklauser/numcpus v0.2.1/go.mod h1:9aU+wOc6WjUIZEwWMP62PL/41d65P+iks1gBkr4QyP8=
+github.com/tklauser/numcpus v0.2.2 h1:oyhllyrScuYI6g+h/zUvNXNp1wy7x8qQy3t/piefldA=
+github.com/tklauser/numcpus v0.2.2/go.mod h1:x3qojaO3uyYt0i56EW/VUYs7uBvdl2fkfZFu0T9wgjM=
 github.com/tmc/grpc-websocket-proxy v0.0.0-20170815181823-89b8d40f7ca8/go.mod h1:ncp9v5uamzpCO7NfCPTXjqaC+bZgJeR0sMTm6dMHP7U=
 github.com/tv42/httpunix v0.0.0-20150427012821-b75d8614f926/go.mod h1:9ESjWnEqriFuLhtthL60Sar/7RFoluCcXsuvEwTV5KM=
 github.com/urfave/cli v1.20.0/go.mod h1:70zkFmudgCuE/ngEzBv17Jvp/497gISqfk5gWijbERA=
@ -727,8 +712,6 @@ github.com/valyala/bytebufferpool v1.0.0 h1:GqA5TC/0021Y/b9FG4Oi9Mr3q7XYx6Kllzaw
 github.com/valyala/bytebufferpool v1.0.0/go.mod h1:6bBcMArwyJ5K/AmCkWv1jt77kVWyCJ6HpOuEn7z0Csc=
 github.com/valyala/tcplisten v0.0.0-20161114210144-ceec8f93295a h1:0R4NLDRDZX6JcmhJgXi5E4b8Wg84ihbmUKp/GvSPEzc=
 github.com/valyala/tcplisten v0.0.0-20161114210144-ceec8f93295a/go.mod h1:v3UYOV9WzVtRmSR+PDvWpU/qWl4Wa5LApYYX4ZtKbio=
-github.com/willf/bitset v1.1.11/go.mod h1:83CECat5yLh5zVOf4P1ErAgKA5UDvKtgyUABdr3+MjI=
-github.com/willf/bloom v2.0.3+incompatible/go.mod h1:MmAltL9pDMNTrvUkxdg0k0q5I0suxmuwp3KbyrZLOZ8=
 github.com/xdg/scram v0.0.0-20180814205039-7eeb5667e42c h1:u40Z8hqBAAQyv+vATcGgV0YCnDjqSL7/q/JyPhhJSPk=
 github.com/xdg/scram v0.0.0-20180814205039-7eeb5667e42c/go.mod h1:lB8K/P019DLNhemzwFU4jHLhdvlE6uDZjXFejJXr49I=
 github.com/xdg/stringprep v1.0.0 h1:d9X0esnoa3dFsV0FG35rAT0RIhYFlPq7MiP+DW89La0=
@ -742,9 +725,8 @@ github.com/yuin/goldmark v1.3.5/go.mod h1:mwnBkeHKe2W/ZEtQ+71ViKU8L12m81fl3OWwC1
 go.etcd.io/bbolt v1.3.3/go.mod h1:IbVyRI1SCnLcuJnV2u8VeU0CEYM7e686BmAb1XKL+uU=
 go.etcd.io/bbolt v1.3.5 h1:XAzx9gjCb0Rxj7EoqcClPD1d5ZBxZJk0jbuoPHenBt0=
 go.etcd.io/bbolt v1.3.5/go.mod h1:G5EMThwa9y8QZGBClrRx5EY+Yw9kAhnjy3bSjsnlVTQ=
+go.etcd.io/etcd v0.0.0-20191023171146-3cf2f69b5738 h1:VcrIfasaLFkyjk6KNlXQSzO+B0fZcnECiDrKJsfxka0=
 go.etcd.io/etcd v0.0.0-20191023171146-3cf2f69b5738/go.mod h1:dnLIgRNXwCJa5e+c6mIZCrds/GIG4ncV9HhK5PX7jPg=
-go.etcd.io/etcd v0.0.0-20201125193152-8a03d2e9614b h1:5makfKENOTVu2bNoHzSqwwz+g70ivWLSnExzd33/2bI=
-go.etcd.io/etcd v0.0.0-20201125193152-8a03d2e9614b/go.mod h1:yVHk9ub3CSBatqGNg7GRmsnfLWtoW60w4eDYfh7vHDg=
 go.etcd.io/etcd/api/v3 v3.5.0-beta.4 h1:etIejKeELg3fIXt0i71TXtx1OjK9q+oegcv00zipiis=
 go.etcd.io/etcd/api/v3 v3.5.0-beta.4/go.mod h1:yF0YUmBghT48aC0/eTFrhULo+uKQAr5spQQ6sRhPauE=
 go.etcd.io/etcd/client/pkg/v3 v3.5.0-beta.4 h1:IVvCfkch8truS86wSy67AbnXCYq8nYpM8NPTW14Ttp0=
@ -793,7 +775,6 @@ golang.org/x/crypto v0.0.0-20200820211705-5c72a883971a/go.mod h1:LzIPMQfyMNhhGPh
 golang.org/x/crypto v0.0.0-20201112155050-0c6587e931a9/go.mod h1:LzIPMQfyMNhhGPhUkYOs5KpL4U8rLKemX1yGLhDgUto=
 golang.org/x/crypto v0.0.0-20201217014255-9d1352758620/go.mod h1:jdWPYTVW3xRLrWPugEBEK3UY2ZEsg3UU495nc5E+M+I=
 golang.org/x/crypto v0.0.0-20210220033148-5ea612d1eb83/go.mod h1:jdWPYTVW3xRLrWPugEBEK3UY2ZEsg3UU495nc5E+M+I=
-golang.org/x/crypto v0.0.0-20210415154028-4f45737414dc/go.mod h1:T9bdIzuCu7OtxOm1hfPfRQxPLYneinmdGuTeoZ9dtd4=
 golang.org/x/crypto v0.0.0-20210421170649-83a5a9bb288b h1:7mWr3k41Qtv8XlltBkDkl8LoP3mpSgBW8BUoxtEdbXg=
 golang.org/x/crypto v0.0.0-20210421170649-83a5a9bb288b/go.mod h1:T9bdIzuCu7OtxOm1hfPfRQxPLYneinmdGuTeoZ9dtd4=
 golang.org/x/exp v0.0.0-20190121172915-509febef88a4/go.mod h1:CJ0aWSM057203Lf6IL+f9T1iT9GByDxfZKAQTCR3kQA=
@ -850,7 +831,6 @@ golang.org/x/net v0.0.0-20190628185345-da137c7871d7/go.mod h1:z5CRVTTTmAJ677TzLL
 golang.org/x/net v0.0.0-20190724013045-ca1201d0de80/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=
 golang.org/x/net v0.0.0-20190813141303-74dc4d7220e7/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=
 golang.org/x/net v0.0.0-20190923162816-aa69164e4478/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=
-golang.org/x/net v0.0.0-20191112182307-2180aed22343/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=
 golang.org/x/net v0.0.0-20191209160850-c0dbc17a3553/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=
 golang.org/x/net v0.0.0-20200114155413-6afb5195e5aa/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=
 golang.org/x/net v0.0.0-20200202094626-16171245cfb2/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=
@ -917,7 +897,6 @@ golang.org/x/sys v0.0.0-20190924154521-2837fb4f24fe/go.mod h1:h1NjWce9XRLGQEsW7w
 golang.org/x/sys v0.0.0-20191001151750-bb3f8db39f24/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/sys v0.0.0-20191008105621-543471e840be/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/sys v0.0.0-20191026070338-33540a1f6037/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
-golang.org/x/sys v0.0.0-20191112214154-59a1497f0cea/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/sys v0.0.0-20191204072324-ce4227a45e2e/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/sys v0.0.0-20191220142924-d4481acd189f/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/sys v0.0.0-20191228213918-04cbcbbfeed8/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
@ -941,12 +920,11 @@ golang.org/x/sys v0.0.0-20200803210538-64077c9b5642/go.mod h1:h1NjWce9XRLGQEsW7w
 golang.org/x/sys v0.0.0-20200828194041-157a740278f4/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/sys v0.0.0-20200930185726-fdedc70b468f/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/sys v0.0.0-20201015000850-e3ed0017c211/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
-golang.org/x/sys v0.0.0-20201024232916-9f70ab9862d5/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/sys v0.0.0-20201119102817-f84b799fce68/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
-golang.org/x/sys v0.0.0-20210119212857-b64e53b001e4/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/sys v0.0.0-20210124154548-22da62e12c0c/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/sys v0.0.0-20210217105451-b926d437f341/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/sys v0.0.0-20210225134936-a50acf3fe073/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20210316164454-77fc1eacc6aa/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/sys v0.0.0-20210330210617-4fbd30eecc44/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/sys v0.0.0-20210403161142-5e06dd20ab57/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/sys v0.0.0-20210420072515-93ed5bcd2bfe/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
@ -1020,7 +998,6 @@ golang.org/x/tools v0.0.0-20201022035929-9cf592e881e9/go.mod h1:emZCQorbCU4vsT4f
 golang.org/x/tools v0.0.0-20201105001634-bc3cf281b174/go.mod h1:emZCQorbCU4vsT4fOWvOPXz4eW1wZW4PmDk9uLelYpA=
 golang.org/x/tools v0.0.0-20210106214847-113979e3529a/go.mod h1:emZCQorbCU4vsT4fOWvOPXz4eW1wZW4PmDk9uLelYpA=
 golang.org/x/tools v0.0.0-20210114065538-d78b04bdf963/go.mod h1:emZCQorbCU4vsT4fOWvOPXz4eW1wZW4PmDk9uLelYpA=
-golang.org/x/tools v0.1.0/go.mod h1:xkSsbof2nBLbhDlRMhhhyNLN/zl3eTqcnHD5viDpcZ0=
 golang.org/x/tools v0.1.1 h1:wGiQel/hW0NnEkJUk8lbzkX2gFJU6PFxf1v5OlCfuOs=
 golang.org/x/tools v0.1.1/go.mod h1:o0xws9oXOQQZyjljx8fwUC0k7L1pTE6eaCbjGeHmOkk=
 golang.org/x/xerrors v0.0.0-20190717185122-a985d3407aa7/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
@ -1030,7 +1007,6 @@ golang.org/x/xerrors v0.0.0-20200804184101-5ec99f83aff1 h1:go1bK/D/BFZV2I8cIQd1N
 golang.org/x/xerrors v0.0.0-20200804184101-5ec99f83aff1/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
 google.golang.org/api v0.3.1/go.mod h1:6wY9I6uQWHQ8EM57III9mq/AjF+i8G65rmVagqKMtkk=
 google.golang.org/api v0.4.0/go.mod h1:8k5glujaEP+g9n7WNsDg8QP6cUVNI86fCNMcbazEtwE=
-google.golang.org/api v0.5.0/go.mod h1:8k5glujaEP+g9n7WNsDg8QP6cUVNI86fCNMcbazEtwE=
 google.golang.org/api v0.7.0/go.mod h1:WtwebWUNSVBH/HAw79HIFXZNqEvBhG+Ra+ax0hx3E3M=
 google.golang.org/api v0.8.0/go.mod h1:o4eAsZoiT+ibD93RtjEohWalFOjRDx6CVaqeizhEnKg=
 google.golang.org/api v0.9.0/go.mod h1:o4eAsZoiT+ibD93RtjEohWalFOjRDx6CVaqeizhEnKg=
@ -1061,7 +1037,6 @@ google.golang.org/genproto v0.0.0-20190404172233-64821d5d2107/go.mod h1:VzzqZJRn
 google.golang.org/genproto v0.0.0-20190418145605-e7d98fc518a7/go.mod h1:VzzqZJRnGkLBvHegQrXjBqPurQTc5/KpmUdxsrq26oE=
 google.golang.org/genproto v0.0.0-20190425155659-357c62f0e4bb/go.mod h1:VzzqZJRnGkLBvHegQrXjBqPurQTc5/KpmUdxsrq26oE=
 google.golang.org/genproto v0.0.0-20190502173448-54afdca5d873/go.mod h1:VzzqZJRnGkLBvHegQrXjBqPurQTc5/KpmUdxsrq26oE=
-google.golang.org/genproto v0.0.0-20190508193815-b515fa19cec8/go.mod h1:VzzqZJRnGkLBvHegQrXjBqPurQTc5/KpmUdxsrq26oE=
 google.golang.org/genproto v0.0.0-20190530194941-fb225487d101/go.mod h1:z3L6/3dTEVtUr6QSP8miRzeRqwQOioJ9I66odjN4I7s=
 google.golang.org/genproto v0.0.0-20190801165951-fa694d86fc64/go.mod h1:DMBHOl98Agz4BDEuKkezgsaosCRResVns1a3J2ZsMNc=
 google.golang.org/genproto v0.0.0-20190819201941-24fa4b261c55/go.mod h1:DMBHOl98Agz4BDEuKkezgsaosCRResVns1a3J2ZsMNc=