2206280621

Build # 2206280621

Build Type

github

Committed by GitHub

Commit Message

<a href="https://github.com/MikeSouza/serverless-deployment-bucket/commit/<a class=hub.com/MikeSouza/serverless-deployment-bucket/commit/<a class="double-link" href="https://git"><a class=hub.com/MikeSouza/serverless-deployment-bucket/commit/<a class="double-link" href="https://git"><a class=hub.com/MikeSouza/serverless-deployment-bucket/commit/<a class="double-link" href="https://git"><a class=hub.com/MikeSouza/serverless-deployment-bucket/commit/<a class="double-link" href="https://git"><a class=hub.com/MikeSouza/serverless-deployment-bucket/commit/506505190b50640f031553b9c412831e1f2205bf">506505190">&lt;a href=&quot;https://github.com/MikeSouza/serverless-deployment-bucket/commit/</a><a class="double-link" href="https://github.com/MikeSouza/serverless-deployment-bucket/commit/&lt;a class=&quot;double-link&quot; href=&quot;https://git">&lt;a class=</a>hub.com/MikeSouza/serverless-deployment-bucket/commit/&lt;a class=&quot;double-link&quot; href=&quot;https://git">&lt;a class=</a>hub.com/MikeSouza/serverless-deployment-bucket/commit/&lt;a class=&quot;double-link&quot; href=&quot;https://git">&lt;a class=</a>hub.com/MikeSouza/serverless-deployment-bucket/commit/506505190b50640f031553b9c412831e1f2205bf">506505190</a><a href="https://github.com/MikeSouza/serverless-deployment-bucket/commit/506505190b50640f031553b9c412831e1f2205bf">&lt;a href=&quot;https://github.com/MikeSouza/serverless-deployment-bucket/commit/506505190b50640f031553b9c412831e1f2205bf&quot;&gt;&amp;quot;&amp;gt;&amp;amp;lt;a href=&amp;amp;quot;https://github.com/MikeSouza/serverless-deployment-bucket/commit/&amp;lt;/a&amp;gt;&amp;lt;a class=&amp;quot;double-link&amp;quot; href=&amp;quot;https://github.com/MikeSouza/serverless-deployment-bucket/commit/&amp;amp;lt;a class=&amp;amp;quot;double-link&amp;amp;quot; href=&amp;amp;quot;https://git&amp;quot;&amp;gt;&amp;amp;lt;a class=&amp;lt;/a&amp;gt;hub.com/MikeSouza/serverless-deployment-bucket/commit/506505190b50640f031553b9c412831e1f2205bf&amp;quot;&amp;gt;506505190&amp;lt;/a&amp;gt;&amp;lt;a href=&amp;quot;https://github.com/MikeSouza/serverless-deployment-bucket/commit/506505190b50640f031553b9c412831e1f2205bf&amp;quot;&amp;gt;&amp;amp;lt;a href=&amp;amp;quot;https://github.com/MikeSouza/serverless-deployment-bucket/commit/506505190b50640f031553b9c412831e&amp;lt;/a&amp;gt;1f2205bf&amp;quot;&amp;gt;&amp;amp;quo</a>t;&amp;gt;Merge &amp;lt;/a&amp;gt;&amp;lt;a class=&amp;quot;double-link&amp;quot; href=&amp;quot;https://github... (continued)

Pull Request Pull Request #70: Add possibility to define deployment bucket access logs

Run Details

91 of 93 branches covered (97.85%)

Branch coverage included in aggregate %.

16 of 18 new or added lines in 1 file covered. (88.89%)

145 of 147 relevant lines covered (98.64%)

46.97 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

98.12

/lib/index.js

'use strict'

const chalk = require('chalk')
const util = require('./util')

const get = (obj, path, defaultValue) => {
  return path.split('.').filter(Boolean).every(step => !(step && !(obj = obj[step]))) ? obj : defaultValue
}

