10 examples of 's3 getobject createreadstream' in JavaScript

43
export function getObject (s3, params) {
44
  return s3.getObject(params).promise();
45
};

25
function getObject(minioClient, bucketName, objectName) {
26
  return new Promise((resolve, reject) =>
27
    minioClient.getObject(bucketName, objectName, (err, dataStream) => {
28
      if (err) {
29
        reject(err);
30
        return;
31
      }
32
33
      const chunks = [];
34
      dataStream.on("data", chunk => chunks.push(chunk));
35
      dataStream.on("error", reject);
36
      dataStream.on("end", () => {
37
        resolve(Buffer.concat(chunks).toString("utf8"));
38
      });
39
    })
40
  );
41
}

11
public async getObject(key: string, bucket: string) {
12
  const params: S3.Types.GetObjectRequest = {
13
    Bucket: bucket,
14
    Key: key,
15
  };
16
  return await this.s3
17
    .getObject(params)
18
    .promise()
19
    .then((data: S3.Types.GetObjectOutput) => data)
20
    .catch(err => {
21
      Utils.logError('S3 Get Object', err, params);
22
      return null;
23
    });
24
}

275
function retrieveObject(bucketName, keyName, callback) {
276
    var s3 = new AWS.S3();
277
    var objectBody = "";
278
279
    var objectParams = {
280
        Bucket: bucketName,
281
        Key: keyName
282
    };
283
284
    async.waterfall([
285
        function loadObject(next) {
286
            console.log("Checking for object ", keyName, " in bucket ", bucketName);
287
            s3.getObject(objectParams, next);
288
        }, function handleObject(data, next) {
289
            console.log("Got object");
290
            objectBody = data.Body.toString('utf8').trim();
291
            next(null);
292
        }
293
    ], function (err, result) {
294
        if (err) {
295
            console.log("Error looking for object");
296
            console.log(err, err.stack);
297
            callback(new Error("cannot load object"), null);
298
        } else if (objectBody === '') {
299
            callback(new Error("cannot load object"), null);
300
        } else {
301
            callback(null, objectBody);
302
        }
303
    });
304
}

121
getObjectDetails (bucketKey, objectKey) {
122
123
  var url = `${this.apiUrl}/buckets/` +
124
    `${encodeURIComponent(bucketKey)}/objects/` +
125
    `${encodeURIComponent(objectKey)}/details`
126
127
  return this.ajax({
128
    rawBody: true,
129
    url
130
  })
131
}

22
putObject (region, bucketName, objectName, body, mimeType = undefined, cacheControl = undefined) {
23
  const awsS3 = new AWS.S3({ region })
24
  return new Promise((resolve, reject) => {
25
    if (mimeType === undefined) {
26
      mimeType = mime.lookup(objectName)
27
    }
28
    if (cacheControl === undefined) {
29
      cacheControl = getCacheControl(mimeType)
30
    }
31
    const params = {
32
      Bucket: bucketName,
33
      Body: body,
34
      Key: objectName,
35
      ContentType: mimeType,
36
      CacheControl: cacheControl
37
    }
38
    awsS3.putObject(params, (err, result) => {
39
      if (err) {
40
        return reject(err)
41
      }
42
      resolve()
43
    })
44
  })
45
}

11
async function head_object(req, res) {
12
    const encryption = s3_utils.parse_encryption(req);
13
    const object_md = await req.object_sdk.read_object_md({
14
        bucket: req.params.bucket,
15
        key: req.params.key,
16
        version_id: req.query.versionId,
17
        md_conditions: http_utils.get_md_conditions(req),
18
        encryption
19
    });
20
    s3_utils.set_response_object_md(res, object_md);
21
    s3_utils.set_encryption_response_headers(req, res, object_md.encryption);
22
}

15
async readObject(bucket: string, object: string): Promise {
16
  try {
17
    const hasAccess = this.canReadFiles();
18
    if (hasAccess) {
19
      return this.getObjectData(bucket, object);
20
    }
21
    return '';
22
  } catch (error) {
23
    this.handleError(error);
24
  }
25
}

349
function headObjects(contents, bucket, callback) {
350
  var keys = [];
351
352
  // Get each object in parallel
353
  async.each(contents, function(object, cb) {
354
    s3.headObject({
355
      Bucket: bucket,
356
      Key: object.Key
357
    }, function(err, data) {
358
      if (err) {
359
        cb(err);
360
      } else {
361
        // Add the key attribute
362
        data.Key = object.Key;
363
        keys.push(data);
364
        cb(null);
365
      }
366
    });
367
  }, 
368
  function(err) {
369
    if (err) {
370
      callback(err);
371
    } else {
372
      callback(null, keys);
373
    }
374
  });
375
}

23
function getS3(key) {
24
  return new Promise((resolve, reject) => {
25
    s3.getObject({ Bucket: process.env.BUCKET, Key: key }, (err, data) => {
26
      if (err && err.code == 'NotFound') return reject(Errors.NOT_FOUND);
27
      else if (err) {
28
        const e = Object.assign({}, Errors.SOMETHING_WRONG, { err });
29
        return reject(e);
30
      }
31
      const content_type = data.ContentType;
32
      const image = new Buffer(data.Body).toString('base64');
33
      return resolve({
34
        statusCode: 200,
35
        headers: { 'Content-Type': content_type },
36
        body: image,
37
        isBase64Encoded: true,
38
      });
39
    });
40
  });
41
}