return result[i].Name < result[j].Name
	})

	return result, nil
}

// GetBucketInfo returns bucket stat info about bucket on disk across all peers
func (sys *S3PeerSys) GetBucketInfo(ctx context.Context, bucket string, opts BucketOptions) (binfo BucketInfo, err error) {
	g := errgroup.WithNErrs(len(sys.peerClients))

	bucketInfos := make([]BucketInfo, len(sys.peerClients))

func (s *xlStorage) DiskInfo(ctx context.Context, _ DiskInfoOptions) (info DiskInfo, err error) {
	info, err = s.diskInfoCache.GetWithCtx(ctx)
	info.NRRequests = s.nrRequests
	info.Rotational = s.rotational
	info.MountPath = s.drivePath
	info.Endpoint = s.endpoint.String()
	info.Scanning = atomic.LoadInt32(&s.scanning) == 1
	return info, err
}

// getVolDir - will convert incoming volume names to

		if err != nil {
			return setRestoreHeaderFn(oi, err)
		}
		pInfo, err := er.PutObjectPart(ctx, bucket, object, res.UploadID, partInfo.Number, NewPutObjReader(hr), ObjectOptions{})
		if err != nil {
			return setRestoreHeaderFn(oi, err)
		}
		if pInfo.Size != partInfo.Size {
			return setRestoreHeaderFn(oi, InvalidObjectState{Bucket: bucket, Object: object})
		}

			ctx, cancel := context.WithTimeout(ctx, 10*time.Second)
			defer cancel()
			info, err := client.ServerInfo(ctx, metrics)
			if err != nil {
				info.Endpoint = client.host.String()
				info.State = string(madmin.ItemOffline)
				info.Disks = getOfflineDisks(info.Endpoint, globalEndpoints)
			}
			reply[idx] = info
		}(client, i)
	}
	wg.Wait()

	return reply
}

func TestReplicatedInfos(t *testing.T) {
	for i, test := range replicatedInfosTests {
		rinfos := replicatedInfos{
			Targets: test.tgtInfos,
		}
		if actualSize := rinfos.CompletedSize(); actualSize != test.expectedCompletedSize {
			t.Errorf("Test%d (%s): Size  got %d , want %d", i+1, test.name, actualSize, test.expectedCompletedSize)
		}
		if repStatusStr := rinfos.ReplicationStatusInternal(); repStatusStr != test.expectedReplicationStatusInternal {

	}
	if len(usersList) != 1 {
		c.Fatalf("expected user listing output: %v", usersList)
	}
	uinfo := usersList[userDN]
	if uinfo.PolicyName != policy || uinfo.Status != madmin.AccountEnabled {
		c.Fatalf("expected user listing content: %v", uinfo)
	}

	// Validate that the client from sts creds can access the bucket.
	c.mustListObjects(ctx, minioClient, bucket)

                }

                // Perform the actual reconnection
                boolean success = performReconnection(info);

                if (success) {
                    handleManager.completeReconnect(info.getPath(), true);
                    log.info("Successfully reconnected handle: {}", info.getPath());
                    return info;

<font color="#A6E22E">INFO</font>:     Started server process [<font color="#A1EFE4">27370</font>]
<font color="#A6E22E">INFO</font>:     Waiting for application startup.
<font color="#A6E22E">INFO</font>:     Application startup complete.
<font color="#A6E22E">INFO</font>:     Started server process [<font color="#A1EFE4">27367</font>]
<font color="#A6E22E">INFO</font>:     Waiting for application startup.

			}
			return auth.AccountOff
		}(),
	})

	if err := store.saveUserIdentity(ctx, accessKey, regUser, uinfo); err != nil {
		return updatedAt, err
	}

	if err := cache.updateUserWithClaims(accessKey, uinfo); err != nil {
		return updatedAt, err
	}

	return uinfo.UpdatedAt, nil
}

// AddServiceAccount - add a new service account

        HandleInfo info = guidToHandle.get(guid);
        if (info != null) {
            System.arraycopy(fileId, 0, info.fileId, 0, 16);
            if (info.type == HandleType.PERSISTENT) {
                persistHandle(info);
            }
        }
    }
    
    public HandleInfo getHandleForReconnect(String path) {
        HandleInfo info = handles.get(path);
        if (info != null && !info.isExpired()) {