const getPublicAccessBlock = block => block === true
  ? { BlockPublicAcls: true, BlockPublicPolicy: true, IgnorePublicAcls: true, RestrictPublicBuckets: true }
  : { BlockPublicAcls: false, BlockPublicPolicy: false, IgnorePublicAcls: false, RestrictPublicBuckets: false }

class DeploymentBucketPlugin {
  constructor(serverless, options) {
    this.serverless = serverless
    this.provider = this.serverless.providers.aws

    const deploymentBucketProp = util.deploymentBucketProperty(this.serverless.version)
    this.deploymentBucket = get(this.serverless.service, `provider.${deploymentBucketProp}`, {})

    this.config = get(this.serverless.service, 'custom.deploymentBucket', {})

    this.hooks = {}

    if (this.config.enabled !== undefined && this.config.enabled === false) {
      return;
    }

    if (this.deploymentBucket.name) {
      this.config.versioning = get(this.config, 'versioning', false)
      this.config.accessLog = get(this.config, 'accessLog', false)
      this.config.accelerate = get(this.config, 'accelerate', false)
      this.config.policy = get(this.config, 'policy', undefined)
      this.config.tags = util.filterValidBucketTags(get(this.config, 'tags', undefined))
      this.config.blockPublicAccess = get(this.config, 'blockPublicAccess', undefined)

      const serverlessCommand = get(this.serverless, 'processedInput.commands', [])
      if (!serverlessCommand.includes('package')) {
        this.hooks['before:aws:common:validate:validate'] = this.applyDeploymentBucket.bind(this)
      }
    }
  }

  async bucketExists(name) {
    var params = {
      Bucket: name
    };

    try {
      await this.provider.request('S3', 'headBucket', params)
      return true
    } catch (e) {
      return false
    }
  }

  async waitFor(name, state) {
    var params = {
      Bucket: name
    };

    try {
      const service = new this.provider.sdk['S3'](this.provider.getCredentials())
      await service.waitFor(state, params).promise()

      return true
    } catch (e) {
      this.serverless.cli.log(`Unable to wait for '${state}' - ${e.message}`)

      return false
    }
  }

  async createBucket(name) {
    const params = {
      Bucket: name,
      ACL: 'private'
    };

    return await this.provider.request('S3', 'createBucket', params)
  }

  async hasBucketEncryption(name) {
    const params = {
      Bucket: name
    };

    try {
      await this.provider.request('S3', 'getBucketEncryption', params)
      return true
    } catch (e) {
      return false
    }
  }

  async putBucketEncryption(name, sseAlgorithm, kmsMasterKeyId) {
    const params = {
      Bucket: name,
      ServerSideEncryptionConfiguration: {
        Rules: [
          {
            ApplyServerSideEncryptionByDefault: {
              SSEAlgorithm: sseAlgorithm,
              KMSMasterKeyID: kmsMasterKeyId
            }
          }
        ]
      }
    }

    return await this.provider.request('S3', 'putBucketEncryption', params)
  }

  async hasBucketVersioning(name) {
    const params = {
      Bucket: name
    };

    try {
      const response = await this.provider.request('S3', 'getBucketVersioning', params)
      if (response.Status && response.Status == 'Enabled') {
        return true
      }

      return false
    } catch (e) {
      return false
    }
  }

  async shouldUpdateBucketAccessLogging (name, config) {
    const params = {
      Bucket: name
    }

    try {
      const response = await this.provider.request('S3', 'getBucketLogging', params)
      const loggingEnabledAndMatches = response.LoggingEnabled
        && config.bucket === response.LoggingEnabled.TargetBucket
        && config.prefix === response.LoggingEnabled.TargetPrefix

      return !(loggingEnabledAndMatches || (!response.LoggingEnabled && !config));
    } catch (e) {
      this.serverless.cli.log('Failed to get bucket logging configuration', e)
      return false;
    }
  }

  async putBucketVersioning(name, status) {
    const params = {
      Bucket: name,
      VersioningConfiguration: {
        Status: status ? 'Enabled' : 'Suspended'
      }
    };

    return await this.provider.request('S3', 'putBucketVersioning', params)
  }

