Support the new API GetObjectAttributes

constants.js

@@ -275,6 +275,14 @@ const constants = {
         'bucketPutLogging',
         'bucketGetLogging',
     ],
+    // Supported attributes for the GetObjectAttributes 'x-amz-optional-attributes' header.
+    supportedGetObjectAttributes: new Set([
+        'StorageClass',
+        'ObjectSize',
+        'ObjectParts',
+        'Checksum',
+        'ETag',
+    ]),
 };
 
 module.exports = constants;

lib/api/api.js

@@ -53,6 +53,7 @@ const { objectDelete } = require('./objectDelete');
 const objectDeleteTagging = require('./objectDeleteTagging');
 const objectGet = require('./objectGet');
 const objectGetACL = require('./objectGetACL');
+const objectGetAttributes = require('./objectGetAttributes.js');
 const objectGetLegalHold = require('./objectGetLegalHold');
 const objectGetRetention = require('./objectGetRetention');
 const objectGetTagging = require('./objectGetTagging');
@@ -384,6 +385,7 @@ const api = {
     objectDeleteTagging,
     objectGet,
     objectGetACL,
+    objectGetAttributes,
     objectGetLegalHold,
     objectGetRetention,
     objectGetTagging,

lib/api/apiUtils/object/parseAttributesHeader.js

@@ -0,0 +1,25 @@
+const { errorInstances } = require('arsenal');
+const { supportedGetObjectAttributes } = require('../../../../constants');
+
+/**
+ * parseAttributesHeaders - Parse and validate the x-amz-object-attributes header
+ * @param {object} headers - request headers
+ * @returns {Set<string>} - set of requested attribute names
+ * @throws {Error} - InvalidRequest if header is missing/empty, InvalidArgument if attribute is invalid
+ */
+function parseAttributesHeaders(headers) {
+  const attributes = headers['x-amz-object-attributes']?.split(',').map(attr => attr.trim()) ?? [];
+  if (attributes.length === 0) {
+    throw errorInstances.InvalidRequest.customizeDescription(
+      'The x-amz-object-attributes header specifying the attributes to be retrieved is either missing or empty',
+    );
+  }
+
+  if (attributes.some(attr => !supportedGetObjectAttributes.has(attr))) {
+    throw errorInstances.InvalidArgument.customizeDescription('Invalid attribute name specified.');
+  }
+
+  return new Set(attributes);
+}
+
+module.exports = parseAttributesHeaders;

lib/api/objectGetAttributes.js

@@ -0,0 +1,160 @@
+const { promisify } = require('util');
+const xml2js = require('xml2js');
+const { errors } = require('arsenal');
+const { standardMetadataValidateBucketAndObj } = require('../metadata/metadataUtils');
+const collectCorsHeaders = require('../utilities/collectCorsHeaders');
+const parseAttributesHeaders = require('./apiUtils/object/parseAttributesHeader');
+const { decodeVersionId, getVersionIdResHeader } = require('./apiUtils/object/versioning');
+const { checkExpectedBucketOwner } = require('./apiUtils/authorization/bucketOwner');
+const { pushMetric } = require('../utapi/utilities');
+const { getPartCountFromMd5 } = require('./apiUtils/object/partInfo');
+
+const checkExpectedBucketOwnerPromise = promisify(checkExpectedBucketOwner);
+const validateBucketAndObj = promisify(standardMetadataValidateBucketAndObj);
+
+const OBJECT_GET_ATTRIBUTES = 'objectGetAttributes';
+const ATTRIBUTE_HANDLERS = {
+  ETag: objMD => objMD['content-md5'],
+  ObjectParts: objMD => {
+    const partCount = getPartCountFromMd5(objMD);
+    return partCount ? { PartsCount: partCount } : undefined;
+  },
+  StorageClass: objMD => objMD['x-amz-storage-class'],
+  ObjectSize: objMD => objMD['content-length'],
+};
+
+/**
+ * buildXmlResponse - Build XML response for GetObjectAttributes
+ * @param {object} objMD - object metadata
+ * @param {Set<string>} requestedAttrs - set of requested attribute names
+ * @returns {string} XML response
+ */
+function buildXmlResponse(objMD, requestedAttrs) {
+  const attrResp = {};
+
+  for (const [attr, handler] of Object.entries(ATTRIBUTE_HANDLERS)) {
+    if (requestedAttrs.has(attr)) {
+      const value = handler(objMD);
+      if (value !== undefined) {
+        attrResp[attr] = value;
+      }
+    }
+  }
+
+  const builder = new xml2js.Builder();
+  return builder.buildObject({ GetObjectAttributesResponse: attrResp });
+}
+
+/**
+ * objectGetAttributes - Retrieves all metadata from an object without returning the object itself
+ * @param {AuthInfo} authInfo - Instance of AuthInfo class with requester's info
+ * @param {object} request - http request object
+ * @param {object} log - Werelogs logger
+ * @param {function} callback - callback optional to keep backward compatibility
+ * @returns {Promise<object>} - { xml, responseHeaders }
+ * @throws {ArsenalError} NoSuchVersion - if versionId specified but not found
+ * @throws {ArsenalError} NoSuchKey - if object not found
+ * @throws {ArsenalError} MethodNotAllowed - if object is a delete marker
+ */
+async function objectGetAttributes(authInfo, request, log, callback) {
+  if (callback) {
+    return objectGetAttributes(authInfo, request, log)
+      .then(result => callback(null, result.xml, result.responseHeaders))
+      .catch(err => callback(err, null, err.responseHeaders ?? {}));
+  }
+
+  log.trace('processing request', { method: OBJECT_GET_ATTRIBUTES });
+  const { bucketName, objectKey, headers, actionImplicitDenies } = request;
+
+  const versionId = decodeVersionId(request.query);
+  if (versionId instanceof Error) {
+    log.debug('invalid versionId query', {
+      method: OBJECT_GET_ATTRIBUTES,
+      versionId: request.query.versionId,
+      error: versionId,
+    });
+    throw versionId;
+  }
+
+  const metadataValParams = {
+    authInfo,
+    bucketName,
+    objectKey,
+    versionId,
+    getDeleteMarker: true,
+    requestType: request.apiMethods || OBJECT_GET_ATTRIBUTES,
+    request,
+  };
+
+  let bucket, objectMD;
+  try {
+    ({ bucket, objectMD } = await validateBucketAndObj(metadataValParams, actionImplicitDenies, log));
+    await checkExpectedBucketOwnerPromise(headers, bucket, log);
+  } catch (err) {
+    log.debug('error validating bucket and object', {
+      method: OBJECT_GET_ATTRIBUTES,
+      bucket: bucketName,
+      key: objectKey,
+      versionId,
+      error: err,
+    });
+    throw err;
+  }
+
+  const responseHeaders = collectCorsHeaders(headers.origin, request.method, bucket);
+
+  if (!objectMD) {
+    log.debug('object not found', {
+      method: OBJECT_GET_ATTRIBUTES,
+      bucket: bucketName,
+      key: objectKey,
+      versionId,
+    });
+    const err = versionId ? errors.NoSuchVersion : errors.NoSuchKey;
+    err.responseHeaders = responseHeaders;
+    throw err;
+  }
+
+  responseHeaders['x-amz-version-id'] = getVersionIdResHeader(bucket.getVersioningConfiguration(), objectMD);
+  responseHeaders['Last-Modified'] = objectMD['last-modified'] && new Date(objectMD['last-modified']).toUTCString();
+
+  if (objectMD.isDeleteMarker) {
+    log.debug('attempt to get attributes of a delete marker', {
+      method: OBJECT_GET_ATTRIBUTES,
+      bucket: bucketName,
+      key: objectKey,
+      versionId,
+    });
+    responseHeaders['x-amz-delete-marker'] = true;
+    const err = errors.MethodNotAllowed;
+    err.responseHeaders = responseHeaders;
+    throw err;
+  }
+
+  const requestedAttrs = parseAttributesHeaders(headers);
+
+  if (requestedAttrs.has('Checksum')) {
+    log.debug('Checksum attribute requested but not implemented', {
+      method: OBJECT_GET_ATTRIBUTES,
+      bucket: bucketName,
+      key: objectKey,
+      versionId,
+    });
+    const err = errors.NotImplemented.customizeDescription('Checksum attribute is not implemented');
+    err.responseHeaders = responseHeaders;
+    throw err;
+  }
+
+  pushMetric(OBJECT_GET_ATTRIBUTES, log, {
+    authInfo,
+    bucket: bucketName,
+    keys: [objectKey],
+    versionId: objectMD?.versionId,
+    location: objectMD?.dataStoreName,
+  });
+
+  const xml = buildXmlResponse(objectMD, requestedAttrs);
+  return { xml, responseHeaders };
+}
+
+module.exports = objectGetAttributes;

lib/metadata/metadataUtils.js

@@ -1,3 +1,4 @@
+const { promisify } = require('util');
 const async = require('async');
 const { errors } = require('arsenal');
 
@@ -281,6 +282,15 @@ function standardMetadataValidateBucketAndObj(params, actionImplicitDenies, log,
         return callback(null, bucket, objMD);
     });
 }
+
+standardMetadataValidateBucketAndObj[promisify.custom] = (...args) =>
+    new Promise((resolve, reject) => {
+        standardMetadataValidateBucketAndObj(...args, (err, bucket, objectMD) => {
+            if (err) {return reject(err);}
+            return resolve({ bucket, objectMD });
+        });
+    });
+
 /** standardMetadataValidateBucket - retrieve bucket from metadata and check if user
  * is authorized to access it
  * @param {object} params - function parameters

package.json

@@ -21,7 +21,7 @@
   "dependencies": {
     "@azure/storage-blob": "^12.28.0",
     "@hapi/joi": "^17.1.1",
-    "arsenal": "git+https://github.com/scality/arsenal#8.2.44",
+    "arsenal": "git+https://github.com/scality/Arsenal#feature/ARSN-549/get-object-attributes",
     "async": "2.6.4",
     "aws-sdk": "^2.1692.0",
     "bucketclient": "scality/bucketclient#8.2.7",