Coverage for /pythoncovmergedfiles/medio/medio/usr/local/lib/python3.8/site-packages/c7n_gcp/resources/loadbalancer.py: 92%
298 statements
« prev ^ index » next coverage.py v7.3.2, created at 2023-12-08 06:51 +0000
1# Copyright The Cloud Custodian Authors.
2# SPDX-License-Identifier: Apache-2.0
3from c7n.utils import type_schema, local_session
4from c7n_gcp.actions import MethodAction
5from c7n_gcp.provider import resources
6from c7n_gcp.query import QueryResourceManager, TypeInfo
9@resources.register('loadbalancer-address')
10class LoadBalancingAddress(QueryResourceManager):
11 """GCP resource: https://cloud.google.com/compute/docs/reference/rest/v1/addresses
12 """
13 class resource_type(TypeInfo):
14 service = 'compute'
15 version = 'v1'
16 component = 'addresses'
17 enum_spec = ('aggregatedList', 'items.*.addresses[]', None)
18 scope = 'project'
19 name = id = 'name'
20 default_report_fields = [
21 name, "description", "address", "status", "region", "addressType"
22 ]
23 asset_type = "compute.googleapis.com/Address"
24 urn_component = "address"
26 @staticmethod
27 def get(client, resource_info):
28 return client.execute_command('get', {
29 'project': resource_info['project_id'],
30 'region': resource_info['location'],
31 'address': resource_info[
32 'resourceName'].rsplit('/', 1)[-1]})
35@LoadBalancingAddress.action_registry.register('delete')
36class LoadBalancingAddressDelete(MethodAction):
37 schema = type_schema('delete')
38 method_spec = {'op': 'delete'}
39 attr_filter = ('status', ('RESERVED',))
41 def get_resource_params(self, model, resource):
42 project = local_session(self.manager.source.query.session_factory).get_default_project()
43 return {
44 'project': project,
45 'region': resource['region'].rsplit('/', 1)[-1],
46 'address': resource['name']}
49@resources.register('loadbalancer-url-map')
50class LoadBalancingUrlMap(QueryResourceManager):
51 """GCP resource: https://cloud.google.com/compute/docs/reference/rest/v1/urlMaps
52 """
53 class resource_type(TypeInfo):
54 service = 'compute'
55 version = 'v1'
56 component = 'urlMaps'
57 enum_spec = ('list', 'items[]', None)
58 scope = 'project'
59 name = id = 'name'
60 default_report_fields = [
61 "name", "description", "creationTimestamp", "region", "defaultService"
62 ]
63 asset_type = "compute.googleapis.com/UrlMap"
64 urn_component = "url-map"
66 @staticmethod
67 def get(client, resource_info):
68 return client.execute_command('get', {
69 'project': resource_info['project_id'],
70 'urlMap': resource_info[
71 'resourceName'].rsplit('/', 1)[-1]})
74@resources.register('loadbalancer-target-tcp-proxy')
75class LoadBalancingTargetTcpProxy(QueryResourceManager):
76 """GCP resource: https://cloud.google.com/compute/docs/reference/rest/v1/targetTcpProxies
77 """
78 class resource_type(TypeInfo):
79 service = 'compute'
80 version = 'v1'
81 component = 'targetTcpProxies'
82 enum_spec = ('list', 'items[]', None)
83 scope = 'project'
84 name = id = 'name'
85 default_report_fields = [
86 "name", "description", "creationTimestamp", "service"
87 ]
88 asset_type = " compute.googleapis.com/TargetTcpProxy"
89 urn_component = "target-tcp-proxy"
91 @staticmethod
92 def get(client, resource_info):
93 return client.execute_command('get', {
94 'project': resource_info['project_id'],
95 'targetTcpProxy': resource_info[
96 'resourceName'].rsplit('/', 1)[-1]})
99@resources.register('loadbalancer-target-ssl-proxy')
100class LoadBalancingTargetSslProxy(QueryResourceManager):
101 """GCP resource: https://cloud.google.com/compute/docs/reference/rest/v1/targetSslProxies
102 """
103 class resource_type(TypeInfo):
104 service = 'compute'
105 version = 'v1'
106 component = 'targetSslProxies'
107 enum_spec = ('list', 'items[]', None)
108 scope = 'project'
109 name = id = 'name'
110 default_report_fields = [
111 "name", "description", "creationTimestamp", "service", "sslPolicy"
112 ]
113 asset_type = "compute.googleapis.com/TargetSslProxy"
114 urn_component = "target-ssl-proxy"
116 @staticmethod
117 def get(client, resource_info):
118 return client.execute_command('get', {
119 'project': resource_info['project_id'],
120 'targetSslProxy': resource_info[
121 'resourceName'].rsplit('/', 1)[-1]})
124@resources.register('loadbalancer-ssl-policy')
125class LoadBalancingSslPolicy(QueryResourceManager):
126 """GCP resource: https://cloud.google.com/compute/docs/reference/rest/v1/sslPolicies
127 """
128 class resource_type(TypeInfo):
129 service = 'compute'
130 version = 'v1'
131 component = 'sslPolicies'
132 enum_spec = ('list', 'items[]', None)
133 scope = 'project'
134 name = id = 'name'
135 default_report_fields = [
136 "name", "description", "profile", "minTlsVersion"
137 ]
138 urn_component = "ssl-policy"
139 asset_type = "compute.googleapis.com/SslPolicy"
141 @staticmethod
142 def get(client, resource_info):
143 return client.execute_command('get', {
144 'project': resource_info['project_id'],
145 'sslPolicy': resource_info[
146 'resourceName'].rsplit('/', 1)[-1]})
149@LoadBalancingSslPolicy.action_registry.register('delete')
150class LoadBalancingSslPolicyDelete(MethodAction):
151 """The action is used for Load Balancing SSL Policies delete.
152 GCP action is https://cloud.google.com/compute/docs/reference/rest/v1/sslPolicies/delete.
154 Example:
156 .. code-block:: yaml
158 policies:
159 - name: gcp-load-balancing-ssl-policies-delete
160 resource: gcp.loadbalancer-ssl-policy
161 filters:
162 - type: value
163 key: minTlsVersion
164 op: ne
165 value: TLS_1_2
166 actions:
167 - type: delete
168 """
169 schema = type_schema('delete')
170 method_spec = {'op': 'delete'}
172 def get_resource_params(self, model, resource):
173 project = local_session(self.manager.source.query.session_factory).get_default_project()
174 return {
175 'project': project,
176 'sslPolicy': resource['name']}
179@resources.register('loadbalancer-ssl-certificate')
180class LoadBalancingSslCertificate(QueryResourceManager):
181 """GCP resource: https://cloud.google.com/compute/docs/reference/rest/v1/sslCertificates
182 """
183 class resource_type(TypeInfo):
184 service = 'compute'
185 version = 'v1'
186 component = 'sslCertificates'
187 enum_spec = ('list', 'items[]', None)
188 scope = 'project'
189 name = id = 'name'
190 default_report_fields = [
191 "name", "description", "creationTimestamp", "type", "region", "expireTime"
192 ]
193 asset_type = "compute.googleapis.com/SslCertificate"
194 urn_component = "ssl-certificate"
196 @staticmethod
197 def get(client, resource_info):
198 return client.execute_command('get', {
199 'project': resource_info['project_id'],
200 'sslCertificate': resource_info['ssl_certificate_name']})
203@resources.register('loadbalancer-target-https-proxy')
204class LoadBalancingTargetHttpsProxy(QueryResourceManager):
205 """GCP resource: https://cloud.google.com/compute/docs/reference/rest/v1/targetHttpsProxies
206 """
207 class resource_type(TypeInfo):
208 service = 'compute'
209 version = 'v1'
210 component = 'targetHttpsProxies'
211 enum_spec = ('list', 'items[]', None)
212 scope = 'project'
213 name = id = 'name'
214 default_report_fields = [
215 name, "description", "creationTimestamp", "sslPolicy", "urlMap"
216 ]
217 asset_type = "compute.googleapis.com/TargetHttpsProxy"
218 scc_type = "google.compute.TargetHttpsProxy"
219 urn_component = "target-https-proxy"
221 @staticmethod
222 def get(client, resource_info):
223 return client.execute_command('get', {
224 'project': resource_info['project_id'],
225 'targetHttpsProxy': resource_info[
226 'resourceName'].rsplit('/', 1)[-1]})
229@resources.register('loadbalancer-backend-bucket')
230class LoadBalancingBackendBucket(QueryResourceManager):
231 """GCP resource: https://cloud.google.com/compute/docs/reference/rest/v1/backendBuckets
232 """
233 class resource_type(TypeInfo):
234 service = 'compute'
235 version = 'v1'
236 component = 'backendBuckets'
237 enum_spec = ('list', 'items[]', None)
238 scope = 'project'
239 name = id = 'name'
240 default_report_fields = [
241 "name", "description", "creationTimestamp", "bucketName", "enableCdn"
242 ]
243 asset_type = "compute.googleapis.com/BackendBucket"
244 urn_component = "backend-bucket"
246 @staticmethod
247 def get(client, resource_info):
248 return client.execute_command('get', {
249 'project': resource_info['project_id'],
250 'backendBucket': resource_info[
251 'resourceName'].rsplit('/', 1)[-1]})
254@LoadBalancingBackendBucket.action_registry.register('delete')
255class LoadBalancingBackendBucketDelete(MethodAction):
256 """The action is used for Load Balancing Backend Buckets delete.
257 GCP action is https://cloud.google.com/compute/docs/reference/rest/v1/backendBuckets/delete.
259 Example:
261 .. code-block:: yaml
263 policies:
264 - name: gcp-loadbalancer-backend-buckets-delete
265 resource: gcp.loadbalancer-backend-bucket
266 filters:
267 - type: value
268 key: bucketName
269 op: eq
270 value: custodian-bucket-0
271 actions:
272 - type: delete
273 """
274 schema = type_schema('delete')
275 method_spec = {'op': 'delete'}
277 def get_resource_params(self, model, resource):
278 project = local_session(self.manager.source.query.session_factory).get_default_project()
279 return {
280 'project': project,
281 'backendBucket': resource['name']}
284@resources.register('loadbalancer-https-health-check')
285class LoadBalancingHttpsHealthCheck(QueryResourceManager):
286 """GCP resource: https://cloud.google.com/compute/docs/reference/rest/v1/httpsHealthChecks
287 """
288 class resource_type(TypeInfo):
289 service = 'compute'
290 version = 'v1'
291 component = 'httpsHealthChecks'
292 enum_spec = ('list', 'items[]', None)
293 scope = 'project'
294 name = id = 'name'
295 default_report_fields = [
296 name, "description", "host", "port", "requestPath", "checkIntervalSec"]
297 asset_type = "compute.googleapis.com/HttpsHealthCheck"
298 urn_component = "https-health-check"
300 @staticmethod
301 def get(client, resource_info):
302 return client.execute_command('get', {
303 'project': resource_info['project_id'],
304 'httpsHealthCheck': resource_info[
305 'resourceName'].rsplit('/', 1)[-1]})
308@resources.register('loadbalancer-http-health-check')
309class LoadBalancingHttpHealthCheck(QueryResourceManager):
310 """GCP resource: https://cloud.google.com/compute/docs/reference/rest/v1/httpHealthChecks
311 """
312 class resource_type(TypeInfo):
313 service = 'compute'
314 version = 'v1'
315 component = 'httpHealthChecks'
316 enum_spec = ('list', 'items[]', None)
317 scope = 'project'
318 name = id = 'name'
319 default_report_fields = [
320 name, "description", "host", "port", "requestPath", "checkIntervalSec"]
321 asset_type = "compute.googleapis.com/HttpHealthCheck"
322 urn_component = "http-health-check"
324 @staticmethod
325 def get(client, resource_info):
326 return client.execute_command('get', {
327 'project': resource_info['project_id'],
328 'httpHealthCheck': resource_info[
329 'resourceName'].rsplit('/', 1)[-1]})
332@resources.register('loadbalancer-health-check')
333class LoadBalancingHealthCheck(QueryResourceManager):
334 """GCP resource: https://cloud.google.com/compute/docs/reference/rest/v1/healthChecks
335 """
336 class resource_type(TypeInfo):
337 service = 'compute'
338 version = 'v1'
339 component = 'healthChecks'
340 enum_spec = ('list', 'items[]', None)
341 scope = 'project'
342 name = id = 'name'
343 default_report_fields = [
344 "name", "description", "creationTimestamp", "checkIntervalSec",
345 "healthyThreshold", "unhealthyThreshold", "timeoutSec"]
346 asset_type = "compute.googleapis.com/HealthCheck"
347 urn_component = "health-check"
349 @staticmethod
350 def get(client, resource_info):
351 return client.execute_command('get', {
352 'project': resource_info['project_id'],
353 'healthCheck': resource_info[
354 'resourceName'].rsplit('/', 1)[-1]})
357@resources.register('loadbalancer-target-http-proxy')
358class LoadBalancingTargetHttpProxy(QueryResourceManager):
359 """GCP resource: https://cloud.google.com/compute/docs/reference/rest/v1/targetHttpProxies
360 """
361 class resource_type(TypeInfo):
362 service = 'compute'
363 version = 'v1'
364 component = 'targetHttpProxies'
365 enum_spec = ('list', 'items[]', None)
366 scope = 'project'
367 name = id = 'name'
368 default_report_fields = [
369 "name", "description", "creationTimestamp", "region", "urlMap"]
370 asset_type = "compute.googleapis.com/TargetHttpProxy"
371 urn_component = "target-http-proxy"
373 @staticmethod
374 def get(client, resource_info):
375 return client.execute_command('get', {
376 'project': resource_info['project_id'],
377 'targetHttpProxy': resource_info[
378 'resourceName'].rsplit('/', 1)[-1]})
381@resources.register('loadbalancer-backend-service')
382class LoadBalancingBackendService(QueryResourceManager):
383 """GCP resource: https://cloud.google.com/compute/docs/reference/rest/v1/backendServices
384 """
385 class resource_type(TypeInfo):
386 service = 'compute'
387 version = 'v1'
388 component = 'backendServices'
389 enum_spec = ('aggregatedList', 'items.*.backendServices[]', None)
390 scope = 'project'
391 name = id = 'name'
392 default_report_fields = [
393 "name", "description", "creationTimestamp", "region", "network"]
394 asset_type = "compute.googleapis.com/BackendService"
395 urn_component = "backend-service"
397 @staticmethod
398 def get(client, resource_info):
399 return client.execute_command('get', {
400 'project': resource_info['project_id'],
401 'backendService': resource_info[
402 'resourceName'].rsplit('/', 1)[-1]})
405@resources.register('loadbalancer-target-instance')
406class LoadBalancingTargetInstance(QueryResourceManager):
407 """ GCP resource: https://cloud.google.com/compute/docs/reference/rest/v1/targetInstances
408 """
409 class resource_type(TypeInfo):
410 service = 'compute'
411 version = 'v1'
412 component = 'targetInstances'
413 enum_spec = ('aggregatedList', 'items.*.targetInstances[]', None)
414 scope = 'project'
415 name = id = 'name'
416 default_report_fields = [
417 name, "description", "creationTimestamp", "zone", "natPolicy", "instance"]
418 asset_type = "compute.googleapis.com/TargetInstance"
419 urn_component = "target-instance"
420 urn_zonal = True
422 @staticmethod
423 def get(client, resource_info):
424 return client.execute_command('get', {
425 'project': resource_info['project_id'],
426 'zone': resource_info['zone'],
427 'targetInstance': resource_info[
428 'resourceName'].rsplit('/', 1)[-1]})
431@resources.register('loadbalancer-target-pool')
432class LoadBalancingTargetPool(QueryResourceManager):
433 """ GCP resource: https://cloud.google.com/compute/docs/reference/rest/v1/targetPools
434 """
435 class resource_type(TypeInfo):
436 service = 'compute'
437 version = 'v1'
438 component = 'targetPools'
439 enum_spec = ('aggregatedList', 'items.*.targetPools[]', None)
440 scope = 'project'
441 name = id = 'name'
442 default_report_fields = [
443 name, "description", "region",
444 "failoverRatio", "sessionAffinity", "backupPool"
445 ]
446 asset_type = "compute.googleapis.com/TargetPool"
447 urn_component = "target-pool"
449 @staticmethod
450 def get(client, resource_info):
451 return client.execute_command('get', {
452 'project': resource_info['project_id'],
453 'region': resource_info['zone'],
454 'targetPool': resource_info[
455 'resourceName'].rsplit('/', 1)[-1]})
458@resources.register('loadbalancer-forwarding-rule')
459class LoadBalancingForwardingRule(QueryResourceManager):
460 """GCP resource: https://cloud.google.com/compute/docs/reference/rest/v1/addresses
461 """
462 class resource_type(TypeInfo):
463 service = 'compute'
464 version = 'v1'
465 component = 'forwardingRules'
466 enum_spec = ('aggregatedList', 'items.*.forwardingRules[]', None)
467 scope = 'project'
468 name = id = 'name'
469 default_report_fields = [
470 "name", "description", "region", "IPAddress", "IPProtocol", "target",
471 "loadBalancingScheme", "serviceName", "network"
472 ]
473 asset_type = "compute.googleapis.com/ForwardingRule"
474 urn_component = "forwarding-rule"
476 @staticmethod
477 def get(client, resource_info):
478 return client.execute_command('get', {
479 'project': resource_info['project_id'],
480 'region': resource_info['region'],
481 'forwardingRule': resource_info['resourceName'].rsplit('/', 1)[-1]})
484@resources.register('loadbalancer-global-forwarding-rule')
485class LoadBalancingGlobalForwardingRule(QueryResourceManager):
486 """GCP resource: https://cloud.google.com/compute/docs/reference/rest/v1/forwardingRules
487 """
488 class resource_type(TypeInfo):
489 service = 'compute'
490 version = 'v1'
491 component = 'globalForwardingRules'
492 enum_spec = ('list', 'items[]', None)
493 scope = 'project'
494 name = id = 'name'
495 default_report_fields = [
496 "name", "description", "creationTimestamp", "network",
497 "networkTier", "loadBalancingScheme", "subnetwork", "allowGlobalAccess"
498 ]
499 asset_type = "compute.googleapis.com/GlobalForwardingRule"
500 urn_component = "global-forwarding-rule"
502 @staticmethod
503 def get(client, resource_info):
504 return client.execute_command('get', {
505 'project': resource_info['project_id'],
506 'forwardingRule': resource_info['resourceName'].rsplit('/', 1)[-1]})
509@resources.register('loadbalancer-global-address')
510class LoadBalancingGlobalAddress(QueryResourceManager):
511 """GCP resource: https://cloud.google.com/compute/docs/reference/rest/v1/globalAddresses
512 """
513 class resource_type(TypeInfo):
514 service = 'compute'
515 version = 'v1'
516 component = 'globalAddresses'
517 enum_spec = ('list', 'items[]', None)
518 scope = 'project'
519 name = id = 'name'
520 default_report_fields = [
521 "name", "description", "status", "creationTimestamp", "address", "region"
522 ]
523 asset_type = "compute.googleapis.com/GlobalAddress"
524 urn_component = "global-address"
526 @staticmethod
527 def get(client, resource_info):
528 return client.execute_command('get', {
529 'project': resource_info['project_id'],
530 'address': resource_info['resourceName'].rsplit('/', 1)[-1]})