  async putBucketAccessLogging (name, { bucket, prefix }) {
    const params = bucket ? {
      Bucket: name,
      BucketLoggingStatus: {
        LoggingEnabled: {
          TargetBucket: bucket,
          TargetPrefix: prefix
        }
      }
    } : {
      Bucket: name,
      BucketLoggingStatus: {}
    }
    try {
      return await this.provider.request('S3', 'putBucketLogging', params)
    } catch (e) {
      this.serverless.cli.log('Failed to put bucket logging configuration', e)
      return false
    }

  }

  async hasBucketAcceleration (name) {
    const params = {
      Bucket: name
    };

    try {
      const response = await this.provider.request('S3', 'getBucketAccelerateConfiguration', params)
      if (response.Status && response.Status == 'Enabled') {
        return true
      }

      return false
    } catch (e) {
      return false
    }
  }

  async putBucketAcceleration(name, status) {
    const params = {
      Bucket: name,
      AccelerateConfiguration: {
        Status: status ? 'Enabled' : 'Suspended'
      }
    };

    return await this.provider.request('S3', 'putBucketAccelerateConfiguration', params)
  }

  async putBucketPolicy(name, policy) {
    const params = {
      Bucket: name,
      Policy: JSON.stringify(policy),
    };
    return await this.provider.request('S3', 'putBucketPolicy', params)
  }

  async hasChangedBucketTags(name, tags) {
    try {
      const response = await this.provider.request('S3', 'getBucketTagging', { Bucket: name })
      return response && JSON.stringify(response.TagSet) !== JSON.stringify(tags)
    } catch (e) {
      return Boolean(tags)
    }
  }

  async updateBucketTags(name, tags) {
    if (Array.isArray(tags) && tags.length) {
      return await this.provider.request('S3', 'putBucketTagging', {
        Bucket: name,
        Tagging: { TagSet: tags }
      })
    } else {
      return await this.provider.request('S3', 'deleteBucketTagging', {
        Bucket: name
      })
    }
  }

  async hasChangedPublicAccessBlock(name, blockPublicAccess) {
    try {
      const config = getPublicAccessBlock(blockPublicAccess)
      const response = await this.provider.request('S3', 'getPublicAccessBlock', { Bucket: name })
      return response && JSON.stringify(response.PublicAccessBlockConfiguration) !== JSON.stringify(config)
    } catch (e) {
      return blockPublicAccess
    }
  }

  async updatePublicAccessBlock(name, blockPublicAccess) {
    if (blockPublicAccess === true) {
      return await this.provider.request('S3', 'putPublicAccessBlock', {
        Bucket: name,
        PublicAccessBlockConfiguration: getPublicAccessBlock(blockPublicAccess)
      })
    } else {
      return await this.provider.request('S3', 'deletePublicAccessBlock', {
        Bucket: name
      })
    }
  }

