IsTruncated: false,

			Uploads: []MultipartInfo{
				{
					Object:   objectNames[0],
					UploadID: uploadIDs[4],
				},
				{
					Object:   objectNames[1],
					UploadID: uploadIDs[5],
				},
				{
					Object:   objectNames[2],
					UploadID: uploadIDs[6],
				},
				{
					Object:   objectNames[3],
					UploadID: uploadIDs[7],
				},
				{

				return
			}
		case "Uploads":
			var zb0002 uint32
			zb0002, bts, err = msgp.ReadArrayHeaderBytes(bts)
			if err != nil {
				err = msgp.WrapError(err, "Uploads")
				return
			}
			if cap(z.Uploads) >= int(zb0002) {
				z.Uploads = (z.Uploads)[:zb0002]
			} else {
				z.Uploads = make([]MultipartInfo, zb0002)
			}
			for za0001 := range z.Uploads {

	queryValues.Set("uploadId", uploadID)
	queryValues.Set("partNumber", partNumber)
	return makeTestTargetURL(endPoint, bucketName, objectName, queryValues)
}

// return URL for aborting multipart upload.
func getAbortMultipartUploadURL(endPoint, bucketName, objectName, uploadID string) string {
	queryValue := url.Values{}
	queryValue.Set("uploadId", uploadID)
	return makeTestTargetURL(endPoint, bucketName, objectName, queryValue)

		}

		z.mpCache.Range(func(_ string, mp MultipartInfo) bool {
			if mp.Bucket == bucket {
				poolResult.Uploads = append(poolResult.Uploads, mp)
			}
			return true
		})
		sort.Slice(poolResult.Uploads, func(i int, j int) bool {
			return poolResult.Uploads[i].Initiated.Before(poolResult.Uploads[j].Initiated)
		})
		return poolResult, nil
	}

	if z.SinglePool() {

}

// ListMultipartUploadsHandler - GET Bucket (List Multipart uploads)
// -------------------------
// This operation lists in-progress multipart uploads. An in-progress
// multipart upload is a multipart upload that has been initiated,
// using the Initiate Multipart Upload request, but has not yet been
// completed or aborted. This operation returns at most 1,000 multipart
// uploads in the response.

		globalBucketMetadataSys.Set(upload.bucket, metadata)
		defer globalBucketMetadataSys.Remove(upload.bucket)

		// Upload objects which modtime as one week ago, supposed to be expired by ILM
		for range upload.expired {
			_, err := obj.PutObject(context.Background(), upload.bucket, randString(32),
				mustGetPutObjReader(t,
					bytes.NewBufferString(objContent),
					int64(len(objContent)),
					hex.EncodeToString(objMd5[:]),

```

### Step 3: Test with Thumbnailer

We used [Thumbnailer](https://github.com/minio/thumbnailer) to listen for MinIO notifications when a new JPEG file is uploaded (HTTP PUT). Triggered by a notification, Thumbnailer uploads a thumbnail of new image to MinIO server. To start with, download and install Thumbnailer.

```
git clone https://github.com/minio/thumbnailer/
npm install
```

		HTTPStatusCode: http.StatusNotFound,
	},
	ErrNoSuchUpload: {
		Code:           "NoSuchUpload",
		Description:    "The specified multipart upload does not exist. The upload ID may be invalid, or the upload may have been aborted or completed.",
		HTTPStatusCode: http.StatusNotFound,
	},
	ErrInvalidVersionID: {
		Code:           "InvalidArgument",

adaptive.load.control=50
# Supported JavaScript file extensions for upload.
supported.uploaded.js.extentions=js
# Supported CSS file extensions for upload.
supported.uploaded.css.extentions=css
# Supported media file extensions for upload.
supported.uploaded.media.extentions=jpg,jpeg,gif,png,swf
# Supported files for upload.
supported.uploaded.files=license.properties
# Supported languages.

	}

	pools, ok := objAPI.(*erasureServerPools)
	if !ok {
		return
	}

	// No need to return errors, this is not a highly strict operation.
	uploadID := mss.Get(peerRESTUploadID)
	if uploadID != "" {
		pools.ClearUploadID(uploadID)
	}

	return
}

func (s *peerRESTServer) StopRebalanceHandler(mss *grid.MSS) (np grid.NoPayload, nerr *grid.RemoteErr) {
	objAPI := newObjectLayerFn()