  async applyDeploymentBucket() {
    try {
      let isNewBucket = false

      if (await this.bucketExists(this.deploymentBucket.name)) {
        this.serverless.cli.log(`Using deployment bucket '${this.deploymentBucket.name}'`)
      } else {
        this.serverless.cli.log(`Creating deployment bucket '${this.deploymentBucket.name}'...`)

        await this.createBucket(this.deploymentBucket.name)
        await this.waitFor(this.deploymentBucket.name, 'bucketExists')
        isNewBucket = true
      }

      if (this.deploymentBucket.serverSideEncryption) {
        if (!(await this.hasBucketEncryption(this.deploymentBucket.name))) {
          if (this.deploymentBucket.serverSideEncryption === "aws:kms") {
            await this.putBucketEncryption(this.deploymentBucket.name, this.deploymentBucket.serverSideEncryption, this.deploymentBucket.kmsKeyID)
          }

          if (this.deploymentBucket.serverSideEncryption === "AES256") {
            await this.putBucketEncryption(this.deploymentBucket.name, this.deploymentBucket.serverSideEncryption)
          }

          this.serverless.cli.log(`Applied SSE (${this.deploymentBucket.serverSideEncryption}) to deployment bucket`)
        }
      }

      if ((await this.hasBucketVersioning(this.deploymentBucket.name)) != this.config.versioning) {
        await this.putBucketVersioning(this.deploymentBucket.name, this.config.versioning)

        if (this.config.versioning) {
          this.serverless.cli.log('Enabled versioning on deployment bucket')
        } else {
          this.serverless.cli.log('Suspended versioning on deployment bucket')
        }
      }

      if ((await this.hasBucketAcceleration(this.deploymentBucket.name)) != this.config.accelerate) {
        await this.putBucketAcceleration(this.deploymentBucket.name, this.config.accelerate)

        if (this.config.accelerate) {
          this.serverless.cli.log('Enabled acceleration on deployment bucket')
        } else {
          this.serverless.cli.log('Suspended acceleration on deployment bucket')
        }
      }

      if (this.config.policy) {
        await this.putBucketPolicy(this.deploymentBucket.name, this.config.policy)
        this.serverless.cli.log(`Applied deployment bucket policy`)
      }

      const hasChangedBucketTags = (isNewBucket && Array.isArray(this.config.tags) && this.config.tags.length) ||
        (await this.hasChangedBucketTags(this.deploymentBucket.name, this.config.tags));
      if (hasChangedBucketTags) {
        await this.updateBucketTags(this.deploymentBucket.name, this.config.tags)
        this.serverless.cli.log('Updated deployment bucket tags')
      }

      const hasChangedPublicAccessBlock = (isNewBucket && typeof this.config.blockPublicAccess === 'boolean') ||
        (await this.hasChangedPublicAccessBlock(this.deploymentBucket.name, this.config.blockPublicAccess));
      if (hasChangedPublicAccessBlock) {
        await this.updatePublicAccessBlock(this.deploymentBucket.name, this.config.blockPublicAccess)
        this.serverless.cli.log('Updated deployment bucket public access block')
      }

      if ((await this.shouldUpdateBucketAccessLogging(this.deploymentBucket.name, this.config.accessLog))) {
        await this.putBucketAccessLogging(this.deploymentBucket.name, this.config.accessLog)

        if (this.config.accessLog) {
          this.serverless.cli.log('Enabled access logging on deployment bucket')
        } else {
          this.serverless.cli.log('Suspended access logging on deployment bucket')
        }
      }

    } catch (e) {
      console.error(chalk.red(`\n-------- Deployment Bucket Error --------\n${e.message}`))
    }
  }
}

module.exports = DeploymentBucketPlugin

1	'use strict'
2
3	const chalk = require('chalk')	3✔
4	const util = require('./util')	3✔
5
6	const get = (obj, path, defaultValue) => {	3✔
7	return path.split('.').filter(Boolean).every(step => !(step && !(obj = obj[step]))) ? obj : defaultValue	1,509✔
8	}
9
10	const getPublicAccessBlock = block => block === true	81✔
11	? { BlockPublicAcls: true, BlockPublicPolicy: true, IgnorePublicAcls: true, RestrictPublicBuckets: true }
12	: { BlockPublicAcls: false, BlockPublicPolicy: false, IgnorePublicAcls: false, RestrictPublicBuckets: false }
13
14	class DeploymentBucketPlugin {
15	constructor(serverless, options) {
16	this.serverless = serverless	144✔
17	this.provider = this.serverless.providers.aws	144✔
18
19	const deploymentBucketProp = util.deploymentBucketProperty(this.serverless.version)	144✔
20	this.deploymentBucket = get(this.serverless.service, `provider.${deploymentBucketProp}`, {})	144✔
21
22	this.config = get(this.serverless.service, 'custom.deploymentBucket', {})	144✔
23
24	this.hooks = {}	144✔
25
26	if (this.config.enabled !== undefined && this.config.enabled === false) {	144✔
27	return;	3✔
28	}
29
30	if (this.deploymentBucket.name) {	141✔
31	this.config.versioning = get(this.config, 'versioning', false)	117✔
32	this.config.accessLog = get(this.config, 'accessLog', false)	117✔
33	this.config.accelerate = get(this.config, 'accelerate', false)	117✔
34	this.config.policy = get(this.config, 'policy', undefined)	117✔
35	this.config.tags = util.filterValidBucketTags(get(this.config, 'tags', undefined))	117✔
36	this.config.blockPublicAccess = get(this.config, 'blockPublicAccess', undefined)	117✔
37
38	const serverlessCommand = get(this.serverless, 'processedInput.commands', [])	117✔
39	if (!serverlessCommand.includes('package')) {	117✔
40	this.hooks['before:aws:common:validate:validate'] = this.applyDeploymentBucket.bind(this)	114✔
41	}
42	}
43	}
44
45	async bucketExists(name) {
46	var params = {	90✔
47	Bucket: name
48	};
49
50	try {	90✔
51	await this.provider.request('S3', 'headBucket', params)	90✔
52	return true	33✔
53	} catch (e) {
54	return false	57✔
55	}
56	}
57
58	async waitFor(name, state) {
59	var params = {	54✔
60	Bucket: name
61	};
62
63	try {	54✔
64	const service = new this.provider.sdk['S3'](this.provider.getCredentials())	54✔
65	await service.waitFor(state, params).promise()	3✔
66
67	return true	3✔
68	} catch (e) {
69	this.serverless.cli.log(`Unable to wait for '${state}' - ${e.message}`)	51✔
70
71	return false	51✔
72	}
73	}
74
75	async createBucket(name) {
76	const params = {	57✔
77	Bucket: name,
78	ACL: 'private'
79	};
80
81	return await this.provider.request('S3', 'createBucket', params)	57✔
82	}
83
84	async hasBucketEncryption(name) {
85	const params = {	84✔
86	Bucket: name
87	};
88
89	try {	84✔
90	await this.provider.request('S3', 'getBucketEncryption', params)	84✔
91	return true	66✔
92	} catch (e) {
93	return false	18✔
94	}
95	}
96
97	async putBucketEncryption(name, sseAlgorithm, kmsMasterKeyId) {
98	const params = {	18✔
99	Bucket: name,
100	ServerSideEncryptionConfiguration: {
101	Rules: [
102	{
103	ApplyServerSideEncryptionByDefault: {
104	SSEAlgorithm: sseAlgorithm,
105	KMSMasterKeyID: kmsMasterKeyId
106	}
107	}
108	]
109	}
110	}
111
112	return await this.provider.request('S3', 'putBucketEncryption', params)	18✔
113	}
114
115	async hasBucketVersioning(name) {
116	const params = {	87✔
117	Bucket: name
118	};
119
120	try {	87✔
121	const response = await this.provider.request('S3', 'getBucketVersioning', params)	87✔
122	if (response.Status && response.Status == 'Enabled') {	84✔
123	return true	15✔
124	}
125
126	return false	45✔
127	} catch (e) {
128	return false	27✔
129	}
130	}
131
132	async shouldUpdateBucketAccessLogging (name, config) {
133	const params = {	87✔
134	Bucket: name
135	}
136
137	try {	87✔
138	const response = await this.provider.request('S3', 'getBucketLogging', params)	87✔
139	const loggingEnabledAndMatches = response.LoggingEnabled	87!
140	&& config.bucket === response.LoggingEnabled.TargetBucket
141	&& config.prefix === response.LoggingEnabled.TargetPrefix
142
143	return !(loggingEnabledAndMatches \|\| (!response.LoggingEnabled && !config));	9✔
144	} catch (e) {
145	this.serverless.cli.log('Failed to get bucket logging configuration', e)	78✔
146	return false;	78✔
147	}
148	}
149
150	async putBucketVersioning(name, status) {
151	const params = {	33✔
152	Bucket: name,
153	VersioningConfiguration: {
154	Status: status ? 'Enabled' : 'Suspended'	33✔
155	}
156	};
157
158	return await this.provider.request('S3', 'putBucketVersioning', params)	33✔
159	}
160
161	async putBucketAccessLogging (name, { bucket, prefix }) {
162	const params = bucket ? {	6!
163	Bucket: name,
164	BucketLoggingStatus: {
165	LoggingEnabled: {
166	TargetBucket: bucket,
167	TargetPrefix: prefix
168	}
169	}
170	} : {
171	Bucket: name,
172	BucketLoggingStatus: {}
173	}
174	try {	6✔
175	return await this.provider.request('S3', 'putBucketLogging', params)	6✔
176	} catch (e) {
NEW 177	this.serverless.cli.log('Failed to put bucket logging configuration', e)	×
NEW 178	return false	×
179	}
180
181	}
182
183	async hasBucketAcceleration (name) {
184	const params = {	87✔
185	Bucket: name
186	};
187
188	try {	87✔
189	const response = await this.provider.request('S3', 'getBucketAccelerateConfiguration', params)	87✔
190	if (response.Status && response.Status == 'Enabled') {	87✔
191	return true	6✔
192	}
193
194	return false	45✔
195	} catch (e) {
196	return false	36✔
197	}
198	}
199
200	async putBucketAcceleration(name, status) {
201	const params = {	42✔
202	Bucket: name,
203	AccelerateConfiguration: {
204	Status: status ? 'Enabled' : 'Suspended'	42✔
205	}
206	};
207
208	return await this.provider.request('S3', 'putBucketAccelerateConfiguration', params)	42✔
209	}
210
211	async putBucketPolicy(name, policy) {
212	const params = {	3✔
213	Bucket: name,
214	Policy: JSON.stringify(policy),
215	};
216	return await this.provider.request('S3', 'putBucketPolicy', params)	3✔
217	}
218
219	async hasChangedBucketTags(name, tags) {
220	try {	84✔
221	const response = await this.provider.request('S3', 'getBucketTagging', { Bucket: name })	84✔
222	return response && JSON.stringify(response.TagSet) !== JSON.stringify(tags)	78✔
223	} catch (e) {
224	return Boolean(tags)	6✔
225	}
226	}
227
228	async updateBucketTags(name, tags) {
229	if (Array.isArray(tags) && tags.length) {	9✔
230	return await this.provider.request('S3', 'putBucketTagging', {	6✔
231	Bucket: name,
232	Tagging: { TagSet: tags }
233	})
234	} else {
235	return await this.provider.request('S3', 'deleteBucketTagging', {	3✔
236	Bucket: name
237	})
238	}
239	}
240
241	async hasChangedPublicAccessBlock(name, blockPublicAccess) {
242	try {	72✔
243	const config = getPublicAccessBlock(blockPublicAccess)	72✔
244	const response = await this.provider.request('S3', 'getPublicAccessBlock', { Bucket: name })	72✔
245	return response && JSON.stringify(response.PublicAccessBlockConfiguration) !== JSON.stringify(config)	66✔
246	} catch (e) {
247	return blockPublicAccess	6✔
248	}
249	}
250
251	async updatePublicAccessBlock(name, blockPublicAccess) {
252	if (blockPublicAccess === true) {	21✔
253	return await this.provider.request('S3', 'putPublicAccessBlock', {	9✔
254	Bucket: name,
255	PublicAccessBlockConfiguration: getPublicAccessBlock(blockPublicAccess)
256	})
257	} else {
258	return await this.provider.request('S3', 'deletePublicAccessBlock', {	12✔
259	Bucket: name
260	})
261	}
262	}
263
264	async applyDeploymentBucket() {
265	try {	90✔
266	let isNewBucket = false	90✔
267
268	if (await this.bucketExists(this.deploymentBucket.name)) {	90✔
269	this.serverless.cli.log(`Using deployment bucket '${this.deploymentBucket.name}'`)	33✔
270	} else {
271	this.serverless.cli.log(`Creating deployment bucket '${this.deploymentBucket.name}'...`)	57✔
272
273	await this.createBucket(this.deploymentBucket.name)	57✔
274	await this.waitFor(this.deploymentBucket.name, 'bucketExists')	54✔
275	isNewBucket = true	54✔
276	}
277
278	if (this.deploymentBucket.serverSideEncryption) {	87✔
279	if (!(await this.hasBucketEncryption(this.deploymentBucket.name))) {	84✔
280	if (this.deploymentBucket.serverSideEncryption === "aws:kms") {	18✔
281	await this.putBucketEncryption(this.deploymentBucket.name, this.deploymentBucket.serverSideEncryption, this.deploymentBucket.kmsKeyID)	3✔
282	}
283
284	if (this.deploymentBucket.serverSideEncryption === "AES256") {	18✔
285	await this.putBucketEncryption(this.deploymentBucket.name, this.deploymentBucket.serverSideEncryption)	15✔
286	}
287
288	this.serverless.cli.log(`Applied SSE (${this.deploymentBucket.serverSideEncryption}) to deployment bucket`)	18✔
289	}
290	}
291
292	if ((await this.hasBucketVersioning(this.deploymentBucket.name)) != this.config.versioning) {	87✔
293	await this.putBucketVersioning(this.deploymentBucket.name, this.config.versioning)	33✔
294
295	if (this.config.versioning) {	33✔
296	this.serverless.cli.log('Enabled versioning on deployment bucket')	30✔
297	} else {
298	this.serverless.cli.log('Suspended versioning on deployment bucket')	3✔
299	}
300	}
301
302	if ((await this.hasBucketAcceleration(this.deploymentBucket.name)) != this.config.accelerate) {	87✔
303	await this.putBucketAcceleration(this.deploymentBucket.name, this.config.accelerate)	42✔
304
305	if (this.config.accelerate) {	42✔
306	this.serverless.cli.log('Enabled acceleration on deployment bucket')	39✔
307	} else {
308	this.serverless.cli.log('Suspended acceleration on deployment bucket')	3✔
309	}
310	}
311
312	if (this.config.policy) {	87✔
313	await this.putBucketPolicy(this.deploymentBucket.name, this.config.policy)	3✔
314	this.serverless.cli.log(`Applied deployment bucket policy`)	3✔
315	}
316
317	const hasChangedBucketTags = (isNewBucket && Array.isArray(this.config.tags) && this.config.tags.length) \|\|	87✔
318	(await this.hasChangedBucketTags(this.deploymentBucket.name, this.config.tags));
319	if (hasChangedBucketTags) {	87✔
320	await this.updateBucketTags(this.deploymentBucket.name, this.config.tags)	9✔
321	this.serverless.cli.log('Updated deployment bucket tags')	9✔
322	}
323
324	const hasChangedPublicAccessBlock = (isNewBucket && typeof this.config.blockPublicAccess === 'boolean') \|\|	87✔
325	(await this.hasChangedPublicAccessBlock(this.deploymentBucket.name, this.config.blockPublicAccess));
326	if (hasChangedPublicAccessBlock) {	87✔
327	await this.updatePublicAccessBlock(this.deploymentBucket.name, this.config.blockPublicAccess)	21✔
328	this.serverless.cli.log('Updated deployment bucket public access block')	21✔
329	}
330
331	if ((await this.shouldUpdateBucketAccessLogging(this.deploymentBucket.name, this.config.accessLog))) {	87✔
332	await this.putBucketAccessLogging(this.deploymentBucket.name, this.config.accessLog)	6✔
333
334	if (this.config.accessLog) {	6✔
335	this.serverless.cli.log('Enabled access logging on deployment bucket')	3✔
336	} else {
337	this.serverless.cli.log('Suspended access logging on deployment bucket')	3✔
338	}
339	}
340
341	} catch (e) {
342	console.error(chalk.red(`\n-------- Deployment Bucket Error --------\n${e.message}`))	3✔
343	}
344	}
345	}
346
347	module.exports = DeploymentBucketPlugin	3✔

MikeSouza / serverless-deployment-bucket / 2206280621

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous